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,
+    base::WeakPtr<webkit_blob::BlobStorageContext> 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() {
   DCHECK_EQ(NOT_DETERMINED, response_type_);
   response_type_ = FORWARD_TO_SERVICE_WORKER;
   MaybeStartRequest();
 }
 
 void ServiceWorkerURLRequestJob::Start() {
   is_started_ = true;
   MaybeStartRequest();
 }
 
 void ServiceWorkerURLRequestJob::Kill() {
   net::URLRequestJob::Kill();

[michaeln, 2014/05/23 02:23:23]

would it be good to kill the blob_request here too... as in delete it?

[falken, 2014/05/23 11:15:46]

Yes, that looks like the right thing to do. Done.

   fetch_dispatcher_.reset();
   weak_factory_.InvalidateWeakPtrs();
 }
 
 net::LoadState ServiceWorkerURLRequestJob::GetLoadState() const {
   // TODO(kinuko): refine this for better debug.
   return net::URLRequestJob::GetLoadState();
 }
 
 bool ServiceWorkerURLRequestJob::GetCharset(std::string* charset) {
@@ skipping 29 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) {
+  // TODO(falken): Add Content-Length, Content-Type if they were not provided in
+  // the ServiceWorkerResponse.
+  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 62 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 &&

[michaeln, 2014/05/23 02:23:23]

Should this just be a function of fetchresult and status, can we get here if
response_type_ is not FTSW?

[falken, 2014/05/23 11:15:46]

Good point. When we get here status is OK and fetch_result is
SERVICE_WORKER_FETCH_EVENT_RESULT_RESPONSE. I'll move this below the DCHECK to
show this.

+      !response.blob_uuid.empty()) {
+    scoped_ptr<webkit_blob::BlobDataHandle> blob_data_handle =
+        blob_storage_context_->GetBlobDataFromUUID(response.blob_uuid);

[michaeln, 2014/05/23 02:23:23]

test if (blob_storage_context_) to see if the weakptr is still good first?

[falken, 2014/05/23 11:15:46]

Done.

+    blob_request_ = webkit_blob::BlobProtocolHandler::CreateBlobRequest(

[michaeln, 2014/05/23 02:32:32]

This line right here setups so the webkit_blob::BlobProtocolHandler will return
the blob found via the uuid. The mockhandler knows nothing of this.

In case you're wondering, the reason we lookup early instead of just doing it
inside of blobjob.Start() is that with RDH there can be a lengthy delay between
when the request obj is created and when its started, many msg loop cycles. The
BlobDataHandle returned guarantees the blob will still be around at
blobjob.Start() time.

[falken, 2014/05/23 11:15:46]

I see!
Ah I think I see. Thanks for explaining.

+        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);

[michaeln, 2014/05/23 02:23:23]

i think we might want to defer setting http_response_info_ till just prior to
NotifyHeadersComplete time. Otherwise the various getters could be called early
and could return a valid looking but ultimiately invalid result.

[falken, 2014/05/23 11:15:46]

That does seem safer though it complicates the code a little. How does it look
now?

-  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