Home | History | Annotate | Download | only in appcache 
      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 WEBKIT_BROWSER_APPCACHE_APPCACHE_REQUEST_HANDLER_H_
      6 #define WEBKIT_BROWSER_APPCACHE_APPCACHE_REQUEST_HANDLER_H_
      7 
      8 #include "base/compiler_specific.h"
      9 #include "base/supports_user_data.h"
     10 #include "webkit/browser/appcache/appcache_entry.h"
     11 #include "webkit/browser/appcache/appcache_host.h"
     12 #include "webkit/browser/webkit_storage_browser_export.h"
     13 #include "webkit/common/resource_type.h"
     14 
     15 namespace net {
     16 class NetworkDelegate;
     17 class URLRequest;
     18 class URLRequestJob;
     19 }  // namespace net
     20 
     21 namespace appcache {
     22 
     23 class AppCacheURLRequestJob;
     24 
     25 // An instance is created for each net::URLRequest. The instance survives all
     26 // http transactions involved in the processing of its net::URLRequest, and is
     27 // given the opportunity to hijack the request along the way. Callers
     28 // should use AppCacheHost::CreateRequestHandler to manufacture instances
     29 // that can retrieve resources for a particular host.
     30 class WEBKIT_STORAGE_BROWSER_EXPORT AppCacheRequestHandler
     31     : public base::SupportsUserData::Data,
     32       public AppCacheHost::Observer,
     33       public AppCacheStorage::Delegate  {
     34  public:
     35   virtual ~AppCacheRequestHandler();
     36 
     37   // These are called on each request intercept opportunity.
     38   AppCacheURLRequestJob* MaybeLoadResource(
     39       net::URLRequest* request, net::NetworkDelegate* network_delegate);
     40   AppCacheURLRequestJob* MaybeLoadFallbackForRedirect(
     41       net::URLRequest* request,
     42       net::NetworkDelegate* network_delegate,
     43       const GURL& location);
     44   AppCacheURLRequestJob* MaybeLoadFallbackForResponse(
     45       net::URLRequest* request, net::NetworkDelegate* network_delegate);
     46 
     47   void GetExtraResponseInfo(int64* cache_id, GURL* manifest_url);
     48 
     49   // Methods to support cross site navigations.
     50   void PrepareForCrossSiteTransfer(int old_process_id);
     51   void CompleteCrossSiteTransfer(int new_process_id, int new_host_id);
     52 
     53   static bool IsMainResourceType(ResourceType::Type type) {
     54     return ResourceType::IsFrame(type) ||
     55            ResourceType::IsSharedWorker(type);
     56   }
     57 
     58  private:
     59   friend class AppCacheHost;
     60 
     61   // Callers should use AppCacheHost::CreateRequestHandler.
     62   AppCacheRequestHandler(AppCacheHost* host, ResourceType::Type resource_type);
     63 
     64   // AppCacheHost::Observer override
     65   virtual void OnDestructionImminent(AppCacheHost* host) OVERRIDE;
     66 
     67   // Helpers to instruct a waiting job with what response to
     68   // deliver for the request we're handling.
     69   void DeliverAppCachedResponse(const AppCacheEntry& entry, int64 cache_id,
     70                                 int64 group_id, const GURL& manifest_url,
     71                                 bool is_fallback,
     72                                 const GURL& namespace_entry_url);
     73   void DeliverNetworkResponse();
     74   void DeliverErrorResponse();
     75 
     76   // Helper to retrieve a pointer to the storage object.
     77   AppCacheStorage* storage() const;
     78 
     79   bool is_main_resource() const {
     80     return IsMainResourceType(resource_type_);
     81   }
     82 
     83   // Main-resource loading -------------------------------------
     84   // Frame and SharedWorker main resources are handled here.
     85 
     86   void MaybeLoadMainResource(net::URLRequest* request,
     87                              net::NetworkDelegate* network_delegate);
     88 
     89   // AppCacheStorage::Delegate methods
     90   virtual void OnMainResponseFound(
     91       const GURL& url, const AppCacheEntry& entry,
     92       const GURL& fallback_url, const AppCacheEntry& fallback_entry,
     93       int64 cache_id, int64 group_id, const GURL& mainfest_url) OVERRIDE;
     94 
     95   // Sub-resource loading -------------------------------------
     96   // Dedicated worker and all manner of sub-resources are handled here.
     97 
     98   void MaybeLoadSubResource(net::URLRequest* request,
     99                             net::NetworkDelegate* network_delegate);
    100   void ContinueMaybeLoadSubResource();
    101 
    102   // AppCacheHost::Observer override
    103   virtual void OnCacheSelectionComplete(AppCacheHost* host) OVERRIDE;
    104 
    105   // Data members -----------------------------------------------
    106 
    107   // What host we're servicing a request for.
    108   AppCacheHost* host_;
    109 
    110   // Frame vs subresource vs sharedworker loads are somewhat different.
    111   ResourceType::Type resource_type_;
    112 
    113   // Subresource requests wait until after cache selection completes.
    114   bool is_waiting_for_cache_selection_;
    115 
    116   // Info about the type of response we found for delivery.
    117   // These are relevant for both main and subresource requests.
    118   int64 found_group_id_;
    119   int64 found_cache_id_;
    120   AppCacheEntry found_entry_;
    121   AppCacheEntry found_fallback_entry_;
    122   GURL found_namespace_entry_url_;
    123   GURL found_manifest_url_;
    124   bool found_network_namespace_;
    125 
    126   // True if a cache entry this handler attempted to return was
    127   // not found in the disk cache. Once set, the handler will take
    128   // no action on all subsequent intercept opportunities, so the
    129   // request and any redirects will be handled by the network library.
    130   bool cache_entry_not_found_;
    131 
    132   // True if this->MaybeLoadResource(...) has been called in the past.
    133   bool maybe_load_resource_executed_;
    134 
    135   // The job we use to deliver a response.
    136   scoped_refptr<AppCacheURLRequestJob> job_;
    137 
    138   // During a cross site navigation, we transfer ownership the AppcacheHost
    139   // from the old processes structures over to the new structures.
    140   scoped_ptr<AppCacheHost> host_for_cross_site_transfer_;
    141 
    142   friend class AppCacheRequestHandlerTest;
    143   DISALLOW_COPY_AND_ASSIGN(AppCacheRequestHandler);
    144 };
    145 
    146 }  // namespace appcache
    147 
    148 #endif  // WEBKIT_BROWSER_APPCACHE_APPCACHE_REQUEST_HANDLER_H_
    149