Get main frame and subframe AppCache loads to work.

content/browser/loader/navigation_url_loader_network_service.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/loader/navigation_url_loader_network_service.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/memory/ptr_util.h"
 #include "base/trace_event/trace_event.h"
 #include "content/browser/appcache/appcache_navigation_handle.h"
+#include "content/browser/appcache/appcache_navigation_handle_core.h"
+#include "content/browser/appcache/appcache_url_loader_factory.h"
 #include "content/browser/blob_storage/chrome_blob_storage_context.h"
 #include "content/browser/frame_host/frame_tree_node.h"
 #include "content/browser/frame_host/navigation_request_info.h"
 #include "content/browser/loader/navigation_resource_handler.h"
 #include "content/browser/loader/navigation_resource_throttle.h"
 #include "content/browser/loader/navigation_url_loader_delegate.h"
 #include "content/browser/resource_context_impl.h"
 #include "content/browser/service_worker/service_worker_navigation_handle.h"
 #include "content/browser/service_worker/service_worker_navigation_handle_core.h"
 #include "content/browser/service_worker/service_worker_request_handler.h"
@@ skipping 77 matching lines @@
   // gave us, or otherwise fallback to the default.
   mojom::URLLoaderFactory* factory;
   if (url_loader_factory_ptr) {
     factory = url_loader_factory_ptr.get();
   } else {
     if (factory_from_ui.is_valid()) {
       url_loader_factory_ptr.Bind(std::move(factory_from_ui));
       factory = url_loader_factory_ptr.get();
     } else {
       if (appcache_handle_core) {
         factory = url_loader_factory_getter->GetAppCacheFactory()->get();

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

I think I see a problem with this function. It seems like there's an assumption
that the appcache and serviceworker systems can synchronously determine IF they
will produce a response for the request. But figuring out which system (sw,
appcache, network) the request will be loaded from is an asyncrhonous process.
As coded, if the sw system returns a factory_ptr, the appcache system will not
get a chance.

Q: Can the |url_loader_request| be left unsatisfied upon return from this
function with the expectation that it will be satisfied asyncly? What if we
don't CreateLoaderAndStart prior to return?

Why does "factory_from_ui" take precedence over appacache but not over
serviceworkers What is the use case for the "factory_from_ui". Oh, I see, its
for WebUI handling for chrome:urls. Maybe we could call this webui_factory to
better connect the dots, i thought "ui" was referring to it being posted over
from the UI thread

I think its useful to keep appcache and serviceworker impls as parallel as
possible where the function is the same. I'd like to see this logic buried put
into appacache specific function more similar to that one sketched out for the
serviceworker.

+        // TODO(ananta)
+        // Change this when we don't use URLLoaderFactories in the browser.
+        AppCacheURLLoaderFactory::SetAppCacheHost(appcache_handle_core->host());

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

The plan for now is to have each factory call the next guy in the chain if it
does not handle it. kinuko's change will basically restart the request if one
handler decides to not handle the request. I think we are ok for now here.
This is again a WIP

       } else {
         factory = url_loader_factory_getter->GetNetworkFactory()->get();
       }
     }
   }
 
   factory->CreateLoaderAndStart(
       std::move(url_loader_request), 0 /* routing_id? */, 0 /* request_id? */,
       mojom::kURLLoadOptionSendSSLInfo, *resource_request,
       std::move(url_loader_client_to_pass));
@@ skipping 155 matching lines @@
     TRACE_EVENT_ASYNC_END2("navigation", "Navigation timeToResponseStarted",
                            this, "&NavigationURLLoaderNetworkService", this,
                            "success", false);
 
     delegate_->OnRequestFailed(completion_status.exists_in_cache,
                                completion_status.error_code);
   }
 }
 
 }  // namespace content