src/content/browser/appcache/appcache_host.h

   1 // Copyright (c) 2011 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 CONTENT_BROWSER_APPCACHE_APPCACHE_HOST_H_
   6 #define CONTENT_BROWSER_APPCACHE_APPCACHE_HOST_H_
   7
   8 #include "base/callback.h"
   9 #include "base/gtest_prod_util.h"
  10 #include "base/memory/ref_counted.h"
  11 #include "base/observer_list.h"
  12 #include "content/browser/appcache/appcache_group.h"
  13 #include "content/browser/appcache/appcache_service_impl.h"
  14 #include "content/browser/appcache/appcache_storage.h"
  15 #include "content/common/appcache_interfaces.h"
  16 #include "content/common/content_export.h"
  17 #include "content/public/common/resource_type.h"
  18 #include "url/gurl.h"
  19
  20 namespace net {
  21 class URLRequest;
  22 }  // namespace net
  23
  24 namespace content {
  25 FORWARD_DECLARE_TEST(AppCacheGroupTest, CleanupUnusedGroup);
  26 FORWARD_DECLARE_TEST(AppCacheGroupTest, QueueUpdate);
  27 FORWARD_DECLARE_TEST(AppCacheHostTest, Basic);
  28 FORWARD_DECLARE_TEST(AppCacheHostTest, SelectNoCache);
  29 FORWARD_DECLARE_TEST(AppCacheHostTest, ForeignEntry);
  30 FORWARD_DECLARE_TEST(AppCacheHostTest, FailedCacheLoad);
  31 FORWARD_DECLARE_TEST(AppCacheHostTest, FailedGroupLoad);
  32 FORWARD_DECLARE_TEST(AppCacheHostTest, SetSwappableCache);
  33 FORWARD_DECLARE_TEST(AppCacheHostTest, ForDedicatedWorker);
  34 FORWARD_DECLARE_TEST(AppCacheHostTest, SelectCacheAllowed);
  35 FORWARD_DECLARE_TEST(AppCacheHostTest, SelectCacheBlocked);
  36 FORWARD_DECLARE_TEST(AppCacheTest, CleanupUnusedCache);
  37 class AppCache;
  38 class AppCacheFrontend;
  39 class AppCacheGroupTest;
  40 class AppCacheHostTest;
  41 class AppCacheRequestHandler;
  42 class AppCacheRequestHandlerTest;
  43 class AppCacheStorageImplTest;
  44 class AppCacheTest;
  45 class AppCacheUpdateJobTest;
  46
  47 typedef base::Callback<void(AppCacheStatus, void*)> GetStatusCallback;
  48 typedef base::Callback<void(bool, void*)> StartUpdateCallback;
  49 typedef base::Callback<void(bool, void*)> SwapCacheCallback;
  50
  51 // Server-side representation of an application cache host.
  52 class CONTENT_EXPORT AppCacheHost
  53     : public AppCacheStorage::Delegate,
  54       public AppCacheGroup::UpdateObserver,
  55       public AppCacheServiceImpl::Observer {
  56  public:
  57
  58   class CONTENT_EXPORT Observer {
  59    public:
  60     // Called just after the cache selection algorithm completes.
  61     virtual void OnCacheSelectionComplete(AppCacheHost* host) = 0;
  62
  63     // Called just prior to the instance being deleted.
  64     virtual void OnDestructionImminent(AppCacheHost* host) = 0;
  65
  66     virtual ~Observer() {}
  67   };
  68
  69   AppCacheHost(int host_id, AppCacheFrontend* frontend,
  70                AppCacheServiceImpl* service);
  71   ~AppCacheHost() override;
  72
  73   // Adds/removes an observer, the AppCacheHost does not take
  74   // ownership of the observer.
  75   void AddObserver(Observer* observer);
  76   void RemoveObserver(Observer* observer);
  77
  78   // Support for cache selection and scriptable method calls.
  79   void SelectCache(const GURL& document_url,
  80                    const int64 cache_document_was_loaded_from,
  81                    const GURL& manifest_url);
  82   void SelectCacheForWorker(int parent_process_id,
  83                             int parent_host_id);
  84   void SelectCacheForSharedWorker(int64 appcache_id);
  85   void MarkAsForeignEntry(const GURL& document_url,
  86                           int64 cache_document_was_loaded_from);
  87   void GetStatusWithCallback(const GetStatusCallback& callback,
  88                              void* callback_param);
  89   void StartUpdateWithCallback(const StartUpdateCallback& callback,
  90                                void* callback_param);
  91   void SwapCacheWithCallback(const SwapCacheCallback& callback,
  92                              void* callback_param);
  93
  94   // Called prior to the main resource load. When the system contains multiple
  95   // candidates for a main resource load, the appcache preferred by the host
  96   // that created this host is used to break ties.
  97   void SetSpawningHostId(int spawning_process_id, int spawning_host_id);
  98
  99   // May return NULL if the spawning host context has been closed, or if a
 100   // spawning host context was never identified.
 101   const AppCacheHost* GetSpawningHost() const;
 102
 103   const GURL& preferred_manifest_url() const {
 104     return preferred_manifest_url_;
 105   }
 106   void set_preferred_manifest_url(const GURL& url) {
 107     preferred_manifest_url_ = url;
 108   }
 109
 110   // Support for loading resources out of the appcache.
 111   // May return NULL if the request isn't subject to retrieval from an appache.
 112   AppCacheRequestHandler* CreateRequestHandler(
 113       net::URLRequest* request,
 114       ResourceType resource_type);
 115
 116   // Support for devtools inspecting appcache resources.
 117   void GetResourceList(std::vector<AppCacheResourceInfo>* resource_infos);
 118
 119   // Breaks any existing association between this host and a cache.
 120   // 'manifest_url' is sent to DevTools as the manifest url that could have
 121   // been associated before or could be associated later with this host.
 122   // Associations are broken either thru the cache selection algorithm
 123   // implemented in this class, or by the update algorithm (see
 124   // AppCacheUpdateJob).
 125   void AssociateNoCache(const GURL& manifest_url);
 126
 127   // Establishes an association between this host and an incomplete cache.
 128   // 'manifest_url' is manifest url of the cache group being updated.
 129   // Associations with incomplete caches are established by the update algorithm
 130   // (see AppCacheUpdateJob).
 131   void AssociateIncompleteCache(AppCache* cache, const GURL& manifest_url);
 132
 133   // Establishes an association between this host and a complete cache.
 134   // Associations with complete caches are established either thru the cache
 135   // selection algorithm implemented (in this class), or by the update algorithm
 136   // (see AppCacheUpdateJob).
 137   void AssociateCompleteCache(AppCache* cache);
 138
 139   // Adds a reference to the newest complete cache in a group, unless it's the
 140   // same as the cache that is currently associated with the host.
 141   void SetSwappableCache(AppCacheGroup* group);
 142
 143   // Used to ensure that a loaded appcache survives a frame navigation.
 144   void LoadMainResourceCache(int64 cache_id);
 145
 146   // Used to notify the host that a namespace resource is being delivered as
 147   // the main resource of the page and to provide its url.
 148   void NotifyMainResourceIsNamespaceEntry(const GURL& namespace_entry_url);
 149
 150   // Used to notify the host that the main resource was blocked by a policy. To
 151   // work properly, this method needs to by invoked prior to cache selection.
 152   void NotifyMainResourceBlocked(const GURL& manifest_url);
 153
 154   // Used by the update job to keep track of which hosts are associated
 155   // with which pending master entries.
 156   const GURL& pending_master_entry_url() const {
 157     return new_master_entry_url_;
 158   }
 159
 160   int host_id() const { return host_id_; }
 161   AppCacheServiceImpl* service() const { return service_; }
 162   AppCacheStorage* storage() const { return storage_; }
 163   AppCacheFrontend* frontend() const { return frontend_; }
 164   AppCache* associated_cache() const { return associated_cache_.get(); }
 165
 166   void enable_cache_selection(bool enable) {
 167     is_cache_selection_enabled_ = enable;
 168   }
 169
 170   bool is_selection_pending() const {
 171     return pending_selected_cache_id_ != kAppCacheNoCacheId ||
 172            !pending_selected_manifest_url_.is_empty();
 173   }
 174
 175   const GURL& first_party_url() const { return first_party_url_; }
 176
 177   // Methods to support cross site navigations.
 178   void PrepareForTransfer();
 179   void CompleteTransfer(int host_id, AppCacheFrontend* frontend);
 180
 181  private:
 182   friend class content::AppCacheHostTest;
 183   friend class content::AppCacheStorageImplTest;
 184   friend class content::AppCacheRequestHandlerTest;
 185   friend class content::AppCacheUpdateJobTest;
 186
 187   AppCacheStatus GetStatus();
 188   void LoadSelectedCache(int64 cache_id);
 189   void LoadOrCreateGroup(const GURL& manifest_url);
 190
 191   // See public Associate*Host() methods above.
 192   void AssociateCacheHelper(AppCache* cache, const GURL& manifest_url);
 193
 194   // AppCacheStorage::Delegate impl
 195   void OnCacheLoaded(AppCache* cache, int64 cache_id) override;
 196   void OnGroupLoaded(AppCacheGroup* group, const GURL& manifest_url) override;
 197   // AppCacheServiceImpl::Observer impl
 198   void OnServiceReinitialized(
 199       AppCacheStorageReference* old_storage_ref) override;
 200
 201   void FinishCacheSelection(AppCache* cache, AppCacheGroup* group);
 202   void DoPendingGetStatus();
 203   void DoPendingStartUpdate();
 204   void DoPendingSwapCache();
 205
 206   void ObserveGroupBeingUpdated(AppCacheGroup* group);
 207
 208   // AppCacheGroup::UpdateObserver methods.
 209   void OnUpdateComplete(AppCacheGroup* group) override;
 210
 211   // Returns true if this host is for a dedicated worker context.
 212   bool is_for_dedicated_worker() const {
 213     return parent_host_id_ != kAppCacheNoHostId;
 214   }
 215
 216   // Returns the parent context's host instance. This is only valid
 217   // to call when this instance is_for_dedicated_worker.
 218   AppCacheHost* GetParentAppCacheHost() const;
 219
 220   // Identifies the corresponding appcache host in the child process.
 221   int host_id_;
 222
 223   // Information about the host that created this one; the manifest
 224   // preferred by our creator influences which cache our main resource
 225   // should be loaded from.
 226   int spawning_host_id_;
 227   int spawning_process_id_;
 228   GURL preferred_manifest_url_;
 229
 230   // Hosts for dedicated workers are special cased to shunt
 231   // request handling off to the dedicated worker's parent.
 232   // The scriptable api is not accessible in dedicated workers
 233   // so the other aspects of this class are not relevant for
 234   // these special case instances.
 235   int parent_host_id_;
 236   int parent_process_id_;
 237
 238   // Defined prior to refs to AppCaches and Groups because destruction
 239   // order matters, the disabled_storage_reference_ must outlive those
 240   // objects. See additional comments for the storage_ member.
 241   scoped_refptr<AppCacheStorageReference> disabled_storage_reference_;
 242
 243   // The cache associated with this host, if any.
 244   scoped_refptr<AppCache> associated_cache_;
 245
 246   // Hold a reference to the newest complete cache (if associated cache is
 247   // not the newest) to keep the newest cache in existence while the app cache
 248   // group is in use. The newest complete cache may have no associated hosts
 249   // holding any references to it and would otherwise be deleted prematurely.
 250   scoped_refptr<AppCache> swappable_cache_;
 251
 252   // Keep a reference to the group being updated until the update completes.
 253   scoped_refptr<AppCacheGroup> group_being_updated_;
 254
 255   // Similarly, keep a reference to the newest cache of the group until the
 256   // update completes. When adding a new master entry to a cache that is not
 257   // in use in any other host, this reference keeps the cache in  memory.
 258   scoped_refptr<AppCache> newest_cache_of_group_being_updated_;
 259
 260   // Keep a reference to the cache of the main resource so it survives frame
 261   // navigations.
 262   scoped_refptr<AppCache> main_resource_cache_;
 263   int64 pending_main_resource_cache_id_;
 264
 265   // Cache loading is async, if we're loading a specific cache or group
 266   // for the purposes of cache selection, one or the other of these will
 267   // indicate which cache or group is being loaded.
 268   int64 pending_selected_cache_id_;
 269   GURL pending_selected_manifest_url_;
 270
 271   // Used to avoid stepping on pages controlled by ServiceWorkers.
 272   bool is_cache_selection_enabled_;
 273
 274   // A new master entry to be added to the cache, may be empty.
 275   GURL new_master_entry_url_;
 276
 277   // The frontend proxy to deliver notifications to the child process.
 278   AppCacheFrontend* frontend_;
 279
 280   // Our central service object.
 281   AppCacheServiceImpl* service_;
 282
 283   // And the equally central storage object, with a twist. In some error
 284   // conditions the storage object gets recreated and reinitialized. The
 285   // disabled_storage_reference_ (defined earlier) allows for cleanup of an
 286   // instance that got disabled  after we had latched onto it. In normal
 287   // circumstances, disabled_storage_reference_ is expected to be NULL.
 288   // When non-NULL both storage_ and disabled_storage_reference_ refer to the
 289   // same instance.
 290   AppCacheStorage* storage_;
 291
 292   // Since these are synchronous scriptable API calls in the client, there can
 293   // only be one type of callback pending. Also, we have to wait until we have a
 294   // cache selection prior to responding to these calls, as cache selection
 295   // involves async loading of a cache or a group from storage.
 296   GetStatusCallback pending_get_status_callback_;
 297   StartUpdateCallback pending_start_update_callback_;
 298   SwapCacheCallback pending_swap_cache_callback_;
 299   void* pending_callback_param_;
 300
 301   // True if an intercept or fallback namespace resource was
 302   // delivered as the main resource.
 303   bool main_resource_was_namespace_entry_;
 304   GURL namespace_entry_url_;
 305
 306   // True if requests for this host were blocked by a policy.
 307   bool main_resource_blocked_;
 308   GURL blocked_manifest_url_;
 309
 310   // Tells if info about associated cache is pending. Info is pending
 311   // when update job has not returned success yet.
 312   bool associated_cache_info_pending_;
 313
 314   // List of objects observing us.
 315   ObserverList<Observer> observers_;
 316
 317   // Used to inform the QuotaManager of what origins are currently in use.
 318   GURL origin_in_use_;
 319
 320   // First party url to be used in policy checks.
 321   GURL first_party_url_;
 322
 323   FRIEND_TEST_ALL_PREFIXES(content::AppCacheGroupTest, CleanupUnusedGroup);
 324   FRIEND_TEST_ALL_PREFIXES(content::AppCacheGroupTest, QueueUpdate);
 325   FRIEND_TEST_ALL_PREFIXES(content::AppCacheHostTest, Basic);
 326   FRIEND_TEST_ALL_PREFIXES(content::AppCacheHostTest, SelectNoCache);
 327   FRIEND_TEST_ALL_PREFIXES(content::AppCacheHostTest, ForeignEntry);
 328   FRIEND_TEST_ALL_PREFIXES(content::AppCacheHostTest, FailedCacheLoad);
 329   FRIEND_TEST_ALL_PREFIXES(content::AppCacheHostTest, FailedGroupLoad);
 330   FRIEND_TEST_ALL_PREFIXES(content::AppCacheHostTest, SetSwappableCache);
 331   FRIEND_TEST_ALL_PREFIXES(content::AppCacheHostTest, ForDedicatedWorker);
 332   FRIEND_TEST_ALL_PREFIXES(content::AppCacheHostTest, SelectCacheAllowed);
 333   FRIEND_TEST_ALL_PREFIXES(content::AppCacheHostTest, SelectCacheBlocked);
 334   FRIEND_TEST_ALL_PREFIXES(content::AppCacheTest, CleanupUnusedCache);
 335
 336   DISALLOW_COPY_AND_ASSIGN(AppCacheHost);
 337 };
 338
 339 }  // namespace content
 340
 341 #endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_HOST_H_