Adds a new class HttpCache::Writers for multiple cache transactions reading from the network.

net/http/http_cache_unittest.cc

 // Copyright (c) 2012 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 <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 200 matching lines @@
   // write to the cache
 
   std::unique_ptr<HttpTransaction> trans;
   int rv = cache->CreateTransaction(DEFAULT_PRIORITY, &trans);
   EXPECT_THAT(rv, IsOk());
   ASSERT_TRUE(trans.get());
 
   rv = trans->Start(&request, callback.callback(), net_log);
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
-  ASSERT_EQ(trans_info.return_code, rv);
+  ASSERT_EQ(trans_info.start_return_code, rv);
 
   if (OK != rv)
     return;
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   ASSERT_TRUE(response);
 
   if (response_info)
     *response_info = *response;
 
@@ skipping 837 matching lines @@
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers = "Cache-Control: no-cache\n";
 
   AddMockTransaction(&transaction);
   RunTransactionTest(cache.http_cache(), transaction);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction);
 
   // Network failure with error; should fail but have was_cached set.
-  transaction.return_code = ERR_FAILED;
+  transaction.start_return_code = ERR_FAILED;
   AddMockTransaction(&transaction);
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
   std::unique_ptr<HttpTransaction> trans;
   int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
   EXPECT_THAT(rv, IsOk());
   ASSERT_TRUE(trans.get());
   rv = trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsError(ERR_FAILED));
@@ skipping 3416 matching lines @@
   MockTransaction transaction(kSimpleGET_Transaction);
   AddMockTransaction(&transaction);
 
   // Populate the cache.
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Load from cache.
   transaction.method = "HEAD";
   transaction.request_headers = "Range: bytes = 0-4\r\n";
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
-  transaction.return_code = ERR_CACHE_MISS;
+  transaction.start_return_code = ERR_CACHE_MISS;
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that a HEAD request can be served from a partialy cached resource.
 TEST(HttpCache, SimpleHEAD_WithCachedRanges) {
   MockHttpCache cache;
@@ skipping 145 matching lines @@
 
   // Update the cache.
   transaction.method = "HEAD";
   transaction.data = "";
   RunTransactionTest(cache.http_cache(), transaction);
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
 
   // Load from the cache.
   transaction.method = "GET";
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
-  transaction.return_code = ERR_CACHE_MISS;
+  transaction.start_return_code = ERR_CACHE_MISS;
   RunTransactionTest(cache.http_cache(), transaction);
 
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that we do not cache the response of a PUT.
 TEST(HttpCache, SimplePUT_Miss) {
   MockHttpCache cache;
 
   MockTransaction transaction(kSimplePOST_Transaction);
@@ skipping 256 matching lines @@
 // Tests that we don't invalidate entries after a failed network transaction.
 TEST(HttpCache, SimpleGET_DontInvalidateOnFailure) {
   MockHttpCache cache;
 
   // Populate the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
 
   // Fail the network request.
   MockTransaction transaction(kSimpleGET_Transaction);
-  transaction.return_code = ERR_FAILED;
+  transaction.start_return_code = ERR_FAILED;
   transaction.load_flags |= LOAD_VALIDATE_CACHE;
 
   AddMockTransaction(&transaction);
   RunTransactionTest(cache.http_cache(), transaction);
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   RemoveMockTransaction(&transaction);
 
   transaction.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
-  transaction.return_code = OK;
+  transaction.start_return_code = OK;
   AddMockTransaction(&transaction);
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Make sure the transaction didn't reach the network.
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   RemoveMockTransaction(&transaction);
 }
 
 TEST(HttpCache, RangeGET_SkipsCache) {
   MockHttpCache cache;
@@ skipping 3054 matching lines @@
   transaction.request_headers = "accept-encoding: gzip\r\n";
   transaction.response_headers =
       "Vary: accept-encoding\n"
       "Cache-Control: max-age=10000\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Change the request headers so that the request doesn't match due to vary.
   // The request should fail.
   transaction.load_flags = LOAD_ONLY_FROM_CACHE;
   transaction.request_headers = "accept-encoding: foo\r\n";
-  transaction.return_code = ERR_CACHE_MISS;
+  transaction.start_return_code = ERR_CACHE_MISS;
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Change the load flags to ignore vary checks, the request should now hit.
   transaction.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_VARY_CHECK;
-  transaction.return_code = OK;
+  transaction.start_return_code = OK;
   RunTransactionTest(cache.http_cache(), transaction);
 }
 
 // Tests that we only return valid entries with LOAD_ONLY_FROM_CACHE
 // transactions unless LOAD_SKIP_CACHE_VALIDATION is set.
 TEST(HttpCache, ValidLoadOnlyFromCache) {
   MockHttpCache cache;
   base::SimpleTestClock* clock = new base::SimpleTestClock();
   cache.http_cache()->SetClockForTesting(base::WrapUnique(clock));
   cache.network_layer()->SetClock(clock);
 
   // Write a resource that will expire in 100 seconds.
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers = "Cache-Control: max-age=100\n";
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Move forward in time such that the cached response is no longer valid.
   clock->Advance(base::TimeDelta::FromSeconds(101));
 
   // Skipping cache validation should still return a response.
   transaction.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
   RunTransactionTest(cache.http_cache(), transaction);
 
   // If the cache entry is checked for validitiy, it should fail.
   transaction.load_flags = LOAD_ONLY_FROM_CACHE;
-  transaction.return_code = ERR_CACHE_MISS;
+  transaction.start_return_code = ERR_CACHE_MISS;
   RunTransactionTest(cache.http_cache(), transaction);
 }
 
 TEST(HttpCache, InvalidLoadFlagCombination) {
   MockHttpCache cache;
 
   // Put the resource in the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   // Now try to fetch it again, but with a flag combination disallowing both
   // cache and network access.
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   // DevTools relies on this combination of flags for "disable cache" mode
   // when a resource is only supposed to be loaded from cache.
   transaction.load_flags = LOAD_ONLY_FROM_CACHE | LOAD_BYPASS_CACHE;
-  transaction.return_code = ERR_CACHE_MISS;
+  transaction.start_return_code = ERR_CACHE_MISS;
   RunTransactionTest(cache.http_cache(), transaction);
 }
 
 // Tests that we can read metadata after validating the entry and with READ mode
 // transactions.
 TEST(HttpCache, ReadMetadata) {
   MockHttpCache cache;
 
   // Write to the cache
   HttpResponseInfo response;
@@ skipping 1258 matching lines @@
   ASSERT_TRUE(attrs->GetDictionary(
       base::trace_event::MemoryAllocatorDump::kNameSize, &size_attrs));
   std::string size;
   ASSERT_TRUE(size_attrs->GetString("value", &size));
   int actual_size = 0;
   ASSERT_TRUE(base::HexStringToInt(size, &actual_size));
   ASSERT_LT(0, actual_size);
 }
 
 }  // namespace net