Provide skeleton functionality for AppCache handling in 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/common/content_export.h"
+#include "content/common/url_loader_factory.mojom.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;
+class ResourceContext;
 
 // 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 20 matching lines @@
   // 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;
   }
 
+  // PlzNavigate and --enable-network-service.
+  // Checks whether the |resource_request| can be served out of the AppCache
+  // and invokes the |callback| accordingly. If the request can be served
+  // out of the AppCache, we could return a URLLoaderFactory which can serve
+  // requests out of the AppCache to the callback, or we could create the
+  // loader right there. At this point we are leaning towards the latter.
+  static void InitializeForNavigationNetworkService(
+      std::unique_ptr<ResourceRequest> resource_request,
+      ResourceContext* resource_context,
+      AppCacheNavigationHandleCore* navigation_handle_core,
+      ResourceType resource_type,
+      base::Callback<void(mojom::URLLoaderFactoryPtrInfo,
+                          std::unique_ptr<ResourceRequest>)> callback);
+
  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 113 matching lines @@
 
   std::unique_ptr<AppCacheRequest> request_;
 
   friend class content::AppCacheRequestHandlerTest;
   DISALLOW_COPY_AND_ASSIGN(AppCacheRequestHandler);
 };
 
 }  // namespace content
 
 #endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_REQUEST_HANDLER_H_