service worker: Remove WriteToDiskCacheWithCustomResponseInfoSync()

This function isn't used.

This CL also moves WriteToDiskCacheWithCustomResponseInfoAsync()
to anonymous namespace in service_worker_test_utils.cc because it
is only used from service_worker_test_utils.cc

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

content/browser/service_worker/service_worker_test_utils.cc

@@ -196,6 +196,31 @@ void WriteMetaDataToDiskCache(
           std::move(writer), std::move(callback), meta_data.size()));
 }
 
+// Writes the script with custom net::HttpResponseInfo down to |storage|
+// asynchronously. When completing tasks, |callback| will be called. You must
+// wait for |callback| instead of base::RunUntilIdle because wiriting to the
+// storage might happen on another thread and base::RunLoop could get idle
+// before writes has not finished yet.
+ServiceWorkerDatabase::ResourceRecord
+WriteToDiskCacheWithCustomResponseInfoAsync(
+    ServiceWorkerStorage* storage,
+    const GURL& script_url,
+    int64_t resource_id,
+    std::unique_ptr<net::HttpResponseInfo> http_info,
+    const std::string& body,
+    const std::string& meta_data,
+    base::OnceClosure callback) {
+  base::RepeatingClosure barrier = base::BarrierClosure(2, std::move(callback));
+  auto body_writer = storage->CreateResponseWriter(resource_id);
+  WriteBodyToDiskCache(std::move(body_writer), std::move(http_info), body,
+                       barrier);
+  auto metadata_writer = storage->CreateResponseMetadataWriter(resource_id);
+  WriteMetaDataToDiskCache(std::move(metadata_writer), meta_data,
+                           std::move(barrier));
+  return ServiceWorkerDatabase::ResourceRecord(resource_id, script_url,
+                                               body.size());
+}
+
 }  // namespace
 
 ServiceWorkerRemoteProviderEndpoint::ServiceWorkerRemoteProviderEndpoint() {}
@@ -385,23 +410,6 @@ ServiceWorkerDatabase::ResourceRecord WriteToDiskCacheSync(
   return record;
 }
 
-ServiceWorkerDatabase::ResourceRecord
-WriteToDiskCacheWithCustomResponseInfoSync(
-    ServiceWorkerStorage* storage,
-    const GURL& script_url,
-    int64_t resource_id,
-    std::unique_ptr<net::HttpResponseInfo> http_info,
-    const std::string& body,
-    const std::string& meta_data) {
-  base::RunLoop loop;
-  ServiceWorkerDatabase::ResourceRecord record =
-      WriteToDiskCacheWithCustomResponseInfoAsync(
-          storage, script_url, resource_id, std::move(http_info), body,
-          meta_data, loop.QuitClosure());
-  loop.Run();
-  return record;
-}
-
 ServiceWorkerDatabase::ResourceRecord WriteToDiskCacheAsync(
     ServiceWorkerStorage* storage,
     const GURL& script_url,
@@ -423,26 +431,6 @@ ServiceWorkerDatabase::ResourceRecord WriteToDiskCacheAsync(
       std::move(callback));
 }
 
-ServiceWorkerDatabase::ResourceRecord
-WriteToDiskCacheWithCustomResponseInfoAsync(
-    ServiceWorkerStorage* storage,
-    const GURL& script_url,
-    int64_t resource_id,
-    std::unique_ptr<net::HttpResponseInfo> http_info,
-    const std::string& body,
-    const std::string& meta_data,
-    base::OnceClosure callback) {
-  base::RepeatingClosure barrier = base::BarrierClosure(2, std::move(callback));
-  auto body_writer = storage->CreateResponseWriter(resource_id);
-  WriteBodyToDiskCache(std::move(body_writer), std::move(http_info), body,
-                       barrier);
-  auto metadata_writer = storage->CreateResponseMetadataWriter(resource_id);
-  WriteMetaDataToDiskCache(std::move(metadata_writer), meta_data,
-                           std::move(barrier));
-  return ServiceWorkerDatabase::ResourceRecord(resource_id, script_url,
-                                               body.size());
-}
-
 MockServiceWorkerResponseReader::MockServiceWorkerResponseReader()
     : ServiceWorkerResponseReader(/* resource_id=*/0, /*disk_cache=*/nullptr) {}
 

content/browser/service_worker/service_worker_test_utils.h

@@ -28,12 +28,6 @@
 #include "third_party/blink/public/mojom/service_worker/service_worker_provider.mojom.h"
 #include "third_party/blink/public/mojom/service_worker/service_worker_registration.mojom.h"
 
-namespace net {
-
-class HttpResponseInfo;
-
-}  // namespace net
-
 namespace content {
 
 class EmbeddedWorkerTestHelper;
@@ -165,19 +159,6 @@ ServiceWorkerDatabase::ResourceRecord WriteToDiskCacheSync(
     const std::string& body,
     const std::string& meta_data);
 
-// Writes the script with custom net::HttpResponseInfo down to |storage|
-// synchronously. This should not be used in base::RunLoop since base::RunLoop
-// is used internally to wait for completing all of tasks. If it's in another
-// base::RunLoop, consider to use WriteToDiskCacheWithCustomResponseInfoAsync().
-ServiceWorkerDatabase::ResourceRecord
-WriteToDiskCacheWithCustomResponseInfoSync(
-    ServiceWorkerStorage* storage,
-    const GURL& script_url,
-    int64_t resource_id,
-    std::unique_ptr<net::HttpResponseInfo> http_info,
-    const std::string& body,
-    const std::string& meta_data);
-
 // Writes the script down to |storage| asynchronously. When completing tasks,
 // |callback| will be called. You must wait for |callback| instead of
 // base::RunUntilIdle because wiriting to the storage might happen on another
@@ -191,21 +172,6 @@ ServiceWorkerDatabase::ResourceRecord WriteToDiskCacheAsync(
     const std::string& meta_data,
     base::OnceClosure callback);
 
-// Writes the script with custom net::HttpResponseInfo down to |storage|
-// asynchronously. When completing tasks, |callback| will be called. You must
-// wait for |callback| instead of base::RunUntilIdle because wiriting to the
-// storage might happen on another thread and base::RunLoop could get idle
-// before writes has not finished yet.
-ServiceWorkerDatabase::ResourceRecord
-WriteToDiskCacheWithCustomResponseInfoAsync(
-    ServiceWorkerStorage* storage,
-    const GURL& script_url,
-    int64_t resource_id,
-    std::unique_ptr<net::HttpResponseInfo> http_info,
-    const std::string& body,
-    const std::string& meta_data,
-    base::OnceClosure callback);
-
 // A test implementation of ServiceWorkerResponseReader.
 //
 // This class exposes the ability to expect reads (see ExpectRead*() below).