Home | History | Annotate | Download | only in appcache
      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 kAppCacheNoHostId = 0;
     27 static const int64 kAppCacheNoCacheId = 0;
     28 static const int64 kAppCacheNoResponseId = 0;
     29 static const int64 kAppCacheUnknownCacheId = -1;
     30 
     31 enum AppCacheStatus {
     32   APPCACHE_STATUS_UNCACHED,
     33   APPCACHE_STATUS_IDLE,
     34   APPCACHE_STATUS_CHECKING,
     35   APPCACHE_STATUS_DOWNLOADING,
     36   APPCACHE_STATUS_UPDATE_READY,
     37   APPCACHE_STATUS_OBSOLETE,
     38   APPCACHE_STATUS_LAST = APPCACHE_STATUS_OBSOLETE
     39 };
     40 
     41 enum AppCacheEventID {
     42   APPCACHE_CHECKING_EVENT,
     43   APPCACHE_ERROR_EVENT,
     44   APPCACHE_NO_UPDATE_EVENT,
     45   APPCACHE_DOWNLOADING_EVENT,
     46   APPCACHE_PROGRESS_EVENT,
     47   APPCACHE_UPDATE_READY_EVENT,
     48   APPCACHE_CACHED_EVENT,
     49   APPCACHE_OBSOLETE_EVENT,
     50   APPCACHE_EVENT_ID_LAST = APPCACHE_OBSOLETE_EVENT
     51 };
     52 
     53 // Temporarily renumber them in wierd way, to help remove LOG_TIP from WebKit
     54 enum AppCacheLogLevel {
     55   APPCACHE_LOG_DEBUG = 4,
     56   APPCACHE_LOG_INFO = 1,
     57   APPCACHE_LOG_WARNING = 2,
     58   APPCACHE_LOG_ERROR = 3,
     59 };
     60 
     61 enum AppCacheNamespaceType {
     62   APPCACHE_FALLBACK_NAMESPACE,
     63   APPCACHE_INTERCEPT_NAMESPACE,
     64   APPCACHE_NETWORK_NAMESPACE
     65 };
     66 
     67 enum AppCacheErrorReason {
     68   APPCACHE_MANIFEST_ERROR,
     69   APPCACHE_SIGNATURE_ERROR,
     70   APPCACHE_RESOURCE_ERROR,
     71   APPCACHE_CHANGED_ERROR,
     72   APPCACHE_ABORT_ERROR,
     73   APPCACHE_QUOTA_ERROR,
     74   APPCACHE_POLICY_ERROR,
     75   APPCACHE_UNKNOWN_ERROR,
     76   APPCACHE_ERROR_REASON_LAST = APPCACHE_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   AppCacheStatus 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 AppCacheErrorDetails {
    113   AppCacheErrorDetails();
    114   AppCacheErrorDetails(std::string message,
    115                AppCacheErrorReason reason,
    116                GURL url,
    117                int status,
    118                bool is_cross_origin);
    119   ~AppCacheErrorDetails();
    120 
    121   std::string message;
    122   AppCacheErrorReason 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 APPCACHE_FALLBACK_NAMESPACE by default.
    132   Namespace(AppCacheNamespaceType type, const GURL& url, const GURL& target,
    133             bool is_pattern);
    134   Namespace(AppCacheNamespaceType 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   AppCacheNamespaceType 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                                AppCacheStatus status) = 0;
    156   virtual void OnEventRaised(const std::vector<int>& host_ids,
    157                              AppCacheEventID 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(
    162       const std::vector<int>& host_ids,
    163       const appcache::AppCacheErrorDetails& details) = 0;
    164   virtual void OnContentBlocked(int host_id,
    165                                 const GURL& manifest_url) = 0;
    166   virtual void OnLogMessage(int host_id, AppCacheLogLevel log_level,
    167                             const std::string& message) = 0;
    168   virtual ~AppCacheFrontend() {}
    169 };
    170 
    171 // Interface used by frontend (renderer) to talk to backend (browser-process).
    172 class WEBKIT_STORAGE_COMMON_EXPORT AppCacheBackend {
    173  public:
    174   virtual void RegisterHost(int host_id) = 0;
    175   virtual void UnregisterHost(int host_id) = 0;
    176   virtual void SetSpawningHostId(int host_id, int spawning_host_id) = 0;
    177   virtual void SelectCache(int host_id,
    178                            const GURL& document_url,
    179                            const int64 cache_document_was_loaded_from,
    180                            const GURL& manifest_url) = 0;
    181   virtual void SelectCacheForWorker(
    182                            int host_id,
    183                            int parent_process_id,
    184                            int parent_host_id) = 0;
    185   virtual void SelectCacheForSharedWorker(
    186                            int host_id,
    187                            int64 appcache_id) = 0;
    188   virtual void MarkAsForeignEntry(int host_id, const GURL& document_url,
    189                                   int64 cache_document_was_loaded_from) = 0;
    190   virtual AppCacheStatus GetStatus(int host_id) = 0;
    191   virtual bool StartUpdate(int host_id) = 0;
    192   virtual bool SwapCache(int host_id) = 0;
    193   virtual void GetResourceList(
    194       int host_id, std::vector<AppCacheResourceInfo>* resource_infos) = 0;
    195 
    196  protected:
    197   virtual ~AppCacheBackend() {}
    198 };
    199 
    200 // Useful string constants.
    201 // Note: These are also defined elsewhere in the chrome code base in
    202 // url_contants.h .cc, however the appcache library doesn't not have
    203 // any dependencies on the chrome library, so we can't use them in here.
    204 WEBKIT_STORAGE_COMMON_EXPORT extern const char kHttpScheme[];
    205 WEBKIT_STORAGE_COMMON_EXPORT extern const char kHttpsScheme[];
    206 WEBKIT_STORAGE_COMMON_EXPORT extern const char kHttpGETMethod[];
    207 WEBKIT_STORAGE_COMMON_EXPORT extern const char kHttpHEADMethod[];
    208 
    209 // CommandLine flag to turn this experimental feature on.
    210 WEBKIT_STORAGE_COMMON_EXPORT extern const char kEnableExecutableHandlers[];
    211 
    212 WEBKIT_STORAGE_COMMON_EXPORT bool IsSchemeSupported(const GURL& url);
    213 WEBKIT_STORAGE_COMMON_EXPORT bool IsMethodSupported(const std::string& method);
    214 WEBKIT_STORAGE_COMMON_EXPORT bool IsSchemeAndMethodSupported(
    215     const net::URLRequest* request);
    216 
    217 WEBKIT_STORAGE_COMMON_EXPORT extern const base::FilePath::CharType
    218     kAppCacheDatabaseName[];
    219 
    220 }  // namespace
    221 
    222 #endif  // WEBKIT_COMMON_APPCACHE_APPCACHE_INTERFACES_H_
    223