Move ServiceWorkerCache backend creation to a lazy init function.

content/browser/service_worker/service_worker_cache_unittest.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 "base/files/file_path.h"
 #include "base/files/scoped_temp_dir.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/run_loop.h"
@@ skipping 58 matching lines @@
       cache_ = ServiceWorkerCache::CreateMemoryCache(
           url_request_context,
           blob_storage_context->context()->AsWeakPtr());
     } else {
       ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
       cache_ = ServiceWorkerCache::CreatePersistentCache(
           temp_dir_.path(),
           url_request_context,
           blob_storage_context->context()->AsWeakPtr());
     }
-    CreateBackend();
   }
 
   virtual void TearDown() OVERRIDE {
     base::RunLoop().RunUntilIdle();
     disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
     base::RunLoop().RunUntilIdle();
     cache_.reset();
     base::RunLoop().RunUntilIdle();
     disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
     base::RunLoop().RunUntilIdle();
@@ skipping 26 matching lines @@
     body_response_ = ServiceWorkerResponse(GURL("http://example.com/body.html"),
                                            200,
                                            "OK",
                                            headers,
                                            blob_handle_->uuid());
 
     no_body_response_ = ServiceWorkerResponse(
         GURL("http://example.com/no_body.html"), 200, "OK", headers, "");
   }
 
-  void CreateBackend() {
-    scoped_ptr<base::RunLoop> loop(new base::RunLoop());
-    cache_->CreateBackend(base::Bind(&ServiceWorkerCacheTest::ErrorTypeCallback,
-                                     base::Unretained(this),
-                                     base::Unretained(loop.get())));
-    loop->Run();
-    EXPECT_EQ(ServiceWorkerCache::ErrorTypeOK, callback_error_);
-  }
-
   scoped_ptr<ServiceWorkerFetchRequest> CopyFetchRequest(
       const ServiceWorkerFetchRequest& request) {
     return make_scoped_ptr(new ServiceWorkerFetchRequest(request.url,
                                                          request.method,
                                                          request.headers,
                                                          request.referrer,
                                                          request.is_reload));
   }
 
   scoped_ptr<ServiceWorkerResponse> CopyFetchResponse(
@@ skipping 141 matching lines @@
 };
 
 TEST_P(ServiceWorkerCacheTestP, PutNoBody) {
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
 }
 
 TEST_P(ServiceWorkerCacheTestP, PutBody) {
   EXPECT_TRUE(Put(body_request_, body_response_));
 }
 
-TEST_P(ServiceWorkerCacheTestP, PutBodyDropBlobRef) {
+TEST_F(ServiceWorkerCacheTest, PutBodyDropBlobRef) {
   scoped_ptr<base::RunLoop> loop(new base::RunLoop());
   cache_->Put(CopyFetchRequest(body_request_),
               CopyFetchResponse(body_response_),
               base::Bind(&ServiceWorkerCacheTestP::ErrorTypeCallback,
                          base::Unretained(this),
                          base::Unretained(loop.get())));
   // The handle should be held by the cache now so the deref here should be
   // okay.
   blob_handle_.reset();
   loop->Run();
@@ skipping 99 matching lines @@
     ASSERT_TRUE(Delete(body_request_));
   }
 }
 #endif  // OS_WIN
 
 INSTANTIATE_TEST_CASE_P(ServiceWorkerCacheTest,
                         ServiceWorkerCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content