[DO NOT COMMIT] ServiceWorker: First touch of mojo

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 51 matching lines @@
                    base::Bind(&NetLogServiceWorkerStatusCallback, status));
 }
 
 ServiceWorkerMetrics::EventType FetchTypeToWaitUntilEventType(
     ServiceWorkerFetchType type) {
   if (type == ServiceWorkerFetchType::FOREIGN_FETCH)
     return ServiceWorkerMetrics::EventType::FOREIGN_FETCH_WAITUNTIL;
   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
 // ServiceWorkerFetchDispatcher has been destroyed.
 class ServiceWorkerFetchDispatcher::ResponseCallback {
  public:
   ResponseCallback(base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher,
                    ServiceWorkerVersion* version)
       : fetch_dispatcher_(fetch_dispatcher), version_(version) {}
 
@@ skipping 11 matching lines @@
   }
 
  private:
   base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher_;
   // Owns |this|.
   ServiceWorkerVersion* version_;
 
   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,
     ResourceType resource_type,
     const net::BoundNetLog& net_log,
     const base::Closure& prepare_callback,
     const FetchCallback& fetch_callback)
     : version_(version),
       net_log_(net_log),
       prepare_callback_(prepare_callback),
@@ skipping 69 matching lines @@
 
 void 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);
+
+
   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));
 
+  // 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>(
       response_id,
       base::Bind(&ServiceWorkerFetchDispatcher::ResponseCallback::Run,
                  base::Owned(response_callback)));
   version_->RegisterSimpleRequest<ServiceWorkerHostMsg_FetchEventFinished>(
       event_finish_id);
   version_->DispatchEvent({response_id, event_finish_id},
                           ServiceWorkerMsg_FetchEvent(
                               response_id, event_finish_id, *request_.get()));
+
 }
 
 void ServiceWorkerFetchDispatcher::DidFailToDispatch(
     ServiceWorkerStatusCode status) {
   EndNetLogEventWithServiceWorkerStatus(
       net_log_, net::NetLog::TYPE_SERVICE_WORKER_FETCH_EVENT, status);
   DidFail(status);
 }
 
 void ServiceWorkerFetchDispatcher::DidFail(ServiceWorkerStatusCode status) {
@@ skipping 27 matching lines @@
 }
 
 ServiceWorkerMetrics::EventType ServiceWorkerFetchDispatcher::GetEventType()
     const {
   if (request_->fetch_type == ServiceWorkerFetchType::FOREIGN_FETCH)
     return ServiceWorkerMetrics::EventType::FOREIGN_FETCH;
   return ResourceTypeToEventType(resource_type_);
 }
 
 }  // namespace content