service worker: Cleanup legacy non-Mojo Blob codepath for responses.

I believe this code is never reached since Mojo Blobs is now enabled by
default.

R=kinuko

Change-Id: I31ff07484290ab932a3569c9e10e00316a5bafd0
Reviewed-on: https://chromium-review.googlesource.com/925863Reviewed-by: Kinuko Yasuda <kinuko@chromium.org>
Commit-Queue: Matt Falkenhagen <falken@chromium.org>
Cr-Commit-Position: refs/heads/master@{#537708}

content/browser/service_worker/service_worker_url_request_job.cc

@@ -761,6 +761,8 @@ void ServiceWorkerURLRequestJob::DidDispatchFetchEvent(
   // Set up a request for reading the blob.
   // |body_as_blob| must be kept around until we call this to ensure that
   // it's alive.
+  // TODO(falken): Can we just read |body_as_blob| directly like in
+  // ServiceWorkerURLLoaderJob?
   if (!response.blob_uuid.empty() && blob_storage_context_) {
     SetResponseBodyType(BLOB);
     std::unique_ptr<storage::BlobDataHandle> blob_data_handle =

content/common/service_worker/service_worker_types.h

@@ -111,7 +111,16 @@ struct CONTENT_EXPORT ServiceWorkerFetchRequest {
   ServiceWorkerFetchType fetch_type = ServiceWorkerFetchType::FETCH;
 };
 
-// Represents a response to a fetch.
+// Roughly corresponds to the Fetch API's Response type. This struct has several
+// users:
+// - Service Worker API: The renderer sends the browser this type to
+// represent the response a service worker provided to FetchEvent#respondWith.
+// - Background Fetch API: Uses this type to represent responses to background
+// fetches.
+// - Cache Storage API: Uses this type to represent responses to requests.
+// Note that the Fetch API does not use this type; it uses ResourceResponse
+// instead.
+// TODO(falken): Can everyone just use ResourceResponse?
 struct CONTENT_EXPORT ServiceWorkerResponse {
   ServiceWorkerResponse();
   ServiceWorkerResponse(
@@ -144,7 +153,6 @@ struct CONTENT_EXPORT ServiceWorkerResponse {
   // ServiceWorkerFetchResponseCallback.
   std::string blob_uuid;
   uint64_t blob_size;
-  // |blob| is only used when features::kMojoBlobs is enabled.
   scoped_refptr<storage::BlobHandle> blob;
   blink::mojom::ServiceWorkerResponseError error;
   base::Time response_time;

content/renderer/service_worker/service_worker_context_client.cc

@@ -336,11 +336,6 @@ base::OnceCallback<void(int /* event_id */)> CreateAbortCallback(MapType* map,
       map, std::forward<Args>(args)..., base::Time::Now());
 }
 
-void OnResponseBlobDispatchDone(
-    const blink::WebServiceWorkerResponse& response) {
-  // This frees the ref to the internal data of |response|.
-}
-
 template <typename Signature>
 class CallbackWrapperOnWorkerThread;
 
@@ -1109,20 +1104,16 @@ void ServiceWorkerContextClient::RespondToFetchEvent(
   const mojom::ServiceWorkerFetchResponseCallbackPtr& response_callback =
       context_->fetch_response_callbacks[fetch_event_id];
 
-  if (response.blob_uuid.size()) {
+  if (!response.blob_uuid.empty()) {
+    // TODO(falken): Can we just keep |response.blob| and call OnResponse
+    // directly?
     blink::mojom::BlobPtr blob_ptr;
-    if (response.blob) {
-      blob_ptr = response.blob->TakeBlobPtr();
-      response.blob = nullptr;
-      response_callback->OnResponseBlob(
-          response, std::move(blob_ptr),
-          base::Time::FromDoubleT(event_dispatch_time));
-    } else {
-      // TODO(kinuko): Remove this hack once kMojoBlobs is enabled by default.
-      response_callback->OnResponseLegacyBlob(
-          response, base::Time::FromDoubleT(event_dispatch_time),
-          base::BindOnce(&OnResponseBlobDispatchDone, web_response));
-    }
+    DCHECK(response.blob);
+    blob_ptr = response.blob->TakeBlobPtr();
+    response.blob = nullptr;
+    response_callback->OnResponseBlob(
+        response, std::move(blob_ptr),
+        base::Time::FromDoubleT(event_dispatch_time));
   } else {
     response_callback->OnResponse(response,
                                   base::Time::FromDoubleT(event_dispatch_time));