Network service: Implement URLLoader chaining for interceptors

content/browser/service_worker/service_worker_request_handler.cc

 // Copyright 2014 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/service_worker/service_worker_request_handler.h"
 
 #include <string>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/macros.h"
+#include "content/browser/loader/url_loader_request_handler.h"
 #include "content/browser/service_worker/service_worker_context_core.h"
 #include "content/browser/service_worker/service_worker_context_wrapper.h"
 #include "content/browser/service_worker/service_worker_navigation_handle_core.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "content/browser/service_worker/service_worker_registration.h"
 #include "content/browser/service_worker/service_worker_url_request_job.h"
 #include "content/common/resource_request_body_impl.h"
 #include "content/common/service_worker/service_worker_types.h"
 #include "content/common/service_worker/service_worker_utils.h"
 #include "content/public/browser/resource_context.h"
@@ skipping 28 matching lines @@
       return NULL;
     return handler->MaybeCreateJob(
         request, network_delegate, resource_context_);
   }
 
  private:
   ResourceContext* resource_context_;
   DISALLOW_COPY_AND_ASSIGN(ServiceWorkerRequestInterceptor);
 };
 
-void FinalizeHandlerInitialization(
-    net::URLRequest* request,
-    ServiceWorkerProviderHost* provider_host,
-    storage::BlobStorageContext* blob_storage_context,
-    bool skip_service_worker,
-    FetchRequestMode request_mode,
-    FetchCredentialsMode credentials_mode,
-    FetchRedirectMode redirect_mode,
-    ResourceType resource_type,
-    RequestContextType request_context_type,
-    RequestContextFrameType frame_type,
-    scoped_refptr<ResourceRequestBodyImpl> body) {
-  std::unique_ptr<ServiceWorkerRequestHandler> handler(
-      provider_host->CreateRequestHandler(
-          request_mode, credentials_mode, redirect_mode, resource_type,
-          request_context_type, frame_type, blob_storage_context->AsWeakPtr(),
-          body, skip_service_worker));
-  if (!handler)
-    return;
-
-  request->SetUserData(&kUserDataKey, std::move(handler));
-}
-
 }  // namespace
 
 // PlzNavigate
 void ServiceWorkerRequestHandler::InitializeForNavigation(
     net::URLRequest* request,
     ServiceWorkerNavigationHandleCore* navigation_handle_core,
     storage::BlobStorageContext* blob_storage_context,
     bool skip_service_worker,
     ResourceType resource_type,
     RequestContextType request_context_type,
@@ skipping 19 matching lines @@
       !navigation_handle_core->context_wrapper()->context()) {
     return;
   }
 
   // Initialize the SWProviderHost.
   std::unique_ptr<ServiceWorkerProviderHost> provider_host =
       ServiceWorkerProviderHost::PreCreateNavigationHost(
           navigation_handle_core->context_wrapper()->context()->AsWeakPtr(),
           is_parent_frame_secure, web_contents_getter);
 
-  FinalizeHandlerInitialization(
-      request, provider_host.get(), blob_storage_context, skip_service_worker,
-      FETCH_REQUEST_MODE_NAVIGATE, FETCH_CREDENTIALS_MODE_INCLUDE,
-      FetchRedirectMode::MANUAL_MODE, resource_type, request_context_type,
-      frame_type, body);
+  std::unique_ptr<ServiceWorkerRequestHandler> handler(
+      provider_host->CreateRequestHandler(
+          FETCH_REQUEST_MODE_NAVIGATE, FETCH_CREDENTIALS_MODE_INCLUDE,
+          FetchRedirectMode::MANUAL_MODE, resource_type, request_context_type,
+          frame_type, blob_storage_context->AsWeakPtr(), body,
+          skip_service_worker));
+  if (handler)
+    request->SetUserData(&kUserDataKey, std::move(handler));
 
   // Transfer ownership to the ServiceWorkerNavigationHandleCore.
   // In the case of a successful navigation, the SWProviderHost will be
   // transferred to its "final" destination in the OnProviderCreated handler. If
   // the navigation fails, it will be destroyed along with the
   // ServiceWorkerNavigationHandleCore.
   navigation_handle_core->DidPreCreateProviderHost(std::move(provider_host));
 }
 
 // PlzNavigate and --enable-network-service.
 // static
-mojom::URLLoaderFactoryPtr
+std::unique_ptr<URLLoaderRequestHandler>
 ServiceWorkerRequestHandler::InitializeForNavigationNetworkService(
     const ResourceRequest& resource_request,
     ResourceContext* resource_context,
     ServiceWorkerNavigationHandleCore* navigation_handle_core,
     storage::BlobStorageContext* blob_storage_context,
     bool skip_service_worker,
     ResourceType resource_type,
     RequestContextType request_context_type,
     RequestContextFrameType frame_type,
     bool is_parent_frame_secure,
     scoped_refptr<ResourceRequestBodyImpl> body,
     const base::Callback<WebContents*(void)>& web_contents_getter) {
   DCHECK(IsBrowserSideNavigationEnabled() &&
          base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kEnableNetworkService));
-  // TODO(scottmg): Currently being implemented. See https://crbug.com/715640.
-  return mojom::URLLoaderFactoryPtr();
+  DCHECK(navigation_handle_core);
+
+  // Create the handler even for insecure HTTP since it's used in the
+  // case of redirect to HTTPS.
+  if (!resource_request.url.SchemeIsHTTPOrHTTPS() &&
+      !OriginCanAccessServiceWorkers(resource_request.url)) {
+    return nullptr;
+  }
+
+  if (!navigation_handle_core->context_wrapper() ||
+      !navigation_handle_core->context_wrapper()->context()) {
+    return nullptr;
+  }
+
+  // Initialize the SWProviderHost.
+  std::unique_ptr<ServiceWorkerProviderHost> provider_host =
+      ServiceWorkerProviderHost::PreCreateNavigationHost(
+          navigation_handle_core->context_wrapper()->context()->AsWeakPtr(),
+          is_parent_frame_secure, web_contents_getter);
+
+  std::unique_ptr<ServiceWorkerRequestHandler> handler(
+      provider_host->CreateRequestHandler(
+          FETCH_REQUEST_MODE_NAVIGATE, FETCH_CREDENTIALS_MODE_INCLUDE,
+          FetchRedirectMode::MANUAL_MODE, resource_type, request_context_type,
+          frame_type, blob_storage_context->AsWeakPtr(), body,
+          skip_service_worker));
+
+  // Transfer ownership to the ServiceWorkerNavigationHandleCore.
+  // In the case of a successful navigation, the SWProviderHost will be
+  // transferred to its "final" destination in the OnProviderCreated handler. If
+  // the navigation fails, it will be destroyed along with the
+  // ServiceWorkerNavigationHandleCore.
+  navigation_handle_core->DidPreCreateProviderHost(std::move(provider_host));
+
+  return base::WrapUnique<URLLoaderRequestHandler>(handler.release());
 }
 
 void ServiceWorkerRequestHandler::InitializeHandler(
     net::URLRequest* request,
     ServiceWorkerContextWrapper* context_wrapper,
     storage::BlobStorageContext* blob_storage_context,
     int process_id,
     int provider_id,
     bool skip_service_worker,
     FetchRequestMode request_mode,
@@ skipping 13 matching lines @@
   if (!context_wrapper || !context_wrapper->context() ||
       provider_id == kInvalidServiceWorkerProviderId) {
     return;
   }
 
   ServiceWorkerProviderHost* provider_host =
       context_wrapper->context()->GetProviderHost(process_id, provider_id);
   if (!provider_host || !provider_host->IsContextAlive())
     return;
 
-  FinalizeHandlerInitialization(request, provider_host, blob_storage_context,
-                                skip_service_worker, request_mode,
-                                credentials_mode, redirect_mode, resource_type,
-                                request_context_type, frame_type, body);
+  std::unique_ptr<ServiceWorkerRequestHandler> handler(
+      provider_host->CreateRequestHandler(
+          request_mode, credentials_mode, redirect_mode, resource_type,
+          request_context_type, frame_type, blob_storage_context->AsWeakPtr(),
+          body, skip_service_worker));
+  if (handler)
+    request->SetUserData(&kUserDataKey, std::move(handler));
 }
 
 ServiceWorkerRequestHandler* ServiceWorkerRequestHandler::GetHandler(
     const net::URLRequest* request) {
   return static_cast<ServiceWorkerRequestHandler*>(
       request->GetUserData(&kUserDataKey));
 }
 
 std::unique_ptr<net::URLRequestInterceptor>
 ServiceWorkerRequestHandler::CreateInterceptor(
@@ skipping 10 matching lines @@
   return handler->provider_host_->associated_registration() ||
          handler->provider_host_->running_hosted_version();
 }
 
 ServiceWorkerProviderHost* ServiceWorkerRequestHandler::GetProviderHost(
     const net::URLRequest* request) {
   ServiceWorkerRequestHandler* handler = GetHandler(request);
   return handler ? handler->provider_host_.get() : nullptr;
 }
 
+void ServiceWorkerRequestHandler::Start(
+    const ResourceRequest& request,
+    Controller* controller,
+    ResourceContext* resource_context,
+    mojom::URLLoaderAssociatedRequest loader_request,
+    mojom::URLLoaderClientPtr loader_client_ptr) {
+  NOTREACHED();

[scottmg, 2017/05/25 15:12:24]

This is only for ServiceWorkerURLTrackingRequestHandler and
ServiceWorkerContextRequestHandler right? (i.e.
ServiceWorkerControlleeRequestHandler already works now)

[kinuko, 2017/05/26 02:34:20]

Yep. I could make only SWControlleeRequestHandler inherit from
URLLoaderReqHandler but not this one, but it was a little easier

+}
+
 void ServiceWorkerRequestHandler::PrepareForCrossSiteTransfer(
     int old_process_id) {
   CHECK(!IsBrowserSideNavigationEnabled());
   if (!provider_host_ || !context_)
     return;
   old_process_id_ = old_process_id;
   old_provider_id_ = provider_host_->provider_id();
   host_for_cross_site_transfer_ = context_->TransferProviderHostOut(
       old_process_id, provider_host_->provider_id());
   DCHECK_EQ(provider_host_.get(), host_for_cross_site_transfer_.get());
@@ skipping 37 matching lines @@
     ResourceType resource_type)
     : context_(context),
       provider_host_(provider_host),
       blob_storage_context_(blob_storage_context),
       resource_type_(resource_type),
       old_process_id_(0),
       old_provider_id_(kInvalidServiceWorkerProviderId) {
 }
 
 }  // namespace content