[ServiceWorkerCache] Serialize ServiceWorkerCacheStorage operations

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"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_util.h"
 #include "content/browser/service_worker/service_worker_cache.pb.h"
+#include "content/browser/service_worker/service_worker_cache_scheduler.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/common/referrer.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/disk_cache.h"
 #include "net/url_request/url_request_context.h"
 #include "storage/browser/blob/blob_data_builder.h"
 #include "storage/browser/blob/blob_data_handle.h"
 #include "storage/browser/blob/blob_storage_context.h"
 #include "storage/browser/blob/blob_url_request_job_factory.h"
@@ skipping 430 matching lines @@
       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.
     put_context->out_blob_data_handle =
         blob_storage_context_->GetBlobDataFromUUID(
             put_context->response->blob_uuid);
   }
 
-  pending_operations_.push_back(base::Bind(&ServiceWorkerCache::PutImpl,
+  if (backend_state_ == BACKEND_UNINITIALIZED)
+    InitBackend();
+
+  scheduler_->ScheduleOperation(base::Bind(&ServiceWorkerCache::PutImpl,
                                            weak_ptr_factory_.GetWeakPtr(),
                                            base::Passed(put_context.Pass())));
-
-  if (backend_state_ == BACKEND_UNINITIALIZED) {
-    InitBackend();
-    return;
-  }
-
-  RunOperationIfIdle();
 }
 
 void ServiceWorkerCache::Match(scoped_ptr<ServiceWorkerFetchRequest> request,
                                const ResponseCallback& callback) {
+  switch (backend_state_) {
+    case BACKEND_UNINITIALIZED:
+      InitBackend();
+      break;
+    case BACKEND_CLOSED:
+      callback.Run(ErrorTypeStorage, scoped_ptr<ServiceWorkerResponse>(),
+                   scoped_ptr<storage::BlobDataHandle>());
+      return;
+    case BACKEND_OPEN:
+      DCHECK(backend_);
+      break;
+  }
+
   ResponseCallback pending_callback =
       base::Bind(&ServiceWorkerCache::PendingResponseCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
-  pending_operations_.push_back(
+  scheduler_->ScheduleOperation(
       base::Bind(&ServiceWorkerCache::MatchImpl, weak_ptr_factory_.GetWeakPtr(),
                  base::Passed(request.Pass()), pending_callback));
-
-  switch (backend_state_) {
-    case BACKEND_UNINITIALIZED:
-      InitBackend();
-      return;
-    case BACKEND_CLOSED:
-      pending_callback.Run(ErrorTypeStorage,
-                           scoped_ptr<ServiceWorkerResponse>(),
-                           scoped_ptr<storage::BlobDataHandle>());
-      return;
-    case BACKEND_OPEN:
-      DCHECK(backend_);
-      RunOperationIfIdle();
-      return;
-  }
-  NOTREACHED();
 }
 
 void ServiceWorkerCache::Delete(scoped_ptr<ServiceWorkerFetchRequest> request,
                                 const ErrorCallback& callback) {
+  switch (backend_state_) {
+    case BACKEND_UNINITIALIZED:
+      InitBackend();
+      break;
+    case BACKEND_CLOSED:
+      callback.Run(ErrorTypeStorage);
+      return;
+    case BACKEND_OPEN:
+      DCHECK(backend_);
+      break;
+  }
   ErrorCallback pending_callback =
       base::Bind(&ServiceWorkerCache::PendingErrorCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
-  pending_operations_.push_back(base::Bind(
+  scheduler_->ScheduleOperation(base::Bind(
       &ServiceWorkerCache::DeleteImpl, weak_ptr_factory_.GetWeakPtr(),
       base::Passed(request.Pass()), pending_callback));
+}
 
+void ServiceWorkerCache::Keys(const RequestsCallback& callback) {
   switch (backend_state_) {
     case BACKEND_UNINITIALIZED:
       InitBackend();
-      return;
+      break;
     case BACKEND_CLOSED:
-      pending_callback.Run(ErrorTypeStorage);
+      callback.Run(ErrorTypeStorage, scoped_ptr<Requests>());
       return;
     case BACKEND_OPEN:
       DCHECK(backend_);
-      RunOperationIfIdle();
-      return;
+      break;
   }
-  NOTREACHED();
-}
 
-void ServiceWorkerCache::Keys(const RequestsCallback& callback) {
   RequestsCallback pending_callback =
       base::Bind(&ServiceWorkerCache::PendingRequestsCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
-  pending_operations_.push_back(base::Bind(&ServiceWorkerCache::KeysImpl,
+  scheduler_->ScheduleOperation(base::Bind(&ServiceWorkerCache::KeysImpl,
                                            weak_ptr_factory_.GetWeakPtr(),
                                            pending_callback));
-
-  switch (backend_state_) {
-    case BACKEND_UNINITIALIZED:
-      InitBackend();
-      return;
-    case BACKEND_CLOSED:
-      pending_callback.Run(ErrorTypeStorage, scoped_ptr<Requests>());
-      return;
-    case BACKEND_OPEN:
-      DCHECK(backend_);
-      RunOperationIfIdle();
-      return;
-  }
-  NOTREACHED();
 }
 
 void ServiceWorkerCache::Close(const base::Closure& callback) {
   DCHECK(backend_state_ != BACKEND_CLOSED)
       << "Don't call ServiceWorkerCache::Close() twice.";
 
   base::Closure pending_callback =
       base::Bind(&ServiceWorkerCache::PendingClosure,
                  weak_ptr_factory_.GetWeakPtr(), callback);
 
-  pending_operations_.push_back(base::Bind(&ServiceWorkerCache::CloseImpl,
+  scheduler_->ScheduleOperation(base::Bind(&ServiceWorkerCache::CloseImpl,
                                            weak_ptr_factory_.GetWeakPtr(),
                                            pending_callback));
-  RunOperationIfIdle();
 }
 
 int64 ServiceWorkerCache::MemoryBackedSize() const {
   if (backend_state_ != BACKEND_OPEN || !memory_only_)
     return 0;
 
   scoped_ptr<disk_cache::Backend::Iterator> backend_iter =
       backend_->CreateIterator();
   disk_cache::Entry* entry = nullptr;
 
@@ skipping 22 matching lines @@
     const base::FilePath& path,
     net::URLRequestContext* request_context,
     const scoped_refptr<storage::QuotaManagerProxy>& quota_manager_proxy,
     base::WeakPtr<storage::BlobStorageContext> blob_context)
     : origin_(origin),
       path_(path),
       request_context_(request_context),
       quota_manager_proxy_(quota_manager_proxy),
       blob_storage_context_(blob_context),
       backend_state_(BACKEND_UNINITIALIZED),
-      operation_running_(false),
+      scheduler_(new ServiceWorkerCacheScheduler()),
       initializing_(false),
       memory_only_(path.empty()),
       weak_ptr_factory_(this) {
 }
 
 void ServiceWorkerCache::MatchImpl(
     scoped_ptr<ServiceWorkerFetchRequest> request,
     const ResponseCallback& callback) {
   DCHECK(backend_state_ != BACKEND_UNINITIALIZED);
   if (backend_state_ != BACKEND_OPEN) {
@@ skipping 583 matching lines @@
     return;
   }
 
   backend_ = backend_ptr->Pass();
   callback.Run(ServiceWorkerCache::ErrorTypeOK);
 }
 
 void ServiceWorkerCache::InitBackend() {
   DCHECK(backend_state_ == BACKEND_UNINITIALIZED);
 
-  if (initializing_) {
-    DCHECK(operation_running_);
+  if (initializing_)
     return;
-  }
 
-  DCHECK(!operation_running_);  // All ops should wait for backend init.
+  DCHECK(scheduler_->Empty());
   initializing_ = true;
-  // Note that this operation pushes to the front of the queue.
-  pending_operations_.push_front(base::Bind(
+
+  scheduler_->ScheduleOperation(base::Bind(
       &ServiceWorkerCache::CreateBackend, weak_ptr_factory_.GetWeakPtr(),
       base::Bind(&ServiceWorkerCache::InitDone,
                  weak_ptr_factory_.GetWeakPtr())));
-  RunOperationIfIdle();
 }
 
 void ServiceWorkerCache::InitDone(ErrorType error) {
   initializing_ = false;
   backend_state_ = (error == ErrorTypeOK && backend_ &&
                     backend_state_ == BACKEND_UNINITIALIZED)
                        ? BACKEND_OPEN
                        : BACKEND_CLOSED;
-  CompleteOperationAndRunNext();
-}
-
-void ServiceWorkerCache::CompleteOperationAndRunNext() {
-  DCHECK(!pending_operations_.empty());
-  operation_running_ = false;
-  pending_operations_.pop_front();
-  RunOperationIfIdle();
-}
-
-void ServiceWorkerCache::RunOperationIfIdle() {
-  DCHECK(!operation_running_ || !pending_operations_.empty());
-
-  if (!operation_running_ && !pending_operations_.empty()) {
-    operation_running_ = true;
-    // TODO(jkarlin): Run multiple operations in parallel where allowed (e.g.,
-    // if they're for different keys then they won't interfere). See
-    // https://crbug.com/451174.
-    pending_operations_.front().Run();
-  }
+  scheduler_->CompleteOperationAndRunNext();
 }
 
 void ServiceWorkerCache::PendingClosure(const base::Closure& callback) {
+  base::WeakPtr<ServiceWorkerCache> cache = weak_ptr_factory_.GetWeakPtr();
+
   callback.Run();
-  CompleteOperationAndRunNext();
+  if (cache)
+    scheduler_->CompleteOperationAndRunNext();
 }
 
 void ServiceWorkerCache::PendingErrorCallback(const ErrorCallback& callback,
                                               ErrorType error) {
+  base::WeakPtr<ServiceWorkerCache> cache = weak_ptr_factory_.GetWeakPtr();
+
   callback.Run(error);
-  CompleteOperationAndRunNext();
+  if (cache)
+    scheduler_->CompleteOperationAndRunNext();
 }
 
 void ServiceWorkerCache::PendingResponseCallback(
     const ResponseCallback& callback,
     ErrorType error,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<storage::BlobDataHandle> blob_data_handle) {
+  base::WeakPtr<ServiceWorkerCache> cache = weak_ptr_factory_.GetWeakPtr();
+
   callback.Run(error, response.Pass(), blob_data_handle.Pass());
-  CompleteOperationAndRunNext();
+  if (cache)
+    scheduler_->CompleteOperationAndRunNext();
 }
 
 void ServiceWorkerCache::PendingRequestsCallback(
     const RequestsCallback& callback,
     ErrorType error,
     scoped_ptr<Requests> requests) {
+  base::WeakPtr<ServiceWorkerCache> cache = weak_ptr_factory_.GetWeakPtr();
+
   callback.Run(error, requests.Pass());
-  CompleteOperationAndRunNext();
+  if (cache)
+    scheduler_->CompleteOperationAndRunNext();
 }
 
 }  // namespace content