The Appcache subresource URL factory needs to inform the URLLoaderClient if there is a failure.

content/browser/appcache/appcache_subresource_url_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_subresource_url_factory.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "content/browser/appcache/appcache_host.h"
 #include "content/browser/appcache/appcache_request_handler.h"
 #include "content/browser/appcache/appcache_url_loader_job.h"
 #include "content/browser/appcache/appcache_url_loader_request.h"
 #include "content/browser/url_loader_factory_getter.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/resource_request.h"
 #include "content/public/common/url_loader_factory.mojom.h"
 #include "mojo/public/cpp/bindings/binding.h"
 #include "mojo/public/cpp/bindings/binding_set.h"
 #include "mojo/public/cpp/bindings/interface_ptr.h"
 #include "net/traffic_annotation/network_traffic_annotation.h"
 
 namespace content {
 
+namespace {
+
+// Set to true if we are running as part of tests.
+bool g_for_testing = false;
+
+}  // namespace.
+
 // Implements the URLLoaderFactory mojom for AppCache requests.
 AppCacheSubresourceURLFactory::AppCacheSubresourceURLFactory(
     mojom::URLLoaderFactoryRequest request,
     URLLoaderFactoryGetter* default_url_loader_factory_getter,
     base::WeakPtr<AppCacheHost> host)
     : binding_(this, std::move(request)),
       default_url_loader_factory_getter_(default_url_loader_factory_getter),
       appcache_host_(host) {
   binding_.set_connection_error_handler(
       base::Bind(&AppCacheSubresourceURLFactory::OnConnectionError,
@@ skipping 22 matching lines @@
     int32_t request_id,
     uint32_t options,
     const ResourceRequest& request,
     mojom::URLLoaderClientPtr client,
     const net::MutableNetworkTrafficAnnotationTag& traffic_annotation) {
   DCHECK_CURRENTLY_ON(BrowserThread::IO);
   DLOG(WARNING) << "Received request for loading : " << request.url.spec();
 
   // If the host is invalid, it means that the renderer has probably died.
   // (Frame has navigated elsewhere?)
-  if (!appcache_host_.get())
+  if (!appcache_host_.get() && !g_for_testing) {
+    NotifyError(std::move(client), net::ERR_FAILED);
     return;
+  }
 
   std::unique_ptr<AppCacheRequestHandler> handler =
       appcache_host_->CreateRequestHandler(
           AppCacheURLLoaderRequest::Create(request), request.resource_type,
           request.should_reset_appcache);
   if (!handler) {
-    ResourceRequestCompletionStatus request_result;
-    request_result.error_code = net::ERR_FAILED;
-    client->OnComplete(request_result);
+    NotifyError(std::move(client), net::ERR_FAILED);
     return;
   }
 
   handler->set_network_url_loader_factory_getter(
       default_url_loader_factory_getter_.get());
 
   std::unique_ptr<SubresourceLoadInfo> load_info(new SubresourceLoadInfo());
   load_info->url_loader_request = std::move(url_loader_request);
   load_info->routing_id = routing_id;
   load_info->request_id = request_id;
@@ skipping 15 matching lines @@
                                              int32_t request_id,
                                              const ResourceRequest& request,
                                              SyncLoadCallback callback) {
   NOTREACHED();
 }
 
 void AppCacheSubresourceURLFactory::OnConnectionError() {
   base::ThreadTaskRunnerHandle::Get()->DeleteSoon(FROM_HERE, this);
 }
 
+void AppCacheSubresourceURLFactory::NotifyError(
+    mojom::URLLoaderClientPtr client,
+    int error_code) {
+  ResourceRequestCompletionStatus request_result;
+  request_result.error_code = error_code;
+  client->OnComplete(request_result);
+}
+
+// static
+void AppCacheSubresourceURLFactory::SetForTesting(bool for_testing) {
+  g_for_testing = for_testing;
+}
+
 }  // namespace content