Get main frame and subframe AppCache loads to work.

content/browser/appcache/appcache_url_loader_factory.cc

 // Copyright 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_factory.h"
 
 #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"
 #include "content/browser/appcache/chrome_appcache_service.h"
 #include "content/browser/url_loader_factory_getter.h"
 #include "content/common/network_service.mojom.h"
 #include "content/common/resource_request.h"
 #include "content/common/url_loader.mojom.h"
 #include "content/common/url_loader_factory.mojom.h"
 #include "content/public/browser/browser_thread.h"
 #include "mojo/public/cpp/bindings/associated_binding.h"
 #include "mojo/public/cpp/bindings/associated_interface_ptr.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 
 namespace content {
 
 namespace {
 
+AppCacheHost* g_host = nullptr;

[michaeln, 2017/05/24 00:59:32]

I don't think we should add this, i'd vote to take the time, in the context of
these early code reviews, to figure out how to more cleanly structure things.

[ananta, 2017/05/24 02:14:03]

This code is going to change once kinuko lands her changes to not use factories
in the browser navigation code path. We will have a much cleaner C++ call to
pass the host in then. This is just to get us started on the route to use
AppCacheRequestHandler to initiate requests.

+
 // Handles AppCache URL loads for the network service.
 class AppCacheURLLoader : public AppCacheStorage::Delegate,
                           public mojom::URLLoader {
  public:
   AppCacheURLLoader(const ResourceRequest& request,
                     mojom::URLLoaderAssociatedRequest url_loader_request,
                     int32_t routing_id,
                     int32_t request_id,
                     mojom::URLLoaderClientPtr client_info,
                     ChromeAppCacheService* appcache_service,
-                    URLLoaderFactoryGetter* factory_getter)
+                    URLLoaderFactoryGetter* factory_getter,
+                    AppCacheHost* host)
       : request_(request),
         routing_id_(routing_id),
         request_id_(request_id),
         client_info_(std::move(client_info)),
         appcache_service_(appcache_service),
         factory_getter_(factory_getter),
+        host_(host),
         binding_(this, std::move(url_loader_request)) {
     binding_.set_connection_error_handler(base::Bind(
         &AppCacheURLLoader::OnConnectionError, base::Unretained(this)));
   }
 
   ~AppCacheURLLoader() override {}
 
   void Start() {
     // 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(

[michaeln, 2017/05/24 00:59:32]

we need to test IsInitTaskComplete() for this check to be valid

Another place for this test might be
AppCacheRequestHandler::MaybeLoadMainResource(), that way the current
net::URLRequest based impl would get the benefit of this early return too.

[ananta, 2017/05/24 02:14:03]

Added a virtual function IsInitialized() in AppCacheStorage which internally
calls this in the AppCacheStorageImpl class.

             request_.url.GetOrigin()) ==
         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,

[michaeln, 2017/05/24 00:59:32]

Since this class is only used the main resource, maybe we can name accordingly?
AppCacheMainResourceURLLoader

[ananta, 2017/05/24 02:14:03]

This class should be handling main and sub resources both. Added a check for the
same.

                                                              GURL(), this);
   }
 
   // mojom::URLLoader implementation:
   void FollowRedirect() override { network_loader_request_->FollowRedirect(); }
 
   void SetPriority(net::RequestPriority priority,
                    int32_t intra_priority_value) override {
     DCHECK(false);
   }
 
  private:
   // AppCacheStorage::Delegate methods.
   void OnMainResponseFound(const GURL& url,

[michaeln, 2017/05/24 00:59:32]

When we talk a couple weeks ago, we talked about reusing AppCacheRequestHandler
logic, having this new code be a consumer of that existing code.

This class could internally use an instance of the AppCacheRquestHandler to
perform the work of figuring out what resource to load.  Start could call
handler->MaybeLoadResource() and have the handler would do the work of looking
for the main resource. I think we could end up with more code reuse and greater
compat between the new and old impls.

[ananta, 2017/05/24 02:14:03]

Yes. The plan is to do that. I was going to call
AppCacheRequestHandler::MaybeLoadResource here. I see your point though. I will
look into this in a subsequent patchset when we start implementing the core
logic for the AppCache read

                            const AppCacheEntry& entry,
                            const GURL& fallback_url,
                            const AppCacheEntry& fallback_entry,
                            int64_t cache_id,
                            int64_t group_id,
                            const GURL& manifest_url) override {
     AppCachePolicy* policy = appcache_service_->appcache_policy();
     bool was_blocked_by_policy =
         !manifest_url.is_empty() && policy &&
         !policy->CanLoadAppCache(manifest_url,
                                  request_.first_party_for_cookies);
 
     if (was_blocked_by_policy || !entry.has_response_id() ||
         cache_id == kAppCacheNoCacheId) {
       factory_getter_->GetNetworkFactory()->get()->CreateLoaderAndStart(
           mojo::MakeRequest(&network_loader_request_), routing_id_, request_id_,
           mojom::kURLLoadOptionSendSSLInfo, request_, std::move(client_info_));
     } else {
       DLOG(WARNING) << "AppCache found for url " << url
-                    << " Returning AppCache factory\n";
+                    << " host id is " << host_->host_id()
+                    << " Passing request to default factory\n";
       // TODO(ananta)
       // Provide the plumbing to initiate AppCache requests here.
       factory_getter_->GetNetworkFactory()->get()->CreateLoaderAndStart(
           mojo::MakeRequest(&network_loader_request_), routing_id_, request_id_,
           mojom::kURLLoadOptionSendSSLInfo, request_, std::move(client_info_));
     }
   }
 
   void OnConnectionError() { delete this; }
 
@@ skipping 15 matching lines @@
   mojom::URLLoaderClientPtr client_info_;
 
   // Used to query AppCacheStorage to see if a request can be served out of the
   /// AppCache.
   scoped_refptr<ChromeAppCacheService> appcache_service_;
 
   // Used to retrieve the network service factory to pass requests to the
   // network service.
   scoped_refptr<URLLoaderFactoryGetter> factory_getter_;
 
+  // We don't own the AppCacheHost pointer. This is safe as the host outlives

[michaeln, 2017/05/24 00:59:32]

what guarantees that?

[ananta, 2017/05/24 02:14:03]

Changed to take the host in the Start() function. We will eventually pass it to
the AppCacheRequestHandler instance

+  // us.
+  AppCacheHost* host_;
+
   // Binds the URLLoaderClient with us.
   mojo::AssociatedBinding<mojom::URLLoader> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(AppCacheURLLoader);
 };
 
 }  // namespace
 
 // 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() {}
 
 // static
 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,
     int32_t request_id,
     uint32_t options,
     const ResourceRequest& request,
     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());
+      std::move(client), appcache_service_.get(), factory_getter_.get(), host);
   loader->Start();
 }
 
 void AppCacheURLLoaderFactory::SyncLoad(int32_t routing_id,
                                         int32_t request_id,
                                         const ResourceRequest& request,
                                         SyncLoadCallback callback) {
   NOTREACHED();
 }
 
 }  // namespace content