Add a "LoadLog*" parameter to transactions, hostresolver, clientsocketpool.

net/http/http_network_transaction_unittest.cc

 // Copyright (c) 2006-2008 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 <math.h>  // ceil
 
 #include "base/compiler_specific.h"
 #include "net/base/completion_callback.h"
 #include "net/base/mock_host_resolver.h"
 #include "net/base/ssl_info.h"
@@ skipping 78 matching lines @@
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/");
     request.load_flags = 0;
 
     StaticMockSocket data(data_reads, NULL);
     session_deps.socket_factory.AddMockSocket(&data);
 
     TestCompletionCallback callback;
 
-    int rv = trans->Start(&request, &callback);
+    int rv = trans->Start(NULL, &request, &callback);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     out.rv = callback.WaitForResult();
     if (out.rv != OK)
       return out;
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_TRUE(response != NULL);
 
     EXPECT_TRUE(response->headers != NULL);
@@ skipping 52 matching lines @@
 }
 
 std::string MockGetHostName() {
   return "WTC-WIN7";
 }
 
 class CaptureGroupNameSocketPool : public ClientSocketPool {
  public:
   CaptureGroupNameSocketPool() {
   }
-  virtual int RequestSocket(const std::string& group_name,
+  virtual int RequestSocket(LoadLog* load_log,
+                            const std::string& group_name,
                             const HostResolver::RequestInfo& resolve_info,
                             int priority,
                             ClientSocketHandle* handle,
                             CompletionCallback* callback) {
     last_group_name_ = group_name;
     return ERR_IO_PENDING;
   }
 
   const std::string last_group_name_received() const {
     return last_group_name_;
@@ skipping 161 matching lines @@
 
     // No response body because the test stops reading here.
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticMockSocket data1(data_reads1, data_writes1);
   session_deps.socket_factory.AddMockSocket(&data1);
 
   TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1);
+  int rv = trans->Start(NULL, &request, &callback1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   // Check that the headers got parsed.
   EXPECT_TRUE(response->headers != NULL);
@@ skipping 37 matching lines @@
     scoped_ptr<HttpTransaction> trans(
         new HttpNetworkTransaction(session, &session_deps.socket_factory));
 
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/");
     request.load_flags = 0;
 
     TestCompletionCallback callback;
 
-    int rv = trans->Start(&request, &callback);
+    int rv = trans->Start(NULL, &request, &callback);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_TRUE(response != NULL);
 
     EXPECT_TRUE(response->headers != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
@@ skipping 23 matching lines @@
     MockRead("HTTP/1.0 100 Continue\r\n\r\n"),
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(false, OK),
   };
   StaticMockSocket data(data_reads, NULL);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
@@ skipping 23 matching lines @@
     MockRead("HTTP/1.1 102 Unspecified status code\r\n\r\n"),
     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
     MockRead("hello world"),
     MockRead(false, OK),
   };
   StaticMockSocket data(data_reads, NULL);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
@@ skipping 35 matching lines @@
   const char* kExpectedResponseData[] = {
     "hello", "world"
   };
 
   for (int i = 0; i < 2; ++i) {
     TestCompletionCallback callback;
 
     scoped_ptr<HttpTransaction> trans(
         new HttpNetworkTransaction(session, &session_deps.socket_factory));
 
-    int rv = trans->Start(&request, &callback);
+    int rv = trans->Start(NULL, &request, &callback);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_TRUE(response != NULL);
 
     EXPECT_TRUE(response->headers != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
@@ skipping 31 matching lines @@
     MockRead(true, ERR_CONNECTION_RESET),
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),  // Should not be used
     MockRead("hello world"),
     MockRead(false, OK),
   };
   StaticMockSocket data(data_reads, NULL);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CONNECTION_RESET, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 }
 
 // What do various browsers do when the server closes a non-keepalive
@@ skipping 66 matching lines @@
     MockRead(false, OK),
   };
 
   StaticMockSocket data1(data_reads1, data_writes1);
   StaticMockSocket data2(data_reads2, data_writes2);
   session_deps.socket_factory.AddMockSocket(&data1);
   session_deps.socket_factory.AddMockSocket(&data2);
 
   TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1);
+  int rv = trans->Start(NULL, &request, &callback1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   // The password prompt info should have been set in response->auth_challenge.
   EXPECT_FALSE(response->auth_challenge.get() == NULL);
@@ skipping 55 matching lines @@
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticMockSocket data1(data_reads1, data_writes1);
   session_deps.socket_factory.AddMockSocket(&data1);
 
   TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1);
+  int rv = trans->Start(NULL, &request, &callback1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   // The password prompt info should have been set in response->auth_challenge.
   EXPECT_FALSE(response->auth_challenge.get() == NULL);
@@ skipping 58 matching lines @@
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticMockSocket data1(data_reads1, data_writes1);
   session_deps.socket_factory.AddMockSocket(&data1);
 
   TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1);
+  int rv = trans->Start(NULL, &request, &callback1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   // The password prompt info should have been set in response->auth_challenge.
   EXPECT_FALSE(response->auth_challenge.get() == NULL);
@@ skipping 61 matching lines @@
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticMockSocket data1(data_reads1, data_writes1);
   session_deps.socket_factory.AddMockSocket(&data1);
 
   TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1);
+  int rv = trans->Start(NULL, &request, &callback1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   // The password prompt info should have been set in response->auth_challenge.
   EXPECT_FALSE(response->auth_challenge.get() == NULL);
@@ skipping 60 matching lines @@
     MockRead("Content-Length: 10\r\n\r\n"),
     // No response body because the test stops reading here.
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticMockSocket data1(data_reads1, data_writes1);
   session_deps.socket_factory.AddMockSocket(&data1);
 
   TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1);
+  int rv = trans->Start(NULL, &request, &callback1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
@@ skipping 61 matching lines @@
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
@@ skipping 32 matching lines @@
     MockRead("Content-Length: 10\r\n\r\n"),
     // No response body because the test stops reading here.
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(expected_status, rv);
 }
 
 void HttpNetworkTransactionTest::ConnectStatusHelper(const MockRead& status) {
   ConnectStatusHelperWithExpectedStatus(
       status, ERR_TUNNEL_CONNECTION_FAILED);
 }
@@ skipping 239 matching lines @@
 
   StaticMockSocket data1(data_reads1, data_writes1);
   StaticMockSocket data2(data_reads2, data_writes2);
   StaticMockSocket data3(data_reads3, data_writes3);
   session_deps.socket_factory.AddMockSocket(&data1);
   session_deps.socket_factory.AddMockSocket(&data2);
   session_deps.socket_factory.AddMockSocket(&data3);
 
   TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1);
+  int rv = trans->Start(NULL, &request, &callback1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   // The password prompt info should have been set in response->auth_challenge.
   EXPECT_FALSE(response->auth_challenge.get() == NULL);
@@ skipping 114 matching lines @@
     MockRead(false, OK),
   };
 
   StaticMockSocket data1(data_reads1, data_writes1);
   StaticMockSocket data2(data_reads2, data_writes2);
   session_deps.socket_factory.AddMockSocket(&data1);
   session_deps.socket_factory.AddMockSocket(&data2);
 
   TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1);
+  int rv = trans->Start(NULL, &request, &callback1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
   TestCompletionCallback callback2;
   rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback2.WaitForResult();
@@ skipping 153 matching lines @@
 
   StaticMockSocket data1(data_reads1, data_writes1);
   StaticMockSocket data2(data_reads2, data_writes2);
   StaticMockSocket data3(data_reads3, data_writes3);
   session_deps.socket_factory.AddMockSocket(&data1);
   session_deps.socket_factory.AddMockSocket(&data2);
   session_deps.socket_factory.AddMockSocket(&data3);
 
   TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1);
+  int rv = trans->Start(NULL, &request, &callback1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
   TestCompletionCallback callback2;
   rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback2.WaitForResult();
@@ skipping 74 matching lines @@
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead(true, large_headers_string.data(), large_headers_string.size()),
     MockRead("\r\nBODY"),
     MockRead(false, OK),
   };
   StaticMockSocket data(data_reads, NULL);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_RESPONSE_HEADERS_TOO_BIG, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 }
 
 // Make sure that we don't try to reuse a TCPClientSocket when failing to
@@ skipping 27 matching lines @@
     MockRead("HTTP/1.1 404 Not Found\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
     MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   StaticMockSocket data1(data_reads1, data_writes1);
   session_deps.socket_factory.AddMockSocket(&data1);
 
   TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1);
+  int rv = trans->Start(NULL, &request, &callback1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 
   // Empty the current queue.  This is necessary because idle sockets are
   // added to the connection pool asynchronously with a PostTask.
@@ skipping 29 matching lines @@
     MockRead(" world"),
     MockRead("junk"),  // Should not be read!!
     MockRead(false, OK),
   };
 
   StaticMockSocket data(data_reads, NULL);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   std::string status_line = response->headers->GetStatusLine();
@@ skipping 37 matching lines @@
              "Content-Type: text/html\r\n\r\n"),
     MockRead("junk"),  // Should not be read!!
     MockRead(false, OK),
   };
 
   StaticMockSocket data(data_reads, NULL);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   std::string status_line = response->headers->GetStatusLine();
@@ skipping 73 matching lines @@
   const char* kExpectedResponseData[] = {
     "hello world", "welcome"
   };
 
   for (int i = 0; i < 2; ++i) {
     scoped_ptr<HttpTransaction> trans(
         new HttpNetworkTransaction(session, &session_deps.socket_factory));
 
     TestCompletionCallback callback;
 
-    int rv = trans->Start(&request[i], &callback);
+    int rv = trans->Start(NULL, &request[i], &callback);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_TRUE(response != NULL);
 
     EXPECT_TRUE(response->headers != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
@@ skipping 49 matching lines @@
     MockRead(false, OK),
   };
 
   StaticMockSocket data1(data_reads1, data_writes1);
   StaticMockSocket data2(data_reads2, data_writes2);
   session_deps.socket_factory.AddMockSocket(&data1);
   session_deps.socket_factory.AddMockSocket(&data2);
 
   TestCompletionCallback callback1;
 
-  int rv = trans->Start(&request, &callback1);
+  int rv = trans->Start(NULL, &request, &callback1);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
   TestCompletionCallback callback2;
   rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback2.WaitForResult();
@@ skipping 55 matching lines @@
       MockRead(false, OK),
     };
 
     StaticMockSocket data1(data_reads1, data_writes1);
     StaticMockSocket data2(data_reads2, data_writes2);
     session_deps.socket_factory.AddMockSocket(&data1);
     session_deps.socket_factory.AddMockSocket(&data2);
 
     TestCompletionCallback callback1;
 
-    int rv = trans->Start(&request, &callback1);
+    int rv = trans->Start(NULL, &request, &callback1);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_FALSE(response == NULL);
 
     // The password prompt info should have been set in
     // response->auth_challenge.
@@ skipping 63 matching lines @@
       MockRead(false, OK),
     };
 
     StaticMockSocket data1(data_reads1, data_writes1);
     StaticMockSocket data2(data_reads2, data_writes2);
     session_deps.socket_factory.AddMockSocket(&data1);
     session_deps.socket_factory.AddMockSocket(&data2);
 
     TestCompletionCallback callback1;
 
-    int rv = trans->Start(&request, &callback1);
+    int rv = trans->Start(NULL, &request, &callback1);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_FALSE(response == NULL);
 
     // The password prompt info should have been set in
     // response->auth_challenge.
@@ skipping 44 matching lines @@
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
       MockRead(false, OK),
     };
 
     StaticMockSocket data1(data_reads1, data_writes1);
     session_deps.socket_factory.AddMockSocket(&data1);
 
     TestCompletionCallback callback1;
 
-    int rv = trans->Start(&request, &callback1);
+    int rv = trans->Start(NULL, &request, &callback1);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_FALSE(response == NULL);
 
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
@@ skipping 40 matching lines @@
       MockRead(false, OK),
     };
 
     StaticMockSocket data1(data_reads1, data_writes1);
     StaticMockSocket data2(data_reads2, data_writes2);
     session_deps.socket_factory.AddMockSocket(&data1);
     session_deps.socket_factory.AddMockSocket(&data2);
 
     TestCompletionCallback callback1;
 
-    int rv = trans->Start(&request, &callback1);
+    int rv = trans->Start(NULL, &request, &callback1);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     EXPECT_TRUE(trans->IsReadyToRestartForAuth());
     TestCompletionCallback callback2;
     rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
     EXPECT_EQ(ERR_IO_PENDING, rv);
     rv = callback2.WaitForResult();
@@ skipping 66 matching lines @@
 
     StaticMockSocket data1(data_reads1, data_writes1);
     StaticMockSocket data2(data_reads2, data_writes2);
     StaticMockSocket data3(data_reads3, data_writes3);
     session_deps.socket_factory.AddMockSocket(&data1);
     session_deps.socket_factory.AddMockSocket(&data2);
     session_deps.socket_factory.AddMockSocket(&data3);
 
     TestCompletionCallback callback1;
 
-    int rv = trans->Start(&request, &callback1);
+    int rv = trans->Start(NULL, &request, &callback1);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     EXPECT_TRUE(trans->IsReadyToRestartForAuth());
     TestCompletionCallback callback2;
     rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
     EXPECT_EQ(ERR_IO_PENDING, rv);
     rv = callback2.WaitForResult();
@@ skipping 116 matching lines @@
   MockSSLSocket ssl_bad(true, ERR_CERT_AUTHORITY_INVALID);
   MockSSLSocket ssl(true, OK);
 
   session_deps.socket_factory.AddMockSocket(&ssl_bad_certificate);
   session_deps.socket_factory.AddMockSocket(&data);
   session_deps.socket_factory.AddMockSSLSocket(&ssl_bad);
   session_deps.socket_factory.AddMockSSLSocket(&ssl);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, rv);
 
   rv = trans->RestartIgnoringLastError(&callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
@@ skipping 55 matching lines @@
   TestCompletionCallback callback;
 
   for (int i = 0; i < 2; i++) {
     session_deps.socket_factory.ResetNextMockIndexes();
 
     scoped_ptr<HttpTransaction> trans(
         new HttpNetworkTransaction(
             CreateSession(&session_deps),
             &session_deps.socket_factory));
 
-    int rv = trans->Start(&request, &callback);
+    int rv = trans->Start(NULL, &request, &callback);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
     EXPECT_EQ(ERR_CERT_AUTHORITY_INVALID, rv);
 
     rv = trans->RestartIgnoringLastError(&callback);
     EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
     EXPECT_EQ(OK, rv);
@@ skipping 30 matching lines @@
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_Referer) {
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(
@@ skipping 19 matching lines @@
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_PostContentLengthZero) {
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(
@@ skipping 17 matching lines @@
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_PutContentLengthZero) {
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(
@@ skipping 17 matching lines @@
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_HeadContentLengthZero) {
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(
@@ skipping 17 matching lines @@
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_CacheControlNoCache) {
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(
@@ skipping 19 matching lines @@
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest,
        BuildRequest_CacheControlValidateCache) {
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
@@ skipping 19 matching lines @@
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, BuildRequest_ExtraHeaders) {
   SessionDependencies session_deps;
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(
@@ skipping 18 matching lines @@
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
     MockRead(false, OK),
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 }
 
 TEST_F(HttpNetworkTransactionTest, SOCKS4_HTTP_GET) {
   SessionDependencies session_deps;
   session_deps.proxy_service.reset(CreateFixedProxyService(
       "socks4://myproxy:1080"));
@@ skipping 24 matching lines @@
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n\r\n"),
     MockRead("Payload"),
     MockRead(false, OK)
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
@@ skipping 37 matching lines @@
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   MockSSLSocket ssl(true, OK);
   session_deps.socket_factory.AddMockSSLSocket(&ssl);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
@@ skipping 38 matching lines @@
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n\r\n"),
     MockRead("Payload"),
     MockRead(false, OK)
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
@@ skipping 42 matching lines @@
   };
 
   StaticMockSocket data(data_reads, data_writes);
   session_deps.socket_factory.AddMockSocket(&data);
 
   MockSSLSocket ssl(true, OK);
   session_deps.socket_factory.AddMockSSLSocket(&ssl);
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(OK, rv);
 
   const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   std::string response_text;
   rv = ReadTransaction(trans.get(), &response_text);
@@ skipping 59 matching lines @@
             &session_deps.socket_factory));
 
     HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL(tests[i].url);
     request.load_flags = 0;
 
     TestCompletionCallback callback;
 
     // We do not complete this request, the dtor will clean the transaction up.
-    EXPECT_EQ(ERR_IO_PENDING, trans->Start(&request, &callback));
+    EXPECT_EQ(ERR_IO_PENDING, trans->Start(NULL, &request, &callback));
     EXPECT_EQ(tests[i].expected_group_name,
               conn_pool->last_group_name_received());
   }
 }
 
 TEST_F(HttpNetworkTransactionTest, ReconsiderProxyAfterFailedConnection) {
   SessionDependencies session_deps(
       CreateFixedProxyService("myproxy:70;foobar:80"));
 
   session_deps.host_resolver->rules()->AddSimulatedFailure("*");
 
   scoped_ptr<HttpTransaction> trans(
       new HttpNetworkTransaction(
           CreateSession(&session_deps),
           &session_deps.socket_factory));
 
   HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
 
   TestCompletionCallback callback;
 
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 }
 
 // Host resolution observer used by
 // HttpNetworkTransactionTest.ResolveMadeWithReferrer to check that host
 // resovle requests are issued with a referrer of |expected_referrer|.
 class ResolutionReferrerObserver : public HostResolver::Observer {
@@ skipping 55 matching lines @@
   session_deps.socket_factory.AddMockSocket(&data);
 
   // Issue a request, containing an HTTP referrer.
   HttpRequestInfo request;
   request.method = "GET";
   request.referrer = referrer;
   request.url = GURL("http://www.google.com/");
 
   // Run the request until it fails reading from the socket.
   TestCompletionCallback callback;
-  int rv = trans->Start(&request, &callback);
+  int rv = trans->Start(NULL, &request, &callback);
   EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
   EXPECT_EQ(ERR_FAILED, rv);
 
   // Check that the host resolution observer saw |referrer|.
   EXPECT_TRUE(resolution_observer.did_complete_with_expected_referrer());
 }
 
 // Make sure that when the load flags contain LOAD_BYPASS_CACHE, the resolver's
 // host cache is bypassed.
 TEST_F(HttpNetworkTransactionTest, BypassHostCacheOnRefresh) {
   SessionDependencies session_deps;
 
   // Select a host resolver that does caching.
   session_deps.host_resolver = new MockCachingHostResolver;
 
   scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(&session_deps), &session_deps.socket_factory));
 
   // Warm up the host cache so it has an entry for "www.google.com" (by doing
   // a synchronous lookup.)
   AddressList addrlist;
   int rv = session_deps.host_resolver->Resolve(
-    HostResolver::RequestInfo("www.google.com", 80), &addrlist, NULL, NULL);
+      NULL, HostResolver::RequestInfo("www.google.com", 80), &addrlist,
+      NULL, NULL);
   EXPECT_EQ(OK, rv);
 
   // Verify that it was added to host cache, by doing a subsequent async lookup
   // and confirming it completes synchronously.
   TestCompletionCallback resolve_callback;
-  rv = session_deps.host_resolver->Resolve(
+  rv = session_deps.host_resolver->Resolve(NULL,
       HostResolver::RequestInfo("www.google.com", 80), &addrlist,
       &resolve_callback, NULL);
   ASSERT_EQ(OK, rv);
 
   // Inject a failure the next time that "www.google.com" is resolved. This way
   // we can tell if the next lookup hit the cache, or the "network".
   // (cache --> success, "network" --> failure).
   session_deps.host_resolver->rules()->AddSimulatedFailure("www.google.com");
 
   // Connect up a mock socket which will fail with ERR_UNEXPECTED during the
   // first read -- this won't be reached as the host resolution will fail first.
   MockRead data_reads[] = { MockRead(false, ERR_UNEXPECTED) };
   StaticMockSocket data(data_reads, NULL);
   session_deps.socket_factory.AddMockSocket(&data);
 
   // Issue a request, asking to bypass the cache(s).
   HttpRequestInfo request;
   request.method = "GET";
   request.load_flags = LOAD_BYPASS_CACHE;
   request.url = GURL("http://www.google.com/");
 
   // Run the request.
   TestCompletionCallback callback;
-  rv = trans->Start(&request, &callback);
+  rv = trans->Start(NULL, &request, &callback);
   ASSERT_EQ(ERR_IO_PENDING, rv);
   rv = callback.WaitForResult();
 
   // If we bypassed the cache, we would have gotten a failure while resolving
   // "www.google.com".
   EXPECT_EQ(ERR_NAME_NOT_RESOLVED, rv);
 }
 
 }  // namespace net