Http cache: Convert data writes from sysnchronous to asynchronous....

net/http/http_cache_unittest.cc

 // Copyright (c) 2006-2009 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 "net/http/http_cache.h"
 
 #include "base/hash_tables.h"
 #include "base/message_loop.h"
 #include "base/string_util.h"
 #include "net/base/net_errors.h"
@@ skipping 108 matching lines @@
 
     if (fail_requests_)
       return net::ERR_CACHE_READ_FAILURE;
 
     if (offset < 0 || offset > static_cast<int>(data_[index].size()))
       return net::ERR_FAILED;
 
     data_[index].resize(offset + buf_len);
     if (buf_len)
       memcpy(&data_[index][offset], buf->data(), buf_len);
-    return buf_len;
+
+    if (!callback || (test_mode_ & TEST_MODE_SYNC_CACHE_WRITE))
+      return buf_len;
+
+    CallbackLater(callback, buf_len);
+    return net::ERR_IO_PENDING;
   }
 
   virtual int ReadSparseData(int64 offset, net::IOBuffer* buf, int buf_len,
                              net::CompletionCallback* completion_callback) {
     if (!sparse_)
       return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
     if (offset < 0)
       return net::ERR_FAILED;
 
     if (fail_requests_)
@@ skipping 30 matching lines @@
     if (fail_requests_)
       return net::ERR_CACHE_READ_FAILURE;
 
     DCHECK(offset < kint32max);
     int real_offset = static_cast<int>(offset);
 
     if (static_cast<int>(data_[1].size()) < real_offset + buf_len)
       data_[1].resize(real_offset + buf_len);
 
     memcpy(&data_[1][real_offset], buf->data(), buf_len);
-    return buf_len;
+    if (!completion_callback || (test_mode_ & TEST_MODE_SYNC_CACHE_WRITE))
+      return buf_len;
+
+    CallbackLater(completion_callback, buf_len);
+    return net::ERR_IO_PENDING;
   }
 
   virtual int GetAvailableRange(int64 offset, int len, int64* start) {
     if (!sparse_)
       return net::ERR_CACHE_OPERATION_NOT_SUPPORTED;
     if (offset < 0)
       return net::ERR_FAILED;
 
     if (fail_requests_)
       return net::ERR_CACHE_READ_FAILURE;
@@ skipping 1771 matching lines @@
 // Tests that we can cache range requests when the start or end is unknown.
 // We start with one request from a given point, followed by a suffix request.
 // We'll also verify that synchronous cache responses work as intended.
 TEST(HttpCache, UnknownRangeGET_2) {
   MockHttpCache cache;
   cache.http_cache()->set_enable_range_support(true);
   std::string headers;
 
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.test_mode = TEST_MODE_SYNC_CACHE_START |
-                          TEST_MODE_SYNC_CACHE_READ;
+                          TEST_MODE_SYNC_CACHE_READ |
+                          TEST_MODE_SYNC_CACHE_WRITE;
   AddMockTransaction(&transaction);
 
   // Write to the cache (70-79).
   transaction.request_headers = "Range: bytes = 70-\r\n";
   transaction.data = "rg: 70-79 ";
   RunTransactionTestWithResponse(cache.http_cache(), transaction, &headers);
 
   EXPECT_TRUE(Verify206Response(headers, 70, 79));
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
@@ skipping 544 matching lines @@
 }
 
 TEST(HttpCache, SyncRead) {
   MockHttpCache cache;
 
   // This test ensures that a read that completes synchronously does not cause
   // any problems.
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.test_mode |= (TEST_MODE_SYNC_CACHE_START |
-                            TEST_MODE_SYNC_CACHE_READ);
+                            TEST_MODE_SYNC_CACHE_READ |
+                            TEST_MODE_SYNC_CACHE_WRITE);
 
   MockHttpRequest r1(transaction),
                   r2(transaction),
                   r3(transaction);
 
   TestTransactionConsumer c1(cache.http_cache()),
                           c2(cache.http_cache()),
                           c3(cache.http_cache());
 
   c1.Start(&r1, NULL);
@@ skipping 304 matching lines @@
   std::string headers;
   response.headers->GetNormalizedHeaders(&headers);
 
   EXPECT_EQ("HTTP/1.1 200 OK\n"
             "Date: Wed, 22 Jul 2009 03:15:26 GMT\n"
             "Last-Modified: Wed, 06 Feb 2008 22:38:21 GMT\n",
             headers);
 
   RemoveMockTransaction(&mock_network_response);
 }