Have ServiceWorkerCache::Put return a Response when completed.

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 128 matching lines @@
                                                      response.headers,
                                                      response.blob_uuid));
   }
 
   bool Put(const ServiceWorkerFetchRequest& request,
            const ServiceWorkerResponse& response) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 
     cache_->Put(CopyFetchRequest(request),
                 CopyFetchResponse(response),
-                base::Bind(&ServiceWorkerCacheTest::ErrorTypeCallback,
+                base::Bind(&ServiceWorkerCacheTest::ResponseAndErrorCallback,
                            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;
   }
 
@@ skipping 110 matching lines @@
   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_, no_body_response_));
+  EXPECT_TRUE(callback_response_);
+  EXPECT_STREQ(no_body_response_.url.spec().c_str(),
+               callback_response_->url.spec().c_str());
+  EXPECT_FALSE(callback_response_data_);
 }
 
 TEST_P(ServiceWorkerCacheTestP, PutBody) {
   EXPECT_TRUE(Put(body_request_, body_response_));
+  EXPECT_TRUE(callback_response_);
+  EXPECT_STREQ(body_response_.url.spec().c_str(),
+               callback_response_->url.spec().c_str());
+  EXPECT_TRUE(callback_response_data_);
+  std::string response_body;
+  CopyBody(callback_response_data_.get(), &response_body);
+  EXPECT_STREQ(expected_blob_data_.c_str(), response_body.c_str());
 }
 
 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::Bind(&ServiceWorkerCacheTestP::ResponseAndErrorCallback,
                          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_);
 }
 
@@ skipping 178 matching lines @@
   request.headers["content-type"] = "foo";
   request.headers["Content-Type"] = "bar";
   EXPECT_EQ("bar", request.headers["content-type"]);
 }
 
 INSTANTIATE_TEST_CASE_P(ServiceWorkerCacheTest,
                         ServiceWorkerCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content