[ServiceWorkerCache] Reland backend state CL

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 697 matching lines @@
   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);
   }
 
   base::Closure continuation = base::Bind(&ServiceWorkerCache::PutImpl,
                                           base::Passed(put_context.Pass()));
 
-  if (!initialized_) {
-    Init(continuation);
+  if (backend_state_ == BACKEND_UNINITIALIZED) {
+    InitBackend(continuation);
     return;
   }
 
   continuation.Run();
 }
 
 void ServiceWorkerCache::Match(scoped_ptr<ServiceWorkerFetchRequest> request,
                                const ResponseCallback& callback) {
   IncPendingOps();
   ResponseCallback pending_callback =
       base::Bind(&ServiceWorkerCache::PendingResponseCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
 
-  if (!initialized_) {
-    Init(base::Bind(&ServiceWorkerCache::Match, weak_ptr_factory_.GetWeakPtr(),
-                    base::Passed(request.Pass()), pending_callback));
-    return;
-  }
-  if (!backend_) {
-    pending_callback.Run(ErrorTypeStorage, scoped_ptr<ServiceWorkerResponse>(),
-                         scoped_ptr<storage::BlobDataHandle>());
-    return;
+  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>());
+      return;
+    case BACKEND_OPEN:
+      DCHECK(backend_);
+      break;
   }
 
   scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
 
   disk_cache::Entry** entry_ptr = entry.get();
 
   ServiceWorkerFetchRequest* request_ptr = request.get();
 
   net::CompletionCallback open_entry_callback = base::Bind(
       MatchDidOpenEntry, base::Passed(request.Pass()), pending_callback,
       blob_storage_context_, base::Passed(entry.Pass()));
 
   int rv = backend_->OpenEntry(
       request_ptr->url.spec(), entry_ptr, open_entry_callback);
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void ServiceWorkerCache::Delete(scoped_ptr<ServiceWorkerFetchRequest> request,
                                 const ErrorCallback& callback) {
   IncPendingOps();
   ErrorCallback pending_callback =
       base::Bind(&ServiceWorkerCache::PendingErrorCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
 
-  if (!initialized_) {
-    Init(base::Bind(&ServiceWorkerCache::Delete, weak_ptr_factory_.GetWeakPtr(),
-                    base::Passed(request.Pass()), pending_callback));
-    return;
-  }
-  if (!backend_) {
-    pending_callback.Run(ErrorTypeStorage);
-    return;
+  switch (backend_state_) {
+    case BACKEND_UNINITIALIZED:
+      InitBackend(base::Bind(&ServiceWorkerCache::Delete,
+                             weak_ptr_factory_.GetWeakPtr(),
+                             base::Passed(request.Pass()), pending_callback));
+      return;
+    case BACKEND_CLOSED:
+      pending_callback.Run(ErrorTypeStorage);
+      return;
+    case BACKEND_OPEN:
+      DCHECK(backend_);
+      break;
   }
 
   scoped_ptr<disk_cache::Entry*> entry(new disk_cache::Entry*);
 
   disk_cache::Entry** entry_ptr = entry.get();
 
   ServiceWorkerFetchRequest* request_ptr = request.get();
 
   net::CompletionCallback open_entry_callback = base::Bind(
       DeleteDidOpenEntry, origin_, base::Passed(request.Pass()),
       pending_callback, base::Passed(entry.Pass()), quota_manager_proxy_);
 
   int rv = backend_->OpenEntry(
       request_ptr->url.spec(), entry_ptr, open_entry_callback);
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void ServiceWorkerCache::Keys(const RequestsCallback& callback) {
   IncPendingOps();
   RequestsCallback pending_callback =
       base::Bind(&ServiceWorkerCache::PendingRequestsCallback,
                  weak_ptr_factory_.GetWeakPtr(), callback);
-  if (!initialized_) {
-    Init(base::Bind(&ServiceWorkerCache::Keys, weak_ptr_factory_.GetWeakPtr(),
-                    pending_callback));
-    return;
-  }
-  if (!backend_) {
-    pending_callback.Run(ErrorTypeStorage, scoped_ptr<Requests>());
-    return;
+
+  switch (backend_state_) {
+    case BACKEND_UNINITIALIZED:
+      InitBackend(base::Bind(&ServiceWorkerCache::Keys,
+                             weak_ptr_factory_.GetWeakPtr(), pending_callback));
+      return;
+    case BACKEND_CLOSED:
+      pending_callback.Run(ErrorTypeStorage, scoped_ptr<Requests>());
+      return;
+    case BACKEND_OPEN:
+      DCHECK(backend_);
+      break;
   }
 
   // 1. Iterate through all of the entries, open them, and add them to a vector.
   // 2. For each open entry:
   //  2.1. Read the headers into a protobuf.
   //  2.2. Copy the protobuf into a ServiceWorkerFetchRequest (a "key").
   //  2.3. Push the response into a vector of requests to be returned.
   // 3. Return the vector of requests (keys).
 
   // The entries have to be loaded into a vector first because enumeration loops
   // forever if you read data from a cache entry while enumerating.
 
   scoped_ptr<KeysContext> keys_context(
       new KeysContext(pending_callback, weak_ptr_factory_.GetWeakPtr()));
 
   keys_context->backend_iterator = backend_->CreateIterator();
   disk_cache::Backend::Iterator& iterator = *keys_context->backend_iterator;
   disk_cache::Entry** enumerated_entry = &keys_context->enumerated_entry;
 
   net::CompletionCallback open_entry_callback =
       base::Bind(KeysDidOpenNextEntry, base::Passed(keys_context.Pass()));
 
   int rv = iterator.OpenNextEntry(enumerated_entry, open_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
 void ServiceWorkerCache::Close(const base::Closure& callback) {
-  DCHECK(!initialized_ || backend_)
+  DCHECK(backend_state_ != BACKEND_CLOSED)
       << "Don't call ServiceWorkerCache::Close() twice.";
 
+  backend_state_ = BACKEND_CLOSED;
   if (pending_ops_ > 0) {
     DCHECK(ops_complete_callback_.is_null());
-    initialized_ = true;  // So that future operations halt.
-    ops_complete_callback_ = base::Bind(
-        &ServiceWorkerCache::Close, weak_ptr_factory_.GetWeakPtr(), callback);
+    ops_complete_callback_ =
+        base::Bind(&ServiceWorkerCache::CloseImpl,
+                   weak_ptr_factory_.GetWeakPtr(), callback);
     return;
   }
 
-  initialized_ = true;
-  backend_.reset();
-  callback.Run();
+  CloseImpl(callback);
 }
 
 int64 ServiceWorkerCache::MemoryBackedSize() const {
-  if (!backend_ || !memory_only_)
+  if (backend_state_ != BACKEND_OPEN || !memory_only_)
     return 0;
 
   scoped_ptr<disk_cache::Backend::Iterator> backend_iter =
       backend_->CreateIterator();
   disk_cache::Entry* entry = nullptr;
 
   int64 sum = 0;
 
   std::vector<disk_cache::Entry*> entries;
   int rv = net::OK;
@@ skipping 17 matching lines @@
     const GURL& origin,
     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),
-      initialized_(false),
+      backend_state_(BACKEND_UNINITIALIZED),
       memory_only_(path.empty()),
       pending_ops_(0),
       weak_ptr_factory_(this) {
 }
 
 // static
 void ServiceWorkerCache::PutImpl(scoped_ptr<PutContext> put_context) {
-  if (!put_context->cache || !put_context->cache->backend_) {
+  if (!put_context->cache ||
+      put_context->cache->backend_state_ != BACKEND_OPEN) {
     put_context->callback.Run(ErrorTypeStorage,
                               scoped_ptr<ServiceWorkerResponse>(),
                               scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   scoped_ptr<ServiceWorkerFetchRequest> request_copy(
       new ServiceWorkerFetchRequest(*put_context->request));
   ServiceWorkerCache* cache_ptr = put_context->cache.get();
 
   cache_ptr->Delete(request_copy.Pass(),
                     base::Bind(PutDidDelete, base::Passed(put_context.Pass())));
 }
 
 // static
 void ServiceWorkerCache::PutDidDelete(scoped_ptr<PutContext> put_context,
                                       ErrorType delete_error) {
-  if (!put_context->cache || !put_context->cache->backend_) {
+  if (!put_context->cache ||
+      put_context->cache->backend_state_ != BACKEND_OPEN) {
     put_context->callback.Run(ErrorTypeStorage,
                               scoped_ptr<ServiceWorkerResponse>(),
                               scoped_ptr<storage::BlobDataHandle>());
     return;
   }
 
   disk_cache::Entry** entry_ptr = &put_context->cache_entry;
   ServiceWorkerFetchRequest* request_ptr = put_context->request.get();
   disk_cache::Backend* backend_ptr = put_context->cache->backend_.get();
 
@@ skipping 167 matching lines @@
     return;
   }
 
   base::WeakPtr<ServiceWorkerCache> cache = keys_context->cache;
   if (rv < 0 || !cache) {
     keys_context->original_callback.Run(ErrorTypeStorage,
                                         scoped_ptr<Requests>());
     return;
   }
 
-  if (!cache->backend_) {
+  if (cache->backend_state_ != BACKEND_OPEN) {
     keys_context->original_callback.Run(ErrorTypeNotFound,
                                         scoped_ptr<Requests>());
     return;
   }
 
   // Store the entry.
   keys_context->entries.push_back(keys_context->enumerated_entry);
   keys_context->enumerated_entry = NULL;
 
   // Enumerate the next entry.
@@ skipping 46 matching lines @@
       const ServiceWorkerCacheHeaderMap header = metadata->request().headers(i);
       req_headers.insert(std::make_pair(header.name(), header.value()));
     }
   } else {
     entry->Doom();
   }
 
   KeysProcessNextEntry(keys_context.Pass(), iter + 1);
 }
 
+void ServiceWorkerCache::CloseImpl(const base::Closure& callback) {
+  DCHECK(backend_state_ == BACKEND_CLOSED);
+  backend_.reset();
+  callback.Run();
+}
+
 void ServiceWorkerCache::CreateBackend(const ErrorCallback& callback) {
   DCHECK(!backend_);
 
   // Use APP_CACHE as opposed to DISK_CACHE to prevent cache eviction.
   net::CacheType cache_type = memory_only_ ? net::MEMORY_CACHE : net::APP_CACHE;
 
   scoped_ptr<ScopedBackendPtr> backend_ptr(new ScopedBackendPtr());
 
   // Temporary pointer so that backend_ptr can be Pass()'d in Bind below.
   ScopedBackendPtr* backend = backend_ptr.get();
@@ skipping 13 matching lines @@
       kMaxCacheBytes,
       false, /* force */
       BrowserThread::GetMessageLoopProxyForThread(BrowserThread::CACHE).get(),
       NULL,
       backend,
       create_cache_callback);
   if (rv != net::ERR_IO_PENDING)
     create_cache_callback.Run(rv);
 }
 
-void ServiceWorkerCache::Init(const base::Closure& callback) {
-  DCHECK(!initialized_);
+void ServiceWorkerCache::InitBackend(const base::Closure& callback) {
+  DCHECK(backend_state_ == BACKEND_UNINITIALIZED);
   init_callbacks_.push_back(callback);
 
   // If this isn't the first call to Init then return as the initialization
   // has already started.
   if (init_callbacks_.size() > 1u)
     return;
 
   CreateBackend(base::Bind(&ServiceWorkerCache::InitDone,
                            weak_ptr_factory_.GetWeakPtr()));
 }
 
 void ServiceWorkerCache::InitDone(ErrorType error) {
-  initialized_ = true;
+  backend_state_ = (error == ErrorTypeOK && backend_ &&
+                    backend_state_ == BACKEND_UNINITIALIZED)
+                       ? BACKEND_OPEN
+                       : BACKEND_CLOSED;
   for (std::vector<base::Closure>::iterator it = init_callbacks_.begin();
-       it != init_callbacks_.end();
-       ++it) {
+       it != init_callbacks_.end(); ++it) {
     it->Run();
   }
   init_callbacks_.clear();
 }
 
 void ServiceWorkerCache::DecPendingOps() {
   DCHECK(pending_ops_ > 0);
   pending_ops_--;
   if (pending_ops_ == 0 && !ops_complete_callback_.is_null()) {
     ops_complete_callback_.Run();
@@ skipping 18 matching lines @@
 
 void ServiceWorkerCache::PendingRequestsCallback(
     const RequestsCallback& callback,
     ErrorType error,
     scoped_ptr<Requests> requests) {
   callback.Run(error, requests.Pass());
   DecPendingOps();
 }
 
 }  // namespace content