CacheStorage: Support multiple batch operations

content/browser/cache_storage/cache_storage_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/cache_storage/cache_storage_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 234 matching lines @@
         blink::WebServiceWorkerResponseTypeDefault, headers, "", 0, GURL());
   }
 
   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) {
-    scoped_ptr<ServiceWorkerResponse> sw_response(new ServiceWorkerResponse(
-        response.url, response.status_code, response.status_text,
-        response.response_type, response.headers, response.blob_uuid,
-        response.blob_size, response.stream_url));
-    return sw_response.Pass();
-  }
-
   bool Put(const ServiceWorkerFetchRequest& request,
            const ServiceWorkerResponse& response) {
+    CacheStorageBatchOperation operation;
+    operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
+    operation.request = request;
+    operation.response = response;
+
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 
-    cache_->Put(
-        CopyFetchRequest(request), CopyFetchResponse(response),
+    cache_->BatchOperation(
+        std::vector<CacheStorageBatchOperation>(1, operation),
         base::Bind(&CacheStorageCacheTest::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_ == CacheStorageCache::ERROR_TYPE_OK;
   }
 
   bool Match(const ServiceWorkerFetchRequest& request) {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 
     cache_->Match(
         CopyFetchRequest(request),
         base::Bind(&CacheStorageCacheTest::ResponseAndErrorCallback,
                    base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
 
     return callback_error_ == CacheStorageCache::ERROR_TYPE_OK;
   }
 
   bool Delete(const ServiceWorkerFetchRequest& request) {
+    CacheStorageBatchOperation operation;
+    operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_DELETE;
+    operation.request = request;
+
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 
-    cache_->Delete(
-        CopyFetchRequest(request),
+    cache_->BatchOperation(
+        std::vector<CacheStorageBatchOperation>(1, operation),
         base::Bind(&CacheStorageCacheTest::ErrorTypeCallback,
                    base::Unretained(this), base::Unretained(loop.get())));
     loop->Run();
 
     return callback_error_ == CacheStorageCache::ERROR_TYPE_OK;
   }
 
   bool Keys() {
     scoped_ptr<base::RunLoop> loop(new base::RunLoop());
 
@@ skipping 164 matching lines @@
 
 TEST_P(CacheStorageCacheTestP, ResponseURLEmpty) {
   no_body_response_.url = GURL();
   EXPECT_STRNE("", no_body_request_.url.spec().c_str());
   EXPECT_TRUE(Put(no_body_request_, no_body_response_));
   EXPECT_TRUE(Match(no_body_request_));
   EXPECT_STREQ("", callback_response_->url.spec().c_str());
 }
 
 TEST_F(CacheStorageCacheTest, PutBodyDropBlobRef) {
+  CacheStorageBatchOperation operation;
+  operation.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
+  operation.request = body_request_;
+  operation.response = body_response_;
+
   scoped_ptr<base::RunLoop> loop(new base::RunLoop());
-  cache_->Put(CopyFetchRequest(body_request_),
-              CopyFetchResponse(body_response_),
-              base::Bind(&CacheStorageCacheTestP::ErrorTypeCallback,
-                         base::Unretained(this), base::Unretained(loop.get())));
+  cache_->BatchOperation(
+      std::vector<CacheStorageBatchOperation>(1, operation),
+      base::Bind(&CacheStorageCacheTestP::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(CacheStorageCache::ERROR_TYPE_OK, callback_error_);
 }
 
 TEST_P(CacheStorageCacheTestP, PutReplace) {
   EXPECT_TRUE(Put(body_request_, no_body_response_));
@@ skipping 261 matching lines @@
 
 TEST_P(CacheStorageCacheTestP, VerifySerialScheduling) {
   // Start two operations, the first one is delayed but the second isn't. The
   // second should wait for the first.
   EXPECT_TRUE(Keys());  // Opens the backend.
   DelayableBackend* delayable_backend = cache_->UseDelayableBackend();
   delayable_backend->set_delay_open(true);
 
   int sequence_out = -1;
 
-  scoped_ptr<ServiceWorkerResponse> response1 =
-      CopyFetchResponse(body_response_);
+  CacheStorageBatchOperation operation1;
+  operation1.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
+  operation1.request = body_request_;
+  operation1.response = body_response_;
+
   scoped_ptr<base::RunLoop> close_loop1(new base::RunLoop());
-  cache_->Put(
-      CopyFetchRequest(body_request_), response1.Pass(),
+  cache_->BatchOperation(
+      std::vector<CacheStorageBatchOperation>(1, operation1),
       base::Bind(&CacheStorageCacheTest::SequenceCallback,
                  base::Unretained(this), 1, &sequence_out, close_loop1.get()));
 
   // Blocks on opening the cache entry.
   base::RunLoop().RunUntilIdle();
 
+  CacheStorageBatchOperation operation2;
+  operation2.operation_type = CACHE_STORAGE_CACHE_OPERATION_TYPE_PUT;
+  operation2.request = body_request_;
+  operation2.response = body_response_;
+
   delayable_backend->set_delay_open(false);
-  scoped_ptr<ServiceWorkerResponse> response2 =
-      CopyFetchResponse(body_response_);
   scoped_ptr<base::RunLoop> close_loop2(new base::RunLoop());
-  cache_->Put(
-      CopyFetchRequest(body_request_), response2.Pass(),
+  cache_->BatchOperation(
+      std::vector<CacheStorageBatchOperation>(1, operation2),
       base::Bind(&CacheStorageCacheTest::SequenceCallback,
                  base::Unretained(this), 2, &sequence_out, close_loop2.get()));
 
   // The second put operation should wait for the first to complete.
   base::RunLoop().RunUntilIdle();
   EXPECT_FALSE(callback_response_);
 
   delayable_backend->OpenEntryContinue();
   close_loop1->Run();
   EXPECT_EQ(1, sequence_out);
   close_loop2->Run();
   EXPECT_EQ(2, sequence_out);
 }
 
 INSTANTIATE_TEST_CASE_P(CacheStorageCacheTest,
                         CacheStorageCacheTestP,
                         ::testing::Values(false, true));
 
 }  // namespace content