[proof-of-concept] SW thread independent of the main thread

content/browser/service_worker/service_worker_fetch_dispatcher.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_fetch_dispatcher.h"
 
 #include <string>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 99 matching lines @@
     const base::Closure& prepare_callback,
     const FetchCallback& fetch_callback)
     : version_(version),
       net_log_(net_log),
       prepare_callback_(prepare_callback),
       fetch_callback_(fetch_callback),
       request_(std::move(request)),
       resource_type_(resource_type),
       did_complete_(false),
       weak_factory_(this) {
+  LOG(ERROR) << "ServiceWorkerFetchDispatcher::ServiceWorkerFetchDispatcher "
+             << this;
   net_log_.BeginEvent(net::NetLog::TYPE_SERVICE_WORKER_DISPATCH_FETCH_EVENT,
                       net::NetLog::StringCallback(
                           "event_type", ServiceWorkerMetrics::EventTypeToString(
                                             GetEventType())));
 }
 
 ServiceWorkerFetchDispatcher::~ServiceWorkerFetchDispatcher() {
+  LOG(ERROR) << "ServiceWorkerFetchDispatcher::~ServiceWorkerFetchDispatcher "
+             << this;
   if (!did_complete_)
     net_log_.EndEvent(net::NetLog::TYPE_SERVICE_WORKER_DISPATCH_FETCH_EVENT);
 }
 
 void ServiceWorkerFetchDispatcher::Run() {
   DCHECK(version_->status() == ServiceWorkerVersion::ACTIVATING ||
          version_->status() == ServiceWorkerVersion::ACTIVATED)
       << version_->status();
 
   if (version_->status() == ServiceWorkerVersion::ACTIVATING) {
@@ skipping 39 matching lines @@
 }
 
 void ServiceWorkerFetchDispatcher::DidFailToStartWorker(
     ServiceWorkerStatusCode status) {
   EndNetLogEventWithServiceWorkerStatus(
       net_log_, net::NetLog::TYPE_SERVICE_WORKER_START_WORKER, status);
   DidFail(status);
 }
 
 void ServiceWorkerFetchDispatcher::DispatchFetchEvent() {
+  LOG(ERROR) << "ServiceWorkerFetchDispatcher::DispatchFetchEvent";
   DCHECK_EQ(EmbeddedWorkerStatus::RUNNING, version_->running_status())
       << "Worker stopped too soon after it was started.";
 
   DCHECK(!prepare_callback_.is_null());
   base::Closure prepare_callback = prepare_callback_;
   prepare_callback.Run();
 
   net_log_.BeginEvent(net::NetLog::TYPE_SERVICE_WORKER_FETCH_EVENT);
+
+  if (version_->IsIsolatedWorker()) {
+    int response_id = version_->StartRequest(
+        GetEventType(),
+        base::Bind(&ServiceWorkerFetchDispatcher::DidFailToDispatch,
+                   weak_factory_.GetWeakPtr()));
+    int event_finish_id = version_->StartRequest(
+        FetchTypeToWaitUntilEventType(request_->fetch_type),
+        base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
+    version_->isolated_worker_ptr()->OnFetchEvent(
+        response_id, event_finish_id, request_->url.spec(),
+        request_->mode == FETCH_REQUEST_MODE_NAVIGATE,
+        base::Bind(&ServiceWorkerFetchDispatcher::OnFetchEventCallback,
+                   weak_factory_.GetWeakPtr()));
+    return;
+  }
+
   int response_id = version_->StartRequest(
       GetEventType(),
       base::Bind(&ServiceWorkerFetchDispatcher::DidFailToDispatch,
                  weak_factory_.GetWeakPtr()));
   int event_finish_id = version_->StartRequest(
       FetchTypeToWaitUntilEventType(request_->fetch_type),
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 
   ResponseCallback* response_callback =
       new ResponseCallback(weak_factory_.GetWeakPtr(), version_.get());
@@ skipping 22 matching lines @@
 }
 
 void ServiceWorkerFetchDispatcher::DidFinish(
     int request_id,
     ServiceWorkerFetchEventResult fetch_result,
     const ServiceWorkerResponse& response) {
   net_log_.EndEvent(net::NetLog::TYPE_SERVICE_WORKER_FETCH_EVENT);
   Complete(SERVICE_WORKER_OK, fetch_result, response);
 }
 
+void ServiceWorkerFetchDispatcher::OnFetchEventCallback(
+    bool handled,
+    mojo::StructPtr<blink::mojom::ServiceWorkerResponse> response) {
+  LOG(ERROR) << "ServiceWorkerFetchDispatcher::OnFetchEventCallback "
+             << handled;
+  net_log_.EndEvent(net::NetLog::TYPE_SERVICE_WORKER_FETCH_EVENT);
+  ServiceWorkerResponse result;
+  if (response) {
+    LOG(ERROR) << " url: " << response->url;
+    LOG(ERROR) << " status_code: " << response->status_code;
+    LOG(ERROR) << " status_text: " << response->status_text;
+    LOG(ERROR) << " blob_uuid: " << response->blob_uuid;
+    LOG(ERROR) << " blob_size: " << response->blob_size;
+    LOG(ERROR) << " stream_url: " << response->stream_url;
+    result.url = GURL(std::string(response->url));
+    result.status_code = response->status_code;
+    result.status_text = response->status_text;
+    result.blob_uuid = response->blob_uuid;
+    result.blob_size = response->blob_size;
+    result.stream_url = GURL(std::string(response->stream_url));
+  }
+  Complete(SERVICE_WORKER_OK,
+           handled ? SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE
+                   : SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK,
+           result);
+}
+
 void ServiceWorkerFetchDispatcher::Complete(
     ServiceWorkerStatusCode status,
     ServiceWorkerFetchEventResult fetch_result,
     const ServiceWorkerResponse& response) {
   DCHECK(!fetch_callback_.is_null());
 
   did_complete_ = true;
   net_log_.EndEvent(
       net::NetLog::TYPE_SERVICE_WORKER_DISPATCH_FETCH_EVENT,
       base::Bind(&NetLogFetchEventCallback, status, fetch_result));
 
   FetchCallback fetch_callback = fetch_callback_;
   scoped_refptr<ServiceWorkerVersion> version = version_;
   fetch_callback.Run(status, fetch_result, response, version);
 }
 
 ServiceWorkerMetrics::EventType ServiceWorkerFetchDispatcher::GetEventType()
     const {
   if (request_->fetch_type == ServiceWorkerFetchType::FOREIGN_FETCH)
     return ServiceWorkerMetrics::EventType::FOREIGN_FETCH;
   return ResourceTypeToEventType(resource_type_);
 }
 
 }  // namespace content