service worker: Reduce old response writers use in tests

This CL replaces old response writers with new mojo-based writers in the
following test helper functions:
* WriteToDiskCacheWithIdSync()
* WriteToDiskCacheSync()
* WriteToDiskCacheAsync()

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

content/browser/service_worker/embedded_worker_test_helper.cc

@@ -184,7 +184,7 @@ void EmbeddedWorkerTestHelper::PopulateScriptCacheMap(
     // Add a dummy ResourceRecord for the main script to the script cache map of
     // the ServiceWorkerVersion.
     WriteToDiskCacheAsync(
-        context()->storage(), version->script_url(), {} /* headers */,
+        context()->GetStorageControl(), version->script_url(), {} /* headers */,
         "I'm a body", "I'm a meta data",
         base::BindOnce(
             [](scoped_refptr<ServiceWorkerVersion> version,

content/browser/service_worker/service_worker_controllee_request_handler_unittest.cc

@@ -109,8 +109,8 @@ class ServiceWorkerControlleeRequestHandlerTest : public testing::Test {
 
     std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> records;
     records.push_back(WriteToDiskCacheSync(
-        context()->storage(), version_->script_url(), {} /* headers */,
-        "I'm a body", "I'm a meta data"));
+        context()->GetStorageControl(), version_->script_url(),
+        {} /* headers */, "I'm a body", "I'm a meta data"));
     version_->script_cache_map()->SetResources(records);
     version_->SetMainScriptResponse(
         EmbeddedWorkerTestHelper::CreateMainScriptResponse());

content/browser/service_worker/service_worker_installed_scripts_sender_unittest.cc

@@ -43,7 +43,8 @@ class ExpectedScriptInfo {
         meta_data_(meta_data) {}
 
   storage::mojom::ServiceWorkerResourceRecordPtr WriteToDiskCache(
-      ServiceWorkerStorage* storage) const {
+      mojo::Remote<storage::mojom::ServiceWorkerStorageControl>& storage)
+      const {
     return ::content::WriteToDiskCacheWithIdSync(
         storage, script_url_, resource_id_, headers_, body_, meta_data_);
   }
@@ -202,7 +203,8 @@ TEST_F(ServiceWorkerInstalledScriptsSenderTest, SendScripts) {
   {
     std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> records;
     for (const auto& info : kExpectedScriptInfoMap)
-      records.push_back(info.second.WriteToDiskCache(context()->storage()));
+      records.push_back(
+          info.second.WriteToDiskCache(context()->GetStorageControl()));
     version()->script_cache_map()->SetResources(records);
   }
 
@@ -260,7 +262,8 @@ TEST_F(ServiceWorkerInstalledScriptsSenderTest, FailedToSendBody) {
   {
     std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> records;
     for (const auto& info : kExpectedScriptInfoMap)
-      records.push_back(info.second.WriteToDiskCache(context()->storage()));
+      records.push_back(
+          info.second.WriteToDiskCache(context()->GetStorageControl()));
     version()->script_cache_map()->SetResources(records);
   }
 
@@ -319,7 +322,8 @@ TEST_F(ServiceWorkerInstalledScriptsSenderTest, FailedToSendMetaData) {
   {
     std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> records;
     for (const auto& info : kExpectedScriptInfoMap)
-      records.push_back(info.second.WriteToDiskCache(context()->storage()));
+      records.push_back(
+          info.second.WriteToDiskCache(context()->GetStorageControl()));
     version()->script_cache_map()->SetResources(records);
   }
 
@@ -390,7 +394,8 @@ TEST_F(ServiceWorkerInstalledScriptsSenderTest, Histograms) {
   {
     std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> records;
     for (const auto& info : kExpectedScriptInfoMap)
-      records.push_back(info.second.WriteToDiskCache(context()->storage()));
+      records.push_back(
+          info.second.WriteToDiskCache(context()->GetStorageControl()));
     version()->script_cache_map()->SetResources(records);
   }
 
@@ -472,7 +477,8 @@ TEST_F(ServiceWorkerInstalledScriptsSenderTest, RequestScriptBeforeStreaming) {
   {
     std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> records;
     for (const auto& info : kExpectedScriptInfoMap)
-      records.push_back(info.second.WriteToDiskCache(context()->storage()));
+      records.push_back(
+          info.second.WriteToDiskCache(context()->GetStorageControl()));
     version()->script_cache_map()->SetResources(records);
   }
 
@@ -562,7 +568,8 @@ TEST_F(ServiceWorkerInstalledScriptsSenderTest, RequestScriptAfterStreaming) {
   {
     std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> records;
     for (const auto& info : kExpectedScriptInfoMap)
-      records.push_back(info.second.WriteToDiskCache(context()->storage()));
+      records.push_back(
+          info.second.WriteToDiskCache(context()->GetStorageControl()));
     version()->script_cache_map()->SetResources(records);
   }
 
@@ -633,7 +640,8 @@ TEST_F(ServiceWorkerInstalledScriptsSenderTest, NoContext) {
         "I'm meta data for the main script"}}};
   std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> records;
   for (const auto& info : kExpectedScriptInfoMap)
-    records.push_back(info.second.WriteToDiskCache(context()->storage()));
+    records.push_back(
+        info.second.WriteToDiskCache(context()->GetStorageControl()));
   version()->script_cache_map()->SetResources(records);
   auto sender =
       std::make_unique<ServiceWorkerInstalledScriptsSender>(version());

content/browser/service_worker/service_worker_main_resource_loader_unittest.cc

@@ -408,9 +408,9 @@ class ServiceWorkerMainResourceLoaderTest : public testing::Test {
         GURL("https://example.com/service_worker.js"),
         blink::mojom::ScriptType::kClassic);
     std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> records;
-    records.push_back(WriteToDiskCacheSync(storage(), version_->script_url(),
-                                           {} /* headers */, "I'm the body",
-                                           "I'm the meta data"));
+    records.push_back(WriteToDiskCacheSync(
+        GetStorageControl(), version_->script_url(), {} /* headers */,
+        "I'm the body", "I'm the meta data"));
     version_->script_cache_map()->SetResources(records);
     version_->set_fetch_handler_existence(
         ServiceWorkerVersion::FetchHandlerExistence::EXISTS);
@@ -454,6 +454,10 @@ class ServiceWorkerMainResourceLoaderTest : public testing::Test {
 
   ServiceWorkerRegistry* registry() { return helper_->context()->registry(); }
   ServiceWorkerStorage* storage() { return helper_->context()->storage(); }
+  mojo::Remote<storage::mojom::ServiceWorkerStorageControl>&
+  GetStorageControl() {
+    return helper_->context()->GetStorageControl();
+  }
 
   // Starts a request. After calling this, the request is ongoing and the
   // caller can use functions like client_.RunUntilComplete() to wait for

content/browser/service_worker/service_worker_registration_unittest.cc

@@ -404,7 +404,7 @@ class ServiceWorkerActivationTest : public ServiceWorkerRegistrationTest,
     // Store the registration.
     std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> records_1;
     records_1.push_back(WriteToDiskCacheSync(
-        helper_->context()->storage(), version_1->script_url(),
+        helper_->context()->GetStorageControl(), version_1->script_url(),
         {} /* headers */, "I'm the body", "I'm the meta data"));
     version_1->script_cache_map()->SetResources(records_1);
     version_1->SetMainScriptResponse(
@@ -446,7 +446,7 @@ class ServiceWorkerActivationTest : public ServiceWorkerRegistrationTest,
                                       blink::mojom::ScriptType::kClassic);
     std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> records_2;
     records_2.push_back(WriteToDiskCacheSync(
-        helper_->context()->storage(), version_2->script_url(),
+        helper_->context()->GetStorageControl(), version_2->script_url(),
         {} /* headers */, "I'm the body", "I'm the meta data"));
     version_2->script_cache_map()->SetResources(records_2);
     version_2->SetMainScriptResponse(
@@ -890,9 +890,9 @@ class ServiceWorkerRegistrationObjectHostTest
         context()->registry(), registration, script_url,
         blink::mojom::ScriptType::kClassic);
     std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> records;
-    records.push_back(WriteToDiskCacheSync(storage(), version->script_url(),
-                                           {} /* headers */, "I'm the body",
-                                           "I'm the meta data"));
+    records.push_back(WriteToDiskCacheSync(
+        helper_->context()->GetStorageControl(), version->script_url(),
+        {} /* headers */, "I'm the body", "I'm the meta data"));
     version->script_cache_map()->SetResources(records);
     version->SetMainScriptResponse(
         EmbeddedWorkerTestHelper::CreateMainScriptResponse());

content/browser/service_worker/service_worker_script_loader_factory_unittest.cc

@@ -133,9 +133,9 @@ class ServiceWorkerScriptLoaderFactoryCopyResumeTest
 
   void SetUp() override {
     ServiceWorkerScriptLoaderFactoryTest::SetUp();
-    WriteToDiskCacheWithIdSync(helper_->context()->storage(), script_url_,
-                               kOldResourceId, kOldHeaders, kOldData,
-                               std::string());
+    WriteToDiskCacheWithIdSync(helper_->context()->GetStorageControl(),
+                               script_url_, kOldResourceId, kOldHeaders,
+                               kOldData, std::string());
   }
 
   void CheckResponse(const std::string& expected_body) {

content/browser/service_worker/service_worker_test_utils.cc

@@ -152,106 +152,100 @@ class FakeNavigationClient : public mojom::NavigationClient {
   DISALLOW_COPY_AND_ASSIGN(FakeNavigationClient);
 };
 
-void OnWriteMetadataToDiskCache(
-    std::unique_ptr<ServiceWorkerResponseMetadataWriter> metadata_writer,
-    const GURL& script_url,
-    int body_size,
-    int meta_data_size,
-    WriteToDiskCacheCallback callback,
-    int result) {
-  EXPECT_EQ(result, meta_data_size);
-  std::move(callback).Run(storage::mojom::ServiceWorkerResourceRecord::New(
-      metadata_writer->response_id(), script_url, body_size));
-}
-
-void OnWriteBodyDataToDiskCache(
-    std::unique_ptr<ServiceWorkerResponseWriter> writer,
-    std::unique_ptr<ServiceWorkerResponseMetadataWriter> metadata_writer,
-    const GURL& script_url,
-    int body_size,
-    const std::string& meta_data,
-    WriteToDiskCacheCallback callback,
-    int result) {
-  EXPECT_EQ(result, body_size);
-  scoped_refptr<net::IOBuffer> meta_data_buffer =
-      base::MakeRefCounted<net::StringIOBuffer>(meta_data);
-  ServiceWorkerResponseMetadataWriter* metadata_writer_rawptr =
-      metadata_writer.get();
-  metadata_writer_rawptr->WriteMetadata(
-      meta_data_buffer.get(), meta_data.size(),
-      base::BindOnce(&OnWriteMetadataToDiskCache, std::move(metadata_writer),
-                     script_url, body_size, meta_data.size(),
-                     std::move(callback)));
-}
-
-void OnWriteBodyInfoToDiskCache(
-    std::unique_ptr<ServiceWorkerResponseWriter> writer,
-    std::unique_ptr<ServiceWorkerResponseMetadataWriter> metadata_writer,
-    const GURL& script_url,
-    const std::string& body,
-    const std::string& meta_data,
-    WriteToDiskCacheCallback callback,
-    int result) {
-  EXPECT_GE(result, 0);
-  scoped_refptr<net::IOBuffer> body_buffer =
-      base::MakeRefCounted<net::StringIOBuffer>(body);
-  ServiceWorkerResponseWriter* writer_rawptr = writer.get();
-  writer_rawptr->WriteData(
-      body_buffer.get(), body.size(),
-      base::BindOnce(&OnWriteBodyDataToDiskCache, std::move(writer),
-                     std::move(metadata_writer), script_url, body.size(),
-                     meta_data, std::move(callback)));
-}
-
-void WriteToDiskCacheAsyncInternal(
+class ResourceWriter {
+ public:
+  ResourceWriter(
+      const mojo::Remote<storage::mojom::ServiceWorkerStorageControl>& storage,
       const GURL& script_url,
       const std::vector<std::pair<std::string, std::string>>& headers,
       const std::string& body,
-    const std::string& meta_data,
-    std::unique_ptr<ServiceWorkerResponseWriter> body_writer,
-    std::unique_ptr<ServiceWorkerResponseMetadataWriter> metadata_writer,
+      const std::string& meta_data)
+      : storage_(storage),
+        script_url_(script_url),
+        headers_(headers),
+        body_(body),
+        meta_data_(meta_data) {}
+
+  void Start(WriteToDiskCacheCallback callback) {
+    DCHECK(storage_.is_connected());
+    callback_ = std::move(callback);
+    storage_->GetNewResourceId(base::BindOnce(&ResourceWriter::DidGetResourceId,
+                                              base::Unretained(this)));
+  }
+
+  void StartWithResourceId(int64_t resource_id,
                            WriteToDiskCacheCallback callback) {
-  std::unique_ptr<net::HttpResponseInfo> http_info =
-      std::make_unique<net::HttpResponseInfo>();
-  http_info->request_time = base::Time::Now();
-  http_info->response_time = base::Time::Now();
-  http_info->headers =
-      base::MakeRefCounted<net::HttpResponseHeaders>("HTTP/1.0 200 OK\0\0");
-  for (const auto& header : headers)
-    http_info->headers->AddHeader(header.first, header.second);
+    DCHECK(storage_.is_connected());
+    callback_ = std::move(callback);
+    DidGetResourceId(resource_id);
+  }
 
-  scoped_refptr<HttpResponseInfoIOBuffer> info_buffer =
-      base::MakeRefCounted<HttpResponseInfoIOBuffer>(std::move(http_info));
-  info_buffer->response_data_size = body.size();
-  ServiceWorkerResponseWriter* writer_rawptr = body_writer.get();
-  writer_rawptr->WriteInfo(
-      info_buffer.get(),
-      base::BindOnce(&OnWriteBodyInfoToDiskCache, std::move(body_writer),
-                     std::move(metadata_writer), script_url, body, meta_data,
-                     std::move(callback)));
-}
+ private:
+  void DidGetResourceId(int64_t resource_id) {
+    DCHECK(storage_.is_connected());
+    DCHECK_NE(resource_id, blink::mojom::kInvalidServiceWorkerResourceId);
 
-storage::mojom::ServiceWorkerResourceRecordPtr WriteToDiskCacheSyncInternal(
-    const GURL& script_url,
-    const std::vector<std::pair<std::string, std::string>>& headers,
-    const std::string& body,
-    const std::string& meta_data,
-    std::unique_ptr<ServiceWorkerResponseWriter> body_writer,
-    std::unique_ptr<ServiceWorkerResponseMetadataWriter> metadata_writer) {
-  storage::mojom::ServiceWorkerResourceRecordPtr record;
+    resource_id_ = resource_id;
+    storage_->CreateResourceWriter(resource_id,
+                                   body_writer_.BindNewPipeAndPassReceiver());
+    storage_->CreateResourceMetadataWriter(
+        resource_id, metadata_writer_.BindNewPipeAndPassReceiver());
 
-  base::RunLoop loop;
-  WriteToDiskCacheAsyncInternal(
-      script_url, headers, body, meta_data, std::move(body_writer),
-      std::move(metadata_writer),
-      base::BindLambdaForTesting(
-          [&](storage::mojom::ServiceWorkerResourceRecordPtr result) {
-            record = std::move(result);
-            loop.Quit();
-          }));
-  loop.Run();
+    auto response_head = network::mojom::URLResponseHead::New();
+    response_head->headers = base::MakeRefCounted<net::HttpResponseHeaders>(
+        net::HttpUtil::AssembleRawHeaders("HTTP/1.1 200 OK\n"));
+    response_head->request_time = base::Time::Now();
+    response_head->response_time = base::Time::Now();
+    response_head->content_length = body_.size();
+    for (const auto& header : headers_)
+      response_head->headers->AddHeader(header.first, header.second);
+
+    body_writer_->WriteResponseHead(
+        std::move(response_head),
+        base::BindOnce(&ResourceWriter::DidWriteResponseHead,
+                       base::Unretained(this)));
+  }
 
-  return record;
+  void DidWriteResponseHead(int result) {
+    DCHECK_GE(result, 0);
+    mojo_base::BigBuffer buffer(base::as_bytes(base::make_span(body_)));
+    body_writer_->WriteData(
+        std::move(buffer),
+        base::BindOnce(&ResourceWriter::DidWriteData, base::Unretained(this)));
+  }
+
+  void DidWriteData(int result) {
+    DCHECK_EQ(result, static_cast<int>(body_.size()));
+    mojo_base::BigBuffer buffer(base::as_bytes(base::make_span(meta_data_)));
+    metadata_writer_->WriteMetadata(
+        std::move(buffer), base::BindOnce(&ResourceWriter::DidWriteMetadata,
+                                          base::Unretained(this)));
+  }
+
+  void DidWriteMetadata(int result) {
+    DCHECK_EQ(result, static_cast<int>(meta_data_.size()));
+    std::move(callback_).Run(storage::mojom::ServiceWorkerResourceRecord::New(
+        resource_id_, script_url_, body_.size()));
+  }
+
+  const mojo::Remote<storage::mojom::ServiceWorkerStorageControl>& storage_;
+  const GURL script_url_;
+  const std::vector<std::pair<std::string, std::string>> headers_;
+  const std::string body_;
+  const std::string meta_data_;
+  WriteToDiskCacheCallback callback_;
+
+  int64_t resource_id_ = blink::mojom::kInvalidServiceWorkerResourceId;
+  mojo::Remote<storage::mojom::ServiceWorkerResourceWriter> body_writer_;
+  mojo::Remote<storage::mojom::ServiceWorkerResourceMetadataWriter>
+      metadata_writer_;
+};
+
+void OnWriteToDiskCacheFinished(
+    std::unique_ptr<ResourceWriter> self_owned_writer,
+    WriteToDiskCacheCallback callback,
+    storage::mojom::ServiceWorkerResourceRecordPtr record) {
+  std::move(callback).Run(std::move(record));
 }
 
 }  // namespace
@@ -473,50 +467,56 @@ CreateServiceWorkerRegistrationAndVersion(ServiceWorkerContextCore* context,
 }
 
 storage::mojom::ServiceWorkerResourceRecordPtr WriteToDiskCacheWithIdSync(
-    ServiceWorkerStorage* storage,
+    mojo::Remote<storage::mojom::ServiceWorkerStorageControl>& storage,
     const GURL& script_url,
     int64_t resource_id,
     const std::vector<std::pair<std::string, std::string>>& headers,
     const std::string& body,
     const std::string& meta_data) {
-  std::unique_ptr<ServiceWorkerResponseWriter> body_writer =
-      storage->CreateResponseWriter(resource_id);
-  std::unique_ptr<ServiceWorkerResponseMetadataWriter> metadata_writer =
-      storage->CreateResponseMetadataWriter(resource_id);
-  return WriteToDiskCacheSyncInternal(script_url, headers, body, meta_data,
-                                      std::move(body_writer),
-                                      std::move(metadata_writer));
+  storage::mojom::ServiceWorkerResourceRecordPtr record;
+  ResourceWriter writer(storage, script_url, headers, body, meta_data);
+  base::RunLoop loop;
+  writer.StartWithResourceId(
+      resource_id,
+      base::BindLambdaForTesting(
+          [&](storage::mojom::ServiceWorkerResourceRecordPtr result) {
+            record = std::move(result);
+            loop.Quit();
+          }));
+  loop.Run();
+  return record;
 }
 
 storage::mojom::ServiceWorkerResourceRecordPtr WriteToDiskCacheSync(
-    ServiceWorkerStorage* storage,
+    mojo::Remote<storage::mojom::ServiceWorkerStorageControl>& storage,
     const GURL& script_url,
     const std::vector<std::pair<std::string, std::string>>& headers,
     const std::string& body,
     const std::string& meta_data) {
-  std::unique_ptr<ServiceWorkerResponseWriter> body_writer =
-      CreateNewResponseWriterSync(storage);
-  std::unique_ptr<ServiceWorkerResponseMetadataWriter> metadata_writer =
-      storage->CreateResponseMetadataWriter(body_writer->response_id());
-  return WriteToDiskCacheSyncInternal(script_url, headers, body, meta_data,
-                                      std::move(body_writer),
-                                      std::move(metadata_writer));
+  storage::mojom::ServiceWorkerResourceRecordPtr record;
+  ResourceWriter writer(storage, script_url, headers, body, meta_data);
+  base::RunLoop loop;
+  writer.Start(base::BindLambdaForTesting(
+      [&](storage::mojom::ServiceWorkerResourceRecordPtr result) {
+        record = std::move(result);
+        loop.Quit();
+      }));
+  loop.Run();
+  return record;
 }
 
 void WriteToDiskCacheAsync(
-    ServiceWorkerStorage* storage,
+    mojo::Remote<storage::mojom::ServiceWorkerStorageControl>& storage,
     const GURL& script_url,
     const std::vector<std::pair<std::string, std::string>>& headers,
     const std::string& body,
     const std::string& meta_data,
     WriteToDiskCacheCallback callback) {
-  std::unique_ptr<ServiceWorkerResponseWriter> body_writer =
-      CreateNewResponseWriterSync(storage);
-  std::unique_ptr<ServiceWorkerResponseMetadataWriter> metadata_writer =
-      storage->CreateResponseMetadataWriter(body_writer->response_id());
-  WriteToDiskCacheAsyncInternal(
-      script_url, headers, body, meta_data, std::move(body_writer),
-      std::move(metadata_writer), std::move(callback));
+  auto writer = std::make_unique<ResourceWriter>(storage, script_url, headers,
+                                                 body, meta_data);
+  auto* raw_writer = writer.get();
+  raw_writer->Start(base::BindOnce(&OnWriteToDiskCacheFinished,
+                                   std::move(writer), std::move(callback)));
 }
 
 std::unique_ptr<ServiceWorkerResponseWriter> CreateNewResponseWriterSync(

content/browser/service_worker/service_worker_test_utils.h

@@ -169,7 +169,7 @@ CreateServiceWorkerRegistrationAndVersion(ServiceWorkerContextCore* context,
 // all of tasks. If it's in another base::RunLoop, consider to use
 // WriteToDiskCacheAsync().
 storage::mojom::ServiceWorkerResourceRecordPtr WriteToDiskCacheWithIdSync(
-    ServiceWorkerStorage* storage,
+    mojo::Remote<storage::mojom::ServiceWorkerStorageControl>& storage,
     const GURL& script_url,
     int64_t resource_id,
     const std::vector<std::pair<std::string, std::string>>& headers,
@@ -179,7 +179,7 @@ storage::mojom::ServiceWorkerResourceRecordPtr WriteToDiskCacheWithIdSync(
 // Similar to WriteToDiskCacheWithIdSync() but instead of taking a resource id,
 // this assigns a new resource ID internally.
 storage::mojom::ServiceWorkerResourceRecordPtr WriteToDiskCacheSync(
-    ServiceWorkerStorage* storage,
+    mojo::Remote<storage::mojom::ServiceWorkerStorageControl>& storage,
     const GURL& script_url,
     const std::vector<std::pair<std::string, std::string>>& headers,
     const std::string& body,
@@ -193,7 +193,7 @@ using WriteToDiskCacheCallback = base::OnceCallback<void(
 // base::RunUntilIdle because wiriting to the storage might happen on another
 // thread and base::RunLoop could get idle before writes has not finished yet.
 void WriteToDiskCacheAsync(
-    ServiceWorkerStorage* storage,
+    mojo::Remote<storage::mojom::ServiceWorkerStorageControl>& storage,
     const GURL& script_url,
     const std::vector<std::pair<std::string, std::string>>& headers,
     const std::string& body,

content/browser/service_worker/service_worker_updated_script_loader_unittest.cc

@@ -83,8 +83,9 @@ class ServiceWorkerUpdatedScriptLoaderTest : public testing::Test {
     SetUpRegistration(kScriptURL);
 
     // Create the old script resource in storage.
-    WriteToDiskCacheWithIdSync(context()->storage(), kScriptURL, kOldResourceId,
-                               kOldHeaders, kOldData, std::string());
+    WriteToDiskCacheWithIdSync(context()->GetStorageControl(), kScriptURL,
+                               kOldResourceId, kOldHeaders, kOldData,
+                               std::string());
   }
 
   // Sets up ServiceWorkerRegistration and ServiceWorkerVersion. This should be

content/browser/service_worker/service_worker_version_unittest.cc

@@ -102,7 +102,7 @@ class ServiceWorkerVersionTest : public testing::Test {
     EXPECT_EQ(url::Origin::Create(scope_), version_->script_origin());
     std::vector<storage::mojom::ServiceWorkerResourceRecordPtr> records;
     records.push_back(WriteToDiskCacheWithIdSync(
-        helper_->context()->storage(), version_->script_url(), 10,
+        helper_->context()->GetStorageControl(), version_->script_url(), 10,
         {} /* headers */, "I'm a body", "I'm a meta data"));
     version_->script_cache_map()->SetResources(records);
     version_->SetMainScriptResponse(