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 57 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();
   }
 
   void CreateRequests(ChromeBlobStorageContext* blob_storage_context) {
     std::map<std::string, std::string> headers;
     headers.insert(std::make_pair("a", "a"));
     headers.insert(std::make_pair("b", "b"));
     body_request_ = ServiceWorkerFetchRequest(
         GURL("http://example.com/body.html"), "GET", headers, GURL(""), false);
     no_body_request_ =
         ServiceWorkerFetchRequest(GURL("http://example.com/no_body.html"),
@@ skipping 16 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.
+  // The BlobHandle needs to be held onto by the caller until either the

[michaeln1, 2014/09/05 23:28:49]

That's too bad.

Not suggesting this for this cl, but maybe it would be nice to add a
ServiceWorkerFetchResponse derivative that's for use in the browser-process-only
to own the blobdatahandle for the duration. Having consumers of the repsonse obj
manage that out-of-band of the resp object itself is a pita.

[jkarlin, 2014/09/09 19:14:34]

Done.

+  // callback returns or the cache is deleted, otherwise Put() fails as shown
+  // here.
   blob_handle_.reset();
   loop->Run();
 
-  EXPECT_EQ(ServiceWorkerCache::ErrorTypeOK, callback_error_);
+  EXPECT_EQ(ServiceWorkerCache::ErrorTypeStorage, callback_error_);
 }
 
 TEST_P(ServiceWorkerCacheTestP, MatchNoBody) {
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Match(no_body_request_));
   EXPECT_EQ(200, callback_response_->status_code);
   EXPECT_STREQ("OK", callback_response_->status_text.c_str());
   EXPECT_STREQ("http://example.com/no_body.html",
                callback_response_->url.spec().c_str());
 }
@@ skipping 87 matching lines @@
     ASSERT_TRUE(Delete(body_request_));
   }
 }
 #endif  // OS_WIN
 
 INSTANTIATE_TEST_CASE_P(ServiceWorkerCacheTest,
                         ServiceWorkerCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content