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

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 75 matching lines @@
     cache_.reset();
     base::RunLoop().RunUntilIdle();
     disk_cache::SimpleBackendImpl::FlushWorkerPoolForTesting();
     base::RunLoop().RunUntilIdle();
   }
 
   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_.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"),
-                                      "GET",
-                                      headers,
-                                      GURL(""),
-                                      false));
+    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);
 
     std::string expected_response;
     for (int i = 0; i < 100; ++i)
       expected_blob_data_ += kTestData;
 
     scoped_refptr<storage::BlobData> blob_data(
         new storage::BlobData("blob-id:myblob"));
     blob_data->AppendData(expected_blob_data_);
 
     blob_handle_ =
         blob_storage_context->context()->AddFinishedBlob(blob_data.get());
 
-    body_response_.reset(
-        new ServiceWorkerResponse(GURL("http://example.com/body.html"),
-                                  200,
-                                  "OK",
-                                  headers,
-                                  blob_handle_->uuid()));
+    body_response_ = ServiceWorkerResponse(GURL("http://example.com/body.html"),
+                                           200,
+                                           "OK",
+                                           headers,
+                                           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() {
     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_);
   }
 
-  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())));
     // TODO(jkarlin): These functions should use base::RunLoop().RunUntilIdle()
     // once the cache uses a passed in MessageLoopProxy instead of the CACHE
     // thread.
     loop->Run();
 
     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())));
     loop->Run();
 
     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())));
     loop->Run();
 
     return callback_error_ == ServiceWorkerCache::ErrorTypeOK;
   }
 
   bool Keys() {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
@@ skipping 64 matching lines @@
 
  protected:
   TestBrowserContext browser_context_;
   TestBrowserThreadBundle browser_thread_bundle_;
   scoped_ptr<net::URLRequestJobFactoryImpl> url_request_job_factory_;
   storage::BlobStorageContext* blob_storage_context_;
 
   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_;
 
   ServiceWorkerCache::ErrorType callback_error_;
   scoped_ptr<ServiceWorkerResponse> callback_response_;
   scoped_ptr<storage::BlobDataHandle> callback_response_data_;
   std::vector<std::string> callback_strings_;
 };
 
 class ServiceWorkerCacheTestP : public ServiceWorkerCacheTest,
                                 public testing::WithParamInterface<bool> {
   virtual bool MemoryOnly() OVERRIDE { return !GetParam(); }
 };
 
 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())));
   // The handle should be held by the cache now so the deref here should be
   // okay.
   blob_handle_.reset();
   loop->Run();
 
   EXPECT_EQ(ServiceWorkerCache::ErrorTypeOK, callback_error_);
 }
 
 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",
                callback_response_->url.spec().c_str());
 }
 
 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",
                callback_response_->url.spec().c_str());
   std::string response_body;
   CopyBody(callback_response_data_.get(), &response_body);
   EXPECT_STREQ(expected_blob_data_.c_str(), response_body.c_str());
 }
 
 TEST_P(ServiceWorkerCacheTestP, EmptyKeys) {
   EXPECT_TRUE(Keys());
   EXPECT_EQ(0u, callback_strings_.size());
 }
 
 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));
 }
 
 // TODO(jkarlin): Once SimpleCache is working bug-free on Windows reenable these
 // tests. In the meanwhile we know that Windows operations will be a little
 // 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
 
 INSTANTIATE_TEST_CASE_P(ServiceWorkerCacheTest,
                         ServiceWorkerCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content