Change ownership of the parameters to ServiceWorkerCache:: Put and Match.

These functions used to take unowned raw pointers as arguments.  Now the functions own them and they're scoped_ptrs.  This both makes ownership clearer and allows for the functions to terminate early without calling their callbacks (needed for a downstream change to run CreateBackend lazily).

Related CLs:
* 1. https://crrev.com/542703002: Change ownership of the parameters to ServiceWorkerCache:: Put and Match.
2. https://crrev.com/545533002: Move ServiceWorkerCache backend creation to a lazy init function.
3. https://crrev.com/548533002: Make ServiceWorkerCacheStorage::CacheLoader::LoadCache synchronous
4. https://crrev.com/549493002: Expose ServiceWorkerCache objects to ServiceWorkerCacheStorageManager clients.

BUG=392621

Review URL: https://codereview.chromium.org/542703002

Cr-Commit-Position: refs/heads/master@{#294366}

content/browser/service_worker/service_worker_cache.cc

@@ -162,14 +162,14 @@ class BlobReader : public net::URLRequest::Delegate {
 };
 
 // Put callbacks
-void PutDidCreateEntry(ServiceWorkerFetchRequest* request,
-                       ServiceWorkerResponse* response,
+void PutDidCreateEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
+                       scoped_ptr<ServiceWorkerResponse> response,
                        const ServiceWorkerCache::ErrorCallback& callback,
                        scoped_ptr<disk_cache::Entry*> entryptr,
                        scoped_ptr<storage::BlobDataHandle> blob_data_handle,
                        net::URLRequestContext* request_context,
                        int rv);
-void PutDidWriteHeaders(ServiceWorkerResponse* response,
+void PutDidWriteHeaders(scoped_ptr<ServiceWorkerResponse> response,
                         const ServiceWorkerCache::ErrorCallback& callback,
                         disk_cache::ScopedEntryPtr entry,
                         scoped_ptr<storage::BlobDataHandle> blob_data_handle,
@@ -182,33 +182,33 @@ void PutDidWriteBlobToCache(const ServiceWorkerCache::ErrorCallback& callback,
                             bool success);
 
 // Match callbacks
-void MatchDidOpenEntry(ServiceWorkerFetchRequest* request,
+void MatchDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<disk_cache::Entry*> entryptr,
                        int rv);
 void MatchDidReadHeaderData(
-    ServiceWorkerFetchRequest* request,
+    scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
     scoped_ptr<ServiceWorkerRequestResponseHeaders> headers);
 void MatchDidReadResponseBodyData(
-    ServiceWorkerFetchRequest* request,
+    scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
     scoped_ptr<ServiceWorkerResponse> response,
     scoped_ptr<ResponseReadContext> response_context,
     int rv);
-void MatchDoneWithBody(ServiceWorkerFetchRequest* request,
+void MatchDoneWithBody(scoped_ptr<ServiceWorkerFetchRequest> request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<ServiceWorkerResponse> response,
                        scoped_ptr<ResponseReadContext> response_context);
 
 // Delete callbacks
-void DeleteDidOpenEntry(ServiceWorkerFetchRequest* request,
+void DeleteDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
                         const ServiceWorkerCache::ErrorCallback& callback,
                         scoped_ptr<disk_cache::Entry*> entryptr,
                         int rv);
@@ -228,8 +228,8 @@ void CreateBackendDidCreate(const ServiceWorkerCache::ErrorCallback& callback,
                             base::WeakPtr<ServiceWorkerCache> cache,
                             int rv);
 
-void PutDidCreateEntry(ServiceWorkerFetchRequest* request,
-                       ServiceWorkerResponse* response,
+void PutDidCreateEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
+                       scoped_ptr<ServiceWorkerResponse> response,
                        const ServiceWorkerCache::ErrorCallback& callback,
                        scoped_ptr<disk_cache::Entry*> entryptr,
                        scoped_ptr<storage::BlobDataHandle> blob_data_handle,
@@ -282,7 +282,7 @@ void PutDidCreateEntry(ServiceWorkerFetchRequest* request,
 
   net::CompletionCallback write_headers_callback =
       base::Bind(PutDidWriteHeaders,
-                 response,
+                 base::Passed(response.Pass()),
                  callback,
                  base::Passed(entry.Pass()),
                  base::Passed(blob_data_handle.Pass()),
@@ -300,7 +300,7 @@ void PutDidCreateEntry(ServiceWorkerFetchRequest* request,
     write_headers_callback.Run(rv);
 }
 
-void PutDidWriteHeaders(ServiceWorkerResponse* response,
+void PutDidWriteHeaders(scoped_ptr<ServiceWorkerResponse> response,
                         const ServiceWorkerCache::ErrorCallback& callback,
                         disk_cache::ScopedEntryPtr entry,
                         scoped_ptr<storage::BlobDataHandle> blob_data_handle,
@@ -346,7 +346,7 @@ void PutDidWriteBlobToCache(const ServiceWorkerCache::ErrorCallback& callback,
   callback.Run(ServiceWorkerCache::ErrorTypeOK);
 }
 
-void MatchDidOpenEntry(ServiceWorkerFetchRequest* request,
+void MatchDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<disk_cache::Entry*> entryptr,
@@ -365,7 +365,7 @@ void MatchDidOpenEntry(ServiceWorkerFetchRequest* request,
   disk_cache::Entry* tmp_entry_ptr = entry.get();
 
   HeadersCallback headers_callback = base::Bind(MatchDidReadHeaderData,
-                                                request,
+                                                base::Passed(request.Pass()),
                                                 callback,
                                                 blob_storage,
                                                 base::Passed(entry.Pass()));
@@ -374,7 +374,7 @@ void MatchDidOpenEntry(ServiceWorkerFetchRequest* request,
 }
 
 void MatchDidReadHeaderData(
-    ServiceWorkerFetchRequest* request,
+    scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
@@ -431,7 +431,7 @@ void MatchDidReadHeaderData(
 
   net::CompletionCallback read_callback =
       base::Bind(MatchDidReadResponseBodyData,
-                 request,
+                 base::Passed(request.Pass()),
                  callback,
                  blob_storage,
                  base::Passed(entry.Pass()),
@@ -449,7 +449,7 @@ void MatchDidReadHeaderData(
 }
 
 void MatchDidReadResponseBodyData(
-    ServiceWorkerFetchRequest* request,
+    scoped_ptr<ServiceWorkerFetchRequest> request,
     const ServiceWorkerCache::ResponseCallback& callback,
     base::WeakPtr<storage::BlobStorageContext> blob_storage,
     disk_cache::ScopedEntryPtr entry,
@@ -464,7 +464,7 @@ void MatchDidReadResponseBodyData(
   }
 
   if (rv == 0) {
-    MatchDoneWithBody(request,
+    MatchDoneWithBody(request.Pass(),
                       callback,
                       blob_storage,
                       response.Pass(),
@@ -485,7 +485,7 @@ void MatchDidReadResponseBodyData(
 
   net::CompletionCallback read_callback =
       base::Bind(MatchDidReadResponseBodyData,
-                 request,
+                 base::Passed(request.Pass()),
                  callback,
                  blob_storage,
                  base::Passed(entry.Pass()),
@@ -502,7 +502,7 @@ void MatchDidReadResponseBodyData(
     read_callback.Run(read_rv);
 }
 
-void MatchDoneWithBody(ServiceWorkerFetchRequest* request,
+void MatchDoneWithBody(scoped_ptr<ServiceWorkerFetchRequest> request,
                        const ServiceWorkerCache::ResponseCallback& callback,
                        base::WeakPtr<storage::BlobStorageContext> blob_storage,
                        scoped_ptr<ServiceWorkerResponse> response,
@@ -522,7 +522,7 @@ void MatchDoneWithBody(ServiceWorkerFetchRequest* request,
                blob_data_handle.Pass());
 }
 
-void DeleteDidOpenEntry(ServiceWorkerFetchRequest* request,
+void DeleteDidOpenEntry(scoped_ptr<ServiceWorkerFetchRequest> request,
                         const ServiceWorkerCache::ErrorCallback& callback,
                         scoped_ptr<disk_cache::Entry*> entryptr,
                         int rv) {
@@ -686,8 +686,8 @@ void ServiceWorkerCache::CreateBackend(const ErrorCallback& callback) {
     create_cache_callback.Run(rv);
 }
 
-void ServiceWorkerCache::Put(ServiceWorkerFetchRequest* request,
-                             ServiceWorkerResponse* response,
+void ServiceWorkerCache::Put(scoped_ptr<ServiceWorkerFetchRequest> request,
+                             scoped_ptr<ServiceWorkerResponse> response,
                              const ErrorCallback& callback) {
   DCHECK(backend_);
 
@@ -710,23 +710,25 @@ void ServiceWorkerCache::Put(ServiceWorkerFetchRequest* request,
     }
   }
 
+  ServiceWorkerFetchRequest* request_ptr = request.get();
+
   net::CompletionCallback create_entry_callback =
       base::Bind(PutDidCreateEntry,
-                 request,
-                 response,
+                 base::Passed(request.Pass()),
+                 base::Passed(response.Pass()),
                  callback,
                  base::Passed(entry.Pass()),
                  base::Passed(blob_data_handle.Pass()),
                  request_context_);
 
   int rv = backend_->CreateEntry(
-      request->url.spec(), entry_ptr, create_entry_callback);
+      request_ptr->url.spec(), entry_ptr, create_entry_callback);
 
   if (rv != net::ERR_IO_PENDING)
     create_entry_callback.Run(rv);
 }
 
-void ServiceWorkerCache::Match(ServiceWorkerFetchRequest* request,
+void ServiceWorkerCache::Match(scoped_ptr<ServiceWorkerFetchRequest> request,
                                const ResponseCallback& callback) {
   DCHECK(backend_);
 
@@ -734,20 +736,22 @@ void ServiceWorkerCache::Match(ServiceWorkerFetchRequest* request,
 
   disk_cache::Entry** entry_ptr = entry.get();
 
+  ServiceWorkerFetchRequest* request_ptr = request.get();
+
   net::CompletionCallback open_entry_callback =
       base::Bind(MatchDidOpenEntry,
-                 request,
+                 base::Passed(request.Pass()),
                  callback,
                  blob_storage_context_,
                  base::Passed(entry.Pass()));
 
-  int rv =
-      backend_->OpenEntry(request->url.spec(), entry_ptr, open_entry_callback);
+  int rv = backend_->OpenEntry(
+      request_ptr->url.spec(), entry_ptr, open_entry_callback);
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }
 
-void ServiceWorkerCache::Delete(ServiceWorkerFetchRequest* request,
+void ServiceWorkerCache::Delete(scoped_ptr<ServiceWorkerFetchRequest> request,
                                 const ErrorCallback& callback) {
   DCHECK(backend_);
 
@@ -755,11 +759,16 @@ void ServiceWorkerCache::Delete(ServiceWorkerFetchRequest* request,
 
   disk_cache::Entry** entry_ptr = entry.get();
 
-  net::CompletionCallback open_entry_callback = base::Bind(
-      DeleteDidOpenEntry, request, callback, base::Passed(entry.Pass()));
+  ServiceWorkerFetchRequest* request_ptr = request.get();
+
+  net::CompletionCallback open_entry_callback =
+      base::Bind(DeleteDidOpenEntry,
+                 base::Passed(request.Pass()),
+                 callback,
+                 base::Passed(entry.Pass()));
 
-  int rv =
-      backend_->OpenEntry(request->url.spec(), entry_ptr, open_entry_callback);
+  int rv = backend_->OpenEntry(
+      request_ptr->url.spec(), entry_ptr, open_entry_callback);
   if (rv != net::ERR_IO_PENDING)
     open_entry_callback.Run(rv);
 }

content/browser/service_worker/service_worker_cache.h

@@ -68,21 +68,21 @@ class CONTENT_EXPORT ServiceWorkerCache {
 
   // Returns ErrorTypeNotFound if not found. The callback will always be called.
   // |request| must remain valid until the callback is called.
-  void Match(ServiceWorkerFetchRequest* request,
+  void Match(scoped_ptr<ServiceWorkerFetchRequest> request,
              const ResponseCallback& callback);
 
   // Puts the request and response object in the cache. The response body (if
   // present) is stored in the cache, but not the request body. Returns
   // ErrorTypeOK on success. The callback will always be called. |request| and
   // |response| must remain valid until the callback is called.
-  void Put(ServiceWorkerFetchRequest* request,
-           ServiceWorkerResponse* response,
+  void Put(scoped_ptr<ServiceWorkerFetchRequest> request,
+           scoped_ptr<ServiceWorkerResponse> response,
            const ErrorCallback& callback);
 
   // Returns ErrorNotFound if not found. Otherwise deletes and returns
   // ErrorTypeOK. The callback will always be called. |request| must remain
   // valid until the callback is called.
-  void Delete(ServiceWorkerFetchRequest* request,
+  void Delete(scoped_ptr<ServiceWorkerFetchRequest> request,
               const ErrorCallback& callback);
 
   // TODO(jkarlin): Have keys take an optional ServiceWorkerFetchRequest.

content/browser/service_worker/service_worker_cache_unittest.cc

@@ -93,14 +93,14 @@ class ServiceWorkerCacheTest : public testing::Test {
     std::map<std::string, std::string> headers;
     headers.insert(std::make_pair("a", "a"));
     headers.insert(std::make_pair("b", "b"));
-    body_request_.reset(new ServiceWorkerFetchRequest(
-        GURL("http://example.com/body.html"), "GET", headers, GURL(""), false));
-    no_body_request_.reset(
-        new ServiceWorkerFetchRequest(GURL("http://example.com/no_body.html"),
+    body_request_ = ServiceWorkerFetchRequest(
+        GURL("http://example.com/body.html"), "GET", headers, GURL(""), false);
+    no_body_request_ =
+        ServiceWorkerFetchRequest(GURL("http://example.com/no_body.html"),
                                   "GET",
                                   headers,
                                   GURL(""),
-                                      false));
+                                  false);
 
     std::string expected_response;
     for (int i = 0; i < 100; ++i)
@@ -113,15 +113,14 @@ class ServiceWorkerCacheTest : public testing::Test {
     blob_handle_ =
         blob_storage_context->context()->AddFinishedBlob(blob_data.get());
 
-    body_response_.reset(
-        new ServiceWorkerResponse(GURL("http://example.com/body.html"),
+    body_response_ = ServiceWorkerResponse(GURL("http://example.com/body.html"),
                                            200,
                                            "OK",
                                            headers,
-                                  blob_handle_->uuid()));
+                                           blob_handle_->uuid());
 
-    no_body_response_.reset(new ServiceWorkerResponse(
-        GURL("http://example.com/no_body.html"), 200, "OK", headers, ""));
+    no_body_response_ = ServiceWorkerResponse(
+        GURL("http://example.com/no_body.html"), 200, "OK", headers, "");
   }
 
   void CreateBackend() {
@@ -133,12 +132,30 @@ class ServiceWorkerCacheTest : public testing::Test {
     EXPECT_EQ(ServiceWorkerCache::ErrorTypeOK, callback_error_);
   }
 
-  bool Put(ServiceWorkerFetchRequest* request,
-           ServiceWorkerResponse* response) {
+  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(
+      const ServiceWorkerResponse& response) {
+    return make_scoped_ptr(new ServiceWorkerResponse(response.url,
+                                                     response.status_code,
+                                                     response.status_text,
+                                                     response.headers,
+                                                     response.blob_uuid));
+  }
+
+  bool Put(const ServiceWorkerFetchRequest& request,
+           const ServiceWorkerResponse& response) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 
-    cache_->Put(request,
-                response,
+    cache_->Put(CopyFetchRequest(request),
+                CopyFetchResponse(response),
                 base::Bind(&ServiceWorkerCacheTest::ErrorTypeCallback,
                            base::Unretained(this),
                            base::Unretained(loop.get())));
@@ -150,10 +167,10 @@ class ServiceWorkerCacheTest : public testing::Test {
     return callback_error_ == ServiceWorkerCache::ErrorTypeOK;
   }
 
-  bool Match(ServiceWorkerFetchRequest* request) {
+  bool Match(const ServiceWorkerFetchRequest& request) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 
-    cache_->Match(request,
+    cache_->Match(CopyFetchRequest(request),
                   base::Bind(&ServiceWorkerCacheTest::ResponseAndErrorCallback,
                              base::Unretained(this),
                              base::Unretained(loop.get())));
@@ -162,10 +179,10 @@ class ServiceWorkerCacheTest : public testing::Test {
     return callback_error_ == ServiceWorkerCache::ErrorTypeOK;
   }
 
-  bool Delete(ServiceWorkerFetchRequest* request) {
+  bool Delete(const ServiceWorkerFetchRequest& request) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 
-    cache_->Delete(request,
+    cache_->Delete(CopyFetchRequest(request),
                    base::Bind(&ServiceWorkerCacheTest::ErrorTypeCallback,
                               base::Unretained(this),
                               base::Unretained(loop.get())));
@@ -250,10 +267,10 @@ class ServiceWorkerCacheTest : public testing::Test {
   base::ScopedTempDir temp_dir_;
   scoped_ptr<ServiceWorkerCache> cache_;
 
-  scoped_ptr<ServiceWorkerFetchRequest> body_request_;
-  scoped_ptr<ServiceWorkerResponse> body_response_;
-  scoped_ptr<ServiceWorkerFetchRequest> no_body_request_;
-  scoped_ptr<ServiceWorkerResponse> no_body_response_;
+  ServiceWorkerFetchRequest body_request_;
+  ServiceWorkerResponse body_response_;
+  ServiceWorkerFetchRequest no_body_request_;
+  ServiceWorkerResponse no_body_response_;
   scoped_ptr<storage::BlobDataHandle> blob_handle_;
   std::string expected_blob_data_;
 
@@ -269,17 +286,17 @@ class ServiceWorkerCacheTestP : public ServiceWorkerCacheTest,
 };
 
 TEST_P(ServiceWorkerCacheTestP, PutNoBody) {
-  EXPECT_TRUE(Put(no_body_request_.get(), no_body_response_.get()));
+  EXPECT_TRUE(Put(no_body_request_, no_body_response_));
 }
 
 TEST_P(ServiceWorkerCacheTestP, PutBody) {
-  EXPECT_TRUE(Put(body_request_.get(), body_response_.get()));
+  EXPECT_TRUE(Put(body_request_, body_response_));
 }
 
 TEST_P(ServiceWorkerCacheTestP, PutBodyDropBlobRef) {
   scoped_ptr<base::RunLoop> loop(new base::RunLoop());
-  cache_->Put(body_request_.get(),
-              body_response_.get(),
+  cache_->Put(CopyFetchRequest(body_request_),
+              CopyFetchResponse(body_response_),
               base::Bind(&ServiceWorkerCacheTestP::ErrorTypeCallback,
                          base::Unretained(this),
                          base::Unretained(loop.get())));
@@ -292,8 +309,8 @@ TEST_P(ServiceWorkerCacheTestP, PutBodyDropBlobRef) {
 }
 
 TEST_P(ServiceWorkerCacheTestP, MatchNoBody) {
-  EXPECT_TRUE(Put(no_body_request_.get(), no_body_response_.get()));
-  EXPECT_TRUE(Match(no_body_request_.get()));
+  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",
@@ -301,8 +318,8 @@ TEST_P(ServiceWorkerCacheTestP, MatchNoBody) {
 }
 
 TEST_P(ServiceWorkerCacheTestP, MatchBody) {
-  EXPECT_TRUE(Put(body_request_.get(), body_response_.get()));
-  EXPECT_TRUE(Match(body_request_.get()));
+  EXPECT_TRUE(Put(body_request_, body_response_));
+  EXPECT_TRUE(Match(body_request_));
   EXPECT_EQ(200, callback_response_->status_code);
   EXPECT_STREQ("OK", callback_response_->status_text.c_str());
   EXPECT_STREQ("http://example.com/body.html",
@@ -318,31 +335,31 @@ TEST_P(ServiceWorkerCacheTestP, EmptyKeys) {
 }
 
 TEST_P(ServiceWorkerCacheTestP, TwoKeys) {
-  EXPECT_TRUE(Put(no_body_request_.get(), no_body_response_.get()));
-  EXPECT_TRUE(Put(body_request_.get(), body_response_.get()));
+  EXPECT_TRUE(Put(no_body_request_, no_body_response_));
+  EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_TRUE(Keys());
   EXPECT_EQ(2u, callback_strings_.size());
   std::vector<std::string> expected_keys;
-  expected_keys.push_back(no_body_request_->url.spec());
-  expected_keys.push_back(body_request_->url.spec());
+  expected_keys.push_back(no_body_request_.url.spec());
+  expected_keys.push_back(body_request_.url.spec());
   EXPECT_TRUE(VerifyKeys(expected_keys));
 }
 
 TEST_P(ServiceWorkerCacheTestP, TwoKeysThenOne) {
-  EXPECT_TRUE(Put(no_body_request_.get(), no_body_response_.get()));
-  EXPECT_TRUE(Put(body_request_.get(), body_response_.get()));
+  EXPECT_TRUE(Put(no_body_request_, no_body_response_));
+  EXPECT_TRUE(Put(body_request_, body_response_));
   EXPECT_TRUE(Keys());
   EXPECT_EQ(2u, callback_strings_.size());
   std::vector<std::string> expected_keys;
-  expected_keys.push_back(no_body_request_->url.spec());
-  expected_keys.push_back(body_request_->url.spec());
+  expected_keys.push_back(no_body_request_.url.spec());
+  expected_keys.push_back(body_request_.url.spec());
   EXPECT_TRUE(VerifyKeys(expected_keys));
 
-  EXPECT_TRUE(Delete(body_request_.get()));
+  EXPECT_TRUE(Delete(body_request_));
   EXPECT_TRUE(Keys());
   EXPECT_EQ(1u, callback_strings_.size());
   std::vector<std::string> expected_key;
-  expected_key.push_back(no_body_request_->url.spec());
+  expected_key.push_back(no_body_request_.url.spec());
   EXPECT_TRUE(VerifyKeys(expected_key));
 }
 
@@ -351,42 +368,42 @@ TEST_P(ServiceWorkerCacheTestP, TwoKeysThenOne) {
 // flaky (though not crashy). See https://crbug.com/409109
 #ifndef OS_WIN
 TEST_P(ServiceWorkerCacheTestP, DeleteNoBody) {
-  EXPECT_TRUE(Put(no_body_request_.get(), no_body_response_.get()));
-  EXPECT_TRUE(Match(no_body_request_.get()));
-  EXPECT_TRUE(Delete(no_body_request_.get()));
-  EXPECT_FALSE(Match(no_body_request_.get()));
-  EXPECT_FALSE(Delete(no_body_request_.get()));
-  EXPECT_TRUE(Put(no_body_request_.get(), no_body_response_.get()));
-  EXPECT_TRUE(Match(no_body_request_.get()));
-  EXPECT_TRUE(Delete(no_body_request_.get()));
+  EXPECT_TRUE(Put(no_body_request_, no_body_response_));
+  EXPECT_TRUE(Match(no_body_request_));
+  EXPECT_TRUE(Delete(no_body_request_));
+  EXPECT_FALSE(Match(no_body_request_));
+  EXPECT_FALSE(Delete(no_body_request_));
+  EXPECT_TRUE(Put(no_body_request_, no_body_response_));
+  EXPECT_TRUE(Match(no_body_request_));
+  EXPECT_TRUE(Delete(no_body_request_));
 }
 
 TEST_P(ServiceWorkerCacheTestP, DeleteBody) {
-  EXPECT_TRUE(Put(body_request_.get(), body_response_.get()));
-  EXPECT_TRUE(Match(body_request_.get()));
-  EXPECT_TRUE(Delete(body_request_.get()));
-  EXPECT_FALSE(Match(body_request_.get()));
-  EXPECT_FALSE(Delete(body_request_.get()));
-  EXPECT_TRUE(Put(body_request_.get(), body_response_.get()));
-  EXPECT_TRUE(Match(body_request_.get()));
-  EXPECT_TRUE(Delete(body_request_.get()));
+  EXPECT_TRUE(Put(body_request_, body_response_));
+  EXPECT_TRUE(Match(body_request_));
+  EXPECT_TRUE(Delete(body_request_));
+  EXPECT_FALSE(Match(body_request_));
+  EXPECT_FALSE(Delete(body_request_));
+  EXPECT_TRUE(Put(body_request_, body_response_));
+  EXPECT_TRUE(Match(body_request_));
+  EXPECT_TRUE(Delete(body_request_));
 }
 
 TEST_P(ServiceWorkerCacheTestP, QuickStressNoBody) {
   for (int i = 0; i < 100; ++i) {
-    EXPECT_FALSE(Match(no_body_request_.get()));
-    EXPECT_TRUE(Put(no_body_request_.get(), no_body_response_.get()));
-    EXPECT_TRUE(Match(no_body_request_.get()));
-    EXPECT_TRUE(Delete(no_body_request_.get()));
+    EXPECT_FALSE(Match(no_body_request_));
+    EXPECT_TRUE(Put(no_body_request_, no_body_response_));
+    EXPECT_TRUE(Match(no_body_request_));
+    EXPECT_TRUE(Delete(no_body_request_));
   }
 }
 
 TEST_P(ServiceWorkerCacheTestP, QuickStressBody) {
   for (int i = 0; i < 100; ++i) {
-    ASSERT_FALSE(Match(body_request_.get()));
-    ASSERT_TRUE(Put(body_request_.get(), body_response_.get()));
-    ASSERT_TRUE(Match(body_request_.get()));
-    ASSERT_TRUE(Delete(body_request_.get()));
+    ASSERT_FALSE(Match(body_request_));
+    ASSERT_TRUE(Put(body_request_, body_response_));
+    ASSERT_TRUE(Match(body_request_));
+    ASSERT_TRUE(Delete(body_request_));
   }
 }
 #endif  // OS_WIN