[network service][SW] Rework browser-side SW on top of URL loader chaining

content/browser/service_worker/service_worker_url_job_wrapper.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/service_worker/service_worker_url_job_wrapper.h"
 
 #include "base/command_line.h"
 #include "content/browser/service_worker/service_worker_response_type.h"
+#include "content/browser/service_worker/service_worker_version.h"
+#include "content/common/service_worker/service_worker_utils.h"
+#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/resource_request_info.h"
 #include "content/public/common/browser_side_navigation_policy.h"
 #include "content/public/common/content_switches.h"
+#include "net/base/io_buffer.h"
+#include "storage/browser/blob/blob_storage_context.h"
 
 namespace content {
 
+namespace {
+
+class URLLoaderImpl : public mojom::URLLoader {
+ public:
+  URLLoaderImpl(const ServiceWorkerResponse& response,
+                blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream,
+                base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
+                mojom::URLLoaderAssociatedRequest url_loader_request,
+                mojom::URLLoaderClientPtr url_loader_client)
+      : blob_storage_context_(blob_storage_context),
+        binding_(this, std::move(url_loader_request)),
+        url_loader_client_(std::move(url_loader_client)),
+        weak_factory_(this) {
+    ResourceResponseHead head;
+    // TODO(scottmg): More fields in |head| required?
+    head.headers = new net::HttpResponseHeaders("");
+    for (const auto& kv : response.headers)
+      head.headers->AddHeader(kv.first + ": " + kv.second);
+    head.url_list_via_service_worker = response.url_list;
+    head.mime_type = "text/html";  // TODO(scottmg): No idea where to get this.
+    head.was_fetched_via_service_worker = true;
+    head.cors_exposed_header_names = response.cors_exposed_header_names;
+    url_loader_client_->OnReceiveResponse(
+        head, base::nullopt /* TODO(scottmg): ssl info */,
+        mojom::DownloadedTempFilePtr());
+
+    // Ideally, we would always get a data pipe fom SWFetchDispatcher and use
+    // this case. See:
+    // https://docs.google.com/a/google.com/document/d/1_ROmusFvd8ATwIZa29-P6Ls5yyLjfld0KvKchVfA84Y/edit?usp=drive_web
+    if (!body_as_stream.is_null() && body_as_stream->stream.is_valid()) {
+      url_loader_client_->OnStartLoadingResponseBody(
+          std::move(body_as_stream->stream));
+    } else {
+      // TODO(scottmg): This is temporary way to load the blob right here and
+      // turn it into a data pipe to respond with, until we are always able to
+      // take the above path.
+      if (!response.blob_uuid.empty() && blob_storage_context_) {
+        std::unique_ptr<storage::BlobDataHandle> blob_data_handle =
+            blob_storage_context_->GetBlobDataFromUUID(response.blob_uuid);
+        blob_reader_ = blob_data_handle->CreateReader(
+            nullptr /* file system context */,
+            BrowserThread::GetTaskRunnerForThread(BrowserThread::FILE).get());
+        CHECK(storage::BlobReader::Status::DONE ==
+              blob_reader_->CalculateSize(net::CompletionCallback()));
+        blob_reader_->SetReadRange(0, blob_reader_->total_size());
+        scoped_refptr<net::IOBuffer> buffer(
+            new net::IOBuffer(static_cast<size_t>(blob_reader_->total_size())));
+
+        int bytes_read;
+        blob_reader_->Read(buffer.get(), blob_reader_->total_size(),
+                           &bytes_read,
+                           base::Bind(&URLLoaderImpl::AfterRead,
+                                      weak_factory_.GetWeakPtr(), buffer));
+      }
+    }
+  }
+
+  // mojom::URLLoader:
+  void FollowRedirect() override { NOTIMPLEMENTED(); }
+
+  void SetPriority(net::RequestPriority priority,
+                   int32_t intra_priority_value) override {
+    NOTIMPLEMENTED();
+  }
+
+ private:
+  void AfterRead(scoped_refptr<net::IOBuffer> buffer, int bytes) {
+    uint32_t bytes_written = static_cast<uint32_t>(bytes);
+    mojo::WriteDataRaw(data_pipe_.producer_handle.get(), buffer->data(),
+                       &bytes_written, MOJO_WRITE_DATA_FLAG_NONE);
+    url_loader_client_->OnStartLoadingResponseBody(
+        std::move(data_pipe_.consumer_handle));
+  }
+
+  base::WeakPtr<storage::BlobStorageContext> blob_storage_context_;
+  mojo::AssociatedBinding<mojom::URLLoader> binding_;
+  mojom::URLLoaderClientPtr url_loader_client_;
+  std::unique_ptr<storage::BlobReader> blob_reader_;
+  mojo::DataPipe data_pipe_;
+
+  base::WeakPtrFactory<URLLoaderImpl> weak_factory_;
+
+  DISALLOW_COPY_AND_ASSIGN(URLLoaderImpl);
+};
+
+}  // namespace
+
+class ServiceWorkerURLJobWrapper::Factory : public mojom::URLLoaderFactory {
+ public:
+  Factory(const ServiceWorkerResponse& response,
+          blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream,
+          base::WeakPtr<storage::BlobStorageContext> blob_storage_context)
+      : response_(response),
+        body_as_stream_(std::move(body_as_stream)),
+        blob_storage_context_(blob_storage_context) {}
+
+  void CreateLoaderAndStart(mojom::URLLoaderAssociatedRequest request,
+                            int32_t routing_id,
+                            int32_t request_id,
+                            uint32_t options,
+                            const ResourceRequest& url_request,
+                            mojom::URLLoaderClientPtr client) override {
+    // Note that url_request is ignored here, as we've already processed the
+    // fetch before even creating the factory.
+    // TODO(scottmg): Use options.
+    new URLLoaderImpl(response_, std::move(body_as_stream_),

[shimazu, 2017/06/06 01:33:30]

If the lifecycle of URLLoaderImpl is the same with the Mojo's pipe for
URLLoader, URLLoaderImpl should use StrongAssociatedBinding here instead of
having the mojo::AssociatedBinding in URLLoaderImpl.

==
mojo::MakeStrongAssociatedBinding(
    base::MakeUnique<URLLoaderImpl>(
        response_, std::move(body_as_stream_), blob_storage_context_,
        std::move(client)),
    std::move(request));

[scottmg, 2017/06/06 16:50:09]

Done.

+                      blob_storage_context_, std::move(request),
+                      std::move(client));
+  }
+
+  void SyncLoad(int32_t routing_id,
+                int32_t request_id,
+                const ResourceRequest& url_request,
+                SyncLoadCallback callback) override {
+    NOTREACHED();
+  }
+
+ private:
+  ServiceWorkerResponse response_;
+  blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream_;
+  base::WeakPtr<storage::BlobStorageContext> blob_storage_context_;
+
+  DISALLOW_COPY_AND_ASSIGN(Factory);
+};
+
 ServiceWorkerURLJobWrapper::ServiceWorkerURLJobWrapper(
     base::WeakPtr<ServiceWorkerURLRequestJob> url_request_job)
     : job_type_(JobType::kURLRequest),
       url_request_job_(std::move(url_request_job)),
       weak_factory_(this) {}
 
 ServiceWorkerURLJobWrapper::ServiceWorkerURLJobWrapper(
-    LoaderFactoryCallback callback)
+    LoaderFactoryCallback callback,
+    Delegate* delegate,
+    const ResourceRequest& resource_request,
+    base::WeakPtr<storage::BlobStorageContext> blob_storage_context)
     : job_type_(JobType::kURLLoader),
       loader_factory_callback_(std::move(callback)),
+      delegate_(delegate),
+      resource_request_(resource_request),
+      blob_storage_context_(blob_storage_context),
       weak_factory_(this) {
   DCHECK(IsBrowserSideNavigationEnabled() &&
          base::CommandLine::ForCurrentProcess()->HasSwitch(
              switches::kEnableNetworkService));
 }
 
 ServiceWorkerURLJobWrapper::~ServiceWorkerURLJobWrapper() {}
 
 void ServiceWorkerURLJobWrapper::FallbackToNetwork() {
   if (job_type_ == JobType::kURLLoader) {
@@ skipping 70 matching lines @@
 bool ServiceWorkerURLJobWrapper::WasCanceled() const {
   if (job_type_ == JobType::kURLLoader) {
     return loader_factory_callback_.is_null();
   } else {
     return !url_request_job_;
   }
 }
 
 void ServiceWorkerURLJobWrapper::StartRequest() {
   DCHECK_EQ(FORWARD_TO_SERVICE_WORKER, response_type_);
-  // TODO(kinuko): Implement. For now we just exercise async fall back path
-  // to the network.
-  base::ThreadTaskRunnerHandle::Get()->PostTask(
-      FROM_HERE, base::Bind(&ServiceWorkerURLJobWrapper::FallbackToNetwork,
-                            weak_factory_.GetWeakPtr()));
+
+  ServiceWorkerMetrics::URLRequestJobResult result =
+      ServiceWorkerMetrics::REQUEST_JOB_ERROR_BAD_DELEGATE;
+  ServiceWorkerVersion* active_worker =
+      delegate_->GetServiceWorkerVersion(&result);
+
+  // TODO(scottmg): Get this from somewhere, and maybe it should probably be set
+  // elsewhere too.
+  net::HttpResponseInfo http_info;
+  http_info.was_cached = true;
+  active_worker->SetMainScriptHttpResponseInfo(http_info);

[kinuko, 2017/06/06 12:52:37]

Do we need this?  (Esp. with the change in
ServiceWorkerVersion::OnScriptLoaded?)

[falken, 2017/06/06 13:20:22]

Good point. I think quite a few things might break if the main script http
response info is not set: see crbug.com/485900. To be "safe" we should set the
info where we'd expect it to be set, which is whenever the service worker starts
up, instead of just setting it here before starting the SW for fetch
interception.

So I think instead we should move this to where the DCHECK is in OnScriptLoaded.

[scottmg, 2017/06/06 16:50:09]

OK, removed for now. 

+
+  fetch_dispatcher_.reset(new ServiceWorkerFetchDispatcher(
+      CreateFetchRequest(resource_request_), active_worker,
+      resource_request_.resource_type, base::nullopt,
+      net::NetLogWithSource() /* TODO(scottmg): net log? */,
+      base::Bind(&ServiceWorkerURLJobWrapper::DidPrepareFetchEvent,
+                 weak_factory_.GetWeakPtr(), active_worker),
+      base::Bind(&ServiceWorkerURLJobWrapper::DidDispatchFetchEvent,
+                 weak_factory_.GetWeakPtr())));
+  fetch_dispatcher_->Run();
+}
+
+std::unique_ptr<ServiceWorkerFetchRequest>
+ServiceWorkerURLJobWrapper::CreateFetchRequest(const ResourceRequest& request) {
+  std::string blob_uuid;
+  uint64_t blob_size = 0;
+  // TODO(scottmg): Implement passing body as blob to handler.
+  DCHECK(!request.request_body);
+  std::unique_ptr<ServiceWorkerFetchRequest> new_request(
+      new ServiceWorkerFetchRequest());
+  new_request->mode = request.fetch_request_mode;
+  new_request->is_main_resource_load =
+      ServiceWorkerUtils::IsMainResourceType(request.resource_type);
+  new_request->request_context_type = request.fetch_request_context_type;
+  new_request->frame_type = request.fetch_frame_type;
+  new_request->url = request.url;
+  new_request->method = request.method;
+  new_request->blob_uuid = blob_uuid;
+  new_request->blob_size = blob_size;
+  new_request->credentials_mode = request.fetch_credentials_mode;
+  new_request->redirect_mode = request.fetch_redirect_mode;
+  CHECK(request.referrer_policy ==
+        blink::kWebReferrerPolicyNoReferrerWhenDowngrade);
+  new_request->referrer =
+      Referrer(GURL(request.referrer), blink::kWebReferrerPolicyDefault);

[falken, 2017/06/06 13:20:22]

Why is line 293 a CHECK instead of DCHECK and line 296 uses a different referrer
policy? Could we add comments to clarify?

[scottmg, 2017/06/06 16:50:09]

Oops, yeah. I copied the fallback case from
ServiceWorkerURLRequestJob::CreateFetchRequest() but that's the wrong path.
Updated to use the data from |request|.

+  new_request->fetch_type = ServiceWorkerFetchType::FETCH;
+  return new_request;
+}
+
+void ServiceWorkerURLJobWrapper::DidPrepareFetchEvent(
+    scoped_refptr<ServiceWorkerVersion> version) {}
+
+void ServiceWorkerURLJobWrapper::DidDispatchFetchEvent(
+    ServiceWorkerStatusCode status,
+    ServiceWorkerFetchEventResult fetch_result,
+    const ServiceWorkerResponse& response,
+    blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream,
+    const scoped_refptr<ServiceWorkerVersion>& version) {
+  if (fetch_result == SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK) {
+    std::move(loader_factory_callback_).Run(nullptr);
+    return;
+  }
+  DCHECK_EQ(fetch_result, SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE);
+
+  factory_ = base::MakeUnique<Factory>(response, std::move(body_as_stream),
+                                       blob_storage_context_);
+  std::move(loader_factory_callback_).Run(factory_.get());
 }
 
 }  // namespace content