Add support for subresource request loads in AppCache for the network service.

content/browser/appcache/appcache_request_handler.h

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef CONTENT_BROWSER_APPCACHE_APPCACHE_REQUEST_HANDLER_H_
 #define CONTENT_BROWSER_APPCACHE_APPCACHE_REQUEST_HANDLER_H_
 
 #include <stdint.h>
 
 #include <memory>
 
 #include "base/compiler_specific.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/supports_user_data.h"
 #include "content/browser/appcache/appcache_entry.h"
 #include "content/browser/appcache/appcache_host.h"
 #include "content/browser/appcache/appcache_service_impl.h"
+#include "content/browser/appcache/appcache_subresource_url_factory.h"
 #include "content/browser/loader/url_loader_request_handler.h"
 #include "content/browser/url_loader_factory_getter.h"
 #include "content/common/content_export.h"
 #include "content/public/common/resource_type.h"
 
 namespace net {
 class NetworkDelegate;
 class URLRequest;
 }  // namespace net
 
 namespace content {
 class AppCacheJob;
 class AppCacheNavigationHandleCore;
 class AppCacheRequest;
 class AppCacheRequestHandlerTest;
 class AppCacheURLRequestJob;
-struct ResourceRequest;
+class AppCacheHost;
 
 // An instance is created for each net::URLRequest. The instance survives all
 // http transactions involved in the processing of its net::URLRequest, and is
 // given the opportunity to hijack the request along the way. Callers
 // should use AppCacheHost::CreateRequestHandler to manufacture instances
 // that can retrieve resources for a particular host.
 class CONTENT_EXPORT AppCacheRequestHandler
     : public base::SupportsUserData::Data,
       public AppCacheHost::Observer,
       public AppCacheServiceImpl::Observer,
@@ skipping 27 matching lines @@
     return IsResourceTypeFrame(type) ||
            type == RESOURCE_TYPE_SHARED_WORKER;
   }
 
   static std::unique_ptr<AppCacheRequestHandler>
   InitializeForNavigationNetworkService(
       const ResourceRequest& request,
       AppCacheNavigationHandleCore* appcache_handle_core,
       URLLoaderFactoryGetter* url_loader_factory_getter);
 
+  // The following setters only apply for the network service code.
+  void set_network_url_loader_factory_getter(
+      URLLoaderFactoryGetter* url_loader_factory_getter) {
+    network_url_loader_factory_getter_ = url_loader_factory_getter;
+  }
+
+  void set_subresource_request_load_info(
+      std::unique_ptr<SubresourceLoadInfo> subresource_load_info) {
+    subresource_load_info_ = std::move(subresource_load_info);
+  }
+
  private:
   friend class AppCacheHost;
 
   // Callers should use AppCacheHost::CreateRequestHandler.
   AppCacheRequestHandler(AppCacheHost* host,
                          ResourceType resource_type,
                          bool should_reset_appcache,
                          std::unique_ptr<AppCacheRequest> request);
 
   // AppCacheHost::Observer override
@@ skipping 52 matching lines @@
 
   // AppCacheHost::Observer override
   void OnCacheSelectionComplete(AppCacheHost* host) override;
 
   // URLLoaderRequestHandler override
   void MaybeCreateLoader(const ResourceRequest& resource_request,
                          ResourceContext* resource_context,
                          LoaderCallback callback) override;
   mojom::URLLoaderFactoryPtr MaybeCreateSubresourceFactory() override;
 
-  void set_network_url_loader_factory_getter(
-      URLLoaderFactoryGetter* url_loader_factory_getter) {
-    network_url_loader_factory_getter_ = url_loader_factory_getter;
-  }
-
   // Data members -----------------------------------------------
 
   // What host we're servicing a request for.
   AppCacheHost* host_;
 
   // Frame vs subresource vs sharedworker loads are somewhat different.
   ResourceType resource_type_;
 
   // True if corresponding AppCache group should be resetted before load.
   bool should_reset_appcache_;
@@ skipping 40 matching lines @@
   // Cached information about the response being currently served by the
   // AppCache, if there is one.
   int cache_id_;
   GURL manifest_url_;
 
   // Backptr to the central service object.
   AppCacheServiceImpl* service_;
 
   std::unique_ptr<AppCacheRequest> request_;
 
+  // Network service related members.
+
   // In the network service world we are queried via the URLLoaderRequestHandler
   // interface to see if the navigation request can be handled via the
   // AppCache. We hold onto the AppCache job created here until the client
   // binds to it (Serviced via AppCache). If the request cannot be handled via
   // the AppCache, we delete the job.
   std::unique_ptr<AppCacheJob> navigation_request_job_;
 
   // In the network service world, points to the getter for the network URL
   // loader.
   scoped_refptr<URLLoaderFactoryGetter> network_url_loader_factory_getter_;
 
   friend class content::AppCacheRequestHandlerTest;
 
+  // Subresource load information.
+  std::unique_ptr<SubresourceLoadInfo> subresource_load_info_;
+
+  // The AppCache host instance. We pass this to the
+  // AppCacheSubresourceURLFactory instance on creation.
+  base::WeakPtr<AppCacheHost> appcache_host_;
+
   DISALLOW_COPY_AND_ASSIGN(AppCacheRequestHandler);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_REQUEST_HANDLER_H_