ServiceWorker: Migrate the script cache backend from BlockFile to Simple

content/browser/appcache/appcache_disk_cache.cc

 // Copyright (c) 2012 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/appcache/appcache_disk_cache.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/files/file_path.h"
 #include "base/logging.h"
@@ skipping 242 matching lines @@
   disk_cache_.reset();
 }
 
 int AppCacheDiskCache::CreateEntry(int64 key, Entry** entry,
                                    const net::CompletionCallback& callback) {
   DCHECK(entry);
   DCHECK(!callback.is_null());
   if (is_disabled_)
     return net::ERR_ABORTED;
 
-  if (is_initializing()) {
+  if (is_initializing_or_waiting_to_initialize()) {
     pending_calls_.push_back(PendingCall(CREATE, key, entry, callback));
     return net::ERR_IO_PENDING;
   }
 
   if (!disk_cache_)
     return net::ERR_FAILED;
 
   return ActiveCall::CreateEntry(
       weak_factory_.GetWeakPtr(), key, entry, callback);
 }
 
 int AppCacheDiskCache::OpenEntry(int64 key, Entry** entry,
                                  const net::CompletionCallback& callback) {
   DCHECK(entry);
   DCHECK(!callback.is_null());
   if (is_disabled_)
     return net::ERR_ABORTED;
 
-  if (is_initializing()) {
+  if (is_initializing_or_waiting_to_initialize()) {
     pending_calls_.push_back(PendingCall(OPEN, key, entry, callback));
     return net::ERR_IO_PENDING;
   }
 
   if (!disk_cache_)
     return net::ERR_FAILED;
 
   return ActiveCall::OpenEntry(
       weak_factory_.GetWeakPtr(), key, entry, callback);
 }
 
 int AppCacheDiskCache::DoomEntry(int64 key,
                                  const net::CompletionCallback& callback) {
   DCHECK(!callback.is_null());
   if (is_disabled_)
     return net::ERR_ABORTED;
 
-  if (is_initializing()) {
+  if (is_initializing_or_waiting_to_initialize()) {
     pending_calls_.push_back(PendingCall(DOOM, key, NULL, callback));
     return net::ERR_IO_PENDING;
   }
 
   if (!disk_cache_)
     return net::ERR_FAILED;
 
   return ActiveCall::DoomEntry(weak_factory_.GetWeakPtr(), key, callback);
 }
 
 AppCacheDiskCache::AppCacheDiskCache(bool use_simple_cache)
     : use_simple_cache_(use_simple_cache),
       is_disabled_(false),
+      is_waiting_to_initialize_(false),
       weak_factory_(this) {
 }
 
 AppCacheDiskCache::PendingCall::PendingCall()
     : call_type(CREATE),
       key(0),
       entry(NULL) {
 }
 
 AppCacheDiskCache::PendingCall::PendingCall(PendingCallType call_type,
     int64 key,
     Entry** entry,
     const net::CompletionCallback& callback)
     : call_type(call_type),
       key(key),
       entry(entry),
       callback(callback) {
 }
 
 AppCacheDiskCache::PendingCall::~PendingCall() {}
 
 int AppCacheDiskCache::Init(
     net::CacheType cache_type,
     const base::FilePath& cache_directory,
     int cache_size,
     bool force,
     const scoped_refptr<base::SingleThreadTaskRunner>& cache_thread,
     const net::CompletionCallback& callback) {
-  DCHECK(!is_initializing() && !disk_cache_.get());
+  DCHECK(!is_initializing_or_waiting_to_initialize() && !disk_cache_.get());
   is_disabled_ = false;
   create_backend_callback_ = new CreateBackendCallbackShim(this);
 
   int rv = disk_cache::CreateCacheBackend(
       cache_type,
       use_simple_cache_ ? net::CACHE_BACKEND_SIMPLE
                         : net::CACHE_BACKEND_DEFAULT,
       cache_directory,
       cache_size,
       force,
@@ skipping 39 matching lines @@
         NOTREACHED();
         break;
     }
     if (rv != net::ERR_IO_PENDING)
       iter->callback.Run(rv);
   }
   pending_calls_.clear();
 }
 
 }  // namespace content