Refactor HttpNetworkTransaction to remove side effects in some member functions.

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/client_socket_factory.h"
 #include "net/base/completion_callback.h"
 #include "net/base/ssl_client_socket.h"
 #include "net/base/ssl_info.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_auth_handler_ntlm.h"
 #include "net/http/http_network_session.h"
 #include "net/http/http_network_transaction.h"
 #include "net/http/http_transaction_unittest.h"
 #include "net/proxy/proxy_config_service_fixed.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/platform_test.h"
 
 //-----------------------------------------------------------------------------
 
 namespace net {
 
-// TODO(eroman): Now that this is inside the net namespace, remove the redundant
-// net:: qualifiers.
-
 struct MockConnect {
   // Asynchronous connection success.
   MockConnect() : async(true), result(OK) { }
   MockConnect(bool a, int r) : async(a), result(r) { }
 
   bool async;
   int result;
 };
 
 struct MockRead {
@@ skipping 297 matching lines @@
       ClientSocket* transport_socket,
       const std::string& hostname,
       const SSLConfig& ssl_config) {
     return new MockSSLClientSocket(transport_socket, hostname, ssl_config);
   }
 };
 
 MockClientSocketFactory mock_socket_factory;
 
 // Create a proxy service which fails on all requests (falls back to direct).
-net::ProxyService* CreateNullProxyService() {
-  return net::ProxyService::CreateNull();
+ProxyService* CreateNullProxyService() {
+  return ProxyService::CreateNull();
 }
 
-net::ProxyService* CreateFixedProxyService(const std::string& proxy) {
-  net::ProxyInfo proxy_info;
+ProxyService* CreateFixedProxyService(const std::string& proxy) {
+  ProxyInfo proxy_info;
   proxy_info.UseNamedProxy(proxy);
-  return net::ProxyService::Create(&proxy_info);
+  return ProxyService::Create(&proxy_info);
 }
 
 
-net::HttpNetworkSession* CreateSession(net::ProxyService* proxy_service) {
-  return new net::HttpNetworkSession(proxy_service);
+HttpNetworkSession* CreateSession(ProxyService* proxy_service) {
+  return new HttpNetworkSession(proxy_service);
 }
 
 class HttpNetworkTransactionTest : public PlatformTest {
  public:
   virtual void SetUp() {
     PlatformTest::SetUp();
     mock_sockets[0] = NULL;
     mock_sockets_index = 0;
     mock_ssl_sockets_index = 0;
   }
@@ skipping 10 matching lines @@
 
 struct SimpleGetHelperResult {
   int rv;
   std::string status_line;
   std::string response_data;
 };
 
 SimpleGetHelperResult SimpleGetHelper(MockRead data_reads[]) {
   SimpleGetHelperResult out;
 
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockSocket data;
   data.reads = data_reads;
   mock_sockets[0] = &data;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   out.rv = callback.WaitForResult();
-  if (out.rv != net::OK)
+  if (out.rv != OK)
     return out;
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   out.status_line = response->headers->GetStatusLine();
 
   rv = ReadTransaction(trans.get(), &out.response_data);
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   return out;
 }
 
 // Fill |str| with a long header list that consumes >= |size| bytes.
 void FillLargeHeadersString(std::string* str, int size) {
   const char* row =
       "SomeHeaderName: xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx\r\n";
   const int sizeof_row = strlen(row);
   const int num_rows = static_cast<int>(
@@ skipping 31 matching lines @@
   }
 }
 
 std::string MockGetHostName() {
   return "WTC-WIN7";
 }
 
 //-----------------------------------------------------------------------------
 
 TEST_F(HttpNetworkTransactionTest, Basic) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 }
 
 TEST_F(HttpNetworkTransactionTest, SimpleGET) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),
     MockRead("hello world"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads);
-  EXPECT_EQ(net::OK, out.rv);
+  EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 200 OK", out.status_line);
   EXPECT_EQ("hello world", out.response_data);
 }
 
 // Response with no status line.
 TEST_F(HttpNetworkTransactionTest, SimpleGETNoHeaders) {
   MockRead data_reads[] = {
     MockRead("hello world"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads);
-  EXPECT_EQ(net::OK, out.rv);
+  EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/0.9 200 OK", out.status_line);
   EXPECT_EQ("hello world", out.response_data);
 }
 
 // Allow up to 4 bytes of junk to precede status line.
 TEST_F(HttpNetworkTransactionTest, StatusLineJunk2Bytes) {
   MockRead data_reads[] = {
     MockRead("xxxHTTP/1.0 404 Not Found\nServer: blah\n\nDATA"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads);
-  EXPECT_EQ(net::OK, out.rv);
+  EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 404 Not Found", out.status_line);
   EXPECT_EQ("DATA", out.response_data);
 }
 
 // Allow up to 4 bytes of junk to precede status line.
 TEST_F(HttpNetworkTransactionTest, StatusLineJunk4Bytes) {
   MockRead data_reads[] = {
     MockRead("\n\nQJHTTP/1.0 404 Not Found\nServer: blah\n\nDATA"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads);
-  EXPECT_EQ(net::OK, out.rv);
+  EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 404 Not Found", out.status_line);
   EXPECT_EQ("DATA", out.response_data);
 }
 
 // Beyond 4 bytes of slop and it should fail to find a status line.
 TEST_F(HttpNetworkTransactionTest, StatusLineJunk5Bytes) {
   MockRead data_reads[] = {
     MockRead("xxxxxHTTP/1.1 404 Not Found\nServer: blah"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads);
-  EXPECT_EQ(net::OK, out.rv);
+  EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/0.9 200 OK", out.status_line);
   EXPECT_EQ("xxxxxHTTP/1.1 404 Not Found\nServer: blah", out.response_data);
 }
 
 // Same as StatusLineJunk4Bytes, except the read chunks are smaller.
 TEST_F(HttpNetworkTransactionTest, StatusLineJunk4Bytes_Slow) {
   MockRead data_reads[] = {
     MockRead("\n"),
     MockRead("\n"),
     MockRead("Q"),
     MockRead("J"),
     MockRead("HTTP/1.0 404 Not Found\nServer: blah\n\nDATA"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads);
-  EXPECT_EQ(net::OK, out.rv);
+  EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.0 404 Not Found", out.status_line);
   EXPECT_EQ("DATA", out.response_data);
 }
 
 // Close the connection before enough bytes to have a status line.
 TEST_F(HttpNetworkTransactionTest, StatusLinePartial) {
   MockRead data_reads[] = {
     MockRead("HTT"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads);
-  EXPECT_EQ(net::OK, out.rv);
+  EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/0.9 200 OK", out.status_line);
   EXPECT_EQ("HTT", out.response_data);
 }
 
 // Simulate a 204 response, lacking a Content-Length header, sent over a
 // persistent connection.  The response should still terminate since a 204
 // cannot have a response body.
 TEST_F(HttpNetworkTransactionTest, StopsReading204) {
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 204 No Content\r\n\r\n"),
     MockRead("junk"),  // Should not be read!!
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads);
-  EXPECT_EQ(net::OK, out.rv);
+  EXPECT_EQ(OK, out.rv);
   EXPECT_EQ("HTTP/1.1 204 No Content", out.status_line);
   EXPECT_EQ("", out.response_data);
 }
 
 // Do a request using the HEAD method. Verify that we don't try to read the
 // message body (since HEAD has none).
 TEST_F(HttpNetworkTransactionTest, Head) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "HEAD";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockWrite data_writes1[] = {
     MockWrite("HEAD / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Content-Length: 0\r\n\r\n"),
   };
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 404 Not Found\r\n"),
     MockRead("Server: Blah\r\n"),
     MockRead("Content-Length: 1234\r\n\r\n"),
 
     // No response body because the test stops reading here.
-    MockRead(false, net::ERR_UNEXPECTED),  // Should not be reached.
+    MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   MockSocket data1;
   data1.reads = data_reads1;
   data1.writes = data_writes1;
   mock_sockets[0] = &data1;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   // Check that the headers got parsed.
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_EQ(1234, response->headers->GetContentLength());
   EXPECT_EQ("HTTP/1.1 404 Not Found", response->headers->GetStatusLine());
 
   std::string server_header;
   void* iter = NULL;
   bool has_server_header = response->headers->EnumerateHeader(
       &iter, "Server", &server_header);
   EXPECT_TRUE(has_server_header);
   EXPECT_EQ("Blah", server_header);
 
   // Reading should give EOF right away, since there is no message body
   // (despite non-zero content-length).
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
   EXPECT_EQ("", response_data);
 }
 
 TEST_F(HttpNetworkTransactionTest, ReuseConnection) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_refptr<net::HttpNetworkSession> session =
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_refptr<HttpNetworkSession> session =
       CreateSession(proxy_service.get());
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("hello"),
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("world"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   MockSocket data;
   data.reads = data_reads;
   mock_sockets[0] = &data;
   mock_sockets[1] = NULL;
 
   const char* kExpectedResponseData[] = {
     "hello", "world"
   };
 
   for (int i = 0; i < 2; ++i) {
-    scoped_ptr<net::HttpTransaction> trans(
-        new net::HttpNetworkTransaction(session, &mock_socket_factory));
+    scoped_ptr<HttpTransaction> trans(
+        new HttpNetworkTransaction(session, &mock_socket_factory));
 
-    net::HttpRequestInfo request;
+    HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/");
     request.load_flags = 0;
 
     TestCompletionCallback callback;
 
     int rv = trans->Start(&request, &callback);
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
 
-    const net::HttpResponseInfo* response = trans->GetResponseInfo();
+    const HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_TRUE(response != NULL);
 
     EXPECT_TRUE(response->headers != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
     rv = ReadTransaction(trans.get(), &response_data);
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
     EXPECT_EQ(kExpectedResponseData[i], response_data);
   }
 }
 
 TEST_F(HttpNetworkTransactionTest, Ignores100) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "POST";
   request.url = GURL("http://www.foo.com/");
-  request.upload_data = new net::UploadData;
+  request.upload_data = new UploadData;
   request.upload_data->AppendBytes("foo", 3);
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     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, net::OK),
+    MockRead(false, OK),
   };
   MockSocket data;
   data.reads = data_reads;
   mock_sockets[0] = &data;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
   EXPECT_EQ("hello world", response_data);
 }
 
 // This test is almost the same as Ignores100 above, but the response contains
 // a 102 instead of a 100. Also, instead of HTTP/1.0 the response is
 // HTTP/1.1.
 TEST_F(HttpNetworkTransactionTest, Ignores1xx) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     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, net::OK),
+    MockRead(false, OK),
   };
   MockSocket data;
   data.reads = data_reads;
   mock_sockets[0] = &data;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
   EXPECT_EQ("hello world", response_data);
 }
 
 // read_failure specifies a read failure that should cause the network
 // transaction to resend the request.
 void HttpNetworkTransactionTest::KeepAliveConnectionResendRequestTest(
     const MockRead& read_failure) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_refptr<net::HttpNetworkSession> session =
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_refptr<HttpNetworkSession> session =
       CreateSession(proxy_service.get());
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   MockRead data1_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("hello"),
     read_failure,  // Now, we reuse the connection and fail the first read.
   };
   MockSocket data1;
   data1.reads = data1_reads;
   mock_sockets[0] = &data1;
 
   MockRead data2_reads[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n"),
     MockRead("world"),
-    MockRead(true, net::OK),
+    MockRead(true, OK),
   };
   MockSocket data2;
   data2.reads = data2_reads;
   mock_sockets[1] = &data2;
 
   const char* kExpectedResponseData[] = {
     "hello", "world"
   };
 
   for (int i = 0; i < 2; ++i) {
     TestCompletionCallback callback;
 
-    scoped_ptr<net::HttpTransaction> trans(
-        new net::HttpNetworkTransaction(session, &mock_socket_factory));
+    scoped_ptr<HttpTransaction> trans(
+        new HttpNetworkTransaction(session, &mock_socket_factory));
 
     int rv = trans->Start(&request, &callback);
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
 
-    const net::HttpResponseInfo* response = trans->GetResponseInfo();
+    const HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_TRUE(response != NULL);
 
     EXPECT_TRUE(response->headers != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
     rv = ReadTransaction(trans.get(), &response_data);
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
     EXPECT_EQ(kExpectedResponseData[i], response_data);
   }
 }
 
 TEST_F(HttpNetworkTransactionTest, KeepAliveConnectionReset) {
-  MockRead read_failure(true, net::ERR_CONNECTION_RESET);
+  MockRead read_failure(true, ERR_CONNECTION_RESET);
   KeepAliveConnectionResendRequestTest(read_failure);
 }
 
 TEST_F(HttpNetworkTransactionTest, KeepAliveConnectionEOF) {
-  MockRead read_failure(false, net::OK);  // EOF
+  MockRead read_failure(false, OK);  // EOF
   KeepAliveConnectionResendRequestTest(read_failure);
 }
 
 TEST_F(HttpNetworkTransactionTest, NonKeepAliveConnectionReset) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
-    MockRead(true, net::ERR_CONNECTION_RESET),
+    MockRead(true, ERR_CONNECTION_RESET),
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),  // Should not be used
     MockRead("hello world"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   MockSocket data;
   data.reads = data_reads;
   mock_sockets[0] = &data;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
-  EXPECT_EQ(net::ERR_CONNECTION_RESET, rv);
+  EXPECT_EQ(ERR_CONNECTION_RESET, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 }
 
 // What do various browsers do when the server closes a non-keepalive
 // connection without sending any response header or body?
 //
 // IE7: error page
 // Safari 3.1.2 (Windows): error page
 // Firefox 3.0.1: blank page
 // Opera 9.52: after five attempts, blank page
-// Us with WinHTTP: error page (net::ERR_INVALID_RESPONSE)
-// Us: error page (net::EMPTY_RESPONSE)
+// Us with WinHTTP: error page (ERR_INVALID_RESPONSE)
+// Us: error page (EMPTY_RESPONSE)
 TEST_F(HttpNetworkTransactionTest, NonKeepAliveConnectionEOF) {
   MockRead data_reads[] = {
-    MockRead(false, net::OK),  // EOF
+    MockRead(false, OK),  // EOF
     MockRead("HTTP/1.0 200 OK\r\n\r\n"),  // Should not be used
     MockRead("hello world"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads);
-  EXPECT_EQ(net::ERR_EMPTY_RESPONSE, out.rv);
+  EXPECT_EQ(ERR_EMPTY_RESPONSE, out.rv);
 }
 
 // Test the request-challenge-retry sequence for basic auth.
 // (basic auth is the easiest to mock, because it has no randomness).
 TEST_F(HttpNetworkTransactionTest, BasicAuth) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockWrite data_writes1[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.0 401 Unauthorized\r\n"),
     // Give a couple authenticate options (only the middle one is actually
     // supported).
     MockRead("WWW-Authenticate: Basic\r\n"),  // Malformed
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("WWW-Authenticate: UNSUPPORTED realm=\"FOO\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     // Large content-length -- won't matter, as connection will be reset.
     MockRead("Content-Length: 10000\r\n\r\n"),
-    MockRead(false, net::ERR_FAILED),
+    MockRead(false, ERR_FAILED),
   };
 
   // After calling trans->RestartWithAuth(), this is the request we should
   // be issuing -- the final header line contains the credentials.
   MockWrite data_writes2[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
 
   // Lastly, the server responds with the actual content.
   MockRead data_reads2[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
 
   MockSocket data1;
   data1.reads = data_reads1;
   data1.writes = data_writes1;
   MockSocket data2;
   data2.reads = data_reads2;
   data2.writes = data_writes2;
   mock_sockets[0] = &data1;
   mock_sockets[1] = &data2;
   mock_sockets[2] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  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);
 
   // TODO(eroman): this should really include the effective port (80)
   EXPECT_EQ(L"www.google.com", response->auth_challenge->host);
   EXPECT_EQ(L"MyRealm1", response->auth_challenge->realm);
   EXPECT_EQ(L"basic", response->auth_challenge->scheme);
 
   TestCompletionCallback callback2;
 
   rv = trans->RestartWithAuth(L"foo", L"bar", &callback2);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
 
 // Test the request-challenge-retry sequence for basic auth, over a keep-alive
 // connection.
 TEST_F(HttpNetworkTransactionTest, BasicAuthKeepAlive) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockWrite data_writes1[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
 
     // After calling trans->RestartWithAuth(), this is the request we should
     // be issuing -- the final header line contains the credentials.
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 401 Unauthorized\r\n"),
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 14\r\n\r\n"),
     MockRead("Unauthorized\r\n"),
 
     // Lastly, the server responds with the actual content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
 
   MockSocket data1;
   data1.reads = data_reads1;
   data1.writes = data_writes1;
   mock_sockets[0] = &data1;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  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);
 
   // TODO(eroman): this should really include the effective port (80)
   EXPECT_EQ(L"www.google.com", response->auth_challenge->host);
   EXPECT_EQ(L"MyRealm1", response->auth_challenge->realm);
   EXPECT_EQ(L"basic", response->auth_challenge->scheme);
 
   TestCompletionCallback callback2;
 
   rv = trans->RestartWithAuth(L"foo", L"bar", &callback2);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
 
 // Test the request-challenge-retry sequence for basic auth, over a keep-alive
 // connection and with no response body to drain.
 TEST_F(HttpNetworkTransactionTest, BasicAuthKeepAliveNoBody) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockWrite data_writes1[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
 
     // After calling trans->RestartWithAuth(), this is the request we should
@@ skipping 11 matching lines @@
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 401 Unauthorized\r\n"),
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 0\r\n\r\n"),
 
     // Lastly, the server responds with the actual content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
 
   MockSocket data1;
   data1.reads = data_reads1;
   data1.writes = data_writes1;
   mock_sockets[0] = &data1;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  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);
 
   // TODO(eroman): this should really include the effective port (80)
   EXPECT_EQ(L"www.google.com", response->auth_challenge->host);
   EXPECT_EQ(L"MyRealm1", response->auth_challenge->realm);
   EXPECT_EQ(L"basic", response->auth_challenge->scheme);
 
   TestCompletionCallback callback2;
 
   rv = trans->RestartWithAuth(L"foo", L"bar", &callback2);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
 
 // Test the request-challenge-retry sequence for basic auth, over a keep-alive
 // connection and with a large response body to drain.
 TEST_F(HttpNetworkTransactionTest, BasicAuthKeepAliveLargeBody) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockWrite data_writes1[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
 
     // After calling trans->RestartWithAuth(), this is the request we should
@@ skipping 14 matching lines @@
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     // 5134 = 12 + 5 * 1024 + 2
     MockRead("Content-Length: 5134\r\n\r\n"),
     MockRead(true, large_body_string.data(), large_body_string.size()),
 
     // Lastly, the server responds with the actual content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
 
   MockSocket data1;
   data1.reads = data_reads1;
   data1.writes = data_writes1;
   mock_sockets[0] = &data1;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  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);
 
   // TODO(eroman): this should really include the effective port (80)
   EXPECT_EQ(L"www.google.com", response->auth_challenge->host);
   EXPECT_EQ(L"MyRealm1", response->auth_challenge->realm);
   EXPECT_EQ(L"basic", response->auth_challenge->scheme);
 
   TestCompletionCallback callback2;
 
   rv = trans->RestartWithAuth(L"foo", L"bar", &callback2);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
 
 // Test the request-challenge-retry sequence for basic auth, over a keep-alive
 // proxy connection, when setting up an SSL tunnel.
 TEST_F(HttpNetworkTransactionTest, BasicAuthProxyKeepAlive) {
   // Configure against proxy server "myproxy:70".
-  scoped_ptr<net::ProxyService> proxy_service(
+  scoped_ptr<ProxyService> proxy_service(
       CreateFixedProxyService("myproxy:70"));
 
-  scoped_refptr<net::HttpNetworkSession> session(
+  scoped_refptr<HttpNetworkSession> session(
       CreateSession(proxy_service.get()));
 
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       session.get(), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   // Since we have proxy, should try to establish tunnel.
   MockWrite data_writes1[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n\r\n"),
 
     // After calling trans->RestartWithAuth(), this is the request we should
@@ skipping 10 matching lines @@
     MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
     MockRead("0123456789"),
 
     // Wrong credentials (wrong password).
     MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
     // No response body because the test stops reading here.
-    MockRead(false, net::ERR_UNEXPECTED),  // Should not be reached.
+    MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   MockSocket data1;
   data1.writes = data_writes1;
   data1.reads = data_reads1;
   mock_sockets[0] = &data1;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_EQ(10, response->headers->GetContentLength());
-  EXPECT_TRUE(net::HttpVersion(1, 1) == response->headers->GetHttpVersion());
+  EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
 
   // The password prompt info should have been set in response->auth_challenge.
   EXPECT_FALSE(response->auth_challenge.get() == NULL);
 
   // TODO(eroman): this should really include the effective port (80)
   EXPECT_EQ(L"myproxy:70", response->auth_challenge->host);
   EXPECT_EQ(L"MyRealm1", response->auth_challenge->realm);
   EXPECT_EQ(L"basic", response->auth_challenge->scheme);
 
   TestCompletionCallback callback2;
 
   // Wrong password (should be "bar").
   rv = trans->RestartWithAuth(L"foo", L"baz", &callback2);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_EQ(10, response->headers->GetContentLength());
-  EXPECT_TRUE(net::HttpVersion(1, 1) == response->headers->GetHttpVersion());
+  EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
 
   // The password prompt info should have been set in response->auth_challenge.
   EXPECT_FALSE(response->auth_challenge.get() == NULL);
 
   // TODO(eroman): this should really include the effective port (80)
   EXPECT_EQ(L"myproxy:70", response->auth_challenge->host);
   EXPECT_EQ(L"MyRealm1", response->auth_challenge->realm);
   EXPECT_EQ(L"basic", response->auth_challenge->scheme);
 }
 
 // Test that we don't read the response body when we fail to establish a tunnel,
 // even if the user cancels the proxy's auth attempt.
 TEST_F(HttpNetworkTransactionTest, BasicAuthProxyCancelTunnel) {
   // Configure against proxy server "myproxy:70".
-  scoped_ptr<net::ProxyService> proxy_service(
+  scoped_ptr<ProxyService> proxy_service(
       CreateFixedProxyService("myproxy:70"));
 
-  scoped_refptr<net::HttpNetworkSession> session(
+  scoped_refptr<HttpNetworkSession> session(
       CreateSession(proxy_service.get()));
 
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       session.get(), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   // Since we have proxy, should try to establish tunnel.
   MockWrite data_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n\r\n"),
   };
 
   // The proxy responds to the connect with a 407.
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
-    MockRead(false, net::ERR_UNEXPECTED),  // Should not be reached.
+    MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   MockSocket data;
   data.writes = data_writes;
   data.reads = data_reads;
   mock_sockets[0] = &data;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   EXPECT_TRUE(response->headers->IsKeepAlive());
   EXPECT_EQ(407, response->headers->response_code());
   EXPECT_EQ(10, response->headers->GetContentLength());
-  EXPECT_TRUE(net::HttpVersion(1, 1) == response->headers->GetHttpVersion());
+  EXPECT_TRUE(HttpVersion(1, 1) == response->headers->GetHttpVersion());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
-  EXPECT_EQ(net::ERR_TUNNEL_CONNECTION_FAILED, rv);
+  EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 }
 
 static void ConnectStatusHelperWithExpectedStatus(
     const MockRead& status, int expected_status) {
   // Configure against proxy server "myproxy:70".
-  scoped_ptr<net::ProxyService> proxy_service(
+  scoped_ptr<ProxyService> proxy_service(
       CreateFixedProxyService("myproxy:70"));
 
-  scoped_refptr<net::HttpNetworkSession> session(
+  scoped_refptr<HttpNetworkSession> session(
       CreateSession(proxy_service.get()));
 
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       session.get(), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   // Since we have proxy, should try to establish tunnel.
   MockWrite data_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n\r\n"),
   };
 
   MockRead data_reads[] = {
     status,
     MockRead("Content-Length: 10\r\n\r\n"),
     // No response body because the test stops reading here.
-    MockRead(false, net::ERR_UNEXPECTED),  // Should not be reached.
+    MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   MockSocket data;
   data.writes = data_writes;
   data.reads = data_reads;
   mock_sockets[0] = &data;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(expected_status, rv);
 }
 
 static void ConnectStatusHelper(const MockRead& status) {
   ConnectStatusHelperWithExpectedStatus(
-      status, net::ERR_TUNNEL_CONNECTION_FAILED);
+      status, ERR_TUNNEL_CONNECTION_FAILED);
 }
 
 TEST_F(HttpNetworkTransactionTest, ConnectStatus100) {
   ConnectStatusHelper(MockRead("HTTP/1.1 100 Continue\r\n"));
 }
 
 TEST_F(HttpNetworkTransactionTest, ConnectStatus101) {
   ConnectStatusHelper(MockRead("HTTP/1.1 101 Switching Protocols\r\n"));
 }
 
@@ skipping 78 matching lines @@
   ConnectStatusHelper(MockRead("HTTP/1.1 405 Method Not Allowed\r\n"));
 }
 
 TEST_F(HttpNetworkTransactionTest, ConnectStatus406) {
   ConnectStatusHelper(MockRead("HTTP/1.1 406 Not Acceptable\r\n"));
 }
 
 TEST_F(HttpNetworkTransactionTest, ConnectStatus407) {
   ConnectStatusHelperWithExpectedStatus(
       MockRead("HTTP/1.1 407 Proxy Authentication Required\r\n"),
-      net::ERR_PROXY_AUTH_REQUESTED);
+      ERR_PROXY_AUTH_REQUESTED);
 }
 
 TEST_F(HttpNetworkTransactionTest, ConnectStatus408) {
   ConnectStatusHelper(MockRead("HTTP/1.1 408 Request Timeout\r\n"));
 }
 
 TEST_F(HttpNetworkTransactionTest, ConnectStatus409) {
   ConnectStatusHelper(MockRead("HTTP/1.1 409 Conflict\r\n"));
 }
 
@@ skipping 51 matching lines @@
 }
 
 TEST_F(HttpNetworkTransactionTest, ConnectStatus505) {
   ConnectStatusHelper(MockRead("HTTP/1.1 505 HTTP Version Not Supported\r\n"));
 }
 
 // Test the flow when both the proxy server AND origin server require
 // authentication. Again, this uses basic auth for both since that is
 // the simplest to mock.
 TEST_F(HttpNetworkTransactionTest, BasicAuthProxyThenServer) {
-  scoped_ptr<net::ProxyService> proxy_service(
+  scoped_ptr<ProxyService> proxy_service(
       CreateFixedProxyService("myproxy:70"));
 
   // Configure against proxy server "myproxy:70".
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()),
       &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockWrite data_writes1[] = {
     MockWrite("GET http://www.google.com/ HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.0 407 Unauthorized\r\n"),
     // Give a couple authenticate options (only the middle one is actually
     // supported).
     MockRead("Proxy-Authenticate: Basic\r\n"),  // Malformed
     MockRead("Proxy-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Proxy-Authenticate: UNSUPPORTED realm=\"FOO\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     // Large content-length -- won't matter, as connection will be reset.
     MockRead("Content-Length: 10000\r\n\r\n"),
-    MockRead(false, net::ERR_FAILED),
+    MockRead(false, ERR_FAILED),
   };
 
   // After calling trans->RestartWithAuth() the first time, this is the
   // request we should be issuing -- the final header line contains the
   // proxy's credentials.
   MockWrite data_writes2[] = {
     MockWrite("GET http://www.google.com/ HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n"
               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
 
   // Now the proxy server lets the request pass through to origin server.
   // The origin server responds with a 401.
   MockRead data_reads2[] = {
     MockRead("HTTP/1.0 401 Unauthorized\r\n"),
     // Note: We are using the same realm-name as the proxy server. This is
     // completely valid, as realms are unique across hosts.
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 2000\r\n\r\n"),
-    MockRead(false, net::ERR_FAILED),  // Won't be reached.
+    MockRead(false, ERR_FAILED),  // Won't be reached.
   };
 
   // After calling trans->RestartWithAuth() the second time, we should send
   // the credentials for both the proxy and origin server.
   MockWrite data_writes3[] = {
     MockWrite("GET http://www.google.com/ HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Proxy-Connection: keep-alive\r\n"
               "Proxy-Authorization: Basic Zm9vOmJhcg==\r\n"
               "Authorization: Basic Zm9vMjpiYXIy\r\n\r\n"),
   };
 
   // Lastly we get the desired content.
   MockRead data_reads3[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
 
   MockSocket data1;
   data1.reads = data_reads1;
   data1.writes = data_writes1;
   MockSocket data2;
   data2.reads = data_reads2;
   data2.writes = data_writes2;
   MockSocket data3;
   data3.reads = data_reads3;
   data3.writes = data_writes3;
   mock_sockets[0] = &data1;
   mock_sockets[1] = &data2;
   mock_sockets[2] = &data3;
   mock_sockets[3] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  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);
 
   EXPECT_EQ(L"myproxy:70", response->auth_challenge->host);
   EXPECT_EQ(L"MyRealm1", response->auth_challenge->realm);
   EXPECT_EQ(L"basic", response->auth_challenge->scheme);
 
   TestCompletionCallback callback2;
 
   rv = trans->RestartWithAuth(L"foo", L"bar", &callback2);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback2.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
   EXPECT_FALSE(response->auth_challenge.get() == NULL);
 
   // TODO(eroman): this should really include the effective port (80)
   EXPECT_EQ(L"www.google.com", response->auth_challenge->host);
   EXPECT_EQ(L"MyRealm1", response->auth_challenge->realm);
   EXPECT_EQ(L"basic", response->auth_challenge->scheme);
 
   TestCompletionCallback callback3;
 
   rv = trans->RestartWithAuth(L"foo2", L"bar2", &callback3);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback3.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(100, response->headers->GetContentLength());
 }
 
 // The NTLM authentication unit tests were generated by capturing the HTTP
 // requests and responses using Fiddler 2 and inspecting the generated random
 // bytes in the debugger.
 
 // Enter the correct password and authenticate successfully.
 TEST_F(HttpNetworkTransactionTest, NTLMAuth1) {
-  net::HttpAuthHandlerNTLM::ScopedProcSetter proc_setter(MockGenerateRandom1,
+  HttpAuthHandlerNTLM::ScopedProcSetter proc_setter(MockGenerateRandom1,
                                                          MockGetHostName);
 
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://172.22.68.17/kids/login.aspx");
   request.load_flags = 0;
 
   MockWrite data_writes1[] = {
     MockWrite("GET /kids/login.aspx HTTP/1.1\r\n"
               "Host: 172.22.68.17\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 401 Access Denied\r\n"),
     // Negotiate and NTLM are often requested together.  We only support NTLM.
     MockRead("WWW-Authenticate: Negotiate\r\n"),
     MockRead("WWW-Authenticate: NTLM\r\n"),
     MockRead("Connection: close\r\n"),
     MockRead("Content-Length: 42\r\n"),
     MockRead("Content-Type: text/html\r\n\r\n"),
     // Missing content -- won't matter, as connection will be reset.
-    MockRead(false, net::ERR_UNEXPECTED),
+    MockRead(false, ERR_UNEXPECTED),
   };
 
   MockWrite data_writes2[] = {
     // After restarting with a null identity, this is the
     // request we should be issuing -- the final header line contains a Type
     // 1 message.
     MockWrite("GET /kids/login.aspx HTTP/1.1\r\n"
               "Host: 172.22.68.17\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: NTLM "
@@ skipping 25 matching lines @@
              "BtAAAAAAA=\r\n"),
     MockRead("Content-Length: 42\r\n"),
     MockRead("Content-Type: text/html\r\n\r\n"),
     MockRead("You are not authorized to view this page\r\n"),
 
     // Lastly we get the desired content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=utf-8\r\n"),
     MockRead("Content-Length: 13\r\n\r\n"),
     MockRead("Please Login\r\n"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
 
   MockSocket data1;
   data1.reads = data_reads1;
   data1.writes = data_writes1;
   MockSocket data2;
   data2.reads = data_reads2;
   data2.writes = data_writes2;
   mock_sockets[0] = &data1;
   mock_sockets[1] = &data2;
   mock_sockets[2] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
   TestCompletionCallback callback2;
   rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback2.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
   EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  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);
 
   // TODO(eroman): this should really include the effective port (80)
   EXPECT_EQ(L"172.22.68.17", response->auth_challenge->host);
   EXPECT_EQ(L"", response->auth_challenge->realm);
   EXPECT_EQ(L"ntlm", response->auth_challenge->scheme);
 
   TestCompletionCallback callback3;
 
   rv = trans->RestartWithAuth(L"testing-ntlm", L"testing-ntlm", &callback3);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback3.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(13, response->headers->GetContentLength());
 }
 
 // Enter a wrong password, and then the correct one.
 TEST_F(HttpNetworkTransactionTest, NTLMAuth2) {
-  net::HttpAuthHandlerNTLM::ScopedProcSetter proc_setter(MockGenerateRandom2,
+  HttpAuthHandlerNTLM::ScopedProcSetter proc_setter(MockGenerateRandom2,
                                                          MockGetHostName);
 
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://172.22.68.17/kids/login.aspx");
   request.load_flags = 0;
 
   MockWrite data_writes1[] = {
     MockWrite("GET /kids/login.aspx HTTP/1.1\r\n"
               "Host: 172.22.68.17\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 401 Access Denied\r\n"),
     // Negotiate and NTLM are often requested together.  We only support NTLM.
     MockRead("WWW-Authenticate: Negotiate\r\n"),
     MockRead("WWW-Authenticate: NTLM\r\n"),
     MockRead("Connection: close\r\n"),
     MockRead("Content-Length: 42\r\n"),
     MockRead("Content-Type: text/html\r\n\r\n"),
     // Missing content -- won't matter, as connection will be reset.
-    MockRead(false, net::ERR_UNEXPECTED),
+    MockRead(false, ERR_UNEXPECTED),
   };
 
   MockWrite data_writes2[] = {
     // After restarting with a null identity, this is the
     // request we should be issuing -- the final header line contains a Type
     // 1 message.
     MockWrite("GET /kids/login.aspx HTTP/1.1\r\n"
               "Host: 172.22.68.17\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: NTLM "
@@ skipping 28 matching lines @@
     MockRead("You are not authorized to view this page\r\n"),
 
     // Wrong password.
     MockRead("HTTP/1.1 401 Access Denied\r\n"),
     MockRead("WWW-Authenticate: Negotiate\r\n"),
     MockRead("WWW-Authenticate: NTLM\r\n"),
     MockRead("Connection: close\r\n"),
     MockRead("Content-Length: 42\r\n"),
     MockRead("Content-Type: text/html\r\n\r\n"),
     // Missing content -- won't matter, as connection will be reset.
-    MockRead(false, net::ERR_UNEXPECTED),
+    MockRead(false, ERR_UNEXPECTED),
   };
 
   MockWrite data_writes3[] = {
     // After restarting with a null identity, this is the
     // request we should be issuing -- the final header line contains a Type
     // 1 message.
     MockWrite("GET /kids/login.aspx HTTP/1.1\r\n"
               "Host: 172.22.68.17\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: NTLM "
@@ skipping 25 matching lines @@
              "BtAAAAAAA=\r\n"),
     MockRead("Content-Length: 42\r\n"),
     MockRead("Content-Type: text/html\r\n\r\n"),
     MockRead("You are not authorized to view this page\r\n"),
 
     // Lastly we get the desired content.
     MockRead("HTTP/1.1 200 OK\r\n"),
     MockRead("Content-Type: text/html; charset=utf-8\r\n"),
     MockRead("Content-Length: 13\r\n\r\n"),
     MockRead("Please Login\r\n"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
 
   MockSocket data1;
   data1.reads = data_reads1;
   data1.writes = data_writes1;
   MockSocket data2;
   data2.reads = data_reads2;
   data2.writes = data_writes2;
   MockSocket data3;
   data3.reads = data_reads3;
   data3.writes = data_writes3;
   mock_sockets[0] = &data1;
   mock_sockets[1] = &data2;
   mock_sockets[2] = &data3;
   mock_sockets[3] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
   TestCompletionCallback callback2;
   rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback2.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
   EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  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);
 
   // TODO(eroman): this should really include the effective port (80)
   EXPECT_EQ(L"172.22.68.17", response->auth_challenge->host);
   EXPECT_EQ(L"", response->auth_challenge->realm);
   EXPECT_EQ(L"ntlm", response->auth_challenge->scheme);
 
   TestCompletionCallback callback3;
 
   // Enter the wrong password.
   rv = trans->RestartWithAuth(L"testing-ntlm", L"wrongpassword", &callback3);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback3.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
   TestCompletionCallback callback4;
   rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback4);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback4.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
   EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
   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);
 
   // TODO(eroman): this should really include the effective port (80)
   EXPECT_EQ(L"172.22.68.17", response->auth_challenge->host);
   EXPECT_EQ(L"", response->auth_challenge->realm);
   EXPECT_EQ(L"ntlm", response->auth_challenge->scheme);
 
   TestCompletionCallback callback5;
 
   // Now enter the right password.
   rv = trans->RestartWithAuth(L"testing-ntlm", L"testing-ntlm", &callback5);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback5.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   response = trans->GetResponseInfo();
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
   EXPECT_EQ(13, response->headers->GetContentLength());
 }
 
 // Test reading a server response which has only headers, and no body.
 // After some maximum number of bytes is consumed, the transaction should
 // fail with ERR_RESPONSE_HEADERS_TOO_BIG.
 TEST_F(HttpNetworkTransactionTest, LargeHeadersNoBody) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   // Respond with 50 kb of headers (we should fail after 32 kb).
   std::string large_headers_string;
   FillLargeHeadersString(&large_headers_string, 50 * 1024);
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead(true, large_headers_string.data(), large_headers_string.size()),
     MockRead("\r\nBODY"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   MockSocket data;
   data.reads = data_reads;
   mock_sockets[0] = &data;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
-  EXPECT_EQ(net::ERR_RESPONSE_HEADERS_TOO_BIG, rv);
+  EXPECT_EQ(ERR_RESPONSE_HEADERS_TOO_BIG, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response == NULL);
 }
 
 // Make sure that we don't try to reuse a TCPClientSocket when failing to
 // establish tunnel.
 // http://code.google.com/p/chromium/issues/detail?id=3772
 TEST_F(HttpNetworkTransactionTest, DontRecycleTCPSocketForSSLTunnel) {
   // Configure against proxy server "myproxy:70".
-  scoped_ptr<net::ProxyService> proxy_service(
+  scoped_ptr<ProxyService> proxy_service(
       CreateFixedProxyService("myproxy:70"));
 
-  scoped_refptr<net::HttpNetworkSession> session(
+  scoped_refptr<HttpNetworkSession> session(
       CreateSession(proxy_service.get()));
 
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       session.get(), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   // Since we have proxy, should try to establish tunnel.
   MockWrite data_writes1[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n\r\n"),
   };
 
   // The proxy responds to the connect with a 404, using a persistent
   // connection. Usually a proxy would return 501 (not implemented),
   // or 200 (tunnel established).
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 404 Not Found\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
-    MockRead(false, net::ERR_UNEXPECTED),  // Should not be reached.
+    MockRead(false, ERR_UNEXPECTED),  // Should not be reached.
   };
 
   MockSocket data1;
   data1.writes = data_writes1;
   data1.reads = data_reads1;
   mock_sockets[0] = &data1;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
-  EXPECT_EQ(net::ERR_TUNNEL_CONNECTION_FAILED, rv);
+  EXPECT_EQ(ERR_TUNNEL_CONNECTION_FAILED, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  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.
   MessageLoop::current()->RunAllPending();
 
   // We now check to make sure the TCPClientSocket was not added back to
   // the pool.
   EXPECT_EQ(0, session->connection_pool()->idle_socket_count());
   trans.reset();
   MessageLoop::current()->RunAllPending();
   // Make sure that the socket didn't get recycled after calling the destructor.
   EXPECT_EQ(0, session->connection_pool()->idle_socket_count());
 }
 
 // Make sure that we recycle a socket after reading all of the response body.
 TEST_F(HttpNetworkTransactionTest, RecycleSocket) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_refptr<net::HttpNetworkSession> session(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_refptr<HttpNetworkSession> session(
       CreateSession(proxy_service.get()));
 
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       session.get(), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     // A part of the response body is received with the response headers.
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 11\r\n\r\nhel"),
     // The rest of the response body is received in two parts.
     MockRead("lo"),
     MockRead(" world"),
     MockRead("junk"),  // Should not be read!!
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
 
   MockSocket data;
   data.reads = data_reads;
   mock_sockets[0] = &data;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   std::string status_line = response->headers->GetStatusLine();
   EXPECT_EQ("HTTP/1.1 200 OK", status_line);
 
   EXPECT_EQ(0, session->connection_pool()->idle_socket_count());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
   EXPECT_EQ("hello world", response_data);
 
   // Empty the current queue.  This is necessary because idle sockets are
   // added to the connection pool asynchronously with a PostTask.
   MessageLoop::current()->RunAllPending();
 
   // We now check to make sure the socket was added back to the pool.
   EXPECT_EQ(1, session->connection_pool()->idle_socket_count());
 }
 
 // Make sure that we recycle a socket after a zero-length response.
 // http://crbug.com/9880
 TEST_F(HttpNetworkTransactionTest, RecycleSocketAfterZeroContentLength) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_refptr<net::HttpNetworkSession> session(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_refptr<HttpNetworkSession> session(
       CreateSession(proxy_service.get()));
 
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       session.get(), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.google.com/csi?v=3&s=web&action=&"
                      "tran=undefined&ei=mAXcSeegAo-SMurloeUN&"
                      "e=17259,18167,19592,19773,19981,20133,20173,20233&"
                      "rt=prt.2642,ol.2649,xjs.2951");
   request.load_flags = 0;
 
   MockRead data_reads[] = {
     MockRead("HTTP/1.1 204 No Content\r\n"
              "Content-Length: 0\r\n"
              "Content-Type: text/html\r\n\r\n"),
     MockRead("junk"),  // Should not be read!!
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
 
   MockSocket data;
   data.reads = data_reads;
   mock_sockets[0] = &data;
   mock_sockets[1] = NULL;
 
   TestCompletionCallback callback;
 
   int rv = trans->Start(&request, &callback);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
   std::string status_line = response->headers->GetStatusLine();
   EXPECT_EQ("HTTP/1.1 204 No Content", status_line);
 
   EXPECT_EQ(0, session->connection_pool()->idle_socket_count());
 
   std::string response_data;
   rv = ReadTransaction(trans.get(), &response_data);
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
   EXPECT_EQ("", response_data);
 
   // Empty the current queue.  This is necessary because idle sockets are
   // added to the connection pool asynchronously with a PostTask.
   MessageLoop::current()->RunAllPending();
 
   // We now check to make sure the socket was added back to the pool.
   EXPECT_EQ(1, session->connection_pool()->idle_socket_count());
 }
 
 TEST_F(HttpNetworkTransactionTest, ResendRequestOnWriteBodyError) {
-  net::HttpRequestInfo request[2];
+  HttpRequestInfo request[2];
   // Transaction 1: a GET request that succeeds.  The socket is recycled
   // after use.
   request[0].method = "GET";
   request[0].url = GURL("http://www.google.com/");
   request[0].load_flags = 0;
   // Transaction 2: a POST request.  Reuses the socket kept alive from
   // transaction 1.  The first attempts fails when writing the POST data.
   // This causes the transaction to retry with a new socket.  The second
   // attempt succeeds.
   request[1].method = "POST";
   request[1].url = GURL("http://www.google.com/login.cgi");
-  request[1].upload_data = new net::UploadData;
+  request[1].upload_data = new UploadData;
   request[1].upload_data->AppendBytes("foo", 3);
   request[1].load_flags = 0;
 
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_refptr<net::HttpNetworkSession> session =
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_refptr<HttpNetworkSession> session =
       CreateSession(proxy_service.get());
 
   // The first socket is used for transaction 1 and the first attempt of
   // transaction 2.
 
   // The response of transaction 1.
   MockRead data_reads1[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 11\r\n\r\n"),
     MockRead("hello world"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   // The mock write results of transaction 1 and the first attempt of
   // transaction 2.
   MockWrite data_writes1[] = {
     MockWrite(false, 64),  // GET
     MockWrite(false, 93),  // POST
-    MockWrite(false, net::ERR_CONNECTION_ABORTED),  // POST data
+    MockWrite(false, ERR_CONNECTION_ABORTED),  // POST data
   };
   MockSocket data1;
   data1.reads = data_reads1;
   data1.writes = data_writes1;
 
   // The second socket is used for the second attempt of transaction 2.
 
   // The response of transaction 2.
   MockRead data_reads2[] = {
     MockRead("HTTP/1.1 200 OK\r\nContent-Length: 7\r\n\r\n"),
     MockRead("welcome"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
   // The mock write results of the second attempt of transaction 2.
   MockWrite data_writes2[] = {
     MockWrite(false, 93),  // POST
     MockWrite(false, 3),  // POST data
   };
   MockSocket data2;
   data2.reads = data_reads2;
   data2.writes = data_writes2;
 
   mock_sockets[0] = &data1;
   mock_sockets[1] = &data2;
   mock_sockets[2] = NULL;
 
   const char* kExpectedResponseData[] = {
     "hello world", "welcome"
   };
 
   for (int i = 0; i < 2; ++i) {
-    scoped_ptr<net::HttpTransaction> trans(
-        new net::HttpNetworkTransaction(session, &mock_socket_factory));
+    scoped_ptr<HttpTransaction> trans(
+        new HttpNetworkTransaction(session, &mock_socket_factory));
 
     TestCompletionCallback callback;
 
     int rv = trans->Start(&request[i], &callback);
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
 
-    const net::HttpResponseInfo* response = trans->GetResponseInfo();
+    const HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_TRUE(response != NULL);
 
     EXPECT_TRUE(response->headers != NULL);
     EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
     rv = ReadTransaction(trans.get(), &response_data);
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
     EXPECT_EQ(kExpectedResponseData[i], response_data);
   }
 }
 
 // Test the request-challenge-retry sequence for basic auth when there is
 // an identity in the URL. The request should be sent as normal, but when
 // it fails the identity from the URL is used to answer the challenge.
 TEST_F(HttpNetworkTransactionTest, AuthIdentityInUrl) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
       CreateSession(proxy_service.get()), &mock_socket_factory));
 
-  net::HttpRequestInfo request;
+  HttpRequestInfo request;
   request.method = "GET";
   // Note: the URL has a username:password in it.
   request.url = GURL("http://foo:bar@www.google.com/");
   request.load_flags = 0;
 
   MockWrite data_writes1[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
   MockRead data_reads1[] = {
     MockRead("HTTP/1.0 401 Unauthorized\r\n"),
     MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
     MockRead("Content-Length: 10\r\n\r\n"),
-    MockRead(false, net::ERR_FAILED),
+    MockRead(false, ERR_FAILED),
   };
 
   // After the challenge above, the transaction will be restarted using the
   // identity from the url (foo, bar) to answer the challenge.
   MockWrite data_writes2[] = {
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n"
               "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
   };
 
   MockRead data_reads2[] = {
     MockRead("HTTP/1.0 200 OK\r\n"),
     MockRead("Content-Length: 100\r\n\r\n"),
-    MockRead(false, net::OK),
+    MockRead(false, OK),
   };
 
   MockSocket data1;
   data1.reads = data_reads1;
   data1.writes = data_writes1;
   MockSocket data2;
   data2.reads = data_reads2;
   data2.writes = data_writes2;
   mock_sockets[0] = &data1;
   mock_sockets[1] = &data2;
   mock_sockets[2] = NULL;
 
   TestCompletionCallback callback1;
 
   int rv = trans->Start(&request, &callback1);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
 
   rv = callback1.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
 
   EXPECT_TRUE(trans->IsReadyToRestartForAuth());
   TestCompletionCallback callback2;
   rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
-  EXPECT_EQ(net::ERR_IO_PENDING, rv);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
   rv = callback2.WaitForResult();
-  EXPECT_EQ(net::OK, rv);
+  EXPECT_EQ(OK, rv);
   EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
-  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  const HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_FALSE(response == NULL);
 
   // There is no challenge info, since the identity in URL worked.
   EXPECT_TRUE(response->auth_challenge.get() == NULL);
 
   EXPECT_EQ(100, response->headers->GetContentLength());
 
   // Empty the current queue.
   MessageLoop::current()->RunAllPending();
 }
 
 // Test that previously tried username/passwords for a realm get re-used.
 TEST_F(HttpNetworkTransactionTest, BasicAuthCacheAndPreauth) {
-  scoped_ptr<net::ProxyService> proxy_service(CreateNullProxyService());
-  scoped_refptr<net::HttpNetworkSession> session =
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_refptr<HttpNetworkSession> session =
       CreateSession(proxy_service.get());
 
   // Transaction 1: authenticate (foo, bar) on MyRealm1
   {
-    scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+    scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
         session, &mock_socket_factory));
 
-    net::HttpRequestInfo request;
+    HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/x/y/z");
     request.load_flags = 0;
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/z HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n\r\n"),
     };
 
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 401 Unauthorized\r\n"),
       MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
       MockRead("Content-Length: 10000\r\n\r\n"),
-      MockRead(false, net::ERR_FAILED),
+      MockRead(false, ERR_FAILED),
     };
 
     // Resend with authorization (username=foo, password=bar)
     MockWrite data_writes2[] = {
       MockWrite("GET /x/y/z HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n"
                 "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads2[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
-      MockRead(false, net::OK),
+      MockRead(false, OK),
     };
 
     MockSocket data1;
     data1.reads = data_reads1;
     data1.writes = data_writes1;
     MockSocket data2;
     data2.reads = data_reads2;
     data2.writes = data_writes2;
     mock_sockets_index = 0;
     mock_sockets[0] = &data1;
     mock_sockets[1] = &data2;
     mock_sockets[2] = NULL;
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, &callback1);
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
 
-    const net::HttpResponseInfo* response = trans->GetResponseInfo();
+    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);
 
     // TODO(eroman): this should really include the effective port (80)
     EXPECT_EQ(L"www.google.com", response->auth_challenge->host);
     EXPECT_EQ(L"MyRealm1", response->auth_challenge->realm);
     EXPECT_EQ(L"basic", response->auth_challenge->scheme);
 
     TestCompletionCallback callback2;
 
     rv = trans->RestartWithAuth(L"foo", L"bar", &callback2);
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback2.WaitForResult();
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
 
     response = trans->GetResponseInfo();
     EXPECT_FALSE(response == NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 
   // ------------------------------------------------------------------------
 
   // Transaction 2: authenticate (foo2, bar2) on MyRealm2
   {
-    scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+    scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
         session, &mock_socket_factory));
 
-    net::HttpRequestInfo request;
+    HttpRequestInfo request;
     request.method = "GET";
     // Note that Transaction 1 was at /x/y/z, so this is in the same
     // protection space as MyRealm1.
     request.url = GURL("http://www.google.com/x/y/a/b");
     request.load_flags = 0;
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/a/b HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n"
                 // Send preemptive authorization for MyRealm1
                 "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     };
 
     // The server didn't like the preemptive authorization, and
     // challenges us for a different realm (MyRealm2).
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 401 Unauthorized\r\n"),
       MockRead("WWW-Authenticate: Basic realm=\"MyRealm2\"\r\n"),
       MockRead("Content-Length: 10000\r\n\r\n"),
-      MockRead(false, net::ERR_FAILED),
+      MockRead(false, ERR_FAILED),
     };
 
     // Resend with authorization for MyRealm2 (username=foo2, password=bar2)
     MockWrite data_writes2[] = {
       MockWrite("GET /x/y/a/b HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n"
                 "Authorization: Basic Zm9vMjpiYXIy\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads2[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
-      MockRead(false, net::OK),
+      MockRead(false, OK),
     };
 
     MockSocket data1;
     data1.reads = data_reads1;
     data1.writes = data_writes1;
     MockSocket data2;
     data2.reads = data_reads2;
     data2.writes = data_writes2;
     mock_sockets_index = 0;
     mock_sockets[0] = &data1;
     mock_sockets[1] = &data2;
     mock_sockets[2] = NULL;
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, &callback1);
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
 
-    const net::HttpResponseInfo* response = trans->GetResponseInfo();
+    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);
 
     // TODO(eroman): this should really include the effective port (80)
     EXPECT_EQ(L"www.google.com", response->auth_challenge->host);
     EXPECT_EQ(L"MyRealm2", response->auth_challenge->realm);
     EXPECT_EQ(L"basic", response->auth_challenge->scheme);
 
     TestCompletionCallback callback2;
 
     rv = trans->RestartWithAuth(L"foo2", L"bar2", &callback2);
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback2.WaitForResult();
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
 
     response = trans->GetResponseInfo();
     EXPECT_FALSE(response == NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 
   // ------------------------------------------------------------------------
 
   // Transaction 3: Resend a request in MyRealm's protection space --
   // succeed with preemptive authorization.
   {
-    scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+    scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
         session, &mock_socket_factory));
 
-    net::HttpRequestInfo request;
+    HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/x/y/z2");
     request.load_flags = 0;
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/y/z2 HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n"
                 // The authorization for MyRealm1 gets sent preemptively
                 // (since the url is in the same protection space)
                 "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     };
 
     // Sever accepts the preemptive authorization
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
-      MockRead(false, net::OK),
+      MockRead(false, OK),
     };
 
     MockSocket data1;
     data1.reads = data_reads1;
     data1.writes = data_writes1;
     mock_sockets_index = 0;
     mock_sockets[0] = &data1;
     mock_sockets[1] = NULL;
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, &callback1);
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
 
-    const net::HttpResponseInfo* response = trans->GetResponseInfo();
+    const HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_FALSE(response == NULL);
 
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 
   // ------------------------------------------------------------------------
 
   // Transaction 4: request another URL in MyRealm (however the
   // url is not known to belong to the protection space, so no pre-auth).
   {
-    scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+    scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
         session, &mock_socket_factory));
 
-    net::HttpRequestInfo request;
+    HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/x/1");
     request.load_flags = 0;
 
     MockWrite data_writes1[] = {
       MockWrite("GET /x/1 HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n\r\n"),
     };
 
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 401 Unauthorized\r\n"),
       MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
       MockRead("Content-Length: 10000\r\n\r\n"),
-      MockRead(false, net::ERR_FAILED),
+      MockRead(false, ERR_FAILED),
     };
 
     // Resend with authorization from MyRealm's cache.
     MockWrite data_writes2[] = {
       MockWrite("GET /x/1 HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n"
                 "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads2[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
-      MockRead(false, net::OK),
+      MockRead(false, OK),
     };
 
     MockSocket data1;
     data1.reads = data_reads1;
     data1.writes = data_writes1;
     MockSocket data2;
     data2.reads = data_reads2;
     data2.writes = data_writes2;
     mock_sockets_index = 0;
     mock_sockets[0] = &data1;
     mock_sockets[1] = &data2;
     mock_sockets[2] = NULL;
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, &callback1);
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
 
     EXPECT_TRUE(trans->IsReadyToRestartForAuth());
     TestCompletionCallback callback2;
     rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
     rv = callback2.WaitForResult();
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
     EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
-    const net::HttpResponseInfo* response = trans->GetResponseInfo();
+    const HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_FALSE(response == NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 
   // ------------------------------------------------------------------------
 
   // Transaction 5: request a URL in MyRealm, but the server rejects the
   // cached identity. Should invalidate and re-prompt.
   {
-    scoped_ptr<net::HttpTransaction> trans(new net::HttpNetworkTransaction(
+    scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
         session, &mock_socket_factory));
 
-    net::HttpRequestInfo request;
+    HttpRequestInfo request;
     request.method = "GET";
     request.url = GURL("http://www.google.com/p/q/t");
     request.load_flags = 0;
 
     MockWrite data_writes1[] = {
       MockWrite("GET /p/q/t HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n\r\n"),
     };
 
     MockRead data_reads1[] = {
       MockRead("HTTP/1.0 401 Unauthorized\r\n"),
       MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
       MockRead("Content-Length: 10000\r\n\r\n"),
-      MockRead(false, net::ERR_FAILED),
+      MockRead(false, ERR_FAILED),
     };
 
     // Resend with authorization from cache for MyRealm.
     MockWrite data_writes2[] = {
       MockWrite("GET /p/q/t HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n"
                 "Authorization: Basic Zm9vOmJhcg==\r\n\r\n"),
     };
 
     // Sever rejects the authorization.
     MockRead data_reads2[] = {
       MockRead("HTTP/1.0 401 Unauthorized\r\n"),
       MockRead("WWW-Authenticate: Basic realm=\"MyRealm1\"\r\n"),
       MockRead("Content-Length: 10000\r\n\r\n"),
-      MockRead(false, net::ERR_FAILED),
+      MockRead(false, ERR_FAILED),
     };
 
     // At this point we should prompt for new credentials for MyRealm.
     // Restart with username=foo3, password=foo4.
     MockWrite data_writes3[] = {
       MockWrite("GET /p/q/t HTTP/1.1\r\n"
                 "Host: www.google.com\r\n"
                 "Connection: keep-alive\r\n"
                 "Authorization: Basic Zm9vMzpiYXIz\r\n\r\n"),
     };
 
     // Sever accepts the authorization.
     MockRead data_reads3[] = {
       MockRead("HTTP/1.0 200 OK\r\n"),
       MockRead("Content-Length: 100\r\n\r\n"),
-      MockRead(false, net::OK),
+      MockRead(false, OK),
     };
 
     MockSocket data1;
     data1.reads = data_reads1;
     data1.writes = data_writes1;
     MockSocket data2;
     data2.reads = data_reads2;
     data2.writes = data_writes2;
     MockSocket data3;
     data3.reads = data_reads3;
     data3.writes = data_writes3;
     mock_sockets_index = 0;
     mock_sockets[0] = &data1;
     mock_sockets[1] = &data2;
     mock_sockets[2] = &data3;
     mock_sockets[3] = NULL;
 
     TestCompletionCallback callback1;
 
     int rv = trans->Start(&request, &callback1);
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback1.WaitForResult();
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
 
     EXPECT_TRUE(trans->IsReadyToRestartForAuth());
     TestCompletionCallback callback2;
     rv = trans->RestartWithAuth(std::wstring(), std::wstring(), &callback2);
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
     rv = callback2.WaitForResult();
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
     EXPECT_FALSE(trans->IsReadyToRestartForAuth());
 
-    const net::HttpResponseInfo* response = trans->GetResponseInfo();
+    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);
 
     // TODO(eroman): this should really include the effective port (80)
     EXPECT_EQ(L"www.google.com", response->auth_challenge->host);
     EXPECT_EQ(L"MyRealm1", response->auth_challenge->realm);
     EXPECT_EQ(L"basic", response->auth_challenge->scheme);
 
     TestCompletionCallback callback3;
 
     rv = trans->RestartWithAuth(L"foo3", L"bar3", &callback3);
-    EXPECT_EQ(net::ERR_IO_PENDING, rv);
+    EXPECT_EQ(ERR_IO_PENDING, rv);
 
     rv = callback3.WaitForResult();
-    EXPECT_EQ(net::OK, rv);
+    EXPECT_EQ(OK, rv);
 
     response = trans->GetResponseInfo();
     EXPECT_FALSE(response == NULL);
     EXPECT_TRUE(response->auth_challenge.get() == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 }
 
 // Test the ResetStateForRestart() private method.
 TEST_F(HttpNetworkTransactionTest, ResetStateForRestart) {
@@ skipping 122 matching lines @@
   request.url = GURL("https://www.google.com/");
   request.load_flags = 0;
 
   MockWrite proxy_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n\r\n"),
   };
 
   MockRead proxy_reads[] = {
     MockRead("HTTP/1.0 200 Connected\r\n\r\n"),
-    MockRead(false, net::OK)
+    MockRead(false, OK)
   };
 
   MockWrite data_writes[] = {
     MockWrite("CONNECT www.google.com:443 HTTP/1.1\r\n"
               "Host: www.google.com\r\n\r\n"),
     MockWrite("GET / HTTP/1.1\r\n"
               "Host: www.google.com\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
 
@@ skipping 39 matching lines @@
     rv = callback.WaitForResult();
     EXPECT_EQ(OK, rv);
 
     const HttpResponseInfo* response = trans->GetResponseInfo();
 
     EXPECT_FALSE(response == NULL);
     EXPECT_EQ(100, response->headers->GetContentLength());
   }
 }
 
+TEST_F(HttpNetworkTransactionTest, BuildRequest_UserAgent) {
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
+      CreateSession(proxy_service.get()), &mock_socket_factory));
+
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/");
+  request.user_agent = "Chromium Ultra Awesome X Edition";
+
+  MockWrite data_writes[] = {
+    MockWrite("GET / HTTP/1.1\r\n"
+              "Host: www.google.com\r\n"
+              "Connection: keep-alive\r\n"
+              "User-Agent: Chromium Ultra Awesome X Edition\r\n\r\n"),
+  };
+
+  // Lastly, the server responds with the actual content.
+  MockRead data_reads[] = {
+    MockRead("HTTP/1.0 200 OK\r\n"),
+    MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
+    MockRead("Content-Length: 100\r\n\r\n"),
+    MockRead(false, OK),
+  };
+
+  MockSocket data;
+  data.reads = data_reads;
+  data.writes = data_writes;
+  mock_sockets[0] = &data;
+  mock_sockets[1] = NULL;
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, &callback);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(OK, rv);
+}
+
+TEST_F(HttpNetworkTransactionTest, BuildRequest_Referer) {
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
+      CreateSession(proxy_service.get()), &mock_socket_factory));
+
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/");
+  request.load_flags = 0;
+  request.referrer = GURL("http://the.previous.site.com/");
+
+  MockWrite data_writes[] = {
+    MockWrite("GET / HTTP/1.1\r\n"
+              "Host: www.google.com\r\n"
+              "Connection: keep-alive\r\n"
+              "Referer: http://the.previous.site.com/\r\n\r\n"),
+  };
+
+  // Lastly, the server responds with the actual content.
+  MockRead data_reads[] = {
+    MockRead("HTTP/1.0 200 OK\r\n"),
+    MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
+    MockRead("Content-Length: 100\r\n\r\n"),
+    MockRead(false, OK),
+  };
+
+  MockSocket data;
+  data.reads = data_reads;
+  data.writes = data_writes;
+  mock_sockets[0] = &data;
+  mock_sockets[1] = NULL;
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, &callback);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(OK, rv);
+}
+
+TEST_F(HttpNetworkTransactionTest, BuildRequest_PostContentLengthZero) {
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
+      CreateSession(proxy_service.get()), &mock_socket_factory));
+
+  HttpRequestInfo request;
+  request.method = "POST";
+  request.url = GURL("http://www.google.com/");
+
+  MockWrite data_writes[] = {
+    MockWrite("POST / HTTP/1.1\r\n"
+              "Host: www.google.com\r\n"
+              "Connection: keep-alive\r\n"
+              "Content-Length: 0\r\n\r\n"),
+  };
+
+  // Lastly, the server responds with the actual content.
+  MockRead data_reads[] = {
+    MockRead("HTTP/1.0 200 OK\r\n"),
+    MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
+    MockRead("Content-Length: 100\r\n\r\n"),
+    MockRead(false, OK),
+  };
+
+  MockSocket data;
+  data.reads = data_reads;
+  data.writes = data_writes;
+  mock_sockets[0] = &data;
+  mock_sockets[1] = NULL;
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, &callback);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(OK, rv);
+}
+
+TEST_F(HttpNetworkTransactionTest, BuildRequest_PutContentLengthZero) {
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
+      CreateSession(proxy_service.get()), &mock_socket_factory));
+
+  HttpRequestInfo request;
+  request.method = "PUT";
+  request.url = GURL("http://www.google.com/");
+
+  MockWrite data_writes[] = {
+    MockWrite("PUT / HTTP/1.1\r\n"
+              "Host: www.google.com\r\n"
+              "Connection: keep-alive\r\n"
+              "Content-Length: 0\r\n\r\n"),
+  };
+
+  // Lastly, the server responds with the actual content.
+  MockRead data_reads[] = {
+    MockRead("HTTP/1.0 200 OK\r\n"),
+    MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
+    MockRead("Content-Length: 100\r\n\r\n"),
+    MockRead(false, OK),
+  };
+
+  MockSocket data;
+  data.reads = data_reads;
+  data.writes = data_writes;
+  mock_sockets[0] = &data;
+  mock_sockets[1] = NULL;
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, &callback);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(OK, rv);
+}
+
+TEST_F(HttpNetworkTransactionTest, BuildRequest_HeadContentLengthZero) {
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
+      CreateSession(proxy_service.get()), &mock_socket_factory));
+
+  HttpRequestInfo request;
+  request.method = "HEAD";
+  request.url = GURL("http://www.google.com/");
+
+  MockWrite data_writes[] = {
+    MockWrite("HEAD / HTTP/1.1\r\n"
+              "Host: www.google.com\r\n"
+              "Connection: keep-alive\r\n"
+              "Content-Length: 0\r\n\r\n"),
+  };
+
+  // Lastly, the server responds with the actual content.
+  MockRead data_reads[] = {
+    MockRead("HTTP/1.0 200 OK\r\n"),
+    MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
+    MockRead("Content-Length: 100\r\n\r\n"),
+    MockRead(false, OK),
+  };
+
+  MockSocket data;
+  data.reads = data_reads;
+  data.writes = data_writes;
+  mock_sockets[0] = &data;
+  mock_sockets[1] = NULL;
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, &callback);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(OK, rv);
+}
+
+TEST_F(HttpNetworkTransactionTest, BuildRequest_CacheControlNoCache) {
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
+      CreateSession(proxy_service.get()), &mock_socket_factory));
+
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/");
+  request.load_flags = LOAD_BYPASS_CACHE;
+
+  MockWrite data_writes[] = {
+    MockWrite("GET / HTTP/1.1\r\n"
+              "Host: www.google.com\r\n"
+              "Connection: keep-alive\r\n"
+              "Pragma: no-cache\r\n"
+              "Cache-Control: no-cache\r\n\r\n"),
+  };
+
+  // Lastly, the server responds with the actual content.
+  MockRead data_reads[] = {
+    MockRead("HTTP/1.0 200 OK\r\n"),
+    MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
+    MockRead("Content-Length: 100\r\n\r\n"),
+    MockRead(false, OK),
+  };
+
+  MockSocket data;
+  data.reads = data_reads;
+  data.writes = data_writes;
+  mock_sockets[0] = &data;
+  mock_sockets[1] = NULL;
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, &callback);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(OK, rv);
+}
+
+TEST_F(HttpNetworkTransactionTest,
+       BuildRequest_CacheControlValidateCache) {
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
+      CreateSession(proxy_service.get()), &mock_socket_factory));
+
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/");
+  request.load_flags = LOAD_VALIDATE_CACHE;
+
+  MockWrite data_writes[] = {
+    MockWrite("GET / HTTP/1.1\r\n"
+              "Host: www.google.com\r\n"
+              "Connection: keep-alive\r\n"
+              "Cache-Control: max-age=0\r\n\r\n"),
+  };
+
+  // Lastly, the server responds with the actual content.
+  MockRead data_reads[] = {
+    MockRead("HTTP/1.0 200 OK\r\n"),
+    MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
+    MockRead("Content-Length: 100\r\n\r\n"),
+    MockRead(false, OK),
+  };
+
+  MockSocket data;
+  data.reads = data_reads;
+  data.writes = data_writes;
+  mock_sockets[0] = &data;
+  mock_sockets[1] = NULL;
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, &callback);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(OK, rv);
+}
+
+TEST_F(HttpNetworkTransactionTest, BuildRequest_ExtraHeaders) {
+  scoped_ptr<ProxyService> proxy_service(CreateNullProxyService());
+  scoped_ptr<HttpTransaction> trans(new HttpNetworkTransaction(
+      CreateSession(proxy_service.get()), &mock_socket_factory));
+
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/");
+  request.extra_headers = "FooHeader: Bar\r\n";
+
+  MockWrite data_writes[] = {
+    MockWrite("GET / HTTP/1.1\r\n"
+              "Host: www.google.com\r\n"
+              "Connection: keep-alive\r\n"
+              "FooHeader: Bar\r\n\r\n"),
+  };
+
+  // Lastly, the server responds with the actual content.
+  MockRead data_reads[] = {
+    MockRead("HTTP/1.0 200 OK\r\n"),
+    MockRead("Content-Type: text/html; charset=iso-8859-1\r\n"),
+    MockRead("Content-Length: 100\r\n\r\n"),
+    MockRead(false, OK),
+  };
+
+  MockSocket data;
+  data.reads = data_reads;
+  data.writes = data_writes;
+  mock_sockets[0] = &data;
+  mock_sockets[1] = NULL;
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, &callback);
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(OK, rv);
+}
+
 }  // namespace net