Add a blob field to ServiceWorkerFetchResponse and read the blob

content/browser/service_worker/service_worker_url_request_job.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "content/browser/service_worker/service_worker_url_request_job.h"
 
 #include "base/bind.h"
 #include "base/strings/stringprintf.h"
+#include "content/browser/fileapi/chrome_blob_storage_context.h"
 #include "content/browser/service_worker/service_worker_fetch_dispatcher.h"
 #include "content/browser/service_worker/service_worker_provider_host.h"
 #include "net/http/http_request_headers.h"
 #include "net/http/http_response_headers.h"
 #include "net/http/http_response_info.h"
 #include "net/http/http_util.h"
+#include "webkit/browser/blob/blob_data_handle.h"
+#include "webkit/browser/blob/blob_storage_context.h"
+#include "webkit/browser/blob/blob_url_request_job_factory.h"
 
 namespace content {
 
 ServiceWorkerURLRequestJob::ServiceWorkerURLRequestJob(
     net::URLRequest* request,
     net::NetworkDelegate* network_delegate,
-    base::WeakPtr<ServiceWorkerProviderHost> provider_host)
+    base::WeakPtr<ServiceWorkerProviderHost> provider_host,
+    scoped_refptr<ChromeBlobStorageContext> blob_storage_context)
     : net::URLRequestJob(request, network_delegate),
       provider_host_(provider_host),
       response_type_(NOT_DETERMINED),
       is_started_(false),
+      blob_storage_context_(blob_storage_context),
       weak_factory_(this) {
 }
 
 void ServiceWorkerURLRequestJob::FallbackToNetwork() {
   DCHECK_EQ(NOT_DETERMINED, response_type_);
   response_type_ = FALLBACK_TO_NETWORK;
   MaybeStartRequest();
 }
 
 void ServiceWorkerURLRequestJob::ForwardToServiceWorker() {
@@ skipping 51 matching lines @@
     return;
   }
 
   // We don't support multiple range requests in one single URL request.
   if (ranges.size() == 1U)
     byte_range_ = ranges[0];
 }
 
 bool ServiceWorkerURLRequestJob::ReadRawData(
     net::IOBuffer* buf, int buf_size, int *bytes_read) {
-  // TODO(kinuko): Implement this.
-  // If the response returned from ServiceWorker had an
-  // identifier to on-disk data (e.g. blob or cache entry) we'll need to
-  // pull the body from disk.
-  NOTIMPLEMENTED();
-  *bytes_read = 0;
-  return true;
+  if (!blob_request_) {
+    *bytes_read = 0;
+    return true;
+  }
+
+  blob_request_->Read(buf, buf_size, bytes_read);
+  net::URLRequestStatus status = blob_request_->status();
+  SetStatus(status);
+  if (status.is_io_pending())
+    return false;
+  return status.is_success();
+}
+
+void ServiceWorkerURLRequestJob::OnReceivedRedirect(net::URLRequest* request,
+                                                    const GURL& new_url,
+                                                    bool* defer_redirect) {
+  NOTREACHED();
+}
+
+void ServiceWorkerURLRequestJob::OnAuthRequired(
+    net::URLRequest* request,
+    net::AuthChallengeInfo* auth_info) {
+  NOTREACHED();
+}
+
+void ServiceWorkerURLRequestJob::OnCertificateRequested(
+    net::URLRequest* request,
+    net::SSLCertRequestInfo* cert_request_info) {
+  NOTREACHED();
+}
+
+void ServiceWorkerURLRequestJob::OnSSLCertificateError(
+    net::URLRequest* request,
+    const net::SSLInfo& ssl_info,
+    bool fatal) {
+  NOTREACHED();
+}
+
+void ServiceWorkerURLRequestJob::OnBeforeNetworkStart(net::URLRequest* request,
+                                                      bool* defer) {
+  NOTREACHED();
+}
+
+void ServiceWorkerURLRequestJob::OnResponseStarted(net::URLRequest* request) {
+  NotifyHeadersComplete();
+}
+
+void ServiceWorkerURLRequestJob::OnReadCompleted(net::URLRequest* request,
+                                                 int bytes_read) {
+  if (!request->status().is_success()) {
+    NotifyDone(request->status());
+    return;
+  }
+  NotifyReadComplete(bytes_read);
+  if (bytes_read == 0)
+    NotifyDone(request->status());
 }
 
 const net::HttpResponseInfo* ServiceWorkerURLRequestJob::http_info() const {
   if (!http_response_info_)
     return NULL;
   if (range_response_info_)
     return range_response_info_.get();
   return http_response_info_.get();
 }
 
@@ skipping 17 matching lines @@
       return;
 
     case FALLBACK_TO_NETWORK:
       // Restart the request to create a new job. Our request handler will
       // return NULL, and the default job (which will hit network) should be
       // created.
       NotifyRestartRequired();
       return;
 
     case FORWARD_TO_SERVICE_WORKER:
-      DCHECK(provider_host_ && provider_host_->active_version());
+      DCHECK(provider_host_);
+      DCHECK(provider_host_->active_version());
       DCHECK(!fetch_dispatcher_);
 
       // Send a fetch event to the ServiceWorker associated to the
       // provider_host.
       fetch_dispatcher_.reset(new ServiceWorkerFetchDispatcher(
           request(), provider_host_->active_version(),
           base::Bind(&ServiceWorkerURLRequestJob::DidDispatchFetchEvent,
                      weak_factory_.GetWeakPtr())));
       fetch_dispatcher_->Run();
       return;
@@ skipping 24 matching lines @@
   }
 
   if (fetch_result == SERVICE_WORKER_FETCH_EVENT_RESULT_FALLBACK) {
     // Change the response type and restart the request to fallback to
     // the network.
     response_type_ = FALLBACK_TO_NETWORK;
     NotifyRestartRequired();
     return;
   }
 
+  // Set up a request for reading the blob.
+  if (response_type_ == FORWARD_TO_SERVICE_WORKER &&
+      !response.blob_uuid.empty()) {
+    scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle =
+        blob_storage_context_->context()->GetBlobDataFromUUID(
+            response.blob_uuid);
+    blob_request_ = webkit_blob::BlobProtocolHandler::CreateBlobRequest(
+        blob_data_handle.Pass(), request()->context(), this);
+    blob_request_->Start();
+  }
+
   // We should have response now.
   DCHECK_EQ(SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE, fetch_result);
 
   CreateResponseHeader(response);
-  NotifyHeadersComplete();
+  if (!blob_request_)
+    NotifyHeadersComplete();
 }
 
 void ServiceWorkerURLRequestJob::CreateResponseHeader(
     const ServiceWorkerResponse& response) {
   // TODO(kinuko): If the response has an identifier to on-disk cache entry,
   // pull response header from the disk.
   std::string status_line(base::StringPrintf("HTTP/1.1 %d %s",
                                              response.status_code,
                                              response.status_text.c_str()));
   status_line.push_back('\0');
   scoped_refptr<net::HttpResponseHeaders> headers(
       new net::HttpResponseHeaders(status_line));
   for (std::map<std::string, std::string>::const_iterator it =
            response.headers.begin();
        it != response.headers.end(); ++it) {
     std::string header;
     header.reserve(it->first.size() + 2 + it->second.size());
     header.append(it->first);
     header.append(": ");
     header.append(it->second);
     headers->AddHeader(header);
   }
 
   http_response_info_.reset(new net::HttpResponseInfo());
   http_response_info_->headers = headers;
 }
 
 }  // namespace content