Get main frame and subframe AppCache loads to work.

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/loader/url_loader_request_handler.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 URLLoaderFactoryGetter;
 
 // 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,
-      public AppCacheStorage::Delegate {
+      public AppCacheStorage::Delegate,
+      public URLLoaderRequestHandler {
  public:
   ~AppCacheRequestHandler() override;
 
   // These are called on each request intercept opportunity.
   AppCacheJob* MaybeLoadResource(net::NetworkDelegate* network_delegate);
   AppCacheJob* MaybeLoadFallbackForRedirect(
       net::NetworkDelegate* network_delegate,
       const GURL& location);
   AppCacheJob* MaybeLoadFallbackForResponse(
       net::NetworkDelegate* network_delegate);
 
   void GetExtraResponseInfo(int64_t* cache_id, GURL* manifest_url);
 
   // Methods to support cross site navigations.
   void PrepareForCrossSiteTransfer(int old_process_id);
   void CompleteCrossSiteTransfer(int new_process_id, int new_host_id);
   void MaybeCompleteCrossSiteTransferInOldProcess(int old_process_id);
 
   // Useful for detecting storage partition mismatches in the context
   // of cross site transfer navigations.
   bool SanityCheckIsSameService(AppCacheService* service) {
     return !host_ || (host_->service() == service);
   }
 
   static bool IsMainResourceType(ResourceType type) {
     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);
+
  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 46 matching lines @@
   // Sub-resource loading -------------------------------------
   // Dedicated worker and all manner of sub-resources are handled here.
 
   std::unique_ptr<AppCacheJob> MaybeLoadSubResource(
       net::NetworkDelegate* network_delegate);
   void ContinueMaybeLoadSubResource();
 
   // AppCacheHost::Observer override
   void OnCacheSelectionComplete(AppCacheHost* host) override;
 
+  // URLLoaderRequestHandler override
+  void MaybeCreateLoaderFactory(const ResourceRequest& resource_request,
+                                ResourceContext* resource_context,
+                                LoaderFactoryCallback callback) override;
+
   // 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_;
 
+  // In the network service world we are queried via the URLLoaderRequestHandler
+  // interface to see if the navigation request can be serviced 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 serviced via

[jam, 2017/06/07 01:42:17]

nit: just to make things a bit clearer, s/serviced/handled by, since service
means so many things now :)

[ananta, 2017/06/07 20:57:16]

Done.

+  // the AppCache, we delete the job.
+  std::unique_ptr<AppCacheJob> navigation_request_job_;
+
+  // The Callback to be invoked in the network service land to indicate if
+  // the request can be serviced via the AppCache.
+  LoaderFactoryCallback loader_factory_callback_;
+
+  // In network service world used to to get the default network service.
+  scoped_refptr<URLLoaderFactoryGetter> url_loader_factory_getter_;

[michaeln, 2017/06/07 02:53:45]

Why is this needed? Is this due to the lifetime issue you mentioned? where the
appcacheloader needed to keep it alive due to the associated message pipe stuff?

If so, this seems like something that should be taken care of at a higher level,
otherwise each possible class of loader has to do this. If this doesn't get
resolved by not using associated loaders, I'd vote to hoist responsibility for
this into the NavigationURLLoaderNetworkService class.

[ananta, 2017/06/07 20:57:16]

This is currently being used to invoke the default service.

+
+  mojom::URLLoaderFactoryPtr appcache_factory_;
+
   friend class content::AppCacheRequestHandlerTest;
   DISALLOW_COPY_AND_ASSIGN(AppCacheRequestHandler);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_REQUEST_HANDLER_H_