ServiceWorker: Use mojo's data pipe for respondWith(stream)

content/browser/service_worker/service_worker_url_request_job_unittest.cc

Index: content/browser/service_worker/service_worker_url_request_job_unittest.cc
diff --git a/content/browser/service_worker/service_worker_url_request_job_unittest.cc b/content/browser/service_worker/service_worker_url_request_job_unittest.cc
index f069999f0de6b79056e00d7d9d36c6783509889c..e6ecbc42cae758942ad81c3d2af00321716f6d9e 100644
--- a/content/browser/service_worker/service_worker_url_request_job_unittest.cc
+++ b/content/browser/service_worker/service_worker_url_request_job_unittest.cc
@@ -28,9 +28,6 @@
 #include "content/browser/service_worker/service_worker_response_info.h"
 #include "content/browser/service_worker/service_worker_test_utils.h"
 #include "content/browser/service_worker/service_worker_version.h"
-#include "content/browser/streams/stream.h"
-#include "content/browser/streams/stream_context.h"
-#include "content/browser/streams/stream_registry.h"
 #include "content/common/resource_request_body_impl.h"
 #include "content/common/service_worker/service_worker_messages.h"
 #include "content/common/service_worker/service_worker_status_code.h"
@@ -402,26 +399,26 @@ class ProviderDeleteHelper : public EmbeddedWorkerTestHelper {
   ~ProviderDeleteHelper() override {}
 
  protected:
-  void OnFetchEvent(int embedded_worker_id,
-                    int fetch_event_id,
-                    const ServiceWorkerFetchRequest& request,
-                    mojom::FetchEventPreloadHandlePtr preload_handle,
-                    const FetchCallback& callback) override {
+  void OnFetchEvent(
+      int /* embedded_worker_id */,
+      int /* fetch_event_id */,
+      const ServiceWorkerFetchRequest& /* request */,
+      mojom::FetchEventPreloadHandlePtr /* preload_handle */,
+      mojom::ServiceWorkerFetchResponseCallbackPtr response_callback,
+      const FetchCallback& finish_callback) override {
     context()->RemoveProviderHost(mock_render_process_id(), kProviderID);
-    SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
-        embedded_worker_id, fetch_event_id,
-        SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
+    response_callback->OnResponse(
         ServiceWorkerResponse(
             base::MakeUnique<std::vector<GURL>>(), 200, "OK",
             blink::WebServiceWorkerResponseTypeDefault,
             base::MakeUnique<ServiceWorkerHeaderMap>(), std::string(), 0,
-            GURL(), blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
+            blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
             false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
             base::MakeUnique<
                 ServiceWorkerHeaderList>() /* cors_exposed_header_names */),
-        base::Time::Now()));
-    callback.Run(SERVICE_WORKER_OK, base::Time::Now());
+        base::Time::Now());
+    finish_callback.Run(SERVICE_WORKER_OK, base::Time::Now());
   }
 
  private:
@@ -488,25 +485,24 @@ class BlobResponder : public EmbeddedWorkerTestHelper {
   ~BlobResponder() override {}
 
  protected:
-  void OnFetchEvent(int embedded_worker_id,
-                    int fetch_event_id,
-                    const ServiceWorkerFetchRequest& request,
-                    mojom::FetchEventPreloadHandlePtr preload_handle,
-                    const FetchCallback& callback) override {
-    SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
-        embedded_worker_id, fetch_event_id,
-        SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
+  void OnFetchEvent(
+      int /* embedded_worker_id */,
+      int /* fetch_event_id */,
+      const ServiceWorkerFetchRequest& /* request */,
+      mojom::FetchEventPreloadHandlePtr /* preload_handle */,
+      mojom::ServiceWorkerFetchResponseCallbackPtr response_callback,
+      const FetchCallback& finish_callback) override {
+    response_callback->OnResponse(
         ServiceWorkerResponse(
             base::MakeUnique<std::vector<GURL>>(), 200, "OK",
             blink::WebServiceWorkerResponseTypeDefault, MakeHeaders(),
-            blob_uuid_, blob_size_, GURL(),
-            blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
-            false /* response_is_in_cache_storage */,
+            blob_uuid_, blob_size_, blink::WebServiceWorkerResponseErrorUnknown,
+            base::Time(), false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
             base::MakeUnique<
                 ServiceWorkerHeaderList>() /* cors_exposed_header_names */),
-        base::Time::Now()));
-    callback.Run(SERVICE_WORKER_OK, base::Time::Now());
+        base::Time::Now());
+    finish_callback.Run(SERVICE_WORKER_OK, base::Time::Now());
   }
 
   std::string blob_uuid_;
@@ -569,45 +565,51 @@ TEST_F(ServiceWorkerURLRequestJobTest, NonExistentBlobUUIDResponse) {
 // Responds to fetch events with a stream.
 class StreamResponder : public EmbeddedWorkerTestHelper {
  public:
-  explicit StreamResponder(const GURL& stream_url)
-      : EmbeddedWorkerTestHelper(base::FilePath()), stream_url_(stream_url) {}
+  explicit StreamResponder(
+      blink::mojom::ServiceWorkerStreamCallbackRequest callback_request,
+      mojo::ScopedDataPipeConsumerHandle consumer_handle)
+      : EmbeddedWorkerTestHelper(base::FilePath()) {
+    EXPECT_TRUE(stream_handle_.is_null());
+    stream_handle_ = blink::mojom::ServiceWorkerStreamHandle::New();
+    stream_handle_->callback_request = std::move(callback_request);
+    stream_handle_->stream = std::move(consumer_handle);
+  }
   ~StreamResponder() override {}
 
  protected:
-  void OnFetchEvent(int embedded_worker_id,
-                    int fetch_event_id,
-                    const ServiceWorkerFetchRequest& request,
-                    mojom::FetchEventPreloadHandlePtr preload_handle,
-                    const FetchCallback& callback) override {
-    SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
-        embedded_worker_id, fetch_event_id,
-        SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
+  void OnFetchEvent(
+      int /* embedded_worker_id */,
+      int /* fetch_event_id */,
+      const ServiceWorkerFetchRequest& /* request */,
+      mojom::FetchEventPreloadHandlePtr /* preload_handle */,
+      mojom::ServiceWorkerFetchResponseCallbackPtr response_callback,
+      const FetchCallback& finish_callback) override {
+    ASSERT_FALSE(stream_handle_.is_null());
+    response_callback->OnResponseStream(
         ServiceWorkerResponse(
             base::MakeUnique<std::vector<GURL>>(), 200, "OK",
             blink::WebServiceWorkerResponseTypeDefault, MakeHeaders(), "", 0,
-            stream_url_, blink::WebServiceWorkerResponseErrorUnknown,
-            base::Time(), false /* response_is_in_cache_storage */,
+            blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
+            false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
             base::MakeUnique<
                 ServiceWorkerHeaderList>() /* cors_exposed_header_names */),
-        base::Time::Now()));
-    callback.Run(SERVICE_WORKER_OK, base::Time::Now());
+        std::move(stream_handle_), base::Time::Now());
+    finish_callback.Run(SERVICE_WORKER_OK, base::Time::Now());
   }
 
-  const GURL stream_url_;
+  blink::mojom::ServiceWorkerStreamHandlePtr stream_handle_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StreamResponder);
 };
 
 TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse) {
-  const GURL stream_url("blob://stream");
-  StreamContext* stream_context =
-      GetStreamContextForResourceContext(
-          browser_context_->GetResourceContext());
-  scoped_refptr<Stream> stream =
-      new Stream(stream_context->registry(), nullptr, stream_url);
-  SetUpWithHelper(new StreamResponder(stream_url));
+  blink::mojom::ServiceWorkerStreamCallbackPtr stream_callback;
+  mojo::DataPipe data_pipe;
+  SetUpWithHelper(new StreamResponder(mojo::MakeRequest(&stream_callback),
+                                      std::move(data_pipe.consumer_handle)));
+
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
       GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
@@ -619,9 +621,13 @@ TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse) {
   expected_response.reserve((sizeof(kTestData) - 1) * 1024);
   for (int i = 0; i < 1024; ++i) {
     expected_response += kTestData;
-    stream->AddData(kTestData, sizeof(kTestData) - 1);
+    uint32_t written_bytes = sizeof(kTestData) - 1;
+    MojoResult result =
+        mojo::WriteDataRaw(data_pipe.producer_handle.get(), kTestData,
+                           &written_bytes, MOJO_WRITE_DATA_FLAG_NONE);
+    ASSERT_EQ(MOJO_RESULT_OK, result);
+    EXPECT_EQ(sizeof(kTestData) - 1, written_bytes);
   }
-  stream->Finalize(net::OK);
 
   EXPECT_FALSE(HasWork());
   base::RunLoop().RunUntilIdle();
@@ -649,78 +655,31 @@ TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse) {
   EXPECT_FALSE(HasWork());
 }
 
-TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse_DelayedRegistration) {
-  const GURL stream_url("blob://stream");
-  StreamContext* stream_context =
-      GetStreamContextForResourceContext(
-          browser_context_->GetResourceContext());
-  SetUpWithHelper(new StreamResponder(stream_url));
-
-  version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
-  request_ = url_request_context_.CreateRequest(
-      GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
-      &url_request_delegate_);
-  request_->set_method("GET");
-  request_->Start();
-
-  scoped_refptr<Stream> stream =
-      new Stream(stream_context->registry(), nullptr, stream_url);
-  std::string expected_response;
-  expected_response.reserve((sizeof(kTestData) - 1) * 1024);
-  for (int i = 0; i < 1024; ++i) {
-    expected_response += kTestData;
-    stream->AddData(kTestData, sizeof(kTestData) - 1);
-  }
-  stream->Finalize(net::OK);
-
-  EXPECT_FALSE(HasWork());
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(HasWork());
-  EXPECT_TRUE(request_->status().is_success());
-  EXPECT_EQ(200,
-            request_->response_headers()->response_code());
-  EXPECT_EQ("OK",
-            request_->response_headers()->GetStatusText());
-  EXPECT_EQ(expected_response, url_request_delegate_.data_received());
-
-  EXPECT_EQ(0, times_prepare_to_restart_invoked_);
-  ServiceWorkerResponseInfo* info =
-      ServiceWorkerResponseInfo::ForRequest(request_.get());
-  ASSERT_TRUE(info);
-  EXPECT_TRUE(info->was_fetched_via_service_worker());
-  EXPECT_FALSE(info->was_fallback_required());
-  EXPECT_EQ(0u, info->url_list_via_service_worker().size());
-  EXPECT_EQ(blink::WebServiceWorkerResponseTypeDefault,
-            info->response_type_via_service_worker());
-  EXPECT_FALSE(info->service_worker_start_time().is_null());
-  EXPECT_FALSE(info->service_worker_ready_time().is_null());
-
-  request_.reset();
-  EXPECT_FALSE(HasWork());
-}
-
 TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse_QuickFinalize) {
-  const GURL stream_url("blob://stream");
-  StreamContext* stream_context =
-      GetStreamContextForResourceContext(
-          browser_context_->GetResourceContext());
-  scoped_refptr<Stream> stream =
-      new Stream(stream_context->registry(), nullptr, stream_url);
+  blink::mojom::ServiceWorkerStreamCallbackPtr stream_callback;
+  mojo::DataPipe data_pipe;
+
   std::string expected_response;
   expected_response.reserve((sizeof(kTestData) - 1) * 1024);
   for (int i = 0; i < 1024; ++i) {
     expected_response += kTestData;
-    stream->AddData(kTestData, sizeof(kTestData) - 1);
+    uint32_t written_bytes = sizeof(kTestData) - 1;
+    MojoResult result =
+        mojo::WriteDataRaw(data_pipe.producer_handle.get(), kTestData,
+                           &written_bytes, MOJO_WRITE_DATA_FLAG_NONE);
+    ASSERT_EQ(MOJO_RESULT_OK, result);
+    EXPECT_EQ(sizeof(kTestData) - 1, written_bytes);
   }
-  stream->Finalize(net::OK);
-  SetUpWithHelper(new StreamResponder(stream_url));
 
+  SetUpWithHelper(new StreamResponder(mojo::MakeRequest(&stream_callback),
+                                      std::move(data_pipe.consumer_handle)));
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
       GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
       &url_request_delegate_);
   request_->set_method("GET");
   request_->Start();
+
   EXPECT_FALSE(HasWork());
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(HasWork());
@@ -729,6 +688,7 @@ TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse_QuickFinalize) {
             request_->response_headers()->response_code());
   EXPECT_EQ("OK",
             request_->response_headers()->GetStatusText());
+  CheckHeaders(request_->response_headers());
   EXPECT_EQ(expected_response, url_request_delegate_.data_received());
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
@@ -747,14 +707,11 @@ TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse_QuickFinalize) {
   EXPECT_FALSE(HasWork());
 }
 
-TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse_Flush) {
-  const GURL stream_url("blob://stream");
-  StreamContext* stream_context =
-      GetStreamContextForResourceContext(
-          browser_context_->GetResourceContext());
-  scoped_refptr<Stream> stream =
-      new Stream(stream_context->registry(), nullptr, stream_url);
-  SetUpWithHelper(new StreamResponder(stream_url));
+TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse_ConsecutiveRead) {
+  blink::mojom::ServiceWorkerStreamCallbackPtr stream_callback;
+  mojo::DataPipe data_pipe;
+  SetUpWithHelper(new StreamResponder(mojo::MakeRequest(&stream_callback),
+                                      std::move(data_pipe.consumer_handle)));
 
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
@@ -766,12 +723,15 @@ TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse_Flush) {
   expected_response.reserve((sizeof(kTestData) - 1) * 1024);
   for (int i = 0; i < 1024; ++i) {
     expected_response += kTestData;
-    stream->AddData(kTestData, sizeof(kTestData) - 1);
-    stream->Flush();
+    uint32_t written_bytes = sizeof(kTestData) - 1;
+    MojoResult result =
+        mojo::WriteDataRaw(data_pipe.producer_handle.get(), kTestData,
+                           &written_bytes, MOJO_WRITE_DATA_FLAG_NONE);
+    ASSERT_EQ(MOJO_RESULT_OK, result);
+    EXPECT_EQ(sizeof(kTestData) - 1, written_bytes);
     base::RunLoop().RunUntilIdle();
     EXPECT_EQ(expected_response, url_request_delegate_.data_received());
   }
-  stream->Finalize(net::OK);
   base::RunLoop().RunUntilIdle();

[horo, 2017/04/06 05:22:09]

Why we don't need to call OnCompleted()?

And could you please add tests for OnAborted()?

[shimazu, 2017/04/07 08:52:29]

Oops, I forgot to add it.
Added OnCompleted and added the tests.

   EXPECT_TRUE(request_->status().is_success());
   EXPECT_EQ(200,
@@ -794,15 +754,10 @@ TEST_F(ServiceWorkerURLRequestJobTest, StreamResponse_Flush) {
 }
 
 TEST_F(ServiceWorkerURLRequestJobTest, StreamResponseAndCancel) {
-  const GURL stream_url("blob://stream");
-  StreamContext* stream_context =
-      GetStreamContextForResourceContext(
-          browser_context_->GetResourceContext());
-  scoped_refptr<Stream> stream =
-      new Stream(stream_context->registry(), nullptr, stream_url);
-  ASSERT_EQ(stream.get(),
-            stream_context->registry()->GetStream(stream_url).get());
-  SetUpWithHelper(new StreamResponder(stream_url));
+  blink::mojom::ServiceWorkerStreamCallbackPtr stream_callback;
+  mojo::DataPipe data_pipe;
+  SetUpWithHelper(new StreamResponder(mojo::MakeRequest(&stream_callback),
+                                      std::move(data_pipe.consumer_handle)));
 
   version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
   request_ = url_request_context_.CreateRequest(
@@ -814,23 +769,27 @@ TEST_F(ServiceWorkerURLRequestJobTest, StreamResponseAndCancel) {
   base::RunLoop().RunUntilIdle();
   EXPECT_TRUE(HasWork());
 
-  std::string expected_response;
-  expected_response.reserve((sizeof(kTestData) - 1) * 1024);
   for (int i = 0; i < 512; ++i) {
-    expected_response += kTestData;
-    stream->AddData(kTestData, sizeof(kTestData) - 1);
+    uint32_t written_bytes = sizeof(kTestData) - 1;
+    MojoResult result =
+        mojo::WriteDataRaw(data_pipe.producer_handle.get(), kTestData,
+                           &written_bytes, MOJO_WRITE_DATA_FLAG_NONE);
+    ASSERT_EQ(MOJO_RESULT_OK, result);
+    EXPECT_EQ(sizeof(kTestData) - 1, written_bytes);
   }
-  ASSERT_TRUE(stream_context->registry()->GetStream(stream_url).get());
+  EXPECT_TRUE(data_pipe.producer_handle.is_valid());
   request_->Cancel();
   EXPECT_FALSE(HasWork());
-  ASSERT_FALSE(stream_context->registry()->GetStream(stream_url).get());
   for (int i = 0; i < 512; ++i) {
-    expected_response += kTestData;
-    stream->AddData(kTestData, sizeof(kTestData) - 1);
+    uint32_t written_bytes = sizeof(kTestData) - 1;
+    MojoResult result =
+        mojo::WriteDataRaw(data_pipe.producer_handle.get(), kTestData,
+                           &written_bytes, MOJO_WRITE_DATA_FLAG_NONE);
+    ASSERT_EQ(MOJO_RESULT_FAILED_PRECONDITION, result);
   }
-  stream->Finalize(net::OK);
 
   base::RunLoop().RunUntilIdle();
+  EXPECT_FALSE(data_pipe.consumer_handle.is_valid());
   EXPECT_FALSE(request_->status().is_success());
 
   EXPECT_EQ(0, times_prepare_to_restart_invoked_);
@@ -846,41 +805,6 @@ TEST_F(ServiceWorkerURLRequestJobTest, StreamResponseAndCancel) {
   EXPECT_FALSE(info->service_worker_ready_time().is_null());
 }
 
-TEST_F(ServiceWorkerURLRequestJobTest,
-       StreamResponse_DelayedRegistrationAndCancel) {
-  const GURL stream_url("blob://stream");
-  StreamContext* stream_context =
-      GetStreamContextForResourceContext(
-          browser_context_->GetResourceContext());
-  SetUpWithHelper(new StreamResponder(stream_url));
-
-  version_->SetStatus(ServiceWorkerVersion::ACTIVATED);
-  request_ = url_request_context_.CreateRequest(
-      GURL("https://example.com/foo.html"), net::DEFAULT_PRIORITY,
-      &url_request_delegate_);
-  request_->set_method("GET");
-  request_->Start();
-  EXPECT_FALSE(HasWork());
-  base::RunLoop().RunUntilIdle();
-  EXPECT_TRUE(HasWork());
-  request_->Cancel();
-  EXPECT_FALSE(HasWork());
-
-  scoped_refptr<Stream> stream =
-      new Stream(stream_context->registry(), nullptr, stream_url);
-  // The stream should not be registered to the stream registry.
-  ASSERT_FALSE(stream_context->registry()->GetStream(stream_url).get());
-  for (int i = 0; i < 1024; ++i)
-    stream->AddData(kTestData, sizeof(kTestData) - 1);
-  stream->Finalize(net::OK);
-
-  base::RunLoop().RunUntilIdle();
-  EXPECT_FALSE(request_->status().is_success());
-
-  EXPECT_EQ(0, times_prepare_to_restart_invoked_);
-  EXPECT_FALSE(ServiceWorkerResponseInfo::ForRequest(request_.get()));
-}
-
 // Helper to simulate failing to dispatch a fetch event to a worker.
 class FailFetchHelper : public EmbeddedWorkerTestHelper {
  public:
@@ -888,13 +812,15 @@ class FailFetchHelper : public EmbeddedWorkerTestHelper {
   ~FailFetchHelper() override {}
 
  protected:
-  void OnFetchEvent(int embedded_worker_id,
-                    int fetch_event_id,
-                    const ServiceWorkerFetchRequest& request,
-                    mojom::FetchEventPreloadHandlePtr preload_handle,
-                    const FetchCallback& callback) override {
+  void OnFetchEvent(
+      int embedded_worker_id,
+      int /* fetch_event_id */,
+      const ServiceWorkerFetchRequest& /* request */,
+      mojom::FetchEventPreloadHandlePtr /* preload_handle */,
+      mojom::ServiceWorkerFetchResponseCallbackPtr /* response_callback */,
+      const FetchCallback& finish_callback) override {
     SimulateWorkerStopped(embedded_worker_id);
-    callback.Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
+    finish_callback.Run(SERVICE_WORKER_ERROR_ABORT, base::Time::Now());
   }
 
  private:
@@ -969,33 +895,33 @@ class EarlyResponseHelper : public EmbeddedWorkerTestHelper {
   ~EarlyResponseHelper() override {}
 
   void FinishWaitUntil() {
-    callback_.Run(SERVICE_WORKER_OK, base::Time::Now());
+    finish_callback_.Run(SERVICE_WORKER_OK, base::Time::Now());
   }
 
  protected:
-  void OnFetchEvent(int embedded_worker_id,
-                    int fetch_event_id,
-                    const ServiceWorkerFetchRequest& request,
-                    mojom::FetchEventPreloadHandlePtr preload_handle,
-                    const FetchCallback& callback) override {
-    callback_ = callback;
-    SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
-        embedded_worker_id, fetch_event_id,
-        SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
+  void OnFetchEvent(
+      int /* embedded_worker_id */,
+      int /* fetch_event_id */,
+      const ServiceWorkerFetchRequest& /* request */,
+      mojom::FetchEventPreloadHandlePtr /* preload_handle */,
+      mojom::ServiceWorkerFetchResponseCallbackPtr response_callback,
+      const FetchCallback& finish_callback) override {
+    finish_callback_ = finish_callback;
+    response_callback->OnResponse(
         ServiceWorkerResponse(
             base::MakeUnique<std::vector<GURL>>(), 200, "OK",
             blink::WebServiceWorkerResponseTypeDefault,
             base::MakeUnique<ServiceWorkerHeaderMap>(), std::string(), 0,
-            GURL(), blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
+            blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
             false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
             base::MakeUnique<
                 ServiceWorkerHeaderList>() /* cors_exposed_header_names */),
-        base::Time::Now()));
+        base::Time::Now());
   }
 
  private:
-  FetchCallback callback_;
+  FetchCallback finish_callback_;
   DISALLOW_COPY_AND_ASSIGN(EarlyResponseHelper);
 };
 
@@ -1035,37 +961,39 @@ class DelayedResponseHelper : public EmbeddedWorkerTestHelper {
   ~DelayedResponseHelper() override {}
 
   void Respond() {
-    SimulateSend(new ServiceWorkerHostMsg_FetchEventResponse(
-        embedded_worker_id_, fetch_event_id_,
-        SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE,
+    response_callback_->OnResponse(
         ServiceWorkerResponse(
             base::MakeUnique<std::vector<GURL>>(), 200, "OK",
             blink::WebServiceWorkerResponseTypeDefault,
             base::MakeUnique<ServiceWorkerHeaderMap>(), std::string(), 0,
-            GURL(), blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
+            blink::WebServiceWorkerResponseErrorUnknown, base::Time(),
             false /* response_is_in_cache_storage */,
             std::string() /* response_cache_storage_cache_name */,
             base::MakeUnique<
                 ServiceWorkerHeaderList>() /* cors_exposed_header_names */),
-        base::Time::Now()));
-    callback_.Run(SERVICE_WORKER_OK, base::Time::Now());
+        base::Time::Now());
+    finish_callback_.Run(SERVICE_WORKER_OK, base::Time::Now());
   }
 
  protected:
-  void OnFetchEvent(int embedded_worker_id,
-                    int fetch_event_id,
-                    const ServiceWorkerFetchRequest& request,
-                    mojom::FetchEventPreloadHandlePtr preload_handle,
-                    const FetchCallback& callback) override {
+  void OnFetchEvent(
+      int embedded_worker_id,
+      int fetch_event_id,
+      const ServiceWorkerFetchRequest& /* request */,
+      mojom::FetchEventPreloadHandlePtr /* preload_handle */,
+      mojom::ServiceWorkerFetchResponseCallbackPtr response_callback,
+      const FetchCallback& finish_callback) override {
     embedded_worker_id_ = embedded_worker_id;
     fetch_event_id_ = fetch_event_id;
-    callback_ = callback;
+    response_callback_ = std::move(response_callback);
+    finish_callback_ = finish_callback;
   }
 
  private:
   int embedded_worker_id_ = 0;
   int fetch_event_id_ = 0;
-  FetchCallback callback_;
+  mojom::ServiceWorkerFetchResponseCallbackPtr response_callback_;
+  FetchCallback finish_callback_;
   DISALLOW_COPY_AND_ASSIGN(DelayedResponseHelper);
 };