CacheStorage: Support multiple batch operations

content/browser/cache_storage/cache_storage_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/cache_storage/cache_storage_cache.h"
 
 #include <string>
 
+#include "base/barrier_closure.h"
 #include "base/files/file_path.h"
 #include "base/guid.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/metrics/histogram_macros.h"
 #include "base/strings/string_util.h"
 #include "content/browser/cache_storage/cache_storage.pb.h"
 #include "content/browser/cache_storage/cache_storage_scheduler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/referrer.h"
 #include "net/base/completion_callback.h"
@@ skipping 375 matching lines @@
       origin, path, request_context, quota_manager_proxy, blob_context));
 }
 
 CacheStorageCache::~CacheStorageCache() {
 }
 
 base::WeakPtr<CacheStorageCache> CacheStorageCache::AsWeakPtr() {
   return weak_ptr_factory_.GetWeakPtr();
 }
 
-void CacheStorageCache::Put(scoped_ptr<ServiceWorkerFetchRequest> request,
-                            scoped_ptr<ServiceWorkerResponse> response,
-                            const ErrorCallback& callback) {
-  scoped_ptr<storage::BlobDataHandle> blob_data_handle;
-
-  if (!response->blob_uuid.empty()) {
-    if (!blob_storage_context_) {
-      callback.Run(ERROR_TYPE_STORAGE);
-      return;
-    }
-    blob_data_handle =
-        blob_storage_context_->GetBlobDataFromUUID(response->blob_uuid);
-    if (!blob_data_handle) {
-      callback.Run(ERROR_TYPE_STORAGE);
-      return;
-    }
-  }
-
-  ErrorCallback pending_callback =
-      base::Bind(&CacheStorageCache::PendingErrorCallback,
-                 weak_ptr_factory_.GetWeakPtr(), callback);
-
-  scoped_ptr<PutContext> put_context(new PutContext(
-      origin_, request.Pass(), response.Pass(), blob_data_handle.Pass(),
-      pending_callback, request_context_, quota_manager_proxy_));
-
-  if (backend_state_ == BACKEND_UNINITIALIZED)
-    InitBackend();
-
-  scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::PutImpl,
-                                           weak_ptr_factory_.GetWeakPtr(),
-                                           base::Passed(put_context.Pass())));
-}
-
 void CacheStorageCache::Match(scoped_ptr<ServiceWorkerFetchRequest> request,
                               const ResponseCallback& callback) {
   switch (backend_state_) {
     case BACKEND_UNINITIALIZED:
       InitBackend();
       break;
     case BACKEND_CLOSED:
       callback.Run(ERROR_TYPE_STORAGE, scoped_ptr<ServiceWorkerResponse>(),
                    scoped_ptr<storage::BlobDataHandle>());
       return;
     case BACKEND_OPEN:
       DCHECK(backend_);
       break;
   }
 
   ResponseCallback pending_callback =
       base::Bind(&CacheStorageCache::PendingResponseCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
   scheduler_->ScheduleOperation(
       base::Bind(&CacheStorageCache::MatchImpl, weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(request.Pass()), pending_callback));
 }
 
-void CacheStorageCache::Delete(scoped_ptr<ServiceWorkerFetchRequest> request,
-                               const ErrorCallback& callback) {
+void CacheStorageCache::BatchOperation(
+    const std::vector<CacheStorageBatchOperation>& operations,
+    const ErrorCallback& callback) {
   switch (backend_state_) {
     case BACKEND_UNINITIALIZED:
       InitBackend();
       break;
     case BACKEND_CLOSED:
       callback.Run(ERROR_TYPE_STORAGE);
       return;
     case BACKEND_OPEN:
       DCHECK(backend_);
       break;
   }
-  ErrorCallback pending_callback =
-      base::Bind(&CacheStorageCache::PendingErrorCallback,
-                 weak_ptr_factory_.GetWeakPtr(), callback);
-  scheduler_->ScheduleOperation(
-      base::Bind(&CacheStorageCache::DeleteImpl, weak_ptr_factory_.GetWeakPtr(),
-                 base::Passed(request.Pass()), pending_callback));
+
+  scoped_ptr<ErrorCallback> callback_copy(new ErrorCallback(callback));
+  ErrorCallback* callback_ptr = callback_copy.get();
+  base::Closure barrier_closure = base::BarrierClosure(
+      operations.size(), base::Bind(&CacheStorageCache::BatchDidAllOperations,
+                                    this, base::Passed(callback_copy.Pass())));
+  ErrorCallback completion_callback =
+      base::Bind(&CacheStorageCache::BatchDidOperation, this, barrier_closure,
+                 callback_ptr);
+
+  for (const auto& operation : operations) {
+    switch (operation.operation_type) {
+      case CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT:
+        Put(operation, completion_callback);
+        break;
+      case CACHE_STORAGE_CACHE_OPERATION_TYPE_DELETE:
+        DCHECK_EQ(1u, operations.size());
+        Delete(operation, completion_callback);
+        break;
+      case CACHE_STORAGE_CACHE_OPERATION_TYPE_UNDEFINED:
+        NOTREACHED();
+        // TODO(nhiroki): This should return "TypeError".
+        // http://crbug.com/425505
+        completion_callback.Run(ERROR_TYPE_STORAGE);
+        break;
+    }
+  }
+}
+
+void CacheStorageCache::BatchDidOperation(const base::Closure& barrier_closure,
+                                          ErrorCallback* callback,
+                                          ErrorType error) {
+  if (callback->is_null() || error == ERROR_TYPE_OK) {
+    barrier_closure.Run();
+    return;
+  }
+  callback->Run(error);
+  callback->Reset();  // Only call the callback once.
+
+  barrier_closure.Run();
+}
+
+void CacheStorageCache::BatchDidAllOperations(
+    scoped_ptr<ErrorCallback> callback) {
+  if (callback->is_null())
+    return;
+  callback->Run(ERROR_TYPE_OK);
 }
 
 void CacheStorageCache::Keys(const RequestsCallback& callback) {
   switch (backend_state_) {
     case BACKEND_UNINITIALIZED:
       InitBackend();
       break;
     case BACKEND_CLOSED:
       callback.Run(ERROR_TYPE_STORAGE, scoped_ptr<Requests>());
       return;
@@ skipping 249 matching lines @@
 
   scoped_ptr<storage::BlobDataHandle> blob_data_handle(
       match_context->blob_storage_context->AddFinishedBlob(
           match_context->blob_data.get()));
 
   match_context->original_callback.Run(CacheStorageCache::ERROR_TYPE_OK,
                                        match_context->response.Pass(),
                                        blob_data_handle.Pass());
 }
 
+void CacheStorageCache::Put(const CacheStorageBatchOperation& operation,
+                            const ErrorCallback& callback) {
+  DCHECK(BACKEND_OPEN == backend_state_ || initializing_);
+  DCHECK_EQ(CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT, operation.operation_type);
+
+  scoped_ptr<ServiceWorkerFetchRequest> request(new ServiceWorkerFetchRequest(
+      operation.request.url, operation.request.method,
+      operation.request.headers, operation.request.referrer,
+      operation.request.is_reload));
+
+  // We don't support streaming for cache.
+  DCHECK(operation.response.stream_url.is_empty());
+  scoped_ptr<ServiceWorkerResponse> response(new ServiceWorkerResponse(
+      operation.response.url, operation.response.status_code,
+      operation.response.status_text, operation.response.response_type,
+      operation.response.headers, operation.response.blob_uuid,
+      operation.response.blob_size, operation.response.stream_url));
+
+  scoped_ptr<storage::BlobDataHandle> blob_data_handle;
+
+  if (!response->blob_uuid.empty()) {
+    if (!blob_storage_context_) {
+      callback.Run(ERROR_TYPE_STORAGE);
+      return;
+    }
+    blob_data_handle =
+        blob_storage_context_->GetBlobDataFromUUID(response->blob_uuid);
+    if (!blob_data_handle) {
+      callback.Run(ERROR_TYPE_STORAGE);
+      return;
+    }
+  }
+
+  ErrorCallback pending_callback =
+      base::Bind(&CacheStorageCache::PendingErrorCallback,
+                 weak_ptr_factory_.GetWeakPtr(), callback);
+
+  scoped_ptr<PutContext> put_context(new PutContext(
+      origin_, request.Pass(), response.Pass(), blob_data_handle.Pass(),
+      pending_callback, request_context_, quota_manager_proxy_));
+
+  scheduler_->ScheduleOperation(base::Bind(&CacheStorageCache::PutImpl,
+                                           weak_ptr_factory_.GetWeakPtr(),
+                                           base::Passed(put_context.Pass())));
+}
+
 void CacheStorageCache::PutImpl(scoped_ptr<PutContext> put_context) {
   DCHECK(backend_state_ != BACKEND_UNINITIALIZED);
   if (backend_state_ != BACKEND_OPEN) {
     put_context->callback.Run(ERROR_TYPE_STORAGE);
     return;
   }
 
   scoped_ptr<ServiceWorkerFetchRequest> request_copy(
       new ServiceWorkerFetchRequest(*put_context->request));
 
@@ skipping 148 matching lines @@
     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));
   }
 
   put_context->callback.Run(CacheStorageCache::ERROR_TYPE_OK);
 }
 
+void CacheStorageCache::Delete(const CacheStorageBatchOperation& operation,
+                               const ErrorCallback& callback) {
+  DCHECK(BACKEND_OPEN == backend_state_ || initializing_);
+  DCHECK_EQ(CACHE_STORAGE_CACHE_OPERATION_TYPE_DELETE,
+            operation.operation_type);
+
+  scoped_ptr<ServiceWorkerFetchRequest> request(new ServiceWorkerFetchRequest(
+      operation.request.url, operation.request.method,
+      operation.request.headers, operation.request.referrer,
+      operation.request.is_reload));
+
+  ErrorCallback pending_callback =
+      base::Bind(&CacheStorageCache::PendingErrorCallback,
+                 weak_ptr_factory_.GetWeakPtr(), callback);
+  scheduler_->ScheduleOperation(
+      base::Bind(&CacheStorageCache::DeleteImpl, weak_ptr_factory_.GetWeakPtr(),
+                 base::Passed(request.Pass()), pending_callback));
+}
+
 void CacheStorageCache::DeleteImpl(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const ErrorCallback& callback) {
   DCHECK(backend_state_ != BACKEND_UNINITIALIZED);
   if (backend_state_ != BACKEND_OPEN) {
     callback.Run(ERROR_TYPE_STORAGE);
     return;
   }
   scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
 
@@ skipping 264 matching lines @@
     ErrorType error,
     scoped_ptr<Requests> requests) {
   base::WeakPtr<CacheStorageCache> cache = weak_ptr_factory_.GetWeakPtr();
 
   callback.Run(error, requests.Pass());
   if (cache)
     scheduler_->CompleteOperationAndRunNext();
 }
 
 }  // namespace content