[OnionSoup] Remove blink::WebServiceWorkerStreamHandle

https://chromium-review.googlesource.com/c/chromium/src/+/1631124
already made WebServiceWorkerStreamHandle used only inside Blink, this
CL removes it.

BUG=922376,879019

Change-Id: Ia9cd4f3cef9354ba64e492d3372b25ae626b64d8
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1634382Reviewed-by: Matt Falkenhagen <falken@chromium.org>
Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Reviewed-by: Makoto Shimazu <shimazu@chromium.org>
Commit-Queue: Leon Han <leon.han@intel.com>
Cr-Commit-Position: refs/heads/master@{#664737}

third_party/blink/public/BUILD.gn

@@ -159,7 +159,6 @@ source_set("blink_headers") {
     "platform/modules/service_worker/web_service_worker_provider.h",
     "platform/modules/service_worker/web_service_worker_provider_client.h",
     "platform/modules/service_worker/web_service_worker_registration_object_info.h",
-    "platform/modules/service_worker/web_service_worker_stream_handle.h",
     "platform/platform.h",
     "platform/pointer_properties.h",
     "platform/scheduler/web_rail_mode_observer.h",

third_party/blink/public/platform/modules/service_worker/web_service_worker_stream_handle.h

-// 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.
-
-#ifndef THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_SERVICE_WORKER_WEB_SERVICE_WORKER_STREAM_HANDLE_H_
-#define THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_SERVICE_WORKER_WEB_SERVICE_WORKER_STREAM_HANDLE_H_
-
-#include <memory>
-
-#include "mojo/public/cpp/system/data_pipe.h"
-#include "third_party/blink/public/platform/web_common.h"
-
-namespace blink {
-
-// Contains the info to send back a body to the page over Mojo's data pipe.
-class BLINK_PLATFORM_EXPORT WebServiceWorkerStreamHandle {
- public:
-  // Listener can observe whether the data pipe is successfully closed at the
-  // end of the body or it has accidentally finished.
-  class Listener {
-   public:
-    virtual ~Listener() = default;
-
-    virtual void OnAborted() = 0;
-    virtual void OnCompleted() = 0;
-  };
-
-  void SetListener(std::unique_ptr<Listener>);
-  mojo::ScopedDataPipeConsumerHandle DrainStreamDataPipe();
-
-#if INSIDE_BLINK
-  WebServiceWorkerStreamHandle(mojo::ScopedDataPipeConsumerHandle stream)
-      : stream_(std::move(stream)) {
-    DCHECK(stream_.is_valid());
-  }
-  void Aborted();
-  void Completed();
-#endif
-
- private:
-  mojo::ScopedDataPipeConsumerHandle stream_;
-  std::unique_ptr<Listener> listener_;
-};
-}  // namespace blink
-
-#endif  // THIRD_PARTY_BLINK_PUBLIC_PLATFORM_MODULES_SERVICE_WORKER_WEB_SERVICE_WORKER_STREAM_HANDLE_H_

third_party/blink/renderer/modules/service_worker/fetch_respond_with_observer.cc

@@ -13,7 +13,6 @@
 #include "services/network/public/mojom/fetch_api.mojom-blink.h"
 #include "third_party/blink/public/mojom/devtools/console_message.mojom-shared.h"
 #include "third_party/blink/public/mojom/loader/request_context_frame_type.mojom-blink.h"
-#include "third_party/blink/public/platform/modules/service_worker/web_service_worker_stream_handle.h"
 #include "third_party/blink/public/platform/task_type.h"
 #include "third_party/blink/renderer/bindings/core/v8/script_value.h"
 #include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_core.h"
@@ -121,75 +120,63 @@ bool IsClientRequest(network::mojom::RequestContextFrameType frame_type,
          request_context == mojom::RequestContextType::WORKER;
 }
 
-// Notifies the result of FetchDataLoader to |handle_|. |handle_| pass through
-// the result to its observer.
+// Notifies the result of FetchDataLoader to |callback_ptr_|, the other endpoint
+// for which is passed to the browser process via
+// blink.mojom.ServiceWorkerFetchResponseCallback.OnResponseStream().
 class FetchLoaderClient final
     : public GarbageCollectedFinalized<FetchLoaderClient>,
       public FetchDataLoader::Client {
   USING_GARBAGE_COLLECTED_MIXIN(FetchLoaderClient);
 
  public:
-  FetchLoaderClient() {}
+  FetchLoaderClient(
+      std::unique_ptr<ServiceWorkerTimeoutTimer::StayAwakeToken> token)
+      : token_(std::move(token)) {
+    // We need to make |callback_ptr_| callable in the first place because some
+    // DidFetchDataLoadXXX() accessing it may be called synchronously from
+    // StartLoading().
+    callback_request_ = mojo::MakeRequest(&callback_ptr_);
+  }
 
   void DidFetchDataStartedDataPipe(
       mojo::ScopedDataPipeConsumerHandle pipe) override {
-    DCHECK(!handle_);
-    handle_ = std::make_unique<WebServiceWorkerStreamHandle>(std::move(pipe));
+    DCHECK(!body_stream_.is_valid());
+    DCHECK(pipe.is_valid());
+    body_stream_ = std::move(pipe);
   }
   void DidFetchDataLoadedDataPipe() override {
-    DCHECK(handle_);
-    // If this method is called synchronously from StartLoading() then we need
-    // to delay notifying the handle until after
-    // RespondToFetchEventWithResponseStream() is called.
-    if (!started_) {
-      pending_complete_ = true;
-      return;
-    }
-    pending_complete_ = false;
-    handle_->Completed();
+    callback_ptr_->OnCompleted();
+    token_.reset();
   }
   void DidFetchDataLoadFailed() override {
-    // If this method is called synchronously from StartLoading() then we need
-    // to delay notifying the handle until after
-    // RespondToFetchEventWithResponseStream() is called.
-    if (!started_) {
-      pending_failure_ = true;
-      return;
-    }
-    pending_failure_ = false;
-    if (handle_)
-      handle_->Aborted();
+    callback_ptr_->OnAborted();
+    token_.reset();
   }
   void Abort() override {
     // A fetch() aborted via AbortSignal in the ServiceWorker will just look
     // like an ordinary failure to the page.
     // TODO(ricea): Should a fetch() on the page get an AbortError instead?
-    if (handle_)
-      handle_->Aborted();
+    callback_ptr_->OnAborted();
+    token_.reset();
   }
 
-  void SetStarted() {
-    DCHECK(!started_);
-    // Note that RespondToFetchEventWithResponseStream() has been called and
-    // flush any pending operation.
-    started_ = true;
-    if (pending_complete_)
-      DidFetchDataLoadedDataPipe();
-    else if (pending_failure_)
-      DidFetchDataLoadFailed();
+  mojom::blink::ServiceWorkerStreamHandlePtr CreateStreamHandle() {
+    if (!body_stream_.is_valid())
+      return nullptr;
+    return mojom::blink::ServiceWorkerStreamHandle::New(
+        std::move(body_stream_), std::move(callback_request_));
   }
 
-  WebServiceWorkerStreamHandle* Handle() const { return handle_.get(); }
-
   void Trace(blink::Visitor* visitor) override {
     FetchDataLoader::Client::Trace(visitor);
   }
 
  private:
-  std::unique_ptr<WebServiceWorkerStreamHandle> handle_;
-  bool started_ = false;
-  bool pending_complete_ = false;
-  bool pending_failure_ = false;
+  mojo::ScopedDataPipeConsumerHandle body_stream_;
+  mojom::blink::ServiceWorkerStreamCallbackRequest callback_request_;
+
+  mojom::blink::ServiceWorkerStreamCallbackPtr callback_ptr_;
+  std::unique_ptr<ServiceWorkerTimeoutTimer::StayAwakeToken> token_;
 
   DISALLOW_COPY_AND_ASSIGN(FetchLoaderClient);
 };
@@ -316,6 +303,8 @@ void FetchRespondWithObserver::OnResponseFulfilled(
 
   mojom::blink::FetchAPIResponsePtr fetch_api_response =
       response->PopulateFetchAPIResponse();
+  ServiceWorkerGlobalScope* service_worker_global_scope =
+      To<ServiceWorkerGlobalScope>(GetExecutionContext());
 
   BodyStreamBuffer* buffer = response->InternalBodyBuffer();
   if (buffer) {
@@ -330,16 +319,17 @@ void FetchRespondWithObserver::OnResponseFulfilled(
     if (blob_data_handle) {
       // Handle the blob response body.
       fetch_api_response->blob = blob_data_handle;
-      To<ServiceWorkerGlobalScope>(GetExecutionContext())
-          ->RespondToFetchEvent(event_id_, std::move(fetch_api_response),
-                                event_dispatch_time_, base::TimeTicks::Now());
+      service_worker_global_scope->RespondToFetchEvent(
+          event_id_, std::move(fetch_api_response), event_dispatch_time_,
+          base::TimeTicks::Now());
       return;
     }
 
-    // Load the Response as a mojo::DataPipe.  The resulting pipe consumer
+    // Load the Response as a Mojo DataPipe. The resulting pipe consumer
     // handle will be passed to the FetchLoaderClient on start.
     FetchLoaderClient* fetch_loader_client =
-        MakeGarbageCollected<FetchLoaderClient>();
+        MakeGarbageCollected<FetchLoaderClient>(
+            service_worker_global_scope->CreateStayAwakeToken());
     buffer->StartLoading(FetchDataLoader::CreateLoaderAsDataPipe(task_runner_),
                          fetch_loader_client, exception_state);
     if (exception_state.HadException()) {
@@ -347,25 +337,22 @@ void FetchRespondWithObserver::OnResponseFulfilled(
       return;
     }
 
-    // If we failed to create the WebServiceWorkerStreamHandle then we must
-    // have failed to allocate the mojo::DataPipe.
-    if (!fetch_loader_client->Handle()) {
+    mojom::blink::ServiceWorkerStreamHandlePtr stream_handle =
+        fetch_loader_client->CreateStreamHandle();
+    // We failed to allocate the Mojo DataPipe.
+    if (!stream_handle) {
       OnResponseRejected(ServiceWorkerResponseError::kDataPipeCreationFailed);
       return;
     }
 
-    To<ServiceWorkerGlobalScope>(GetExecutionContext())
-        ->RespondToFetchEventWithResponseStream(
-            event_id_, std::move(fetch_api_response),
-            fetch_loader_client->Handle(), event_dispatch_time_,
-            base::TimeTicks::Now());
-
-    fetch_loader_client->SetStarted();
+    service_worker_global_scope->RespondToFetchEventWithResponseStream(
+        event_id_, std::move(fetch_api_response), std::move(stream_handle),
+        event_dispatch_time_, base::TimeTicks::Now());
     return;
   }
-  To<ServiceWorkerGlobalScope>(GetExecutionContext())
-      ->RespondToFetchEvent(event_id_, std::move(fetch_api_response),
-                            event_dispatch_time_, base::TimeTicks::Now());
+  service_worker_global_scope->RespondToFetchEvent(
+      event_id_, std::move(fetch_api_response), event_dispatch_time_,
+      base::TimeTicks::Now());
 }
 
 void FetchRespondWithObserver::OnNoResponse() {

third_party/blink/renderer/modules/service_worker/service_worker_global_scope.cc

@@ -38,7 +38,6 @@
 #include "base/numerics/safe_conversions.h"
 #include "third_party/blink/public/common/features.h"
 #include "third_party/blink/public/platform/modules/service_worker/web_service_worker_error.h"
-#include "third_party/blink/public/platform/modules/service_worker/web_service_worker_stream_handle.h"
 #include "third_party/blink/public/platform/platform.h"
 #include "third_party/blink/public/platform/web_url.h"
 #include "third_party/blink/renderer/bindings/core/v8/callback_promise_adapter.h"
@@ -101,7 +100,6 @@
 #include "third_party/blink/renderer/modules/service_worker/service_worker_registration.h"
 #include "third_party/blink/renderer/modules/service_worker/service_worker_script_cached_metadata_handler.h"
 #include "third_party/blink/renderer/modules/service_worker/service_worker_thread.h"
-#include "third_party/blink/renderer/modules/service_worker/service_worker_timeout_timer.h"
 #include "third_party/blink/renderer/modules/service_worker/service_worker_window_client.h"
 #include "third_party/blink/renderer/modules/service_worker/wait_until_observer.h"
 #include "third_party/blink/renderer/platform/bindings/script_state.h"
@@ -124,30 +122,6 @@ namespace {
 constexpr char kServiceWorkerGlobalScopeTraceScope[] =
     "ServiceWorkerGlobalScope";
 
-class StreamHandleListener : public WebServiceWorkerStreamHandle::Listener {
- public:
-  StreamHandleListener(
-      mojom::blink::ServiceWorkerStreamCallbackPtr callback_ptr,
-      std::unique_ptr<ServiceWorkerTimeoutTimer::StayAwakeToken> token)
-      : callback_ptr_(std::move(callback_ptr)), token_(std::move(token)) {}
-
-  ~StreamHandleListener() override {}
-
-  void OnAborted() override {
-    callback_ptr_->OnAborted();
-    token_.reset();
-  }
-
-  void OnCompleted() override {
-    callback_ptr_->OnCompleted();
-    token_.reset();
-  }
-
- private:
-  mojom::blink::ServiceWorkerStreamCallbackPtr callback_ptr_;
-  std::unique_ptr<ServiceWorkerTimeoutTimer::StayAwakeToken> token_;
-};
-
 void DidSkipWaiting(ScriptPromiseResolver* resolver, bool success) {
   if (!resolver->GetExecutionContext() ||
       resolver->GetExecutionContext()->IsContextDestroyed())
@@ -730,6 +704,11 @@ void ServiceWorkerGlobalScope::DispatchOrQueueFetchEvent(
                      std::move(callback));
 }
 
+std::unique_ptr<ServiceWorkerTimeoutTimer::StayAwakeToken>
+ServiceWorkerGlobalScope::CreateStayAwakeToken() {
+  return timeout_timer_->CreateStayAwakeToken();
+}
+
 ServiceWorker* ServiceWorkerGlobalScope::GetOrCreateServiceWorker(
     WebServiceWorkerObjectInfo info) {
   if (info.version_id == mojom::blink::kInvalidServiceWorkerVersionId)
@@ -1018,7 +997,7 @@ void ServiceWorkerGlobalScope::RespondToFetchEvent(
 void ServiceWorkerGlobalScope::RespondToFetchEventWithResponseStream(
     int fetch_event_id,
     mojom::blink::FetchAPIResponsePtr response,
-    blink::WebServiceWorkerStreamHandle* web_body_as_stream,
+    mojom::blink::ServiceWorkerStreamHandlePtr body_as_stream,
     base::TimeTicks event_dispatch_time,
     base::TimeTicks respond_with_settled_time) {
   DCHECK(IsContextThread());
@@ -1031,14 +1010,6 @@ void ServiceWorkerGlobalScope::RespondToFetchEventWithResponseStream(
   DCHECK(fetch_response_callbacks_.Contains(fetch_event_id));
   mojom::blink::ServiceWorkerFetchResponseCallbackPtr response_callback =
       fetch_response_callbacks_.Take(fetch_event_id);
-  auto body_as_stream = mojom::blink::ServiceWorkerStreamHandle::New();
-  mojom::blink::ServiceWorkerStreamCallbackPtr callback_ptr;
-  body_as_stream->callback_request = mojo::MakeRequest(&callback_ptr);
-  body_as_stream->stream = web_body_as_stream->DrainStreamDataPipe();
-  DCHECK(body_as_stream->stream.is_valid());
-
-  web_body_as_stream->SetListener(std::make_unique<StreamHandleListener>(
-      std::move(callback_ptr), timeout_timer_->CreateStayAwakeToken()));
 
   auto timing = mojom::blink::ServiceWorkerFetchEventTiming::New();
   timing->dispatch_event_time = event_dispatch_time;

third_party/blink/renderer/modules/service_worker/service_worker_global_scope.h

@@ -38,6 +38,7 @@
 #include "third_party/blink/renderer/bindings/core/v8/request_or_usv_string.h"
 #include "third_party/blink/renderer/core/workers/worker_global_scope.h"
 #include "third_party/blink/renderer/modules/modules_export.h"
+#include "third_party/blink/renderer/modules/service_worker/service_worker_timeout_timer.h"
 #include "third_party/blink/renderer/platform/heap/handle.h"
 #include "third_party/blink/renderer/platform/wtf/casting.h"
 #include "third_party/blink/renderer/platform/wtf/forward.h"
@@ -55,10 +56,8 @@ class ServiceWorker;
 class ServiceWorkerClients;
 class ServiceWorkerRegistration;
 class ServiceWorkerThread;
-class ServiceWorkerTimeoutTimer;
 class StringOrTrustedScriptURL;
 class WaitUntilObserver;
-class WebServiceWorkerStreamHandle;
 class WebURLResponse;
 class WorkerClassicScriptLoader;
 struct GlobalScopeCreationParams;
@@ -174,6 +173,11 @@ class MODULES_EXPORT ServiceWorkerGlobalScope final
       mojom::blink::ServiceWorkerFetchResponseCallbackPtr response_callback,
       DispatchFetchEventCallback callback);
 
+  // Creates a ServiceWorkerTimeoutTimer::StayAwakeToken to ensure that the idle
+  // timer won't be triggered while any of these are alive.
+  std::unique_ptr<ServiceWorkerTimeoutTimer::StayAwakeToken>
+  CreateStayAwakeToken();
+
   // Returns the ServiceWorker object described by the given info. Creates a new
   // object if needed, or else returns the existing one.
   ::blink::ServiceWorker* GetOrCreateServiceWorker(WebServiceWorkerObjectInfo);
@@ -229,7 +233,7 @@ class MODULES_EXPORT ServiceWorkerGlobalScope final
   void RespondToFetchEventWithResponseStream(
       int fetch_event_id,
       mojom::blink::FetchAPIResponsePtr,
-      WebServiceWorkerStreamHandle*,
+      mojom::blink::ServiceWorkerStreamHandlePtr,
       base::TimeTicks event_dispatch_time,
       base::TimeTicks respond_with_settled_time);
 

third_party/blink/renderer/platform/BUILD.gn

@@ -546,7 +546,6 @@ jumbo_component("platform") {
     "exported/web_rtc_void_request.cc",
     "exported/web_runtime_features.cc",
     "exported/web_security_origin.cc",
-    "exported/web_service_worker_stream_handle.cc",
     "exported/web_speech_synthesis_utterance.cc",
     "exported/web_speech_synthesis_voice.cc",
     "exported/web_speech_synthesizer_client_impl.cc",

third_party/blink/renderer/platform/exported/web_service_worker_stream_handle.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 "third_party/blink/public/platform/modules/service_worker/web_service_worker_stream_handle.h"
-
-namespace blink {
-
-void WebServiceWorkerStreamHandle::SetListener(
-    std::unique_ptr<Listener> listener) {
-  DCHECK(!listener_);
-  listener_ = std::move(listener);
-}
-
-void WebServiceWorkerStreamHandle::Aborted() {
-  DCHECK(listener_);
-  listener_->OnAborted();
-}
-
-void WebServiceWorkerStreamHandle::Completed() {
-  DCHECK(listener_);
-  listener_->OnCompleted();
-}
-
-mojo::ScopedDataPipeConsumerHandle
-WebServiceWorkerStreamHandle::DrainStreamDataPipe() {
-  DCHECK(stream_.is_valid());
-  return std::move(stream_);
-}
-
-}  // namespace blink