Initialize the simple cache backend at runtime.

net/disk_cache/disk_cache_test_base.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 "net/disk_cache/disk_cache_test_base.h"
 
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "net/base/io_buffer.h"
 #include "net/base/net_errors.h"
 #include "net/base/test_completion_callback.h"
 #include "net/disk_cache/backend_impl.h"
+#include "net/disk_cache/cache_util.h"
+#include "net/disk_cache/disk_cache.h"
 #include "net/disk_cache/disk_cache_test_util.h"
 #include "net/disk_cache/mem_backend_impl.h"
+#include "net/disk_cache/simple/simple_backend_impl.h"
 
 DiskCacheTest::DiskCacheTest() {
   CHECK(temp_dir_.CreateUniqueTempDir());
   cache_path_ = temp_dir_.path();
   if (!MessageLoop::current())
     message_loop_.reset(new MessageLoopForIO());
 }
 
 DiskCacheTest::~DiskCacheTest() {
 }
@@ skipping 20 matching lines @@
 }
 
 DiskCacheTestWithCache::DiskCacheTestWithCache()
     : cache_(NULL),
       cache_impl_(NULL),
       mem_cache_(NULL),
       mask_(0),
       size_(0),
       type_(net::DISK_CACHE),
       memory_only_(false),
-      implementation_(false),
+      simple_cache_mode_(false),
       force_creation_(false),
       new_eviction_(false),
       first_cleanup_(true),
       integrity_(true),
       use_current_thread_(false),
       cache_thread_("CacheThread") {
 }
 
 DiskCacheTestWithCache::~DiskCacheTestWithCache() {}
 
 void DiskCacheTestWithCache::InitCache() {
-  if (mask_ || new_eviction_)
-    implementation_ = true;
-
   if (memory_only_)
     InitMemoryCache();
   else
     InitDiskCache();
 
   ASSERT_TRUE(NULL != cache_);
   if (first_cleanup_)
     ASSERT_EQ(0, cache_->GetEntryCount());
 }
 
 // We are expected to leak memory when simulating crashes.
 void DiskCacheTestWithCache::SimulateCrash() {
-  ASSERT_TRUE(implementation_ && !memory_only_);
+  ASSERT_TRUE(!memory_only_);
   net::TestCompletionCallback cb;
   int rv = cache_impl_->FlushQueueForTest(cb.callback());
   ASSERT_EQ(net::OK, cb.GetResult(rv));
   cache_impl_->ClearRefCountForTest();
 
   delete cache_impl_;
   EXPECT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, mask_));
 
-  InitDiskCacheImpl();
+  cache_ = CreateBackendAsModeSuggests(disk_cache::kNoRandom, &cache_thread_);
 }
 
 void DiskCacheTestWithCache::SetTestMode() {
-  ASSERT_TRUE(implementation_ && !memory_only_);
+  ASSERT_TRUE(!memory_only_);
   cache_impl_->SetUnitTestMode();
 }
 
 void DiskCacheTestWithCache::SetMaxSize(int size) {
   size_ = size;
   if (cache_impl_)
     EXPECT_TRUE(cache_impl_->SetMaxSize(size));
 
   if (mem_cache_)
     EXPECT_TRUE(mem_cache_->SetMaxSize(size));
@@ skipping 122 matching lines @@
     cache_thread_.Stop();
 
   if (!memory_only_ && integrity_) {
     EXPECT_TRUE(CheckCacheIntegrity(cache_path_, new_eviction_, mask_));
   }
 
   PlatformTest::TearDown();
 }
 
 void DiskCacheTestWithCache::InitMemoryCache() {
-  if (!implementation_) {
-    cache_ = disk_cache::MemBackendImpl::CreateBackend(size_, NULL);
-    return;
-  }
-
   mem_cache_ = new disk_cache::MemBackendImpl(NULL);
   cache_ = mem_cache_;
   ASSERT_TRUE(NULL != cache_);
 
   if (size_)
     EXPECT_TRUE(mem_cache_->SetMaxSize(size_));
 
   ASSERT_TRUE(mem_cache_->Init());
 }
 
 void DiskCacheTestWithCache::InitDiskCache() {
   if (first_cleanup_)
-    ASSERT_TRUE(CleanupCacheDir());
+    EXPECT_TRUE(CleanupCacheDir());
 
   if (!cache_thread_.IsRunning()) {
     EXPECT_TRUE(cache_thread_.StartWithOptions(
                     base::Thread::Options(MessageLoop::TYPE_IO, 0)));
   }
-  ASSERT_TRUE(cache_thread_.message_loop() != NULL);
+  EXPECT_TRUE(cache_thread_.message_loop() != NULL);
 
-  if (implementation_)
-    return InitDiskCacheImpl();
+  cache_ = CreateBackendAsModeSuggests(disk_cache::kNoRandom, &cache_thread_);
+}
 
-  scoped_refptr<base::MessageLoopProxy> thread =
-      use_current_thread_ ? base::MessageLoopProxy::current() :
-                            cache_thread_.message_loop_proxy();
+// Testing backend creation retry logic is hard because the CacheCreator and
+// cache backend(s) are tightly coupled. So we take the default backend often.
+// Tests themselves need to be adjusted for platforms where the BackendImpl is
+// not the default backend.
+void DiskCacheTestWithCache::InitDefaultCacheViaCreator() {
+  if (!cache_thread_.IsRunning()) {
+    EXPECT_TRUE(cache_thread_.StartWithOptions(
+                    base::Thread::Options(MessageLoop::TYPE_IO, 0)));
+  }
+  EXPECT_TRUE(cache_thread_.message_loop() != NULL);
 
   net::TestCompletionCallback cb;
-  int rv = disk_cache::BackendImpl::CreateBackend(
-               cache_path_, force_creation_, size_, type_,
-               disk_cache::kNoRandom, thread, NULL, &cache_, cb.callback());
-  ASSERT_EQ(net::OK, cb.GetResult(rv));
+  disk_cache::CacheCreator* creator = new disk_cache::CacheCreator(cache_path_,
+      true, 0, net::DISK_CACHE, disk_cache::kNoRandom,
+      cache_thread_.message_loop_proxy(), NULL, &cache_, cb.callback());
+  int rv = creator->Run();
+  EXPECT_EQ(net::OK, cb.GetResult(rv));
 }
 
-void DiskCacheTestWithCache::InitDiskCacheImpl() {
-  scoped_refptr<base::MessageLoopProxy> thread =
-      use_current_thread_ ? base::MessageLoopProxy::current() :
-                            cache_thread_.message_loop_proxy();
+disk_cache::Backend* DiskCacheTestWithCache::CreateBackendAsModeSuggests(
+    uint32 flags, base::Thread* thread) {
+  base::MessageLoopProxy* runner;
+  if (use_current_thread_)
+    runner = base::MessageLoopProxy::current();
+  else
+    runner = thread->message_loop_proxy();
+
+  if (simple_cache_mode_) {
+    net::TestCompletionCallback cb;
+    disk_cache::Backend* simple_backend;
+    // TODO(pasko): split Simple Backend construction from initialization.
+    int rv = disk_cache::SimpleBackendImpl::CreateBackend(cache_path_, size_,
+        type_, disk_cache::kNone, make_scoped_refptr(runner), NULL,
+        &simple_backend, cb.callback());
+    EXPECT_EQ(net::OK, cb.GetResult(rv));
+    return simple_backend;
+  }
+
   if (mask_)
-    cache_impl_ = new disk_cache::BackendImpl(cache_path_, mask_, thread, NULL);
+    cache_impl_ = new disk_cache::BackendImpl(cache_path_, mask_, runner, NULL);
   else
-    cache_impl_ = new disk_cache::BackendImpl(cache_path_, thread, NULL);
-
-  cache_ = cache_impl_;
-  ASSERT_TRUE(NULL != cache_);
-
-  if (size_)
-    EXPECT_TRUE(cache_impl_->SetMaxSize(size_));
-
+    cache_impl_ = new disk_cache::BackendImpl(cache_path_, runner, NULL);
+  cache_impl_->SetFlags(flags);
+  cache_impl_->SetMaxSize(size_);
+  cache_impl_->SetType(type_);
   if (new_eviction_)
     cache_impl_->SetNewEviction();
-
-  cache_impl_->SetType(type_);
-  cache_impl_->SetFlags(disk_cache::kNoRandom);
   net::TestCompletionCallback cb;
   int rv = cache_impl_->Init(cb.callback());
-  ASSERT_EQ(net::OK, cb.GetResult(rv));
+  EXPECT_EQ(net::OK, cb.GetResult(rv));
+  cache_ = cache_impl_;
+  return cache_impl_;
 }
+