service worker: Remove direct use of old resource reader

This removes direct use of ServiceWorkerResponseReader from tests.
Tests use the mojo version instead.

Bug: 1055677
Change-Id: Id1d955a88d76b515c5e2be9ed0b8bd12dbade814
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2302978
Commit-Queue: Kenichi Ishibashi <bashi@chromium.org>
Reviewed-by: Makoto Shimazu <shimazu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#789846}

content/browser/service_worker/service_worker_installed_scripts_sender_unittest.cc

@@ -367,7 +367,7 @@ TEST_F(ServiceWorkerInstalledScriptsSenderTest, FailedToSendMetaData) {
 TEST_F(ServiceWorkerInstalledScriptsSenderTest, Histograms) {
   const GURL kMainScriptURL = version()->script_url();
   // Use script bodies small enough to be read by one
-  // ServiceWorkerResponseReader::ReadData(). The number of
+  // ServiceWorkerResourceReader::ReadData(). The number of
   // ServiceWorker.DiskCache.ReadResponseResult will be two per script (one is
   // reading the body and the other is saying EOD).
   std::map<GURL, ExpectedScriptInfo> kExpectedScriptInfoMap = {

content/browser/service_worker/service_worker_new_script_loader_unittest.cc

@@ -239,7 +239,7 @@ class ServiceWorkerNewScriptLoaderTest : public testing::Test {
   // Returns false if the entry for |url| doesn't exist in the storage.
   bool VerifyStoredResponse(const GURL& url) {
     return ServiceWorkerUpdateCheckTestUtils::VerifyStoredResponse(
-        LookupResourceId(url), context()->storage(),
+        LookupResourceId(url), context()->GetStorageControl(),
         mock_server_.Get(url).body);
   }
 

content/browser/service_worker/service_worker_script_loader_factory_unittest.cc

@@ -142,7 +142,7 @@ class ServiceWorkerScriptLoaderFactoryCopyResumeTest
     // The response should also be stored in the storage.
     EXPECT_TRUE(ServiceWorkerUpdateCheckTestUtils::VerifyStoredResponse(
         version_->script_cache_map()->LookupResourceId(script_url_),
-        helper_->context()->storage(), expected_body));
+        helper_->context()->GetStorageControl(), expected_body));
 
     EXPECT_TRUE(client_.has_received_response());
     EXPECT_TRUE(client_.response_body().is_valid());

content/browser/service_worker/service_worker_storage_control_impl_unittest.cc

@@ -100,37 +100,6 @@ ReadResponseHeadResult ReadResponseHead(
   return result;
 }
 
-class MockServiceWorkerDataPipeStateNotifier
-    : public storage::mojom::ServiceWorkerDataPipeStateNotifier {
- public:
-  MockServiceWorkerDataPipeStateNotifier() = default;
-
-  mojo::PendingRemote<storage::mojom::ServiceWorkerDataPipeStateNotifier>
-  BindNewPipeAndPassRemote() {
-    return receiver_.BindNewPipeAndPassRemote();
-  }
-
-  int32_t WaitUntilComplete() {
-    if (!complete_status_.has_value()) {
-      loop_.Run();
-      DCHECK(complete_status_.has_value());
-    }
-    return *complete_status_;
-  }
-
- private:
-  void OnComplete(int32_t status) override {
-    complete_status_ = status;
-    if (loop_.running())
-      loop_.Quit();
-  }
-
-  base::Optional<int32_t> complete_status_;
-  base::RunLoop loop_;
-  mojo::Receiver<storage::mojom::ServiceWorkerDataPipeStateNotifier> receiver_{
-      this};
-};
-
 ReadDataResult ReadResponseData(
     storage::mojom::ServiceWorkerResourceReader* reader,
     int data_size) {

content/browser/service_worker/service_worker_test_utils.cc

@@ -12,7 +12,6 @@
 #include <vector>
 
 #include "base/barrier_closure.h"
-#include "base/run_loop.h"
 #include "base/test/bind_test_util.h"
 #include "base/time/time.h"
 #include "content/browser/frame_host/frame_tree_node.h"
@@ -707,6 +706,33 @@ void MockServiceWorkerResourceWriter::CompletePendingWrite() {
   base::RunLoop().RunUntilIdle();
 }
 
+MockServiceWorkerDataPipeStateNotifier::
+    MockServiceWorkerDataPipeStateNotifier() = default;
+
+MockServiceWorkerDataPipeStateNotifier::
+    ~MockServiceWorkerDataPipeStateNotifier() = default;
+
+mojo::PendingRemote<storage::mojom::ServiceWorkerDataPipeStateNotifier>
+MockServiceWorkerDataPipeStateNotifier::BindNewPipeAndPassRemote() {
+  return receiver_.BindNewPipeAndPassRemote();
+}
+
+int32_t MockServiceWorkerDataPipeStateNotifier::WaitUntilComplete() {
+  if (!complete_status_.has_value()) {
+    base::RunLoop loop;
+    on_complete_callback_ = loop.QuitClosure();
+    loop.Run();
+    DCHECK(complete_status_.has_value());
+  }
+  return *complete_status_;
+}
+
+void MockServiceWorkerDataPipeStateNotifier::OnComplete(int32_t status) {
+  complete_status_ = status;
+  if (on_complete_callback_)
+    std::move(on_complete_callback_).Run();
+}
+
 ServiceWorkerUpdateCheckTestUtils::ServiceWorkerUpdateCheckTestUtils() =
     default;
 ServiceWorkerUpdateCheckTestUtils::~ServiceWorkerUpdateCheckTestUtils() =
@@ -848,43 +874,57 @@ void ServiceWorkerUpdateCheckTestUtils::
 
 bool ServiceWorkerUpdateCheckTestUtils::VerifyStoredResponse(
     int64_t resource_id,
-    ServiceWorkerStorage* storage,
+    mojo::Remote<storage::mojom::ServiceWorkerStorageControl>& storage,
     const std::string& expected_body) {
   DCHECK(storage);
   if (resource_id == blink::mojom::kInvalidServiceWorkerResourceId)
     return false;
 
+  mojo::Remote<storage::mojom::ServiceWorkerResourceReader> reader;
+  storage->CreateResourceReader(resource_id,
+                                reader.BindNewPipeAndPassReceiver());
+
   // Verify the response status.
   size_t response_data_size = 0;
   {
-    std::unique_ptr<ServiceWorkerResponseReader> reader =
-        storage->CreateResponseReader(resource_id);
-    auto info_buffer = base::MakeRefCounted<HttpResponseInfoIOBuffer>();
-    net::TestCompletionCallback cb;
-    reader->ReadInfo(info_buffer.get(), cb.callback());
-    int rv = cb.WaitForResult();
+    int rv;
+    std::string status_text;
+    base::RunLoop loop;
+    reader->ReadResponseHead(base::BindLambdaForTesting(
+        [&](int status, network::mojom::URLResponseHeadPtr response_head,
+            base::Optional<mojo_base::BigBuffer> metadata) {
+          rv = status;
+          status_text = response_head->headers->GetStatusText();
+          response_data_size = response_head->content_length;
+          loop.Quit();
+        }));
+    loop.Run();
+
     if (rv < 0)
       return false;
     EXPECT_LT(0, rv);
-    EXPECT_EQ("OK", info_buffer->http_info->headers->GetStatusText());
-    response_data_size = info_buffer->response_data_size;
+    EXPECT_EQ("OK", status_text);
   }
 
   // Verify the response body.
   {
-    std::unique_ptr<ServiceWorkerResponseReader> reader =
-        storage->CreateResponseReader(resource_id);
-    auto buffer =
-        base::MakeRefCounted<net::IOBufferWithSize>(response_data_size);
-    net::TestCompletionCallback cb;
-    reader->ReadData(buffer.get(), buffer->size(), cb.callback());
-    int rv = cb.WaitForResult();
+    MockServiceWorkerDataPipeStateNotifier notifier;
+    mojo::ScopedDataPipeConsumerHandle data_consumer;
+    base::RunLoop loop;
+    reader->ReadData(response_data_size, notifier.BindNewPipeAndPassRemote(),
+                     base::BindLambdaForTesting(
+                         [&](mojo::ScopedDataPipeConsumerHandle pipe) {
+                           data_consumer = std::move(pipe);
+                           loop.Quit();
+                         }));
+    loop.Run();
+
+    std::string body = ReadDataPipe(std::move(data_consumer));
+    int rv = notifier.WaitUntilComplete();
     if (rv < 0)
       return false;
     EXPECT_EQ(static_cast<int>(expected_body.size()), rv);
-
-    std::string received_body(buffer->data(), rv);
-    EXPECT_EQ(expected_body, received_body);
+    EXPECT_EQ(expected_body, body);
   }
   return true;
 }

content/browser/service_worker/service_worker_test_utils.h

@@ -11,6 +11,7 @@
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/weak_ptr.h"
+#include "base/run_loop.h"
 #include "base/task/post_task.h"
 #include "components/services/storage/public/mojom/service_worker_storage_control.mojom.h"
 #include "content/browser/service_worker/service_worker_cache_writer.h"
@@ -372,6 +373,28 @@ class MockServiceWorkerResourceWriter
   DISALLOW_COPY_AND_ASSIGN(MockServiceWorkerResourceWriter);
 };
 
+// A test implementation of ServiceWorkerDataPipeStateNotifier.
+class MockServiceWorkerDataPipeStateNotifier
+    : public storage::mojom::ServiceWorkerDataPipeStateNotifier {
+ public:
+  MockServiceWorkerDataPipeStateNotifier();
+  ~MockServiceWorkerDataPipeStateNotifier() override;
+
+  mojo::PendingRemote<storage::mojom::ServiceWorkerDataPipeStateNotifier>
+  BindNewPipeAndPassRemote();
+
+  int32_t WaitUntilComplete();
+
+ private:
+  // storage::mojom::ServiceWorkerDataPipeStateNotifier implementations:
+  void OnComplete(int32_t status) override;
+
+  base::Optional<int32_t> complete_status_;
+  base::OnceClosure on_complete_callback_;
+  mojo::Receiver<storage::mojom::ServiceWorkerDataPipeStateNotifier> receiver_{
+      this};
+};
+
 class ServiceWorkerUpdateCheckTestUtils {
  public:
   ServiceWorkerUpdateCheckTestUtils();
@@ -428,9 +451,10 @@ class ServiceWorkerUpdateCheckTestUtils {
   // Returns false if the entry for |resource_id| doesn't exist in the storage.
   // Returns true when response status is "OK" and response body is same as
   // expected if body exists.
-  static bool VerifyStoredResponse(int64_t resource_id,
-                                   ServiceWorkerStorage* storage,
-                                   const std::string& expected_body);
+  static bool VerifyStoredResponse(
+      int64_t resource_id,
+      mojo::Remote<storage::mojom::ServiceWorkerStorageControl>& storage,
+      const std::string& expected_body);
 };
 
 // Reads all data from the given |handle| and returns data as a string.

content/browser/service_worker/service_worker_updated_script_loader_unittest.cc

@@ -167,7 +167,8 @@ class ServiceWorkerUpdatedScriptLoaderTest : public testing::Test {
 
     // The response should also be stored in the storage.
     EXPECT_TRUE(ServiceWorkerUpdateCheckTestUtils::VerifyStoredResponse(
-        LookupResourceId(kScriptURL), context()->storage(), expected_body));
+        LookupResourceId(kScriptURL), context()->GetStorageControl(),
+        expected_body));
 
     std::string response;
     EXPECT_TRUE(mojo::BlockingCopyToString(client_->response_body_release(),