[WIP] Mojofy respondwith

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 262 matching lines @@
     ServiceWorkerFetchType type) {
   if (type == ServiceWorkerFetchType::FOREIGN_FETCH)
     return ServiceWorkerMetrics::EventType::FOREIGN_FETCH_WAITUNTIL;
   return ServiceWorkerMetrics::EventType::FETCH_WAITUNTIL;
 }
 
 }  // namespace
 
 // Helper to receive the fetch event response even if
 // ServiceWorkerFetchDispatcher has been destroyed.
-class ServiceWorkerFetchDispatcher::ResponseCallback {
+class ServiceWorkerFetchDispatcher::ResponseCallback
+    : public mojom::ServiceWorkerFetchResponseReceiver {
  public:
   ResponseCallback(base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher,
-                   ServiceWorkerVersion* version)
-      : fetch_dispatcher_(fetch_dispatcher), version_(version) {}
+                   ServiceWorkerVersion* version,
+                   int fetch_event_id)
+      : fetch_dispatcher_(fetch_dispatcher),
+        version_(version),
+        fetch_event_id_(fetch_event_id),
+        binding_(this) {
+    // LOG(ERROR) << "ResponseCallback " << this;
+  }
+  ~ResponseCallback() override {
+    // LOG(ERROR) << "~ResponseCallback " << this;
+  }
 
   void Run(int request_id,
-           ServiceWorkerFetchEventResult fetch_result,
            const ServiceWorkerResponse& response,
            base::Time dispatch_event_time) {
-    const bool handled =
-        (fetch_result == SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE);
-    if (!version_->FinishRequest(request_id, handled, dispatch_event_time))
+    // Legacy IPC callback for blob handling.
+    // LOG(ERROR) << "ResponseCallback::Run() " << this;
+    DCHECK_EQ(fetch_event_id_, request_id);
+    DCHECK(response.blob_uuid.size());
+    if (!version_->FinishRequest(request_id, true, dispatch_event_time))
       NOTREACHED() << "Should only receive one reply per event";
 
     // |fetch_dispatcher| is null if the URLRequest was killed.
     if (fetch_dispatcher_)
-      fetch_dispatcher_->DidFinish(request_id, fetch_result, response);
+      fetch_dispatcher_->DidFinish(
+          request_id, SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, response,
+          mojo::ScopedDataPipeConsumerHandle());
+  }
+
+  void OnResponse(const ServiceWorkerResponse& response,
+                  base::Time dispatch_event_time) override {
+    // LOG(ERROR) << "ResponseCallback::OnResponse() " << this;
+    // Protects |fetch_dispatcher_|.
+    base::WeakPtr<ServiceWorkerFetchDispatcher> dispatcher(fetch_dispatcher_);
+    const int event_id(fetch_event_id_);
+    // FinishRequest() will delete |this|.
+    if (!version_->FinishRequest(fetch_event_id_, true, dispatch_event_time))
+      NOTREACHED() << "Should only receive one reply per event";
+    // |dispatcher| is null if the URLRequest was killed.
+    if (!dispatcher)
+      return;
+    dispatcher->DidFinish(event_id, SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
+                          response, mojo::ScopedDataPipeConsumerHandle());
+  }
+  void OnResponseStream(const ServiceWorkerResponse& response,
+                        mojo::ScopedDataPipeConsumerHandle stream,
+                        base::Time dispatch_event_time) override {
+    // LOG(ERROR) << "ResponseCallback::OnResponseStream() " << this;
+    // TODO(horo): Pass stream.
+    // Protects |fetch_dispatcher_|.
+    base::WeakPtr<ServiceWorkerFetchDispatcher> dispatcher(fetch_dispatcher_);
+    const int event_id(fetch_event_id_);
+    // FinishRequest() will delete |this|.
+    if (!version_->FinishRequest(fetch_event_id_, true, dispatch_event_time))
+      NOTREACHED() << "Should only receive one reply per event";
+    // |dispatcher| is null if the URLRequest was killed.
+    if (!dispatcher)
+      return;
+    dispatcher->DidFinish(event_id, SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
+                          response, std::move(stream));
+  }
+  void OnFallback(base::Time dispatch_event_time) override {
+    // LOG(ERROR) << "ResponseCallback::OnFallback() " << this;
+    // Protects |fetch_dispatcher_|.
+    base::WeakPtr<ServiceWorkerFetchDispatcher> dispatcher(fetch_dispatcher_);
+    const int event_id(fetch_event_id_);
+    // FinishRequest() will delete |this|.
+    if (!version_->FinishRequest(fetch_event_id_, false, dispatch_event_time))
+      NOTREACHED() << "Should only receive one reply per event";
+    ServiceWorkerResponse response;
+    // |dispatcher| is null if the URLRequest was killed.
+    if (!dispatcher)
+      return;
+    dispatcher->DidFinish(event_id, SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK,
+                          response, mojo::ScopedDataPipeConsumerHandle());
+  }
+  mojom::ServiceWorkerFetchResponseReceiverPtr Bind() {
+    return binding_.CreateInterfacePtrAndBind();
   }
 
  private:
   base::WeakPtr<ServiceWorkerFetchDispatcher> fetch_dispatcher_;
   // Owns |this|.
   ServiceWorkerVersion* version_;
+  const int fetch_event_id_;
+  mojo::Binding<mojom::ServiceWorkerFetchResponseReceiver> binding_;
 
   DISALLOW_COPY_AND_ASSIGN(ResponseCallback);
 };
 
 // This class keeps the URL loader related assets alive while the FetchEvent is
 // ongoing in the service worker.
 class ServiceWorkerFetchDispatcher::URLLoaderAssets
     : public base::RefCounted<ServiceWorkerFetchDispatcher::URLLoaderAssets> {
  public:
   URLLoaderAssets(mojom::URLLoaderFactoryPtr url_loader_factory,
@@ skipping 127 matching lines @@
   } else {
     fetch_event_id = version_->StartRequest(
         GetEventType(),
         base::Bind(&ServiceWorkerFetchDispatcher::DidFailToDispatch,
                    weak_factory_.GetWeakPtr()));
     event_finish_id = version_->StartRequest(
         FetchTypeToWaitUntilEventType(request_->fetch_type),
         base::Bind(&ServiceWorkerUtils::NoOpStatusCallback));
   }
 
-  ResponseCallback* response_callback =
-      new ResponseCallback(weak_factory_.GetWeakPtr(), version_.get());
+  ResponseCallback* response_callback = new ResponseCallback(
+      weak_factory_.GetWeakPtr(), version_.get(), fetch_event_id);
+  mojom::ServiceWorkerFetchResponseReceiverPtr receiver(
+      response_callback->Bind());
   version_->RegisterRequestCallback<ServiceWorkerHostMsg_FetchEventResponse>(
       fetch_event_id,
       base::Bind(&ServiceWorkerFetchDispatcher::ResponseCallback::Run,
                  base::Owned(response_callback)));
 
   if (url_loader_assets_) {
     url_loader_assets_->MayBeReportToDevTools(
         std::make_pair(
             version_->embedded_worker()->process_id(),
             version_->embedded_worker()->worker_devtools_agent_route_id()),
         fetch_event_id);
   }
 
   // |event_dispatcher| is owned by |version_|. So it is safe to pass the
   // unretained raw pointer of |version_| to OnFetchEventFinished callback.
   // Pass |url_loader_assets_| to the callback to keep the URL loader related
   // assets alive while the FetchEvent is ongoing in the service worker.
   version_->event_dispatcher()->DispatchFetchEvent(
       fetch_event_id, *request_, std::move(preload_handle_),
+      std::move(receiver),
       base::Bind(&ServiceWorkerFetchDispatcher::OnFetchEventFinished,
                  base::Unretained(version_.get()), event_finish_id,
                  url_loader_assets_));
 }
 
 void ServiceWorkerFetchDispatcher::DidFailToDispatch(
     ServiceWorkerStatusCode status) {
   EndNetLogEventWithServiceWorkerStatus(
       net_log_, net::NetLogEventType::SERVICE_WORKER_FETCH_EVENT, status);
   DidFail(status);
 }
 
 void ServiceWorkerFetchDispatcher::DidFail(ServiceWorkerStatusCode status) {
   DCHECK_NE(SERVICE_WORKER_OK, status);
   Complete(status, SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK,
-           ServiceWorkerResponse());
+           ServiceWorkerResponse(), mojo::ScopedDataPipeConsumerHandle());
 }
 
 void ServiceWorkerFetchDispatcher::DidFinish(
     int request_id,
     ServiceWorkerFetchEventResult fetch_result,
-    const ServiceWorkerResponse& response) {
+    const ServiceWorkerResponse& response,
+    mojo::ScopedDataPipeConsumerHandle stream) {
   net_log_.EndEvent(net::NetLogEventType::SERVICE_WORKER_FETCH_EVENT);
-  Complete(SERVICE_WORKER_OK, fetch_result, response);
+  Complete(SERVICE_WORKER_OK, fetch_result, response, std::move(stream));
 }
 
 void ServiceWorkerFetchDispatcher::Complete(
     ServiceWorkerStatusCode status,
     ServiceWorkerFetchEventResult fetch_result,
-    const ServiceWorkerResponse& response) {
+    const ServiceWorkerResponse& response,
+    mojo::ScopedDataPipeConsumerHandle stream) {
   DCHECK(!fetch_callback_.is_null());
 
   did_complete_ = true;
   net_log_.EndEvent(
       net::NetLogEventType::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);
+  fetch_callback.Run(status, fetch_result, response, std::move(stream),
+                     version);
 }
 
 bool ServiceWorkerFetchDispatcher::MaybeStartNavigationPreload(
     net::URLRequest* original_request,
     base::OnceClosure on_response) {
   if (resource_type_ != RESOURCE_TYPE_MAIN_FRAME &&
       resource_type_ != RESOURCE_TYPE_SUB_FRAME) {
     return false;
   }
   if (!version_->navigation_preload_state().enabled)
@@ skipping 99 matching lines @@
     ServiceWorkerVersion* version,
     int event_finish_id,
     scoped_refptr<URLLoaderAssets> url_loader_assets,
     ServiceWorkerStatusCode status,
     base::Time dispatch_event_time) {
   version->FinishRequest(event_finish_id, status != SERVICE_WORKER_ERROR_ABORT,
                          dispatch_event_time);
 }
 
 }  // namespace content