Reduce/Remove URLRequest dependencies from AppCacheRequestHandler

The AppCacheRequestHandler class provides functionality for serving network requests from
the AppCache if applicable. This class is instantiated by the AppCacheInterceptor when a network request
is initiated. Its lifetime depends on the associated URLRequest.

The plan is to reuse this class in the network service world where we won't be intercepting
network requests in the browser process. This effectively means that there won't be any URLRequest as well

To achieve this the proposal is to provide an abstraction for a request called AppCachRequest. This class
will have two subclasses at the moment. AppCacheURLRequest and AppCacheURLLoaderRequest. The AppCacheURLRequest
class will be used by the current network implementation which relies on intercepting n/w requests.

The AppCacheURLLoaderRequest class will be used by the network service mojo implementation.
Next step is to provide an abstraction for the AppCacheURLRequestJob class.

BUG=715632
TBR=jam

Review-Url: https://codereview.chromium.org/2848493007
Cr-Commit-Position: refs/heads/master@{#469254}

content/browser/BUILD.gn

@@ -311,6 +311,8 @@ source_set("browser") {
     "appcache/appcache_policy.h",
     "appcache/appcache_quota_client.cc",
     "appcache/appcache_quota_client.h",
+    "appcache/appcache_request.cc",
+    "appcache/appcache_request.h",
     "appcache/appcache_request_handler.cc",
     "appcache/appcache_request_handler.h",
     "appcache/appcache_response.cc",
@@ -323,6 +325,10 @@ source_set("browser") {
     "appcache/appcache_storage_impl.h",
     "appcache/appcache_update_job.cc",
     "appcache/appcache_update_job.h",
+    "appcache/appcache_url_loader_request.cc",
+    "appcache/appcache_url_loader_request.h",
+    "appcache/appcache_url_request.cc",
+    "appcache/appcache_url_request.h",
     "appcache/appcache_url_request_job.cc",
     "appcache/appcache_url_request_job.h",
     "appcache/appcache_working_set.cc",

content/browser/appcache/appcache_host.cc

@@ -11,6 +11,7 @@
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_backend_impl.h"
 #include "content/browser/appcache/appcache_policy.h"
+#include "content/browser/appcache/appcache_request.h"
 #include "content/browser/appcache/appcache_request_handler.h"
 #include "net/url_request/url_request.h"
 #include "storage/browser/quota/quota_manager_proxy.h"
@@ -312,29 +313,29 @@ AppCacheHost* AppCacheHost::GetParentAppCacheHost() const {
 }
 
 std::unique_ptr<AppCacheRequestHandler> AppCacheHost::CreateRequestHandler(
-    net::URLRequest* request,
+    std::unique_ptr<AppCacheRequest> request,
     ResourceType resource_type,
     bool should_reset_appcache) {
   if (is_for_dedicated_worker()) {
     AppCacheHost* parent_host = GetParentAppCacheHost();
     if (parent_host)
       return parent_host->CreateRequestHandler(
-          request, resource_type, should_reset_appcache);
+          std::move(request), resource_type, should_reset_appcache);
     return NULL;
   }
 
   if (AppCacheRequestHandler::IsMainResourceType(resource_type)) {
     // Store the first party origin so that it can be used later in SelectCache
     // for checking whether the creation of the appcache is allowed.
-    first_party_url_ = request->first_party_for_cookies();
-    return base::WrapUnique(
-        new AppCacheRequestHandler(this, resource_type, should_reset_appcache));
+    first_party_url_ = request->GetFirstPartyForCookies();
+    return base::WrapUnique(new AppCacheRequestHandler(
+        this, resource_type, should_reset_appcache, std::move(request)));
   }
 
   if ((associated_cache() && associated_cache()->is_complete()) ||
       is_selection_pending()) {
-    return base::WrapUnique(
-        new AppCacheRequestHandler(this, resource_type, should_reset_appcache));
+    return base::WrapUnique(new AppCacheRequestHandler(
+        this, resource_type, should_reset_appcache, std::move(request)));
   }
   return NULL;
 }

content/browser/appcache/appcache_host.h

@@ -44,6 +44,7 @@ class AppCache;
 class AppCacheFrontend;
 class AppCacheGroupTest;
 class AppCacheHostTest;
+class AppCacheRequest;
 class AppCacheRequestHandler;
 class AppCacheRequestHandlerTest;
 class AppCacheStorageImplTest;
@@ -116,7 +117,7 @@ class CONTENT_EXPORT AppCacheHost
   // Support for loading resources out of the appcache.
   // May return NULL if the request isn't subject to retrieval from an appache.
   std::unique_ptr<AppCacheRequestHandler> CreateRequestHandler(
-      net::URLRequest* request,
+      std::unique_ptr<AppCacheRequest> request,
       ResourceType resource_type,
       bool should_reset_appcache);
 

content/browser/appcache/appcache_interceptor.cc

@@ -11,6 +11,7 @@
 #include "content/browser/appcache/appcache_host.h"
 #include "content/browser/appcache/appcache_request_handler.h"
 #include "content/browser/appcache/appcache_service_impl.h"
+#include "content/browser/appcache/appcache_url_request.h"
 #include "content/browser/appcache/appcache_url_request_job.h"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/bad_message.h"
@@ -65,7 +66,8 @@ void AppCacheInterceptor::SetExtraRequestInfoForHost(
     bool should_reset_appcache) {
   // Create a handler for this request and associate it with the request.
   std::unique_ptr<AppCacheRequestHandler> handler =
-      host->CreateRequestHandler(request, resource_type, should_reset_appcache);
+      host->CreateRequestHandler(AppCacheURLRequest::Create(request),
+                                 resource_type, should_reset_appcache);
   if (handler)
     SetHandler(request, std::move(handler));
 }
@@ -141,7 +143,7 @@ net::URLRequestJob* AppCacheInterceptor::MaybeInterceptRequest(
   AppCacheRequestHandler* handler = GetHandler(request);
   if (!handler)
     return NULL;
-  return handler->MaybeLoadResource(request, network_delegate);
+  return handler->MaybeLoadResource(network_delegate);
 }
 
 net::URLRequestJob* AppCacheInterceptor::MaybeInterceptRedirect(
@@ -151,8 +153,7 @@ net::URLRequestJob* AppCacheInterceptor::MaybeInterceptRedirect(
   AppCacheRequestHandler* handler = GetHandler(request);
   if (!handler)
     return NULL;
-  return handler->MaybeLoadFallbackForRedirect(
-      request, network_delegate, location);
+  return handler->MaybeLoadFallbackForRedirect(network_delegate, location);
 }
 
 net::URLRequestJob* AppCacheInterceptor::MaybeInterceptResponse(
@@ -160,7 +161,7 @@ net::URLRequestJob* AppCacheInterceptor::MaybeInterceptResponse(
   AppCacheRequestHandler* handler = GetHandler(request);
   if (!handler)
     return NULL;
-  return handler->MaybeLoadFallbackForResponse(request, network_delegate);
+  return handler->MaybeLoadFallbackForResponse(network_delegate);
 }
 
 }  // namespace content

content/browser/appcache/appcache_request.cc

+// Copyright (c) 2017 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.
+
+#include "content/browser/appcache/appcache_request.h"
+#include "content/common/appcache_interfaces.h"
+#include "net/url_request/url_request.h"
+
+namespace content {
+
+// static
+bool AppCacheRequest::IsSchemeAndMethodSupportedForAppCache(
+    const AppCacheRequest* request) {
+  return IsSchemeSupportedForAppCache(request->GetURL()) &&
+         IsMethodSupportedForAppCache(request->GetMethod());
+}
+
+net::URLRequest* AppCacheRequest::GetURLRequest() {
+  return nullptr;
+}
+
+ResourceRequest* AppCacheRequest::GetResourceRequest() {
+  return nullptr;
+}
+
+}  // namespace content

content/browser/appcache/appcache_request.h

+// Copyright (c) 2017 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_H_
+#define CONTENT_BROWSER_APPCACHE_APPCACHE_REQUEST_H_
+
+#include "base/logging.h"
+#include "base/strings/string16.h"
+#include "base/threading/non_thread_safe.h"
+#include "content/common/content_export.h"
+#include "url/gurl.h"
+
+namespace net {
+class URLRequest;
+}
+
+namespace content {
+struct ResourceRequest;
+
+// Interface for an AppCache request. Subclasses implement this interface to
+// wrap custom request objects like URLRequest, etc to ensure that these
+// dependencies stay out of the AppCache code.
+class CONTENT_EXPORT AppCacheRequest
+    : NON_EXPORTED_BASE(public base::NonThreadSafe) {
+ public:
+  virtual ~AppCacheRequest() {}
+
+  // The URL for this request.
+  virtual const GURL& GetURL() const = 0;
+
+  // The method for this request
+  virtual const std::string& GetMethod() const = 0;
+
+  // Used for cookie policy.
+  virtual const GURL& GetFirstPartyForCookies() const = 0;
+
+  // The referrer for this request.
+  virtual const GURL GetReferrer() const = 0;
+
+  // Returns true if the request was successful.
+  virtual bool IsSuccess() const = 0;
+
+  // Returns true if the request was cancelled.
+  virtual bool IsCancelled() const = 0;
+
+  // Returns true if the request had an error.
+  virtual bool IsError() const = 0;
+
+  // Returns the HTTP response code.
+  virtual int GetResponseCode() const = 0;
+
+  // Get response header(s) by name. Returns an empty string if the header
+  // wasn't found,
+  virtual std::string GetResponseHeaderByName(
+      const std::string& name) const = 0;
+
+  // Returns true if the scheme and method are supported for AppCache.
+  static bool IsSchemeAndMethodSupportedForAppCache(
+      const AppCacheRequest* request);
+
+ protected:
+  friend class AppCacheRequestHandler;
+
+  AppCacheRequest() {}
+
+  // Getters for the request types we currently support.
+  virtual net::URLRequest* GetURLRequest();
+
+  // Returns the underlying ResourceRequest. Please note that only one of
+  // GetURLRequest() and GetResourceRequest() should return valid results.
+  virtual ResourceRequest* GetResourceRequest();
+
+  DISALLOW_COPY_AND_ASSIGN(AppCacheRequest);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_REQUEST_H_

content/browser/appcache/appcache_request_handler.cc

@@ -10,6 +10,7 @@
 #include "content/browser/appcache/appcache.h"
 #include "content/browser/appcache/appcache_backend_impl.h"
 #include "content/browser/appcache/appcache_policy.h"
+#include "content/browser/appcache/appcache_request.h"
 #include "content/browser/appcache/appcache_url_request_job.h"
 #include "content/browser/service_worker/service_worker_request_handler.h"
 #include "net/url_request/url_request.h"
@@ -17,9 +18,11 @@
 
 namespace content {
 
-AppCacheRequestHandler::AppCacheRequestHandler(AppCacheHost* host,
-                                               ResourceType resource_type,
-                                               bool should_reset_appcache)
+AppCacheRequestHandler::AppCacheRequestHandler(
+    AppCacheHost* host,
+    ResourceType resource_type,
+    bool should_reset_appcache,
+    std::unique_ptr<AppCacheRequest> request)
     : host_(host),
       resource_type_(resource_type),
       should_reset_appcache_(should_reset_appcache),
@@ -33,7 +36,8 @@ AppCacheRequestHandler::AppCacheRequestHandler(AppCacheHost* host,
       old_process_id_(0),
       old_host_id_(kAppCacheNoHostId),
       cache_id_(kAppCacheNoCacheId),
-      service_(host_->service()) {
+      service_(host_->service()),
+      request_(std::move(request)) {
   DCHECK(host_);
   DCHECK(service_);
   host_->AddObserver(this);
@@ -55,10 +59,10 @@ AppCacheStorage* AppCacheRequestHandler::storage() const {
 }
 
 AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadResource(
-    net::URLRequest* request,
     net::NetworkDelegate* network_delegate) {
   maybe_load_resource_executed_ = true;
-  if (!host_ || !IsSchemeAndMethodSupportedForAppCache(request) ||
+  if (!host_ ||
+      !AppCacheRequest::IsSchemeAndMethodSupportedForAppCache(request_.get()) ||
       cache_entry_not_found_) {
     return NULL;
   }
@@ -85,9 +89,9 @@ AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadResource(
 
   std::unique_ptr<AppCacheURLRequestJob> job;
   if (is_main_resource())
-    job = MaybeLoadMainResource(request, network_delegate);
+    job = MaybeLoadMainResource(network_delegate);
   else
-    job = MaybeLoadSubResource(request, network_delegate);
+    job = MaybeLoadSubResource(network_delegate);
 
   // If its been setup to deliver a network response, we can just delete
   // it now and return NULL instead to achieve that since it couldn't
@@ -101,10 +105,10 @@ AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadResource(
 }
 
 AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadFallbackForRedirect(
-    net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
     const GURL& location) {
-  if (!host_ || !IsSchemeAndMethodSupportedForAppCache(request) ||
+  if (!host_ ||
+      !AppCacheRequest::IsSchemeAndMethodSupportedForAppCache(request_.get()) ||
       cache_entry_not_found_)
     return NULL;
   if (is_main_resource())
@@ -113,7 +117,7 @@ AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadFallbackForRedirect(
   // it once a more general solution to crbug/121325 is in place.
   if (!maybe_load_resource_executed_)
     return NULL;
-  if (request->url().GetOrigin() == location.GetOrigin())
+  if (request_->GetURL().GetOrigin() == location.GetOrigin())
     return NULL;
 
   DCHECK(!job_.get());  // our jobs never generate redirects
@@ -122,13 +126,13 @@ AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadFallbackForRedirect(
   if (found_fallback_entry_.has_response_id()) {
     // 6.9.6, step 4: If this results in a redirect to another origin,
     // get the resource of the fallback entry.
-    job = CreateJob(request, network_delegate);
+    job = CreateJob(network_delegate);
     DeliverAppCachedResponse(found_fallback_entry_, found_cache_id_,
                              found_manifest_url_, true,
                              found_namespace_entry_url_);
   } else if (!found_network_namespace_) {
     // 6.9.6, step 6: Fail the resource load.
-    job = CreateJob(request, network_delegate);
+    job = CreateJob(network_delegate);
     DeliverErrorResponse();
   } else {
     // 6.9.6 step 3 and 5: Fetch the resource normally.
@@ -138,15 +142,15 @@ AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadFallbackForRedirect(
 }
 
 AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadFallbackForResponse(
-    net::URLRequest* request,
     net::NetworkDelegate* network_delegate) {
-  if (!host_ || !IsSchemeAndMethodSupportedForAppCache(request) ||
+  if (!host_ ||
+      !AppCacheRequest::IsSchemeAndMethodSupportedForAppCache(request_.get()) ||
       cache_entry_not_found_)
     return NULL;
   if (!found_fallback_entry_.has_response_id())
     return NULL;
 
-  if (request->status().status() == net::URLRequestStatus::CANCELED) {
+  if (request_->IsCancelled()) {
     // 6.9.6, step 4: But not if the user canceled the download.
     return NULL;
   }
@@ -157,8 +161,8 @@ AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadFallbackForResponse(
     return NULL;
   }
 
-  if (request->status().is_success()) {
-    int code_major = request->GetResponseCode() / 100;
+  if (request_->IsSuccess()) {
+    int code_major = request_->GetResponseCode() / 100;
     if (code_major !=4 && code_major != 5)
       return NULL;
 
@@ -168,15 +172,14 @@ AppCacheURLRequestJob* AppCacheRequestHandler::MaybeLoadFallbackForResponse(
     const std::string kFallbackOverrideValue(
         "disallow-fallback");
     std::string header_value;
-    request->GetResponseHeaderByName(kFallbackOverrideHeader, &header_value);
+    header_value = request_->GetResponseHeaderByName(kFallbackOverrideHeader);
     if (header_value == kFallbackOverrideValue)
       return NULL;
   }
 
   // 6.9.6, step 4: If this results in a 4xx or 5xx status code
   // or there were network errors, get the resource of the fallback entry.
-  std::unique_ptr<AppCacheURLRequestJob> job =
-      CreateJob(request, network_delegate);
+  std::unique_ptr<AppCacheURLRequestJob> job = CreateJob(network_delegate);
   DeliverAppCachedResponse(found_fallback_entry_, found_cache_id_,
                            found_manifest_url_, true,
                            found_namespace_entry_url_);
@@ -295,10 +298,10 @@ void AppCacheRequestHandler::OnPrepareToRestart() {
 }
 
 std::unique_ptr<AppCacheURLRequestJob> AppCacheRequestHandler::CreateJob(
-    net::URLRequest* request,
     net::NetworkDelegate* network_delegate) {
   std::unique_ptr<AppCacheURLRequestJob> job(new AppCacheURLRequestJob(
-      request, network_delegate, storage(), host_, is_main_resource(),
+      request_->GetURLRequest(), network_delegate, storage(), host_,
+      is_main_resource(),
       base::Bind(&AppCacheRequestHandler::OnPrepareToRestart,
                  base::Unretained(this))));
   job_ = job->GetWeakPtr();
@@ -309,7 +312,6 @@ std::unique_ptr<AppCacheURLRequestJob> AppCacheRequestHandler::CreateJob(
 
 std::unique_ptr<AppCacheURLRequestJob>
 AppCacheRequestHandler::MaybeLoadMainResource(
-    net::URLRequest* request,
     net::NetworkDelegate* network_delegate) {
   DCHECK(!job_.get());
   DCHECK(host_);
@@ -317,7 +319,8 @@ AppCacheRequestHandler::MaybeLoadMainResource(
   // If a page falls into the scope of a ServiceWorker, any matching AppCaches
   // should be ignored. This depends on the ServiceWorker handler being invoked
   // prior to the AppCache handler.
-  if (ServiceWorkerRequestHandler::IsControlledByServiceWorker(request)) {
+  if (ServiceWorkerRequestHandler::IsControlledByServiceWorker(
+          request_->GetURLRequest())) {
     host_->enable_cache_selection(false);
     return nullptr;
   }
@@ -332,10 +335,9 @@ AppCacheRequestHandler::MaybeLoadMainResource(
 
   // We may have to wait for our storage query to complete, but
   // this query can also complete syncrhonously.
-  std::unique_ptr<AppCacheURLRequestJob> job =
-      CreateJob(request, network_delegate);
-  storage()->FindResponseForMainRequest(
-      request->url(), preferred_manifest_url, this);
+  std::unique_ptr<AppCacheURLRequestJob> job = CreateJob(network_delegate);
+  storage()->FindResponseForMainRequest(request_->GetURL(),
+                                        preferred_manifest_url, this);
   return job;
 }
 
@@ -412,7 +414,6 @@ void AppCacheRequestHandler::OnMainResponseFound(
 
 std::unique_ptr<AppCacheURLRequestJob>
 AppCacheRequestHandler::MaybeLoadSubResource(
-    net::URLRequest* request,
     net::NetworkDelegate* network_delegate) {
   DCHECK(!job_.get());
 
@@ -420,7 +421,7 @@ AppCacheRequestHandler::MaybeLoadSubResource(
     // We have to wait until cache selection is complete and the
     // selected cache is loaded.
     is_waiting_for_cache_selection_ = true;
-    return CreateJob(request, network_delegate);
+    return CreateJob(network_delegate);
   }
 
   if (!host_->associated_cache() ||
@@ -429,8 +430,7 @@ AppCacheRequestHandler::MaybeLoadSubResource(
     return nullptr;
   }
 
-  std::unique_ptr<AppCacheURLRequestJob> job =
-      CreateJob(request, network_delegate);
+  std::unique_ptr<AppCacheURLRequestJob> job = CreateJob(network_delegate);
   ContinueMaybeLoadSubResource();
   return job;
 }

content/browser/appcache/appcache_request_handler.h

@@ -25,6 +25,7 @@ class URLRequest;
 }  // namespace net
 
 namespace content {
+class AppCacheRequest;
 class AppCacheRequestHandlerTest;
 class AppCacheURLRequestJob;
 
@@ -43,14 +44,11 @@ class CONTENT_EXPORT AppCacheRequestHandler
 
   // These are called on each request intercept opportunity.
   AppCacheURLRequestJob* MaybeLoadResource(
-      net::URLRequest* request,
       net::NetworkDelegate* network_delegate);
   AppCacheURLRequestJob* MaybeLoadFallbackForRedirect(
-      net::URLRequest* request,
       net::NetworkDelegate* network_delegate,
       const GURL& location);
   AppCacheURLRequestJob* MaybeLoadFallbackForResponse(
-      net::URLRequest* request,
       net::NetworkDelegate* network_delegate);
 
   void GetExtraResponseInfo(int64_t* cache_id, GURL* manifest_url);
@@ -75,8 +73,10 @@ class CONTENT_EXPORT AppCacheRequestHandler
   friend class AppCacheHost;
 
   // Callers should use AppCacheHost::CreateRequestHandler.
-  AppCacheRequestHandler(AppCacheHost* host, ResourceType resource_type,
-                         bool should_reset_appcache);
+  AppCacheRequestHandler(AppCacheHost* host,
+                         ResourceType resource_type,
+                         bool should_reset_appcache,
+                         std::unique_ptr<AppCacheRequest> request);
 
   // AppCacheHost::Observer override
   void OnDestructionImminent(AppCacheHost* host) override;
@@ -101,7 +101,6 @@ class CONTENT_EXPORT AppCacheRequestHandler
   // Helper method to create an AppCacheURLRequestJob and populate job_.
   // Caller takes ownership of returned value.
   std::unique_ptr<AppCacheURLRequestJob> CreateJob(
-      net::URLRequest* request,
       net::NetworkDelegate* network_delegate);
 
   // Helper to retrieve a pointer to the storage object.
@@ -115,7 +114,6 @@ class CONTENT_EXPORT AppCacheRequestHandler
   // Frame and SharedWorker main resources are handled here.
 
   std::unique_ptr<AppCacheURLRequestJob> MaybeLoadMainResource(
-      net::URLRequest* request,
       net::NetworkDelegate* network_delegate);
 
   // AppCacheStorage::Delegate methods
@@ -131,7 +129,6 @@ class CONTENT_EXPORT AppCacheRequestHandler
   // Dedicated worker and all manner of sub-resources are handled here.
 
   std::unique_ptr<AppCacheURLRequestJob> MaybeLoadSubResource(
-      net::URLRequest* request,
       net::NetworkDelegate* network_delegate);
   void ContinueMaybeLoadSubResource();
 
@@ -196,6 +193,8 @@ class CONTENT_EXPORT AppCacheRequestHandler
   // Backptr to the central service object.
   AppCacheServiceImpl* service_;
 
+  std::unique_ptr<AppCacheRequest> request_;
+
   friend class content::AppCacheRequestHandlerTest;
   DISALLOW_COPY_AND_ASSIGN(AppCacheRequestHandler);
 };

content/browser/appcache/appcache_url_loader_request.cc

+// Copyright (c) 2017 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.
+
+#include "content/browser/appcache/appcache_url_loader_request.h"
+#include "net/url_request/url_request.h"
+
+namespace content {
+
+// static
+AppCacheURLLoaderRequest* AppCacheURLLoaderRequest::Create(
+    const ResourceRequest& request) {
+  return new AppCacheURLLoaderRequest(request);
+}
+
+const GURL& AppCacheURLLoaderRequest::GetURL() const {
+  return request_.url;
+}
+
+const std::string& AppCacheURLLoaderRequest::GetMethod() const {
+  return request_.method;
+}
+
+const GURL& AppCacheURLLoaderRequest::GetFirstPartyForCookies() const {
+  return request_.first_party_for_cookies;
+}
+
+const GURL AppCacheURLLoaderRequest::GetReferrer() const {
+  return request_.referrer;
+}
+
+bool AppCacheURLLoaderRequest::IsSuccess() const {
+  return false;
+}
+
+bool AppCacheURLLoaderRequest::IsCancelled() const {
+  return false;
+}
+
+bool AppCacheURLLoaderRequest::IsError() const {
+  return false;
+}
+
+int AppCacheURLLoaderRequest::GetResponseCode() const {
+  return 0;
+}
+
+std::string AppCacheURLLoaderRequest::GetResponseHeaderByName(
+    const std::string& name) const {
+  return std::string();
+}
+
+ResourceRequest* AppCacheURLLoaderRequest::GetResourceRequest() {
+  return &request_;
+}
+
+AppCacheURLLoaderRequest::AppCacheURLLoaderRequest(
+    const ResourceRequest& request)
+    : request_(request) {}
+
+AppCacheURLLoaderRequest::~AppCacheURLLoaderRequest() {}
+
+}  // namespace content

content/browser/appcache/appcache_url_loader_request.h

+// Copyright (c) 2017 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_URL_LOADER_REQUEST_H_
+#define CONTENT_BROWSER_APPCACHE_APPCACHE_URL_LOADER_REQUEST_H_
+
+#include "content/browser/appcache/appcache_request.h"
+#include "content/common/resource_request.h"
+
+namespace content {
+
+// AppCacheRequest wrapper for the ResourceRequest class for users of
+// URLLoader.
+class CONTENT_EXPORT AppCacheURLLoaderRequest : public AppCacheRequest {
+ public:
+  // Factory function to create an instance of the AppCacheResourceRequest
+  // class.
+  static AppCacheURLLoaderRequest* Create(const ResourceRequest& request);
+
+  // AppCacheRequest overrides.
+  // TODO(ananta)
+  // Add support to the GetURL() call to return the updated URL while following
+  // a chain of redirects.
+  const GURL& GetURL() const override;
+  const std::string& GetMethod() const override;
+  const GURL& GetFirstPartyForCookies() const override;
+  const GURL GetReferrer() const override;
+  // TODO(ananta)
+  // ResourceRequest only identifies the request unlike URLRequest which
+  // contains response information as well. We need the following methods to
+  // work for AppCache. Look into this.
+  bool IsSuccess() const override;
+  bool IsCancelled() const override;
+  bool IsError() const override;
+  int GetResponseCode() const override;
+  std::string GetResponseHeaderByName(const std::string& name) const override;
+
+  ResourceRequest* GetResourceRequest() override;
+
+ protected:
+  explicit AppCacheURLLoaderRequest(const ResourceRequest& request);
+  ~AppCacheURLLoaderRequest() override;
+
+ private:
+  ResourceRequest request_;
+
+  DISALLOW_COPY_AND_ASSIGN(AppCacheURLLoaderRequest);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_URL_LOADER_REQUEST_H_

content/browser/appcache/appcache_url_request.cc

+// Copyright (c) 2017 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.
+
+#include "content/browser/appcache/appcache_url_request.h"
+#include "net/url_request/url_request.h"
+
+namespace content {
+
+// static
+std::unique_ptr<AppCacheURLRequest> AppCacheURLRequest::Create(
+    net::URLRequest* url_request) {
+  std::unique_ptr<AppCacheURLRequest> request(
+      new AppCacheURLRequest(url_request));
+  return request;
+}
+
+const GURL& AppCacheURLRequest::GetURL() const {
+  return url_request_->url();
+}
+
+const std::string& AppCacheURLRequest::GetMethod() const {
+  return url_request_->method();
+}
+
+const GURL& AppCacheURLRequest::GetFirstPartyForCookies() const {
+  return url_request_->first_party_for_cookies();
+}
+
+const GURL AppCacheURLRequest::GetReferrer() const {
+  return GURL(url_request_->referrer());
+}
+
+bool AppCacheURLRequest::IsSuccess() const {
+  return url_request_->status().is_success();
+}
+
+bool AppCacheURLRequest::IsCancelled() const {
+  return url_request_->status().status() == net::URLRequestStatus::CANCELED;
+}
+
+bool AppCacheURLRequest::IsError() const {
+  return !url_request_->status().is_success();
+}
+
+int AppCacheURLRequest::GetResponseCode() const {
+  return url_request_->GetResponseCode();
+}
+
+std::string AppCacheURLRequest::GetResponseHeaderByName(
+    const std::string& name) const {
+  std::string header;
+  url_request_->GetResponseHeaderByName(name, &header);
+  return header;
+}
+
+net::URLRequest* AppCacheURLRequest::GetURLRequest() {
+  return url_request_;
+}
+
+AppCacheURLRequest::AppCacheURLRequest(net::URLRequest* url_request)
+    : url_request_(url_request) {}
+
+AppCacheURLRequest::~AppCacheURLRequest() {}
+
+}  // namespace content

content/browser/appcache/appcache_url_request.h

+// Copyright (c) 2017 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_URL_REQUEST_H_
+#define CONTENT_BROWSER_APPCACHE_APPCACHE_URL_REQUEST_H_
+
+#include "content/browser/appcache/appcache_request.h"
+#include "content/common/content_export.h"
+
+namespace net {
+class URLRequest;
+}  // namespace net
+
+namespace content {
+
+// AppCacheRequest wrapper for the URLRequest class.
+class CONTENT_EXPORT AppCacheURLRequest : public AppCacheRequest {
+ public:
+  // Factory function to create an instance of the AppCacheURLRequest class.
+  static std::unique_ptr<AppCacheURLRequest> Create(
+      net::URLRequest* url_request);
+
+  ~AppCacheURLRequest() override;
+
+  // AppCacheRequest overrides.
+  const GURL& GetURL() const override;
+  const std::string& GetMethod() const override;
+  const GURL& GetFirstPartyForCookies() const override;
+  const GURL GetReferrer() const override;
+  bool IsSuccess() const override;
+  bool IsCancelled() const override;
+  bool IsError() const override;
+  int GetResponseCode() const override;
+  std::string GetResponseHeaderByName(const std::string& name) const override;
+
+  net::URLRequest* GetURLRequest() override;
+
+ protected:
+  explicit AppCacheURLRequest(net::URLRequest* url_request);
+
+ private:
+  net::URLRequest* url_request_;
+
+  DISALLOW_COPY_AND_ASSIGN(AppCacheURLRequest);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_BROWSER_APPCACHE_APPCACHE_REQUEST_H_

content/common/appcache_interfaces.cc

@@ -9,7 +9,6 @@
 #include "base/strings/pattern.h"
 #include "base/strings/string_util.h"
 #include "content/public/common/url_constants.h"
-#include "net/url_request/url_request.h"
 #include "url/gurl.h"
 #include "url/url_constants.h"
 
@@ -138,9 +137,4 @@ bool IsMethodSupportedForAppCache(const std::string& method) {
   return (method == kHttpGETMethod) || (method == kHttpHEADMethod);
 }
 
-bool IsSchemeAndMethodSupportedForAppCache(const net::URLRequest* request) {
-  return IsSchemeSupportedForAppCache(request->url()) &&
-         IsMethodSupportedForAppCache(request->method());
-}
-
 }  // namespace content

content/common/appcache_interfaces.h

@@ -173,8 +173,6 @@ CONTENT_EXPORT extern const char kEnableExecutableHandlers[];
 CONTENT_EXPORT bool IsSchemeSupportedForAppCache(const GURL& url);
 CONTENT_EXPORT bool IsMethodSupportedForAppCache(
     const std::string& method);
-CONTENT_EXPORT bool IsSchemeAndMethodSupportedForAppCache(
-    const net::URLRequest* request);
 
 CONTENT_EXPORT extern const base::FilePath::CharType
     kAppCacheDatabaseName[];