[Storage] Blob Storage Refactoring pt 1

content/browser/service_worker/service_worker_cache.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_cache.h"
 
 #include <string>
 
 #include "base/files/file_path.h"
 #include "base/guid.h"
@@ skipping 165 matching lines @@
  public:
   typedef base::Callback<void(disk_cache::ScopedEntryPtr, bool)>
       EntryAndBoolCallback;
 
   BlobReader()
       : cache_entry_offset_(0),
         buffer_(new net::IOBufferWithSize(kBufferSize)),
         weak_ptr_factory_(this) {}
 
   // |entry| is passed to the callback once complete.
-  void StreamBlobToCache(disk_cache::ScopedEntryPtr entry,
-                         net::URLRequestContext* request_context,
-                         scoped_ptr<storage::BlobDataHandle> blob_data_handle,
-                         const EntryAndBoolCallback& callback) {
+  void StreamBlobToCache(
+      disk_cache::ScopedEntryPtr entry,
+      net::URLRequestContext* request_context,
+      scoped_ptr<storage::BlobDataSnapshotHandle> blob_data_handle,
+      const EntryAndBoolCallback& callback) {
     DCHECK(entry);
     entry_ = entry.Pass();
     callback_ = callback;
     blob_request_ = storage::BlobProtocolHandler::CreateBlobRequest(
         blob_data_handle.Pass(), request_context, this);
     blob_request_->Start();
   }
 
   // net::URLRequest::Delegate overrides for reading blobs.
   void OnReceivedRedirect(net::URLRequest* request,
@@ skipping 136 matching lines @@
   }
 
   // Input
   scoped_ptr<ServiceWorkerFetchRequest> request;
   ServiceWorkerCache::ResponseCallback original_callback;
   base::WeakPtr<storage::BlobStorageContext> blob_storage_context;
   disk_cache::Entry* entry;
 
   // Output
   scoped_ptr<ServiceWorkerResponse> response;
-  scoped_refptr<storage::BlobData> blob_data;
+  scoped_ptr<storage::BlobDataBuilder> blob_data;
 
   // For reading the cache entry data into a blob.
   scoped_refptr<net::IOBufferWithSize> response_body_buffer;
   size_t total_bytes_read;
 
   DISALLOW_COPY_AND_ASSIGN(MatchContext);
 };
 
 // The state needed to pass between ServiceWorkerCache::Put callbacks.
 struct ServiceWorkerCache::PutContext {
   PutContext(
       const GURL& origin,
       scoped_ptr<ServiceWorkerFetchRequest> request,
       scoped_ptr<ServiceWorkerResponse> response,
-      scoped_ptr<storage::BlobDataHandle> blob_data_handle,
+      scoped_ptr<storage::BlobDataSnapshotHandle> blob_data_handle,
       const ServiceWorkerCache::ResponseCallback& callback,
       net::URLRequestContext* request_context,
       const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy)
       : origin(origin),
         request(request.Pass()),
         response(response.Pass()),
         blob_data_handle(blob_data_handle.Pass()),
         callback(callback),
         request_context(request_context),
         quota_manager_proxy(quota_manager_proxy),
         cache_entry(NULL) {}
   ~PutContext() {
     if (cache_entry)
       cache_entry->Close();
   }
 
   // Input parameters to the Put function.
   GURL origin;
   scoped_ptr<ServiceWorkerFetchRequest> request;
   scoped_ptr<ServiceWorkerResponse> response;
-  scoped_ptr<storage::BlobDataHandle> blob_data_handle;
+  scoped_ptr<storage::BlobDataSnapshotHandle> blob_data_handle;
   ServiceWorkerCache::ResponseCallback callback;
   net::URLRequestContext* request_context;
   scoped_refptr<storage::QuotaManagerProxy> quota_manager_proxy;
 
   // This isn't a scoped_ptr because the disk_cache needs an Entry** as input to
   // CreateEntry.
   disk_cache::Entry* cache_entry;
 
   // The BlobDataHandle for the output ServiceWorkerResponse.
-  scoped_ptr<storage::BlobDataHandle> out_blob_data_handle;
+  scoped_ptr<storage::BlobDataSnapshotHandle> out_blob_data_handle;
 
   DISALLOW_COPY_AND_ASSIGN(PutContext);
 };
 
 // static
 scoped_refptr<ServiceWorkerCache> ServiceWorkerCache::CreateMemoryCache(
     const GURL& origin,
     net::URLRequestContext* request_context,
     const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context) {
@@ skipping 22 matching lines @@
   return weak_ptr_factory_.GetWeakPtr();
 }
 
 void ServiceWorkerCache::Put(scoped_ptr<ServiceWorkerFetchRequest> request,
                              scoped_ptr<ServiceWorkerResponse> response,
                              const ResponseCallback& callback) {
   IncPendingOps();
   ResponseCallback pending_callback =
       base::Bind(&ServiceWorkerCache::PendingResponseCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
-  scoped_ptr<storage::BlobDataHandle> blob_data_handle;
+  scoped_ptr<storage::BlobDataSnapshotHandle> blob_data_handle;
 
   if (!response->blob_uuid.empty()) {
     if (!blob_storage_context_) {
       pending_callback.Run(ErrorTypeStorage,
                            scoped_ptr<ServiceWorkerResponse>(),
-                           scoped_ptr<storage::BlobDataHandle>());
+                           scoped_ptr<storage::BlobDataSnapshotHandle>());
       return;
     }
     blob_data_handle =
         blob_storage_context_->GetBlobDataFromUUID(response->blob_uuid);
     if (!blob_data_handle) {
       pending_callback.Run(ErrorTypeStorage,
                            scoped_ptr<ServiceWorkerResponse>(),
-                           scoped_ptr<storage::BlobDataHandle>());
+                           scoped_ptr<storage::BlobDataSnapshotHandle>());
       return;
     }
   }
 
   scoped_ptr<PutContext> put_context(new PutContext(
       origin_, request.Pass(), response.Pass(), blob_data_handle.Pass(),
       pending_callback, request_context_, quota_manager_proxy_));
 
   if (put_context->blob_data_handle) {
     // Grab another handle to the blob for the callback response.
@@ skipping 23 matching lines @@
 
   switch (backend_state_) {
     case BACKEND_UNINITIALIZED:
       InitBackend(base::Bind(&ServiceWorkerCache::Match,
                              weak_ptr_factory_.GetWeakPtr(),
                              base::Passed(request.Pass()), pending_callback));
       return;
     case BACKEND_CLOSED:
       pending_callback.Run(ErrorTypeStorage,
                            scoped_ptr<ServiceWorkerResponse>(),
-                           scoped_ptr<storage::BlobDataHandle>());
+                           scoped_ptr<storage::BlobDataSnapshotHandle>());
       return;
     case BACKEND_OPEN:
       DCHECK(backend_);
       break;
   }
 
   scoped_ptr<MatchContext> match_context(new MatchContext(
       request.Pass(), pending_callback, blob_storage_context_));
 
   disk_cache::Entry** entry_ptr = &match_context->entry;
@@ skipping 150 matching lines @@
       backend_state_(BACKEND_UNINITIALIZED),
       memory_only_(path.empty()),
       pending_ops_(0),
       weak_ptr_factory_(this) {
 }
 
 void ServiceWorkerCache::MatchDidOpenEntry(
     scoped_ptr<MatchContext> match_context,
     int rv) {
   if (rv != net::OK) {
-    match_context->original_callback.Run(ServiceWorkerCache::ErrorTypeNotFound,
-                                         scoped_ptr<ServiceWorkerResponse>(),
-                                         scoped_ptr<storage::BlobDataHandle>());
+    match_context->original_callback.Run(
+        ServiceWorkerCache::ErrorTypeNotFound,
+        scoped_ptr<ServiceWorkerResponse>(),
+        scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   // Copy the entry pointer before passing it in base::Bind.
   disk_cache::Entry* tmp_entry_ptr = match_context->entry;
   DCHECK(tmp_entry_ptr);
 
   MetadataCallback headers_callback = base::Bind(
       &ServiceWorkerCache::MatchDidReadMetadata, weak_ptr_factory_.GetWeakPtr(),
       base::Passed(match_context.Pass()));
 
   ReadMetadata(tmp_entry_ptr, headers_callback);
 }
 
 void ServiceWorkerCache::MatchDidReadMetadata(
     scoped_ptr<MatchContext> match_context,
     scoped_ptr<ServiceWorkerCacheMetadata> metadata) {
   if (!metadata) {
-    match_context->original_callback.Run(ServiceWorkerCache::ErrorTypeStorage,
-                                         scoped_ptr<ServiceWorkerResponse>(),
-                                         scoped_ptr<storage::BlobDataHandle>());
+    match_context->original_callback.Run(
+        ServiceWorkerCache::ErrorTypeStorage,
+        scoped_ptr<ServiceWorkerResponse>(),
+        scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   match_context->response.reset(new ServiceWorkerResponse(
       match_context->request->url, metadata->response().status_code(),
       metadata->response().status_text(),
       ProtoResponseTypeToWebResponseType(metadata->response().response_type()),
       ServiceWorkerHeaderMap(), "", 0, GURL()));
 
   ServiceWorkerResponse* response = match_context->response.get();
 
   if (metadata->response().has_url())
     response->url = GURL(metadata->response().url());
 
   for (int i = 0; i < metadata->response().headers_size(); ++i) {
     const ServiceWorkerCacheHeaderMap header = metadata->response().headers(i);
     response->headers.insert(std::make_pair(header.name(), header.value()));
   }
 
   ServiceWorkerHeaderMap cached_request_headers;
   for (int i = 0; i < metadata->request().headers_size(); ++i) {
     const ServiceWorkerCacheHeaderMap header = metadata->request().headers(i);
     cached_request_headers[header.name()] = header.value();
   }
 
   if (!VaryMatches(match_context->request->headers, cached_request_headers,
                    response->headers)) {
-    match_context->original_callback.Run(ServiceWorkerCache::ErrorTypeNotFound,
-                                         scoped_ptr<ServiceWorkerResponse>(),
-                                         scoped_ptr<storage::BlobDataHandle>());
+    match_context->original_callback.Run(
+        ServiceWorkerCache::ErrorTypeNotFound,
+        scoped_ptr<ServiceWorkerResponse>(),
+        scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   if (match_context->entry->GetDataSize(INDEX_RESPONSE_BODY) == 0) {
-    match_context->original_callback.Run(ServiceWorkerCache::ErrorTypeOK,
-                                         match_context->response.Pass(),
-                                         scoped_ptr<storage::BlobDataHandle>());
+    match_context->original_callback.Run(
+        ServiceWorkerCache::ErrorTypeOK, match_context->response.Pass(),
+        scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   // Stream the response body into a blob.
   if (!match_context->blob_storage_context) {
-    match_context->original_callback.Run(ServiceWorkerCache::ErrorTypeStorage,
-                                         scoped_ptr<ServiceWorkerResponse>(),
-                                         scoped_ptr<storage::BlobDataHandle>());
+    match_context->original_callback.Run(
+        ServiceWorkerCache::ErrorTypeStorage,
+        scoped_ptr<ServiceWorkerResponse>(),
+        scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   response->blob_uuid = base::GenerateGUID();
 
-  match_context->blob_data = new storage::BlobData(response->blob_uuid);
+  match_context->blob_data.reset(
+      new storage::BlobDataBuilder(response->blob_uuid));
   match_context->response_body_buffer = new net::IOBufferWithSize(kBufferSize);
 
   disk_cache::Entry* tmp_entry_ptr = match_context->entry;
   net::IOBufferWithSize* response_body_buffer =
       match_context->response_body_buffer.get();
 
   net::CompletionCallback read_callback = base::Bind(
       &ServiceWorkerCache::MatchDidReadResponseBodyData,
       weak_ptr_factory_.GetWeakPtr(), base::Passed(match_context.Pass()));
 
   int read_rv =
       tmp_entry_ptr->ReadData(INDEX_RESPONSE_BODY, 0, response_body_buffer,
                               response_body_buffer->size(), read_callback);
 
   if (read_rv != net::ERR_IO_PENDING)
     read_callback.Run(read_rv);
 }
 
 void ServiceWorkerCache::MatchDidReadResponseBodyData(
     scoped_ptr<MatchContext> match_context,
     int rv) {
   // TODO(vadimt): Remove ScopedTracker below once crbug.com/422516 is fixed.
   tracked_objects::ScopedTracker tracking_profile(
       FROM_HERE_WITH_EXPLICIT_FUNCTION(
           "422516 ServiceWorkerCache::MatchDidReadResponseBodyData"));
 
   if (rv < 0) {
-    match_context->original_callback.Run(ServiceWorkerCache::ErrorTypeStorage,
-                                         scoped_ptr<ServiceWorkerResponse>(),
-                                         scoped_ptr<storage::BlobDataHandle>());
+    match_context->original_callback.Run(
+        ServiceWorkerCache::ErrorTypeStorage,
+        scoped_ptr<ServiceWorkerResponse>(),
+        scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   if (rv == 0) {
     match_context->response->blob_uuid = match_context->blob_data->uuid();
     match_context->response->blob_size = match_context->total_bytes_read;
     MatchDoneWithBody(match_context.Pass());
     return;
   }
 
@@ skipping 16 matching lines @@
   int read_rv = tmp_entry_ptr->ReadData(INDEX_RESPONSE_BODY, total_bytes_read,
                                         buffer, buffer->size(), read_callback);
 
   if (read_rv != net::ERR_IO_PENDING)
     read_callback.Run(read_rv);
 }
 
 void ServiceWorkerCache::MatchDoneWithBody(
     scoped_ptr<MatchContext> match_context) {
   if (!match_context->blob_storage_context) {
-    match_context->original_callback.Run(ServiceWorkerCache::ErrorTypeStorage,
-                                         scoped_ptr<ServiceWorkerResponse>(),
-                                         scoped_ptr<storage::BlobDataHandle>());
+    match_context->original_callback.Run(
+        ServiceWorkerCache::ErrorTypeStorage,
+        scoped_ptr<ServiceWorkerResponse>(),
+        scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
-  scoped_ptr<storage::BlobDataHandle> blob_data_handle(
+  scoped_ptr<storage::BlobDataSnapshotHandle> blob_data_handle(
       match_context->blob_storage_context->AddFinishedBlob(
-          match_context->blob_data.get()));
+          *match_context->blob_data.get()));
 
   match_context->original_callback.Run(ServiceWorkerCache::ErrorTypeOK,
                                        match_context->response.Pass(),
                                        blob_data_handle.Pass());
 }
 
 void ServiceWorkerCache::PutImpl(scoped_ptr<PutContext> put_context) {
   if (backend_state_ != BACKEND_OPEN) {
     put_context->callback.Run(ErrorTypeStorage,
                               scoped_ptr<ServiceWorkerResponse>(),
-                              scoped_ptr<storage::BlobDataHandle>());
+                              scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   scoped_ptr<ServiceWorkerFetchRequest> request_copy(
       new ServiceWorkerFetchRequest(*put_context->request));
 
   Delete(request_copy.Pass(), base::Bind(&ServiceWorkerCache::PutDidDelete,
                                          weak_ptr_factory_.GetWeakPtr(),
                                          base::Passed(put_context.Pass())));
 }
 
 void ServiceWorkerCache::PutDidDelete(scoped_ptr<PutContext> put_context,
                                       ErrorType delete_error) {
   if (backend_state_ != BACKEND_OPEN) {
     put_context->callback.Run(ErrorTypeStorage,
                               scoped_ptr<ServiceWorkerResponse>(),
-                              scoped_ptr<storage::BlobDataHandle>());
+                              scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   disk_cache::Entry** entry_ptr = &put_context->cache_entry;
   ServiceWorkerFetchRequest* request_ptr = put_context->request.get();
   disk_cache::Backend* backend_ptr = backend_.get();
 
   net::CompletionCallback create_entry_callback = base::Bind(
       &ServiceWorkerCache::PutDidCreateEntry, weak_ptr_factory_.GetWeakPtr(),
       base::Passed(put_context.Pass()));
 
   int create_rv = backend_ptr->CreateEntry(
       request_ptr->url.spec(), entry_ptr, create_entry_callback);
 
   if (create_rv != net::ERR_IO_PENDING)
     create_entry_callback.Run(create_rv);
 }
 
 void ServiceWorkerCache::PutDidCreateEntry(scoped_ptr<PutContext> put_context,
                                            int rv) {
   if (rv != net::OK) {
     put_context->callback.Run(ServiceWorkerCache::ErrorTypeExists,
                               scoped_ptr<ServiceWorkerResponse>(),
-                              scoped_ptr<storage::BlobDataHandle>());
+                              scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   DCHECK(put_context->cache_entry);
 
   ServiceWorkerCacheMetadata metadata;
   ServiceWorkerCacheRequest* request_metadata = metadata.mutable_request();
   request_metadata->set_method(put_context->request->method);
   for (ServiceWorkerHeaderMap::const_iterator it =
            put_context->request->headers.begin();
@@ skipping 16 matching lines @@
        ++it) {
     ServiceWorkerCacheHeaderMap* header_map = response_metadata->add_headers();
     header_map->set_name(it->first);
     header_map->set_value(it->second);
   }
 
   scoped_ptr<std::string> serialized(new std::string());
   if (!metadata.SerializeToString(serialized.get())) {
     put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage,
                               scoped_ptr<ServiceWorkerResponse>(),
-                              scoped_ptr<storage::BlobDataHandle>());
+                              scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   scoped_refptr<net::StringIOBuffer> buffer(
       new net::StringIOBuffer(serialized.Pass()));
 
   // Get a temporary copy of the entry pointer before passing it in base::Bind.
   disk_cache::Entry* tmp_entry_ptr = put_context->cache_entry;
 
   net::CompletionCallback write_headers_callback = base::Bind(
@@ skipping 11 matching lines @@
     write_headers_callback.Run(rv);
 }
 
 void ServiceWorkerCache::PutDidWriteHeaders(scoped_ptr<PutContext> put_context,
                                             int expected_bytes,
                                             int rv) {
   if (rv != expected_bytes) {
     put_context->cache_entry->Doom();
     put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage,
                               scoped_ptr<ServiceWorkerResponse>(),
-                              scoped_ptr<storage::BlobDataHandle>());
+                              scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   // The metadata is written, now for the response content. The data is streamed
   // from the blob into the cache entry.
 
   if (put_context->response->blob_uuid.empty()) {
     if (put_context->quota_manager_proxy.get()) {
       put_context->quota_manager_proxy->NotifyStorageModified(
           storage::QuotaClient::kServiceWorkerCache,
           put_context->origin,
           storage::kStorageTypeTemporary,
           put_context->cache_entry->GetDataSize(INDEX_HEADERS));
     }
 
     put_context->callback.Run(ServiceWorkerCache::ErrorTypeOK,
                               put_context->response.Pass(),
-                              scoped_ptr<storage::BlobDataHandle>());
+                              scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   DCHECK(put_context->blob_data_handle);
 
   disk_cache::ScopedEntryPtr entry(put_context->cache_entry);
   put_context->cache_entry = NULL;
   scoped_ptr<BlobReader> reader(new BlobReader());
   BlobReader* reader_ptr = reader.get();
 
   // Grab some pointers before passing put_context in Bind.
   net::URLRequestContext* request_context = put_context->request_context;
-  scoped_ptr<storage::BlobDataHandle> blob_data_handle =
+  scoped_ptr<storage::BlobDataSnapshotHandle> blob_data_handle =
       put_context->blob_data_handle.Pass();
 
   reader_ptr->StreamBlobToCache(
       entry.Pass(), request_context, blob_data_handle.Pass(),
       base::Bind(&ServiceWorkerCache::PutDidWriteBlobToCache,
                  weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(put_context.Pass()),
                  base::Passed(reader.Pass())));
 }
 
 void ServiceWorkerCache::PutDidWriteBlobToCache(
     scoped_ptr<PutContext> put_context,
     scoped_ptr<BlobReader> blob_reader,
     disk_cache::ScopedEntryPtr entry,
     bool success) {
   DCHECK(entry);
   put_context->cache_entry = entry.release();
 
   if (!success) {
     put_context->cache_entry->Doom();
     put_context->callback.Run(ServiceWorkerCache::ErrorTypeStorage,
                               scoped_ptr<ServiceWorkerResponse>(),
-                              scoped_ptr<storage::BlobDataHandle>());
+                              scoped_ptr<storage::BlobDataSnapshotHandle>());
     return;
   }
 
   if (put_context->quota_manager_proxy.get()) {
     put_context->quota_manager_proxy->NotifyStorageModified(
         storage::QuotaClient::kServiceWorkerCache,
         put_context->origin,
         storage::kStorageTypeTemporary,
         put_context->cache_entry->GetDataSize(INDEX_HEADERS) +
             put_context->cache_entry->GetDataSize(INDEX_RESPONSE_BODY));
@@ skipping 202 matching lines @@
 void ServiceWorkerCache::PendingErrorCallback(const ErrorCallback& callback,
                                               ErrorType error) {
   callback.Run(error);
   DecPendingOps();
 }
 
 void ServiceWorkerCache::PendingResponseCallback(
     const ResponseCallback& callback,
     ErrorType error,
     scoped_ptr<ServiceWorkerResponse> response,
-    scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
+    scoped_ptr<storage::BlobDataSnapshotHandle> blob_data_handle) {
   callback.Run(error, response.Pass(), blob_data_handle.Pass());
   DecPendingOps();
 }
 
 void ServiceWorkerCache::PendingRequestsCallback(
     const RequestsCallback& callback,
     ErrorType error,
     scoped_ptr<Requests> requests) {
   callback.Run(error, requests.Pass());
   DecPendingOps();
 }
 
 }  // namespace content