Get main frame and subframe AppCache loads to work.

content/browser/appcache/appcache_url_loader_factory.cc

Index: content/browser/appcache/appcache_url_loader_factory.cc
diff --git a/content/browser/appcache/appcache_url_loader_factory.cc b/content/browser/appcache/appcache_url_loader_factory.cc
index 37c105abc9091b0170aa1fb9541736d9d434d9ec..9294db9b7af7a1765446dc74e106b16a25ff7a12 100644
--- a/content/browser/appcache/appcache_url_loader_factory.cc
+++ b/content/browser/appcache/appcache_url_loader_factory.cc
@@ -6,7 +6,9 @@
 
 #include "base/bind.h"
 #include "base/logging.h"
+#include "content/browser/appcache/appcache_backend_impl.h"
 #include "content/browser/appcache/appcache_entry.h"
+#include "content/browser/appcache/appcache_host.h"
 #include "content/browser/appcache/appcache_policy.h"
 #include "content/browser/appcache/appcache_request.h"
 #include "content/browser/appcache/appcache_storage.h"
@@ -25,6 +27,8 @@ namespace content {
 
 namespace {
 
+AppCacheHost* g_host = nullptr;
+
 // Handles AppCache URL loads for the network service.
 class AppCacheURLLoader : public AppCacheStorage::Delegate,
                           public mojom::URLLoader {
@@ -49,20 +53,34 @@ class AppCacheURLLoader : public AppCacheStorage::Delegate,
 
   ~AppCacheURLLoader() override {}
 
-  void Start() {
+  void Start(AppCacheHost* host) {
+    DCHECK(host);
     // If the origin does not exist in the AppCache usage map, then we can
     // safely call the network service here.
-    if (appcache_service_->storage()->usage_map()->find(
+    if (appcache_service_->storage()->IsInitialized() &&
+        appcache_service_->storage()->usage_map()->find(
             request_.url.GetOrigin()) ==
-        appcache_service_->storage()->usage_map()->end()) {
+            appcache_service_->storage()->usage_map()->end()) {
       factory_getter_->GetNetworkFactory()->get()->CreateLoaderAndStart(
           mojo::MakeRequest(&network_loader_request_), routing_id_, request_id_,
           mojom::kURLLoadOptionSendSSLInfo, request_, std::move(client_info_));
       return;
     }
 
-    appcache_service_->storage()->FindResponseForMainRequest(request_.url,
-                                                             GURL(), this);
+    switch (request_.resource_type) {
+      case RESOURCE_TYPE_MAIN_FRAME:
+      case RESOURCE_TYPE_SUB_FRAME:
+        appcache_service_->storage()->FindResponseForMainRequest(request_.url,
+                                                                 GURL(), this);
+        break;
+
+      default:
+        // We should not be hitting this yet. We have to plumb the AppCache
+        // response through to the renderer before we receive requests for sub
+        // resources.
+        DCHECK(false);
+        break;
+    }
   }
 
   // mojom::URLLoader implementation:
@@ -95,7 +113,7 @@ class AppCacheURLLoader : public AppCacheStorage::Delegate,
           mojom::kURLLoadOptionSendSSLInfo, request_, std::move(client_info_));
     } else {
       DLOG(WARNING) << "AppCache found for url " << url
-                    << " Returning AppCache factory\n";
+                    << " Passing request to default factory\n";
       // TODO(ananta)
       // Provide the plumbing to initiate AppCache requests here.
       factory_getter_->GetNetworkFactory()->get()->CreateLoaderAndStart(
@@ -142,8 +160,11 @@ class AppCacheURLLoader : public AppCacheStorage::Delegate,
 // Implements the URLLoaderFactory mojom for AppCache requests.
 AppCacheURLLoaderFactory::AppCacheURLLoaderFactory(
     ChromeAppCacheService* appcache_service,
-    URLLoaderFactoryGetter* factory_getter)
-    : appcache_service_(appcache_service), factory_getter_(factory_getter) {}
+    URLLoaderFactoryGetter* factory_getter,
+    int renderer_process_id)
+    : appcache_service_(appcache_service),
+      factory_getter_(factory_getter),
+      renderer_process_id_(renderer_process_id) {}
 
 AppCacheURLLoaderFactory::~AppCacheURLLoaderFactory() {}
 
@@ -151,14 +172,22 @@ AppCacheURLLoaderFactory::~AppCacheURLLoaderFactory() {}
 void AppCacheURLLoaderFactory::CreateURLLoaderFactory(
     mojom::URLLoaderFactoryRequest request,
     ChromeAppCacheService* appcache_service,
-    URLLoaderFactoryGetter* factory_getter) {
+    URLLoaderFactoryGetter* factory_getter,
+    int renderer_process_id) {
   std::unique_ptr<AppCacheURLLoaderFactory> factory_instance(
-      new AppCacheURLLoaderFactory(appcache_service, factory_getter));
+      new AppCacheURLLoaderFactory(appcache_service, factory_getter,
+                                   renderer_process_id));
   AppCacheURLLoaderFactory* raw_factory = factory_instance.get();
   raw_factory->loader_factory_bindings_.AddBinding(std::move(factory_instance),
                                                    std::move(request));
 }
 
+// static
+void AppCacheURLLoaderFactory::SetAppCacheHost(AppCacheHost* host) {
+  DCHECK(!g_host);
+  g_host = host;
+}
+
 void AppCacheURLLoaderFactory::CreateLoaderAndStart(
     mojom::URLLoaderAssociatedRequest url_loader_request,
     int32_t routing_id,
@@ -168,11 +197,24 @@ void AppCacheURLLoaderFactory::CreateLoaderAndStart(
     mojom::URLLoaderClientPtr client) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
 
+  AppCacheHost* host = nullptr;
+  if (renderer_process_id_ != -1) {
+    AppCacheBackendImpl* backend =
+        appcache_service_->GetBackend(renderer_process_id_);
+    DCHECK(backend);
+    host = backend->GetHost(request.appcache_host_id);
+    DCHECK(host);
+  } else {
+    DCHECK(g_host);
+    host = g_host;
+    g_host = nullptr;
+  }
+
   // This will get deleted when the connection is dropped by the client.
   AppCacheURLLoader* loader = new AppCacheURLLoader(
       request, std::move(url_loader_request), routing_id, request_id,
       std::move(client), appcache_service_.get(), factory_getter_.get());
-  loader->Start();
+  loader->Start(host);
 }
 
 void AppCacheURLLoaderFactory::SyncLoad(int32_t routing_id,