Fixes the cache lock issue.

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 139 matching lines @@
 
 void RunTransactionTestBase(HttpCache* cache,
                             const MockTransaction& trans_info,
                             const MockHttpRequest& request,
                             HttpResponseInfo* response_info,
                             const NetLogWithSource& net_log,
                             LoadTimingInfo* load_timing_info,
                             int64_t* sent_bytes,
                             int64_t* received_bytes,
                             IPEndPoint* remote_endpoint) {
-  TestCompletionCallback callback;
-
   // write to the cache
 
-  std::unique_ptr<HttpTransaction> trans;
-  int rv = cache->CreateTransaction(DEFAULT_PRIORITY, &trans);
+  Context* c = new Context();
+  int rv = cache->CreateTransaction(DEFAULT_PRIORITY, &c->trans);
   EXPECT_THAT(rv, IsOk());
-  ASSERT_TRUE(trans.get());
+  ASSERT_TRUE(c->trans.get());
 
-  rv = trans->Start(&request, callback.callback(), net_log);
+  rv = c->trans->Start(&request, c->callback.callback(), net_log);
   if (rv == ERR_IO_PENDING)
-    rv = callback.WaitForResult();
+    rv = c->callback.WaitForResult();
   ASSERT_EQ(trans_info.return_code, rv);
 
   if (OK != rv)
     return;
 
-  const HttpResponseInfo* response = trans->GetResponseInfo();
+  const HttpResponseInfo* response = c->trans->GetResponseInfo();
   ASSERT_TRUE(response);
 
   if (response_info)
     *response_info = *response;
 
   if (load_timing_info) {
     // If a fake network connection is used, need a NetLog to get a fake socket
     // ID.
     EXPECT_TRUE(net_log.net_log());
     *load_timing_info = LoadTimingInfo();
-    trans->GetLoadTimingInfo(load_timing_info);
+    c->trans->GetLoadTimingInfo(load_timing_info);
   }
 
   if (remote_endpoint)
-    ASSERT_TRUE(trans->GetRemoteEndpoint(remote_endpoint));
+    ASSERT_TRUE(c->trans->GetRemoteEndpoint(remote_endpoint));
 
-  ReadAndVerifyTransaction(trans.get(), trans_info);
+  ReadAndVerifyTransaction(c->trans.get(), trans_info);
 
   if (sent_bytes)
-    *sent_bytes = trans->GetTotalSentBytes();
+    *sent_bytes = c->trans->GetTotalSentBytes();
   if (received_bytes)
-    *received_bytes = trans->GetTotalReceivedBytes();
+    *received_bytes = c->trans->GetTotalReceivedBytes();
+
+  delete c;
 }
 
 void RunTransactionTestWithRequest(HttpCache* cache,
                                    const MockTransaction& trans_info,
                                    const MockHttpRequest& request,
                                    HttpResponseInfo* response_info) {
   RunTransactionTestBase(cache, trans_info, request, response_info,
                          NetLogWithSource(), nullptr, nullptr, nullptr,
                          nullptr);
 }
@@ skipping 355 matching lines @@
 
   std::string status_and_headers() const {
     return std::string(status) + "\n" + std::string(headers);
   }
 
   const char* status;
   const char* headers;
   const char* body;
 };
 
-struct Context {
-  Context() : result(ERR_IO_PENDING) {}
-
-  int result;
-  TestCompletionCallback callback;
-  std::unique_ptr<HttpTransaction> trans;
-};
-
 class FakeWebSocketHandshakeStreamCreateHelper
     : public WebSocketHandshakeStreamBase::CreateHelper {
  public:
   ~FakeWebSocketHandshakeStreamCreateHelper() override {}
   WebSocketHandshakeStreamBase* CreateBasicStream(
       std::unique_ptr<ClientSocketHandle> connect,
       bool using_proxy) override {
     return NULL;
   }
   WebSocketHandshakeStreamBase* CreateSpdyStream(
@@ skipping 41 matching lines @@
 
 }  // namespace
 
 
 //-----------------------------------------------------------------------------
 // Tests.
 
 TEST(HttpCache, CreateThenDestroy) {
   MockHttpCache cache;
 
-  std::unique_ptr<HttpTransaction> trans;
-  EXPECT_THAT(cache.CreateTransaction(&trans), IsOk());
-  ASSERT_TRUE(trans.get());
+  Context* c = new Context();
+  EXPECT_THAT(cache.CreateTransaction(&c->trans), IsOk());
+  ASSERT_TRUE(c->trans.get());
+  delete c;
 }
 
 TEST(HttpCache, GetBackend) {
   MockHttpCache cache(HttpCache::DefaultBackend::InMemory(0));
 
   disk_cache::Backend* backend;
   TestCompletionCallback cb;
   // This will lazily initialize the backend.
   int rv = cache.http_cache()->GetBackend(&backend, cb.callback());
   EXPECT_THAT(cb.GetResult(rv), IsOk());
@@ skipping 68 matching lines @@
 }
 
 // Tests that IOBuffers are not referenced after IO completes.
 TEST(HttpCache, ReleaseBuffer) {
   MockHttpCache cache;
 
   // Write to the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   MockHttpRequest request(kSimpleGET_Transaction);
-  std::unique_ptr<HttpTransaction> trans;
-  ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
+  Context* c = new Context();
+  ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
 
   const int kBufferSize = 10;
   scoped_refptr<IOBuffer> buffer(new IOBuffer(kBufferSize));
   ReleaseBufferCompletionCallback cb(buffer.get());
 
-  int rv = trans->Start(&request, cb.callback(), NetLogWithSource());
+  int rv = c->trans->Start(&request, cb.callback(), NetLogWithSource());
   EXPECT_THAT(cb.GetResult(rv), IsOk());
 
-  rv = trans->Read(buffer.get(), kBufferSize, cb.callback());
+  rv = c->trans->Read(buffer.get(), kBufferSize, cb.callback());
   EXPECT_EQ(kBufferSize, cb.GetResult(rv));
+
+  delete c;
 }
 
 TEST(HttpCache, SimpleGETWithDiskFailures) {
   MockHttpCache cache;
 
   cache.disk_cache()->set_soft_failures(true);
 
   // Read from the network, and fail to write to the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
@@ skipping 156 matching lines @@
 }
 
 TEST(HttpCache, SimpleGET_LoadOnlyFromCache_Miss) {
   MockHttpCache cache;
 
   // force this transaction to read from the cache
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
 
   MockHttpRequest request(transaction);
-  TestCompletionCallback callback;
 
-  std::unique_ptr<HttpTransaction> trans;
-  ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
+  std::unique_ptr<Context> c(new Context());
+  ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
 
-  int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+  int rv =
+      c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
-    rv = callback.WaitForResult();
+    rv = c->callback.WaitForResult();
   ASSERT_THAT(rv, IsError(ERR_CACHE_MISS));
 
-  trans.reset();
-
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
 TEST(HttpCache, SimpleGET_LoadPreferringCache_Hit) {
   MockHttpCache cache;
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
@@ skipping 86 matching lines @@
   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;
   AddMockTransaction(&transaction);
 
   MockHttpRequest request(transaction);
-  TestCompletionCallback callback;
-  std::unique_ptr<HttpTransaction> trans;
-  int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
+  Context* c = new Context();
+  int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &c->trans);
   EXPECT_THAT(rv, IsOk());
-  ASSERT_TRUE(trans.get());
-  rv = trans->Start(&request, callback.callback(), NetLogWithSource());
-  EXPECT_THAT(callback.GetResult(rv), IsError(ERR_FAILED));
+  ASSERT_TRUE(c->trans.get());
+  rv = c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
+  EXPECT_THAT(c->callback.GetResult(rv), IsError(ERR_FAILED));
 
-  const HttpResponseInfo* response_info = trans->GetResponseInfo();
+  const HttpResponseInfo* response_info = c->trans->GetResponseInfo();
   ASSERT_TRUE(response_info);
   EXPECT_TRUE(response_info->was_cached);
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
 
   RemoveMockTransaction(&transaction);
+
+  delete c;
 }
 
 // Confirm if we have an empty cache, a read is marked as network verified.
 TEST(HttpCache, SimpleGET_NetworkAccessed_Network) {
   MockHttpCache cache;
 
   // write to the cache
   HttpResponseInfo response_info;
   RunTransactionTestWithResponseInfo(cache.http_cache(), kSimpleGET_Transaction,
                                      &response_info);
@@ skipping 270 matching lines @@
 
   // All requests are waiting for the active entry.
   for (int i = 0; i < kNumTransactions; ++i) {
     Context* c = context_list[i];
     EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE, c->trans->GetLoadState());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
   base::RunLoop().RunUntilIdle();
 
-  // The first request should be a writer at this point, and the subsequent
-  // requests should be pending.
+  //  At the end of Start: [0] should be in shared_writers->all_writers_,
+  //  [3] and [4] should also be in all_writers_ since its a case of validation
+  //  match/skip, [1] and [2] should be in pending_queue.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // All requests depend on the writer, and the writer is between Start and
   // Read, i.e. idle.
   for (int i = 0; i < kNumTransactions; ++i) {
     Context* c = context_list[i];
     EXPECT_EQ(LOAD_STATE_IDLE, c->trans->GetLoadState());
@@ skipping 55 matching lines @@
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   Context* c = context_list[0];
   ASSERT_THAT(c->result, IsError(ERR_IO_PENDING));
   c->result = c->callback.WaitForResult();
   ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
 
-  // Now we have 2 active readers and two queued transactions.
-
+  // after [0] completes reading and writing, [3] and [4] should be added to
+  // entry->readers from shared writers and pending queue should be
+  // processed to add [1] and [2] to readers as well. They are all waiting for
+  // their consumer to invoke Read.
   EXPECT_EQ(LOAD_STATE_IDLE, context_list[2]->trans->GetLoadState());
-  EXPECT_EQ(LOAD_STATE_WAITING_FOR_CACHE,
-            context_list[3]->trans->GetLoadState());
+  EXPECT_EQ(LOAD_STATE_IDLE, context_list[3]->trans->GetLoadState());
 
   c = context_list[1];
   ASSERT_THAT(c->result, IsError(ERR_IO_PENDING));
   c->result = c->callback.WaitForResult();
   if (c->result == OK)
     ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
 
   // At this point we have one reader, two pending transactions and a task on
   // the queue to move to the next transaction. Now we cancel the request that
   // is the current reader, and expect the queued task to be able to start the
@@ skipping 93 matching lines @@
     c->result =
         c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
   base::RunLoop().RunUntilIdle();
 
   // The first request should be a writer at this point, and the subsequent
   // requests should be pending.
 
-  EXPECT_EQ(1, cache.network_layer()->transaction_count());
+  EXPECT_EQ(3, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
-  EXPECT_EQ(1, cache.disk_cache()->create_count());
+  EXPECT_EQ(2, cache.disk_cache()->create_count());
 
   // Now, make sure that the second request asks for the entry not to be stored.
   request_handler.set_no_store(true);
 
   for (int i = 0; i < kNumTransactions; ++i) {
     Context* c = context_list[i];
     if (c->result == ERR_IO_PENDING)
       c->result = c->callback.WaitForResult();
     ReadAndVerifyTransaction(c->trans.get(), kFastNoStoreGET_Transaction);
     delete c;
@@ skipping 22 matching lines @@
     ASSERT_THAT(c->result, IsOk());
 
     c->result =
         c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   }
 
   // Allow all requests to move from the Create queue to the active entry.
   base::RunLoop().RunUntilIdle();
 
   // The first request should be a writer at this point, and the subsequent
-  // requests should be pending.
+  // requests should have been added to SharedWriters, skipped validation and
+  // completed the start state machine of HttpCache::Transaction.
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   for (int i = 0; i < kNumTransactions; ++i) {
     Context* c = context_list[i];
     if (c->result == ERR_IO_PENDING)
       c->result = c->callback.WaitForResult();
     // Destroy only the first transaction.
     if (i == 0) {
       delete c;
       context_list[i] = NULL;
     }
   }
 
   // Complete the rest of the transactions.
   for (int i = 1; i < kNumTransactions; ++i) {
     Context* c = context_list[i];
     ReadAndVerifyTransaction(c->trans.get(), kSimpleGET_Transaction);
   }
 
-  // We should have had to re-open the disk entry.
-
-  EXPECT_EQ(2, cache.network_layer()->transaction_count());
+  // 2nd transaction will reuse the network transaction as they are both part of
+  // SharedWriters. Similarly it will be part of the same entry.
+  EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
-  EXPECT_EQ(2, cache.disk_cache()->create_count());
+  EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   for (int i = 1; i < kNumTransactions; ++i) {
     Context* c = context_list[i];
     delete c;
   }
 }
 
 // Tests that we can cancel requests that are queued waiting to open the disk
 // cache entry.
 TEST(HttpCache, SimpleGET_ManyWriters_CancelCreate) {
@@ skipping 1330 matching lines @@
 
 TEST(HttpCache, SimplePOST_LoadOnlyFromCache_Miss) {
   MockHttpCache cache;
 
   MockTransaction transaction(kSimplePOST_Transaction);
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
-  std::unique_ptr<HttpTransaction> trans;
-  ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
-  ASSERT_TRUE(trans.get());
+  std::unique_ptr<Context> c(new Context());
+  ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
+  ASSERT_TRUE(c->trans.get());
 
-  int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+  int rv = c->trans->Start(&request, callback.callback(), NetLogWithSource());
   ASSERT_THAT(callback.GetResult(rv), IsError(ERR_CACHE_MISS));
 
-  trans.reset();
-
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
 }
 
 TEST(HttpCache, SimplePOST_LoadOnlyFromCache_Hit) {
   MockHttpCache cache;
 
   // Test that we hit the cache for POST requests.
 
@@ skipping 226 matching lines @@
 TEST(HttpCache, SimpleHEAD_LoadOnlyFromCache_Miss) {
   MockHttpCache cache;
   MockTransaction transaction(kSimplePOST_Transaction);
   AddMockTransaction(&transaction);
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
   transaction.method = "HEAD";
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
-  std::unique_ptr<HttpTransaction> trans;
-  ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
-  ASSERT_TRUE(trans.get());
+  std::unique_ptr<Context> c(new Context());
+  ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
+  ASSERT_TRUE(c->trans.get());
 
-  int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+  int rv = c->trans->Start(&request, callback.callback(), NetLogWithSource());
   ASSERT_THAT(callback.GetResult(rv), IsError(ERR_CACHE_MISS));
 
-  trans.reset();
-
   EXPECT_EQ(0, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(0, cache.disk_cache()->create_count());
   RemoveMockTransaction(&transaction);
 }
 
 // Tests that a HEAD request is served from a cached GET.
 TEST(HttpCache, SimpleHEAD_LoadOnlyFromCache_Hit) {
   MockHttpCache cache;
   MockTransaction transaction(kSimpleGET_Transaction);
@@ skipping 2366 matching lines @@
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Force this transaction to read from the cache.
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
 
   MockHttpRequest request(transaction);
   TestCompletionCallback callback;
 
-  std::unique_ptr<HttpTransaction> trans;
-  int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
+  std::unique_ptr<Context> c(new Context());
+  int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &c->trans);
   EXPECT_THAT(rv, IsOk());
-  ASSERT_TRUE(trans.get());
+  ASSERT_TRUE(c->trans.get());
 
-  rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+  rv = c->trans->Start(&request, callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
     rv = callback.WaitForResult();
   ASSERT_THAT(rv, IsError(ERR_CACHE_MISS));
 
-  trans.reset();
+  c.reset();
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 #endif
 
 // Tests the handling of the "truncation" flag.
@@ skipping 200 matching lines @@
   c->trans.reset();
   MockHttpCache::SetTestMode(0);
 
 
   // Make sure that we don't invoke the callback. We may have an issue if the
   // UrlRequestJob is killed directly (without cancelling the UrlRequest) so we
   // could end up with the transaction being deleted twice if we send any
   // notification from the transaction destructor (see http://crbug.com/31723).
   EXPECT_FALSE(c->callback.have_result());
 
-  // Verify that the entry is marked as incomplete.
-  VerifyTruncatedFlag(&cache, kSimpleGET_Transaction.url, true, 0);
+  // Verify that the entry is not marked as incomplete since SharedWriters
+  // enables response writing to complete even if transaction is destroyed
+  // mid-way.
+  VerifyTruncatedFlag(&cache, kSimpleGET_Transaction.url, false, 0);
 }
 
 // Tests that we don't mark an entry as truncated when we read everything.
 TEST(HttpCache, DontSetTruncatedFlag) {
   MockHttpCache cache;
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.response_headers =
       "Last-Modified: Wed, 28 Nov 2007 00:40:09 GMT\n"
       "Content-Length: 22\n"
@@ skipping 20 matching lines @@
 }
 
 // Tests that sparse entries don't set the truncate flag.
 TEST(HttpCache, RangeGET_DontTruncate) {
   MockHttpCache cache;
 
   ScopedMockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 0-19\r\n" EXTRA_HEADER;
 
   std::unique_ptr<MockHttpRequest> request(new MockHttpRequest(transaction));
-  std::unique_ptr<HttpTransaction> trans;
+  std::unique_ptr<Context> c(new Context());
 
-  int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
+  int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &c->trans);
   EXPECT_THAT(rv, IsOk());
 
   TestCompletionCallback cb;
-  rv = trans->Start(request.get(), cb.callback(), NetLogWithSource());
+  rv = c->trans->Start(request.get(), cb.callback(), NetLogWithSource());
   EXPECT_EQ(0, cb.GetResult(rv));
 
   scoped_refptr<IOBuffer> buf(new IOBuffer(10));
-  rv = trans->Read(buf.get(), 10, cb.callback());
+  rv = c->trans->Read(buf.get(), 10, cb.callback());
   EXPECT_EQ(10, cb.GetResult(rv));
 
-  // Should not trigger any DCHECK.
-  trans.reset();
   VerifyTruncatedFlag(&cache, kRangeGET_TransactionOK.url, false, 0);
 }
 
 // Tests that sparse entries don't set the truncate flag (when the byte range
 //  starts after 0).
 TEST(HttpCache, RangeGET_DontTruncate2) {
   MockHttpCache cache;
 
   ScopedMockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 30-49\r\n" EXTRA_HEADER;
 
   std::unique_ptr<MockHttpRequest> request(new MockHttpRequest(transaction));
-  std::unique_ptr<HttpTransaction> trans;
+  std::unique_ptr<Context> c(new Context());
 
-  int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
+  int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &c->trans);
   EXPECT_THAT(rv, IsOk());
 
-  TestCompletionCallback cb;
-  rv = trans->Start(request.get(), cb.callback(), NetLogWithSource());
-  EXPECT_EQ(0, cb.GetResult(rv));
+  rv = c->trans->Start(request.get(), c->callback.callback(),
+                       NetLogWithSource());
+  EXPECT_EQ(0, c->callback.GetResult(rv));
 
   scoped_refptr<IOBuffer> buf(new IOBuffer(10));
-  rv = trans->Read(buf.get(), 10, cb.callback());
-  EXPECT_EQ(10, cb.GetResult(rv));
+  rv = c->trans->Read(buf.get(), 10, c->callback.callback());
+  EXPECT_EQ(10, c->callback.GetResult(rv));
 
   // Should not trigger any DCHECK.
-  trans.reset();
   VerifyTruncatedFlag(&cache, kRangeGET_TransactionOK.url, false, 0);
 }
 
 // Tests that we can continue with a request that was interrupted.
 TEST(HttpCache, GET_IncompleteResource) {
   MockHttpCache cache;
   ScopedMockTransaction transaction(kRangeGET_TransactionOK);
 
   std::string raw_headers("HTTP/1.1 200 OK\n"
                           "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
@@ skipping 443 matching lines @@
 
   ScopedMockTransaction kTestTransaction(kSimpleGET_Transaction);
   kTestTransaction.status = "HTTP/1.1 301 Moved Permanently";
   kTestTransaction.response_headers = "Location: http://www.bar.com/\n";
 
   MockHttpRequest request(kTestTransaction);
   TestCompletionCallback callback;
 
   // Write to the cache.
   {
-    std::unique_ptr<HttpTransaction> trans;
-    ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
+    std::unique_ptr<Context> c(new Context());
+    ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
 
-    int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+    int rv = c->trans->Start(&request, callback.callback(), NetLogWithSource());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     ASSERT_THAT(rv, IsOk());
 
-    const HttpResponseInfo* info = trans->GetResponseInfo();
+    const HttpResponseInfo* info = c->trans->GetResponseInfo();
     ASSERT_TRUE(info);
 
     EXPECT_EQ(info->headers->response_code(), 301);
 
     std::string location;
     info->headers->EnumerateHeader(NULL, "Location", &location);
     EXPECT_EQ(location, "http://www.bar.com/");
 
     // Mark the transaction as completed so it is cached.
-    trans->DoneReading();
+    c->trans->DoneReading();
 
     // Destroy transaction when going out of scope. We have not actually
     // read the response body -- want to test that it is still getting cached.
   }
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 
   // Active entries in the cache are not retired synchronously. Make
   // sure the next run hits the MockHttpCache and open_count is
   // correct.
   base::RunLoop().RunUntilIdle();
 
   // Read from the cache.
   {
-    std::unique_ptr<HttpTransaction> trans;
-    ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
+    std::unique_ptr<Context> c(new Context());
+    ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
 
-    int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+    int rv = c->trans->Start(&request, callback.callback(), NetLogWithSource());
     if (rv == ERR_IO_PENDING)
       rv = callback.WaitForResult();
     ASSERT_THAT(rv, IsOk());
 
-    const HttpResponseInfo* info = trans->GetResponseInfo();
+    const HttpResponseInfo* info = c->trans->GetResponseInfo();
     ASSERT_TRUE(info);
 
     EXPECT_EQ(info->headers->response_code(), 301);
 
     std::string location;
     info->headers->EnumerateHeader(NULL, "Location", &location);
     EXPECT_EQ(location, "http://www.bar.com/");
 
     // Mark the transaction as completed so it is cached.
-    trans->DoneReading();
+    c->trans->DoneReading();
 
     // Destroy transaction when going out of scope. We have not actually
     // read the response body -- want to test that it is still getting cached.
   }
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Verify that no-cache resources are stored in cache, but are not fetched from
@@ skipping 140 matching lines @@
   transaction.cert_status = CERT_STATUS_REVOKED;
   ScopedMockTransaction scoped_transaction(transaction);
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), transaction);
 
   // Test that it was not cached.
   transaction.load_flags |= LOAD_ONLY_FROM_CACHE | LOAD_SKIP_CACHE_VALIDATION;
 
   MockHttpRequest request(transaction);
-  TestCompletionCallback callback;
 
-  std::unique_ptr<HttpTransaction> trans;
-  ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
+  std::unique_ptr<Context> c(new Context());
+  ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
 
-  int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+  int rv =
+      c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
   if (rv == ERR_IO_PENDING)
-    rv = callback.WaitForResult();
+    rv = c->callback.WaitForResult();
   ASSERT_THAT(rv, IsError(ERR_CACHE_MISS));
 }
 
 // Ensure that we don't crash by if left-behind transactions.
 TEST(HttpCache, OutlivedTransactions) {
   MockHttpCache* cache = new MockHttpCache;
 
-  std::unique_ptr<HttpTransaction> trans;
-  EXPECT_THAT(cache->CreateTransaction(&trans), IsOk());
+  std::unique_ptr<Context> c(new Context());
+  EXPECT_THAT(cache->CreateTransaction(&c->trans), IsOk());
 
   delete cache;
-  trans.reset();
 }
 
 // Test that the disabled mode works.
 TEST(HttpCache, CacheDisabledMode) {
   MockHttpCache cache;
 
   // write to the cache
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   // go into disabled mode
@@ skipping 322 matching lines @@
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we don't mark entries as truncated when a filter detects the end
 // of the stream.
 TEST(HttpCache, FilterCompletion) {
   MockHttpCache cache;
   TestCompletionCallback callback;
 
   {
-    std::unique_ptr<HttpTransaction> trans;
-    ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
+    std::unique_ptr<Context> c(new Context());
+    ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
 
     MockHttpRequest request(kSimpleGET_Transaction);
-    int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+    int rv = c->trans->Start(&request, callback.callback(), NetLogWithSource());
     EXPECT_THAT(callback.GetResult(rv), IsOk());
 
     scoped_refptr<IOBuffer> buf(new IOBuffer(256));
-    rv = trans->Read(buf.get(), 256, callback.callback());
+    rv = c->trans->Read(buf.get(), 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
 
     // Now make sure that the entry is preserved.
-    trans->DoneReading();
+    c->trans->DoneReading();
   }
 
   // Make sure that the ActiveEntry is gone.
   base::RunLoop().RunUntilIdle();
 
   // Read from the cache.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we don't mark entries as truncated and release the cache
 // entry when DoneReading() is called before any Read() calls, such as
 // for a redirect.
 TEST(HttpCache, DoneReading) {
   MockHttpCache cache;
   TestCompletionCallback callback;
 
   ScopedMockTransaction transaction(kSimpleGET_Transaction);
   transaction.data = "";
 
-  std::unique_ptr<HttpTransaction> trans;
-  ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
+  std::unique_ptr<Context> c(new Context());
+  ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
 
   MockHttpRequest request(transaction);
-  int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+  int rv = c->trans->Start(&request, callback.callback(), NetLogWithSource());
   EXPECT_THAT(callback.GetResult(rv), IsOk());
 
-  trans->DoneReading();
+  c->trans->DoneReading();
   // Leave the transaction around.
 
   // Make sure that the ActiveEntry is gone.
   base::RunLoop().RunUntilIdle();
 
   // Read from the cache. This should not deadlock.
   RunTransactionTest(cache.http_cache(), transaction);
 
   EXPECT_EQ(1, cache.network_layer()->transaction_count());
   EXPECT_EQ(1, cache.disk_cache()->open_count());
   EXPECT_EQ(1, cache.disk_cache()->create_count());
 }
 
 // Tests that we stop caching when told.
 TEST(HttpCache, StopCachingDeletesEntry) {
   MockHttpCache cache;
-  TestCompletionCallback callback;
   MockHttpRequest request(kSimpleGET_Transaction);
 
   {
-    std::unique_ptr<HttpTransaction> trans;
-    ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
+    std::unique_ptr<Context> c(new Context());
+    ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
 
-    int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
-    EXPECT_THAT(callback.GetResult(rv), IsOk());
+    int rv =
+        c->trans->Start(&request, c->callback.callback(), NetLogWithSource());
+    EXPECT_THAT(c->callback.GetResult(rv), IsOk());
 
     scoped_refptr<IOBuffer> buf(new IOBuffer(256));
-    rv = trans->Read(buf.get(), 10, callback.callback());
-    EXPECT_EQ(10, callback.GetResult(rv));
+    rv = c->trans->Read(buf.get(), 10, c->callback.callback());
+    EXPECT_EQ(10, c->callback.GetResult(rv));
 
-    trans->StopCaching();
+    c->trans->StopCaching();
 
     // We should be able to keep reading.
-    rv = trans->Read(buf.get(), 256, callback.callback());
-    EXPECT_GT(callback.GetResult(rv), 0);
-    rv = trans->Read(buf.get(), 256, callback.callback());
-    EXPECT_EQ(0, callback.GetResult(rv));
+    rv = c->trans->Read(buf.get(), 256, c->callback.callback());
+    EXPECT_GT(c->callback.GetResult(rv), 0);
+    rv = c->trans->Read(buf.get(), 256, c->callback.callback());
+    EXPECT_EQ(0, c->callback.GetResult(rv));
   }
 
   // Make sure that the ActiveEntry is gone.
   base::RunLoop().RunUntilIdle();
 
   // Verify that the entry is gone.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that we stop caching when told, even if DoneReading is called
 // after StopCaching.
 TEST(HttpCache, StopCachingThenDoneReadingDeletesEntry) {
   MockHttpCache cache;
   TestCompletionCallback callback;
   MockHttpRequest request(kSimpleGET_Transaction);
 
   {
-    std::unique_ptr<HttpTransaction> trans;
-    ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
+    std::unique_ptr<Context> c(new Context());
+    ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
 
-    int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+    int rv = c->trans->Start(&request, callback.callback(), NetLogWithSource());
     EXPECT_THAT(callback.GetResult(rv), IsOk());
 
     scoped_refptr<IOBuffer> buf(new IOBuffer(256));
-    rv = trans->Read(buf.get(), 10, callback.callback());
+    rv = c->trans->Read(buf.get(), 10, callback.callback());
     EXPECT_EQ(10, callback.GetResult(rv));
 
-    trans->StopCaching();
+    c->trans->StopCaching();
 
     // We should be able to keep reading.
-    rv = trans->Read(buf.get(), 256, callback.callback());
+    rv = c->trans->Read(buf.get(), 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
-    rv = trans->Read(buf.get(), 256, callback.callback());
+    rv = c->trans->Read(buf.get(), 256, callback.callback());
     EXPECT_EQ(0, callback.GetResult(rv));
 
     // We should be able to call DoneReading.
-    trans->DoneReading();
+    c->trans->DoneReading();
   }
 
   // Make sure that the ActiveEntry is gone.
   base::RunLoop().RunUntilIdle();
 
   // Verify that the entry is gone.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that we stop caching when told, when using auth.
 TEST(HttpCache, StopCachingWithAuthDeletesEntry) {
   MockHttpCache cache;
   TestCompletionCallback callback;
   MockTransaction mock_transaction(kSimpleGET_Transaction);
   mock_transaction.status = "HTTP/1.1 401 Unauthorized";
   AddMockTransaction(&mock_transaction);
   MockHttpRequest request(mock_transaction);
 
   {
-    std::unique_ptr<HttpTransaction> trans;
-    ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
+    std::unique_ptr<Context> c(new Context());
+    ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
 
-    int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+    int rv = c->trans->Start(&request, callback.callback(), NetLogWithSource());
     EXPECT_THAT(callback.GetResult(rv), IsOk());
 
-    trans->StopCaching();
+    c->trans->StopCaching();
 
     scoped_refptr<IOBuffer> buf(new IOBuffer(256));
-    rv = trans->Read(buf.get(), 10, callback.callback());
+    rv = c->trans->Read(buf.get(), 10, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 10);
   }
   RemoveMockTransaction(&mock_transaction);
 
   // Make sure that the ActiveEntry is gone.
   base::RunLoop().RunUntilIdle();
 
   // Verify that the entry is gone.
   RunTransactionTest(cache.http_cache(), kSimpleGET_Transaction);
 
   EXPECT_EQ(2, cache.network_layer()->transaction_count());
   EXPECT_EQ(0, cache.disk_cache()->open_count());
   EXPECT_EQ(2, cache.disk_cache()->create_count());
 }
 
 // Tests that when we are told to stop caching we don't throw away valid data.
 TEST(HttpCache, StopCachingSavesEntry) {
   MockHttpCache cache;
   TestCompletionCallback callback;
   MockHttpRequest request(kSimpleGET_Transaction);
 
   {
-    std::unique_ptr<HttpTransaction> trans;
-    ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
+    std::unique_ptr<Context> c(new Context());
+    ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
 
     // Force a response that can be resumed.
     ScopedMockTransaction mock_transaction(kSimpleGET_Transaction);
     AddMockTransaction(&mock_transaction);
     mock_transaction.response_headers = "Cache-Control: max-age=10000\n"
                                         "Content-Length: 42\n"
                                         "Etag: \"foo\"\n";
 
-    int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+    int rv = c->trans->Start(&request, callback.callback(), NetLogWithSource());
     EXPECT_THAT(callback.GetResult(rv), IsOk());
 
     scoped_refptr<IOBuffer> buf(new IOBuffer(256));
-    rv = trans->Read(buf.get(), 10, callback.callback());
+    rv = c->trans->Read(buf.get(), 10, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 10);
 
-    trans->StopCaching();
+    c->trans->StopCaching();
 
     // We should be able to keep reading.
-    rv = trans->Read(buf.get(), 256, callback.callback());
+    rv = c->trans->Read(buf.get(), 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
-    rv = trans->Read(buf.get(), 256, callback.callback());
+    rv = c->trans->Read(buf.get(), 256, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 0);
   }
 
   // Verify that the entry is marked as incomplete.
   VerifyTruncatedFlag(&cache, kSimpleGET_Transaction.url, true, 0);
 }
 
 // Tests that we handle truncated enries when StopCaching is called.
 TEST(HttpCache, StopCachingTruncatedEntry) {
   MockHttpCache cache;
   TestCompletionCallback callback;
   MockHttpRequest request(kRangeGET_TransactionOK);
   request.extra_headers.Clear();
   request.extra_headers.AddHeaderFromString(EXTRA_HEADER_LINE);
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   std::string raw_headers("HTTP/1.1 200 OK\n"
                           "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
                           "ETag: \"foo\"\n"
                           "Accept-Ranges: bytes\n"
                           "Content-Length: 80\n");
   CreateTruncatedEntry(raw_headers, &cache);
 
   {
     // Now make a regular request.
-    std::unique_ptr<HttpTransaction> trans;
-    ASSERT_THAT(cache.CreateTransaction(&trans), IsOk());
+    std::unique_ptr<Context> c(new Context());
+    ASSERT_THAT(cache.CreateTransaction(&c->trans), IsOk());
 
-    int rv = trans->Start(&request, callback.callback(), NetLogWithSource());
+    int rv = c->trans->Start(&request, callback.callback(), NetLogWithSource());
     EXPECT_THAT(callback.GetResult(rv), IsOk());
 
     scoped_refptr<IOBuffer> buf(new IOBuffer(256));
-    rv = trans->Read(buf.get(), 10, callback.callback());
+    rv = c->trans->Read(buf.get(), 10, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 10);
 
     // This is actually going to do nothing.
-    trans->StopCaching();
+    c->trans->StopCaching();
 
     // We should be able to keep reading.
-    rv = trans->Read(buf.get(), 256, callback.callback());
+    rv = c->trans->Read(buf.get(), 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
-    rv = trans->Read(buf.get(), 256, callback.callback());
+    rv = c->trans->Read(buf.get(), 256, callback.callback());
     EXPECT_GT(callback.GetResult(rv), 0);
-    rv = trans->Read(buf.get(), 256, callback.callback());
+    rv = c->trans->Read(buf.get(), 256, callback.callback());
     EXPECT_EQ(callback.GetResult(rv), 0);
   }
 
   // Verify that the disk entry was updated.
   VerifyTruncatedFlag(&cache, kRangeGET_TransactionOK.url, false, 80);
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 namespace {
 
@@ skipping 206 matching lines @@
   (*cache_initializer)(&cache);
 
   MockTransaction transaction(kSimpleGET_Transaction);
   transaction.url = kRangeGET_TransactionOK.url;
   transaction.handler = &LargeResourceTransactionHandler;
   transaction.read_handler = &LargeBufferReader;
   ScopedMockTransaction scoped_transaction(transaction);
 
   MockHttpRequest request(transaction);
   net::TestCompletionCallback callback;
-  std::unique_ptr<net::HttpTransaction> http_transaction;
-  int rv = cache.http_cache()->CreateTransaction(net::DEFAULT_PRIORITY,
-                                                 &http_transaction);
+  std::unique_ptr<Context> c(new Context());
+  int rv =
+      cache.http_cache()->CreateTransaction(net::DEFAULT_PRIORITY, &c->trans);
   ASSERT_EQ(net::OK, rv);
-  ASSERT_TRUE(http_transaction.get());
+  ASSERT_TRUE(c->trans.get());
 
   bool network_transaction_started = false;
   if (stop_caching_phase == TransactionPhase::AFTER_NETWORK_READ) {
-    http_transaction->SetBeforeNetworkStartCallback(
+    c->trans->SetBeforeNetworkStartCallback(
         base::Bind(&SetFlagOnBeforeNetworkStart, &network_transaction_started));
   }
 
-  rv = http_transaction->Start(&request, callback.callback(),
-                               NetLogWithSource());
+  rv = c->trans->Start(&request, callback.callback(), NetLogWithSource());
   rv = callback.GetResult(rv);
   ASSERT_EQ(net::OK, rv);
 
   if (stop_caching_phase == TransactionPhase::BEFORE_FIRST_READ)
-    http_transaction->StopCaching();
+    c->trans->StopCaching();
 
   int64_t total_bytes_received = 0;
 
   EXPECT_EQ(kTotalSize,
-            http_transaction->GetResponseInfo()->headers->GetContentLength());
+            c->trans->GetResponseInfo()->headers->GetContentLength());
   do {
     // This test simulates reading gigabytes of data. Buffer size is set to 10MB
     // to reduce the number of reads and speed up the test.
     const int kBufferSize = 1024 * 1024 * 10;
     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kBufferSize));
-    rv = http_transaction->Read(buf.get(), kBufferSize, callback.callback());
+    rv = c->trans->Read(buf.get(), kBufferSize, callback.callback());
     rv = callback.GetResult(rv);
 
     if (stop_caching_phase == TransactionPhase::AFTER_FIRST_READ &&
         total_bytes_received == 0) {
-      http_transaction->StopCaching();
+      c->trans->StopCaching();
     }
 
     if (rv > 0)
       total_bytes_received += rv;
 
     if (network_transaction_started &&
         stop_caching_phase == TransactionPhase::AFTER_NETWORK_READ) {
-      http_transaction->StopCaching();
+      c->trans->StopCaching();
       network_transaction_started = false;
     }
   } while (rv > 0);
 
   // The only verification we are going to do is that the received resource has
   // the correct size. This is sufficient to verify that the state machine
   // didn't terminate abruptly due to the StopCaching() call.
   EXPECT_EQ(kTotalSize, total_bytes_received);
 }
 
@@ skipping 34 matching lines @@
 
   // Verify that the entry is marked as incomplete.
   VerifyTruncatedFlag(&cache, kSimpleGET_Transaction.url, true, 0);
 }
 
 // Make sure that calling SetPriority on a cache transaction passes on
 // its priority updates to its underlying network transaction.
 TEST(HttpCache, SetPriority) {
   MockHttpCache cache;
 
-  std::unique_ptr<HttpTransaction> trans;
-  ASSERT_THAT(cache.http_cache()->CreateTransaction(IDLE, &trans), IsOk());
+  std::unique_ptr<Context> c(new Context);
+  ASSERT_THAT(cache.http_cache()->CreateTransaction(IDLE, &c->trans), IsOk());
 
   // Shouldn't crash, but doesn't do anything either.
-  trans->SetPriority(LOW);
+  c->trans->SetPriority(LOW);
 
   EXPECT_FALSE(cache.network_layer()->last_transaction());
   EXPECT_EQ(DEFAULT_PRIORITY,
             cache.network_layer()->last_create_transaction_priority());
 
   HttpRequestInfo info;
   info.url = GURL(kSimpleGET_Transaction.url);
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            trans->Start(&info, callback.callback(), NetLogWithSource()));
+            c->trans->Start(&info, callback.callback(), NetLogWithSource()));
 
   EXPECT_TRUE(cache.network_layer()->last_transaction());
   if (cache.network_layer()->last_transaction()) {
     EXPECT_EQ(LOW, cache.network_layer()->last_create_transaction_priority());
     EXPECT_EQ(LOW, cache.network_layer()->last_transaction()->priority());
   }
 
-  trans->SetPriority(HIGHEST);
+  c->trans->SetPriority(HIGHEST);
 
   if (cache.network_layer()->last_transaction()) {
     EXPECT_EQ(LOW, cache.network_layer()->last_create_transaction_priority());
     EXPECT_EQ(HIGHEST, cache.network_layer()->last_transaction()->priority());
   }
 
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
 
 // Make sure that calling SetWebSocketHandshakeStreamCreateHelper on a cache
 // transaction passes on its argument to the underlying network transaction.
 TEST(HttpCache, SetWebSocketHandshakeStreamCreateHelper) {
   MockHttpCache cache;
 
   FakeWebSocketHandshakeStreamCreateHelper create_helper;
-  std::unique_ptr<HttpTransaction> trans;
-  ASSERT_THAT(cache.http_cache()->CreateTransaction(IDLE, &trans), IsOk());
+  std::unique_ptr<Context> c(new Context);
+  ASSERT_THAT(cache.http_cache()->CreateTransaction(IDLE, &c->trans), IsOk());
 
   EXPECT_FALSE(cache.network_layer()->last_transaction());
 
   HttpRequestInfo info;
   info.url = GURL(kSimpleGET_Transaction.url);
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            trans->Start(&info, callback.callback(), NetLogWithSource()));
+            c->trans->Start(&info, callback.callback(), NetLogWithSource()));
 
   ASSERT_TRUE(cache.network_layer()->last_transaction());
   EXPECT_FALSE(cache.network_layer()->last_transaction()->
                websocket_handshake_stream_create_helper());
-  trans->SetWebSocketHandshakeStreamCreateHelper(&create_helper);
+  c->trans->SetWebSocketHandshakeStreamCreateHelper(&create_helper);
   EXPECT_EQ(&create_helper,
             cache.network_layer()->last_transaction()->
             websocket_handshake_stream_create_helper());
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 }
 
 // Make sure that a cache transaction passes on its priority to
 // newly-created network transactions.
 TEST(HttpCache, SetPriorityNewTransaction) {
   MockHttpCache cache;
   AddMockTransaction(&kRangeGET_TransactionOK);
 
   std::string raw_headers("HTTP/1.1 200 OK\n"
                           "Last-Modified: Sat, 18 Apr 2007 01:10:43 GMT\n"
                           "ETag: \"foo\"\n"
                           "Accept-Ranges: bytes\n"
                           "Content-Length: 80\n");
   CreateTruncatedEntry(raw_headers, &cache);
 
   // Now make a regular request.
   std::string headers;
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = EXTRA_HEADER;
   transaction.data = kFullRangeData;
 
-  std::unique_ptr<HttpTransaction> trans;
-  ASSERT_THAT(cache.http_cache()->CreateTransaction(MEDIUM, &trans), IsOk());
+  std::unique_ptr<Context> c(new Context);
+  ASSERT_THAT(cache.http_cache()->CreateTransaction(MEDIUM, &c->trans), IsOk());
   EXPECT_EQ(DEFAULT_PRIORITY,
             cache.network_layer()->last_create_transaction_priority());
 
   MockHttpRequest info(transaction);
   TestCompletionCallback callback;
   EXPECT_EQ(ERR_IO_PENDING,
-            trans->Start(&info, callback.callback(), NetLogWithSource()));
+            c->trans->Start(&info, callback.callback(), NetLogWithSource()));
   EXPECT_THAT(callback.WaitForResult(), IsOk());
 
   EXPECT_EQ(MEDIUM, cache.network_layer()->last_create_transaction_priority());
 
-  trans->SetPriority(HIGHEST);
+  c->trans->SetPriority(HIGHEST);
   // Should trigger a new network transaction and pick up the new
   // priority.
-  ReadAndVerifyTransaction(trans.get(), transaction);
+  ReadAndVerifyTransaction(c->trans.get(), transaction);
 
   EXPECT_EQ(HIGHEST, cache.network_layer()->last_create_transaction_priority());
 
   RemoveMockTransaction(&kRangeGET_TransactionOK);
 }
 
 namespace {
 
 void RunTransactionAndGetNetworkBytes(MockHttpCache& cache,
                                       const MockTransaction& trans_info,
@@ skipping 358 matching lines @@
   MockHttpCache cache;
 
   // Create a transaction for bytes 0-9.
   MockHttpRequest request(kRangeGET_TransactionOK);
   MockTransaction transaction(kRangeGET_TransactionOK);
   transaction.request_headers = "Range: bytes = 0-9\r\n" EXTRA_HEADER;
   transaction.data = "rg: 00-09 ";
   AddMockTransaction(&transaction);
 
   TestCompletionCallback callback;
-  std::unique_ptr<HttpTransaction> trans;
-  int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &trans);
+  std::unique_ptr<Context> c(new Context);
+  int rv = cache.http_cache()->CreateTransaction(DEFAULT_PRIORITY, &c->trans);
   EXPECT_THAT(rv, IsOk());
-  ASSERT_TRUE(trans.get());
+  ASSERT_TRUE(c->trans.get());
 
   // Start our transaction.
-  trans->Start(&request, callback.callback(), NetLogWithSource());
+  c->trans->Start(&request, callback.callback(), NetLogWithSource());
 
   // A second transaction on a different part of the file (the default
   // kRangeGET_TransactionOK requests 40-49) should not be blocked by
   // the already pending transaction.
   RunTransactionTest(cache.http_cache(), kRangeGET_TransactionOK);
 
   // Let the first transaction complete.
   callback.WaitForResult();
 
   RemoveMockTransaction(&transaction);
@@ skipping 231 matching lines @@
   RunTransactionTestWithResponseInfo(cache.http_cache(),
                                      kTypicalGET_Transaction, &response_info);
 
   EXPECT_FALSE(response_info.was_cached);
   EXPECT_TRUE(response_info.network_accessed);
   EXPECT_EQ(CacheEntryStatus::ENTRY_CANT_CONDITIONALIZE,
             response_info.cache_entry_status);
 }
 
 }  // namespace net