Provide skeleton functionality for AppCache handling in the network service.

content/browser/appcache/appcache_network_service_handler.cc

+// 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.
+
+#include "content/browser/appcache/appcache_network_service_handler.h"
+#include "base/bind.h"
+#include "base/logging.h"
+#include "content/browser/appcache/appcache_entry.h"
+#include "content/browser/appcache/appcache_host.h"
+#include "content/browser/appcache/appcache_navigation_handle_core.h"
+#include "content/browser/appcache/appcache_policy.h"
+#include "content/browser/appcache/appcache_request.h"
+#include "content/public/browser/browser_thread.h"
+
+namespace content {
+
+AppCacheNetworkServiceHandler::AppCacheNetworkServiceHandler(
+    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)
+    : resource_request_(std::move(resource_request)),
+      resource_context_(resource_context),
+      resource_type_(resource_type),
+      callback_(callback),
+      storage_(navigation_handle_core->host()->storage()),
+      host_(navigation_handle_core->host()) {}
+
+AppCacheNetworkServiceHandler::~AppCacheNetworkServiceHandler() {}
+
+void AppCacheNetworkServiceHandler::Start() {
+  storage_->FindResponseForMainRequest(resource_request_->url, GURL(), this);
+}
+
+void AppCacheNetworkServiceHandler::OnMainResponseFound(
+    const GURL& url,
+    const AppCacheEntry& entry,
+    const GURL& fallback_url,
+    const AppCacheEntry& fallback_entry,
+    int64_t cache_id,
+    int64_t group_id,
+    const GURL& manifest_url) {
+  AppCachePolicy* policy = host_->service()->appcache_policy();
+  bool was_blocked_by_policy =
+      !manifest_url.is_empty() && policy &&
+      !policy->CanLoadAppCache(manifest_url, host_->first_party_url());
+
+  if (was_blocked_by_policy || !entry.has_response_id() ||
+      cache_id == kAppCacheNoCacheId) {
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(callback_,
+                   base::Passed(std::move(mojom::URLLoaderFactoryPtrInfo())),
+                   base::Passed(std::move(resource_request_))));
+  } else {
+    DLOG(WARNING) << "AppCache found for url " << url
+                  << " falling back to network for now\n";
+    // TODO(ananta)
+    // Pass a URLLoaderFactory pointer which supports serving URL requests from

[jam, 2017/05/11 01:42:13]

similar to my comment to scott on the other cl for SW, if we find on the IO
thread that the page is served out of Appcache, we should avoid 2 other thread
hops. We can create the URLLoader  directly here.

[ananta, 2017/05/11 02:12:31]

Noted

[kinuko, 2017/05/11 02:14:14]

Yeah, maybe that's better.

[jam, 2017/05/11 14:50:43]

Just to make sure I understand what you mean: do you agree that this is how it
should be done? If so, this code needs to change then?

+    // the cache.
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(callback_,
+                   base::Passed(std::move(mojom::URLLoaderFactoryPtrInfo())),
+                   base::Passed(std::move(resource_request_))));
+  }
+  delete this;
+}
+
+}  // namespace content