[DO NOT COMMIT] ServiceWorker: First touch of mojo

content/browser/service_worker/service_worker_fetch_dispatcher.cc

Index: content/browser/service_worker/service_worker_fetch_dispatcher.cc
diff --git a/content/browser/service_worker/service_worker_fetch_dispatcher.cc b/content/browser/service_worker/service_worker_fetch_dispatcher.cc
index c08f2659c7b0f86dc4df5b515fd031a8733587c2..aad56eb836d9885110097667db8a839744082d11 100644
--- a/content/browser/service_worker/service_worker_fetch_dispatcher.cc
+++ b/content/browser/service_worker/service_worker_fetch_dispatcher.cc
@@ -69,6 +69,36 @@ ServiceWorkerMetrics::EventType FetchTypeToWaitUntilEventType(
   return ServiceWorkerMetrics::EventType::FETCH_WAITUNTIL;
 }
 
+template<typename T, typename U>
+T MojoType(const U& type) {
+  return static_cast<T>(type);
+}
+
+#define CastAndCopyToMojo(from, to) do {  \
+    from = MojoType<decltype(from)>(to);  \
+  } while(false)
+
+blink::mojom::ServiceWorkerFetchRequestPtr CreateMojoType(
+    const content::ServiceWorkerFetchRequest* request) {
+  auto mojo_request = blink::mojom::ServiceWorkerFetchRequest::New();
+  CastAndCopyToMojo(mojo_request->mode, request->mode);
+  mojo_request->is_main_resource_load = request->is_main_resource_load;
+  CastAndCopyToMojo(mojo_request->request_context_type,
+                    request->request_context_type);
+  CastAndCopyToMojo(mojo_request->frame_type, request->frame_type);
+  mojo_request->url = request->url;
+  mojo_request->method = request->method;
+  // mojo_request->headers = request->headers;
+  mojo_request->blob_uuid = request->blob_uuid;
+  // mojo_request->referrer = request->referrer;
+  CastAndCopyToMojo(mojo_request->credentials_mode, request->credentials_mode);
+  CastAndCopyToMojo(mojo_request->redirect_mode, request->redirect_mode);
+  mojo_request->client_id = request->client_id;
+  mojo_request->is_reload = request->is_reload;
+  CastAndCopyToMojo(mojo_request->fetch_type, request->fetch_type);
+  return mojo_request;
+}
+
 }  // namespace
 
 // Helper to receive the fetch event response even if
@@ -100,6 +130,48 @@ class ServiceWorkerFetchDispatcher::ResponseCallback {
   DISALLOW_COPY_AND_ASSIGN(ResponseCallback);
 };
 
+class ServiceWorkerFetchDispatcher::ResponseMojoCallback {
+ public:
+  ResponseMojoCallback(
+      base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher,
+      ServiceWorkerVersion* version)
+      : fetch_dispatcher_(fetch_dispatcher), version_(version) {
+  }
+
+  void Run(int request_id, bool handled, blink::mojom::ServiceWorkerResponsePtr response) {
+    LOG(ERROR) << "ServiceWorkerFetchDispatcher::ResponseMojoCallback";
+    LOG(ERROR) << "(handled: " << (handled ? "true": "false") << ")";
+    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));
+    }
+    if (!version_->FinishRequest(request_id, handled))
+      NOTREACHED() << "Should only receive one reply per event";
+    LOG(ERROR) << "Complete";
+    // |fetch_dispatcher| is null if the URLRequest was killed.
+    if (fetch_dispatcher_)
+      fetch_dispatcher_->Complete(
+          SERVICE_WORKER_OK,
+          handled ? SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE
+                  : SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK,
+          result);
+  }
+ private:
+  base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher_;
+  ServiceWorkerVersion* version_;
+};
+
 ServiceWorkerFetchDispatcher::ServiceWorkerFetchDispatcher(
     std::unique_ptr<ServiceWorkerFetchRequest> request,
     ServiceWorkerVersion* version,
@@ -189,6 +261,8 @@ void ServiceWorkerFetchDispatcher::DispatchFetchEvent() {
   prepare_callback.Run();
 
   net_log_.BeginEvent(net::NetLog::TYPE_SERVICE_WORKER_FETCH_EVENT);
+
+
   int response_id = version_->StartRequest(
       GetEventType(),
       base::Bind(&ServiceWorkerFetchDispatcher::DidFailToDispatch,
@@ -197,6 +271,22 @@ void ServiceWorkerFetchDispatcher::DispatchFetchEvent() {
       FetchTypeToWaitUntilEventType(request_->fetch_type),
       base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
 
+  // Try mojo
+  base::WeakPtr<blink::mojom::ServiceWorkerGlobalScopeClient> client =
+      version_->GetMojoServiceForRequest<
+        blink::mojom::ServiceWorkerGlobalScopeClient>(response_id);
+  if (client) {
+    LOG(ERROR) << "Mojo fetchevent!";
+    ResponseMojoCallback* mojo_callback =
+        new ResponseMojoCallback(weak_factory_.GetWeakPtr(), version_.get());
+    client->DispatchFetchEvent(response_id, event_finish_id,
+                               CreateMojoType(request_.get()),
+                               base::Bind(&ResponseMojoCallback::Run,
+                                          base::Owned(mojo_callback),
+                                          response_id));
+    return;
+  }
+
   ResponseCallback* response_callback =
       new ResponseCallback(weak_factory_.GetWeakPtr(), version_.get());
   version_->RegisterRequestCallback<ServiceWorkerHostMsg_FetchEventResponse>(
@@ -208,6 +298,7 @@ void ServiceWorkerFetchDispatcher::DispatchFetchEvent() {
   version_->DispatchEvent({response_id, event_finish_id},
                           ServiceWorkerMsg_FetchEvent(
                               response_id, event_finish_id, *request_.get()));
+
 }
 
 void ServiceWorkerFetchDispatcher::DidFailToDispatch(