webkit/appcache/appcache_interfaces.h

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #ifndef WEBKIT_APPCACHE_APPCACHE_INTERFACES_H_
   6 #define WEBKIT_APPCACHE_APPCACHE_INTERFACES_H_
   7
   8 #include <string>
   9 #include <vector>
  10 #include "base/basictypes.h"
  11 #include "base/files/file_path.h"
  12 #include "base/time.h"
  13 #include "googleurl/src/gurl.h"
  14 #include "webkit/storage/webkit_storage_export.h"
  15
  16 namespace net {
  17 class URLRequest;
  18 }  // namespace net
  19
  20 namespace appcache {
  21
  22 // Defines constants, types, and abstract classes used in the main
  23 // process and in child processes.
  24
  25 static const int kNoHostId = 0;
  26 static const int64 kNoCacheId = 0;
  27 static const int64 kNoResponseId = 0;
  28 static const int64 kUnknownCacheId = -1;
  29
  30 enum Status {
  31   UNCACHED,
  32   IDLE,
  33   CHECKING,
  34   DOWNLOADING,
  35   UPDATE_READY,
  36   OBSOLETE
  37 };
  38
  39 enum EventID {
  40   CHECKING_EVENT,
  41   ERROR_EVENT,
  42   NO_UPDATE_EVENT,
  43   DOWNLOADING_EVENT,
  44   PROGRESS_EVENT,
  45   UPDATE_READY_EVENT,
  46   CACHED_EVENT,
  47   OBSOLETE_EVENT
  48 };
  49
  50 // Temporarily renumber them in wierd way, to help remove LOG_TIP from WebKit
  51 enum LogLevel {
  52   LOG_DEBUG = 4,
  53   LOG_INFO = 1,
  54   LOG_WARNING = 2,
  55   LOG_ERROR = 3,
  56 };
  57
  58 enum NamespaceType {
  59   FALLBACK_NAMESPACE,
  60   INTERCEPT_NAMESPACE,
  61   NETWORK_NAMESPACE
  62 };
  63
  64 struct WEBKIT_STORAGE_EXPORT AppCacheInfo {
  65   AppCacheInfo();
  66   ~AppCacheInfo();
  67
  68   GURL manifest_url;
  69   base::Time creation_time;
  70   base::Time last_update_time;
  71   base::Time last_access_time;
  72   int64 cache_id;
  73   int64 group_id;
  74   Status status;
  75   int64 size;
  76   bool is_complete;
  77 };
  78
  79 typedef std::vector<AppCacheInfo> AppCacheInfoVector;
  80
  81 // Type to hold information about a single appcache resource.
  82 struct WEBKIT_STORAGE_EXPORT AppCacheResourceInfo {
  83   AppCacheResourceInfo();
  84   ~AppCacheResourceInfo();
  85
  86   GURL url;
  87   int64 size;
  88   bool is_master;
  89   bool is_manifest;
  90   bool is_intercept;
  91   bool is_fallback;
  92   bool is_foreign;
  93   bool is_explicit;
  94   int64 response_id;
  95 };
  96
  97 typedef std::vector<AppCacheResourceInfo> AppCacheResourceInfoVector;
  98
  99 struct WEBKIT_STORAGE_EXPORT Namespace {
 100   Namespace();  // Type is set to FALLBACK_NAMESPACE by default.
 101   Namespace(NamespaceType type, const GURL& url, const GURL& target,
 102             bool is_pattern);
 103   Namespace(NamespaceType type, const GURL& url, const GURL& target,
 104             bool is_pattern, bool is_executable);
 105   ~Namespace();
 106
 107   bool IsMatch(const GURL& url) const;
 108
 109   NamespaceType type;
 110   GURL namespace_url;
 111   GURL target_url;
 112   bool is_pattern;
 113   bool is_executable;
 114 };
 115
 116 typedef std::vector<Namespace> NamespaceVector;
 117
 118 // Interface used by backend (browser-process) to talk to frontend (renderer).
 119 class WEBKIT_STORAGE_EXPORT AppCacheFrontend {
 120  public:
 121   virtual void OnCacheSelected(
 122       int host_id, const appcache::AppCacheInfo& info) = 0;
 123   virtual void OnStatusChanged(const std::vector<int>& host_ids,
 124                                Status status) = 0;
 125   virtual void OnEventRaised(const std::vector<int>& host_ids,
 126                              EventID event_id) = 0;
 127   virtual void OnProgressEventRaised(const std::vector<int>& host_ids,
 128                                      const GURL& url,
 129                                      int num_total, int num_complete) = 0;
 130   virtual void OnErrorEventRaised(const std::vector<int>& host_ids,
 131                                   const std::string& message) = 0;
 132   virtual void OnContentBlocked(int host_id,
 133                                 const GURL& manifest_url) = 0;
 134   virtual void OnLogMessage(int host_id, LogLevel log_level,
 135                             const std::string& message) = 0;
 136   virtual ~AppCacheFrontend() {}
 137 };
 138
 139 // Interface used by frontend (renderer) to talk to backend (browser-process).
 140 class WEBKIT_STORAGE_EXPORT AppCacheBackend {
 141  public:
 142   virtual void RegisterHost(int host_id) = 0;
 143   virtual void UnregisterHost(int host_id) = 0;
 144   virtual void SetSpawningHostId(int host_id, int spawning_host_id) = 0;
 145   virtual void SelectCache(int host_id,
 146                            const GURL& document_url,
 147                            const int64 cache_document_was_loaded_from,
 148                            const GURL& manifest_url) = 0;
 149   virtual void SelectCacheForWorker(
 150                            int host_id,
 151                            int parent_process_id,
 152                            int parent_host_id) = 0;
 153   virtual void SelectCacheForSharedWorker(
 154                            int host_id,
 155                            int64 appcache_id) = 0;
 156   virtual void MarkAsForeignEntry(int host_id, const GURL& document_url,
 157                                   int64 cache_document_was_loaded_from) = 0;
 158   virtual Status GetStatus(int host_id) = 0;
 159   virtual bool StartUpdate(int host_id) = 0;
 160   virtual bool SwapCache(int host_id) = 0;
 161   virtual void GetResourceList(
 162       int host_id, std::vector<AppCacheResourceInfo>* resource_infos) = 0;
 163
 164  protected:
 165   virtual ~AppCacheBackend() {}
 166 };
 167
 168 // Useful string constants.
 169 // Note: These are also defined elsewhere in the chrome code base in
 170 // url_contants.h .cc, however the appcache library doesn't not have
 171 // any dependencies on the chrome library, so we can't use them in here.
 172 extern const char kHttpScheme[];
 173 extern const char kHttpsScheme[];
 174 extern const char kHttpGETMethod[];
 175 extern const char kHttpHEADMethod[];
 176
 177 // CommandLine flag to turn this experimental feature on.
 178 extern const char kEnableExecutableHandlers[];
 179
 180 WEBKIT_STORAGE_EXPORT void AddSupportedScheme(const char* scheme);
 181
 182 bool IsSchemeSupported(const GURL& url);
 183 bool IsMethodSupported(const std::string& method);
 184 bool IsSchemeAndMethodSupported(const net::URLRequest* request);
 185
 186 WEBKIT_STORAGE_EXPORT extern const base::FilePath::CharType
 187     kAppCacheDatabaseName[];
 188
 189 }  // namespace
 190
 191 #endif  // WEBKIT_APPCACHE_APPCACHE_INTERFACES_H_