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