[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(ServiceWorkerVersion* version,
+                base::WeakPtr<storage::BlobStorageContext> blob_storage_context,
+                mojom::URLLoaderAssociatedRequest url_loader_request,
+                int32_t options,
+                const ResourceRequest& request,
+                mojom::URLLoaderClientPtr url_loader_client)
+      : blob_storage_context_(blob_storage_context),
+        options_(options),
+        binding_(this, std::move(url_loader_request)),
+        url_loader_client_(std::move(url_loader_client)),
+        weak_factory_(this) {
+    if (options_ & mojom::kURLLoadOptionSendSSLInfo) {
+      // TODO(scottmg): User ssl_info() here.
+    }
+    fetch_dispatcher_.reset(new ServiceWorkerFetchDispatcher(
+        CreateFetchRequest(request), version, request.resource_type,
+        base::nullopt, net::NetLogWithSource() /* TODO(scottmg): net log? */,
+        base::Bind(&URLLoaderImpl::DidPrepareFetchEvent,
+                   weak_factory_.GetWeakPtr(), version),
+        base::Bind(&URLLoaderImpl::DidDispatchFetchEvent,
+                   weak_factory_.GetWeakPtr())));
+    fetch_dispatcher_->Run();
+  }
+
+  // mojom::URLLoader:
+  void FollowRedirect() override { NOTIMPLEMENTED(); }
+
+  void SetPriority(net::RequestPriority priority,
+                   int32_t intra_priority_value) override {
+    NOTIMPLEMENTED();
+  }
+
+ private:
+  std::unique_ptr<ServiceWorkerFetchRequest> CreateFetchRequest(
+      const ResourceRequest& request) {
+    std::string blob_uuid;
+    uint64_t blob_size = 0;
+#if 0  // TODO(scottmg):
+    if (HasRequestBody())
+      CreateRequestBodyBlob(&blob_uuid, &blob_size);
+#endif
+    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;
+#if 0  // TODO(scottmg):
+    const net::HttpRequestHeaders& headers = request_->extra_request_headers();
+    for (net::HttpRequestHeaders::Iterator it(headers); it.GetNext();) {
+      if (ServiceWorkerContext::IsExcludedHeaderNameForFetchEvent(it.name()))
+        continue;
+      new_request->headers[it.name()] = it.value();
+    }
+#endif
+    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;
+#if 0  // TODO(scottmg):
+    new_request->client_id = client_id_;
+    const ResourceRequestInfo* info = ResourceRequestInfo::ForRequest(request_);
+    if (info) {
+      new_request->is_reload = ui::PageTransitionCoreTypeIs(
+          info->GetPageTransition(), ui::PAGE_TRANSITION_RELOAD);
+      new_request->referrer =
+          Referrer(GURL(request_->referrer()), info->GetReferrerPolicy());
+    } else {
+      CHECK(
+          request_->referrer_policy() ==
+          net::URLRequest::CLEAR_REFERRER_ON_TRANSITION_FROM_SECURE_TO_INSECURE);
+      new_request->referrer =
+          Referrer(GURL(request_->referrer()), blink::kWebReferrerPolicyDefault);
+    }
+    new_request->fetch_type = fetch_type_;
+#endif
+    return new_request;
+  }
+
+  void DidPrepareFetchEvent(scoped_refptr<ServiceWorkerVersion> version) {}
+
+  void DidDispatchFetchEvent(
+      ServiceWorkerStatusCode status,
+      ServiceWorkerFetchEventResult fetch_result,

[shimazu, 2017/05/31 01:48:00]

If the |fetch_result| is SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK, I think the
request should fall down to the network service because that means no response
was provided from the fetch event handler somehow. 
I guessed we should know whether the fallback happens or not before returning
URLLoaderFactory to URLLoaderRequestController, but it doesn't seems possible
because we need the ResourceRequest object for dispatching the fetch event.
Instead, do we need other way to fall back to the default behavior or restart
the selection process at URLLoaderRequestController again?

// Sorry if I'm missing some context or it's already been discussed.

+      const ServiceWorkerResponse& response,
+      blink::mojom::ServiceWorkerStreamHandlePtr body_as_stream,
+      const scoped_refptr<ServiceWorkerVersion>& version) {
+    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));

[shimazu, 2017/05/30 08:32:00]

If loading the body gets aborted, how the error will be caught?
It'll be notified via body_as_stream->callback_request.

+    } 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));
+      }
+    }
+  }
+
+  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_;
+  int32_t options_;
+  mojo::AssociatedBinding<mojom::URLLoader> binding_;
+  mojom::URLLoaderClientPtr url_loader_client_;
+  std::unique_ptr<ServiceWorkerFetchDispatcher> fetch_dispatcher_;
+  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(ServiceWorkerURLJobWrapper::Delegate* delegate,
+          base::WeakPtr<storage::BlobStorageContext> blob_storage_context)
+      : delegate_(delegate), 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 {
+    ServiceWorkerMetrics::URLRequestJobResult result =
+        ServiceWorkerMetrics::REQUEST_JOB_ERROR_BAD_DELEGATE;
+    ServiceWorkerVersion* active_worker =
+        delegate_->GetServiceWorkerVersion(&result);
+    new URLLoaderImpl(active_worker, blob_storage_context_, std::move(request),
+                      options, url_request, std::move(client));
+  }
+
+  void SyncLoad(int32_t routing_id,
+                int32_t request_id,
+                const ResourceRequest& url_request,
+                SyncLoadCallback callback) override {
+    NOTREACHED();
+  }
+
+ private:
+  ServiceWorkerURLJobWrapper::Delegate* delegate_;
+  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,
+    base::WeakPtr<storage::BlobStorageContext> blob_storage_context)
     : job_type_(JobType::kURLLoader),
       loader_factory_callback_(std::move(callback)),
+      delegate_(delegate),
+      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()));
+  factory_ = base::MakeUnique<Factory>(delegate_, blob_storage_context_);

[kinuko, 2017/05/29 14:30:48]

I think we can delay creating the factory and URLLoader even later until we got
the response from fetch event handler.

[shimazu, 2017/05/30 08:32:00]

+1 for deferring because currently the network request will be back to the
network when no response is provided via respondWith. It could be implemented to
defer creating the factory.

[scottmg, 2017/05/30 18:07:48]

Sorry, maybe I'm misunderstanding, but I think we need the ResourceRequest
object that's provided during CreateLoaderAndStart() in order to be able to
create the ServiceWorkerFetchDispatcher?

[shimazu, 2017/05/31 01:48:00]

Ah, I missed that.. sorry!
We need the ResourceRequest object to dispatch the fetch event as you said.
Let me add another question at ::URLLoaderImpl::DidDispatchFetchEvent instead.

[kinuko, 2017/05/31 02:03:43]

We can pass the info when we create a job.  Either works, but it's not really
necessary to make SW fetching procedure match with the lifetime of one
URLLoader.  I feel having smaller URLLoader implementations for individual cases
would be probably easier.

+  std::move(loader_factory_callback_).Run(factory_.get());
 }
 
 }  // namespace content