Disk cache: Update the disk cache tools and tests to use...

net/disk_cache/backend_impl.cc

 // Copyright (c) 2010 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 "net/disk_cache/backend_impl.h"
 
 #include "base/field_trial.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/histogram.h"
 #include "base/message_loop.h"
 #include "base/rand_util.h"
 #include "base/string_util.h"
 #include "base/sys_info.h"
 #include "base/timer.h"
 #include "base/worker_pool.h"
 #include "net/base/net_errors.h"
 #include "net/disk_cache/cache_util.h"
 #include "net/disk_cache/entry_impl.h"
 #include "net/disk_cache/errors.h"
 #include "net/disk_cache/hash.h"
 #include "net/disk_cache/file.h"
+#include "net/disk_cache/mem_backend_impl.h"
 
 // This has to be defined before including histogram_macros.h from this file.
 #define NET_DISK_CACHE_BACKEND_IMPL_CC_
 #include "net/disk_cache/histogram_macros.h"
 
 using base::Time;
 using base::TimeDelta;
 using base::TimeTicks;
 
 namespace {
@@ skipping 127 matching lines @@
   std::string group1 = StringPrintf("CacheSizeGroup_%d", size_group);
   trial1->AppendGroup(group1, FieldTrial::kAllRemainingProbability);
 }
 
 }  // namespace
 
 // ------------------------------------------------------------------------
 
 namespace disk_cache {
 
-Backend* CreateCacheBackend(const FilePath& full_path, bool force,
-                            int max_bytes, net::CacheType type) {
-  // Create a backend without extra flags.
-  return BackendImpl::CreateBackend(full_path, force, max_bytes, type, kNone);
-}
-
 int CreateCacheBackend(net::CacheType type, const FilePath& path, int max_bytes,
                        bool force, base::MessageLoopProxy* thread,
                        Backend** backend, CompletionCallback* callback) {
-  if (type == net::MEMORY_CACHE)
-    *backend = CreateInMemoryCacheBackend(max_bytes);
-  else
-    *backend = BackendImpl::CreateBackend(path, force, max_bytes, type, kNone);
-  return *backend ? net::OK : net::ERR_FAILED;
+  DCHECK(callback);
+  if (type == net::MEMORY_CACHE) {
+    *backend = MemBackendImpl::CreateBackend(max_bytes);
+    return *backend ? net::OK : net::ERR_FAILED;
+  }
+  DCHECK(thread);
+
+  return BackendImpl::CreateBackend(path, force, max_bytes, type, kNone, thread,
+                                    backend, callback);
 }
 
 // Returns the preferred maximum number of bytes for the cache given the
 // number of available bytes.
 int PreferedCacheSize(int64 available) {
   // Return 80% of the available space if there is not enough space to use
   // kDefaultCacheSize.
   if (available < kDefaultCacheSize * 10 / 8)
     return static_cast<int32>(available * 8 / 10);
 
@@ skipping 23 matching lines @@
 // If the initialization of the cache fails, and force is true, we will discard
 // the whole cache and create a new one. In order to process a potentially large
 // number of files, we'll rename the cache folder to old_ + original_name +
 // number, (located on the same parent folder), and spawn a worker thread to
 // delete all the files on all the stale cache folders. The whole process can
 // still fail if we are not able to rename the cache folder (for instance due to
 // a sharing violation), and in that case a cache for this profile (on the
 // desired path) cannot be created.
 //
 // Static.
-Backend* BackendImpl::CreateBackend(const FilePath& full_path, bool force,
-                                    int max_bytes, net::CacheType type,
-                                    BackendFlags flags) {
-  BackendImpl* cache = new BackendImpl(full_path);
+int BackendImpl::CreateBackend(const FilePath& full_path, bool force,
+                               int max_bytes, net::CacheType type,
+                               uint32 flags, base::MessageLoopProxy* thread,
+                               Backend** backend,
+                               CompletionCallback* callback) {
+  BackendImpl* cache = new BackendImpl(full_path, thread);
   cache->SetMaxSize(max_bytes);
   cache->SetType(type);
   cache->SetFlags(flags);
-  if (cache->Init())
-    return cache;
+  if (cache->Init()) {
+    *backend = cache;
+    return net::OK;
+  }
 
+  *backend = NULL;
   delete cache;
   if (!force)
-    return NULL;
+    return net::ERR_FAILED;
 
   if (!DelayedCacheCleanup(full_path))
-    return NULL;
+    return net::ERR_FAILED;
 
   // The worker thread will start deleting files soon, but the original folder
   // is not there anymore... let's create a new set of files.
-  cache = new BackendImpl(full_path);
+  cache = new BackendImpl(full_path, thread);
   cache->SetMaxSize(max_bytes);
   cache->SetType(type);
   cache->SetFlags(flags);
-  if (cache->Init())
-    return cache;
+  if (cache->Init()) {
+    *backend = cache;
+    return net::OK;
+  }
 
   delete cache;
   LOG(ERROR) << "Unable to create cache";
-  return NULL;
+  return net::ERR_FAILED;
 }
 
 bool BackendImpl::Init() {
   DCHECK(!init_);
   if (init_)
     return false;
 
   bool create_files = false;
   if (!InitBackingStore(&create_files)) {
     ReportError(ERR_STORAGE_ERROR);
@@ skipping 1433 matching lines @@
 
   return num_dirty;
 }
 
 bool BackendImpl::CheckEntry(EntryImpl* cache_entry) {
   RankingsNode* rankings = cache_entry->rankings()->Data();
   return !rankings->dummy;
 }
 
 }  // namespace disk_cache