Add GetFullRequestHeaders, from URLRequestJob to HttpNetworkTransaction.

Dev Tools displays the raw request and response headers.  Right now, it gets
them by snarfing them out of the NetLog, which is bad, as the NetLog is for
huamn consumption only.  I'm trying to refactor the DevToolsNetLogObserver
away; providing an alternate, supported path to get the request headers is the
first step.

BUG=196304
TEST=added to URLRequest, HttpTransaction, and HttpNetworkTransaction unittests

Committed: https://src.chromium.org/viewvc/chrome?view=rev&revision=199535

Review URL: https://chromiumcodereview.appspot.com/12621011

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@207341 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 263 insertions, 3 deletions

diff --git a/net/http/http_network_transaction_unittest.cc b/net/http/http_network_transaction_unittest.cc
index d608a90..54f58a7 100644
--- a/net/http/http_network_transaction_unittest.cc
+++ b/net/http/http_network_transaction_unittest.cc
@@ -351,9 +351,18 @@ class HttpNetworkTransactionTest
     EXPECT_TRUE(entries[pos].GetStringValue("line", &line));
     EXPECT_EQ("GET / HTTP/1.1\r\n", line);
 
-    std::string headers;
-    EXPECT_TRUE(GetHeaders(entries[pos].params.get(), &headers));
-    EXPECT_EQ("['Host: www.google.com','Connection: keep-alive']", headers);
+    HttpRequestHeaders request_headers;
+    EXPECT_TRUE(trans->GetFullRequestHeaders(&request_headers));
+    std::string value;
+    EXPECT_TRUE(request_headers.GetHeader("Host", &value));
+    EXPECT_EQ("www.google.com", value);
+    EXPECT_TRUE(request_headers.GetHeader("Connection", &value));
+    EXPECT_EQ("keep-alive", value);
+
+    std::string response_headers;
+    EXPECT_TRUE(GetHeaders(entries[pos].params.get(), &response_headers));
+    EXPECT_EQ("['Host: www.google.com','Connection: keep-alive']",
+              response_headers);
 
     return out;
   }
@@ -11535,4 +11544,255 @@ TEST_P(HttpNetworkTransactionTest, CloseIdleSpdySessionToOpenNewOne) {
   HttpStreamFactory::SetNextProtos(std::vector<std::string>());
 }
 
+TEST_P(HttpNetworkTransactionTest, HttpSyncConnectError) {
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/");
+  request.load_flags = 0;
+
+  scoped_ptr<HttpTransaction> trans(
+      new HttpNetworkTransaction(DEFAULT_PRIORITY,
+                                 CreateSession(&session_deps_)));
+
+  MockConnect mock_connect(SYNCHRONOUS, ERR_CONNECTION_REFUSED);
+  StaticSocketDataProvider data;
+  data.set_connect_data(mock_connect);
+  session_deps_.socket_factory->AddSocketDataProvider(&data);
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(ERR_CONNECTION_REFUSED, rv);
+
+  EXPECT_EQ(NULL, trans->GetResponseInfo());
+
+  // We don't care whether this succeeds or fails, but it shouldn't crash.
+  HttpRequestHeaders request_headers;
+  trans->GetFullRequestHeaders(&request_headers);
+}
+
+TEST_P(HttpNetworkTransactionTest, HttpAsyncConnectError) {
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/");
+  request.load_flags = 0;
+
+  scoped_ptr<HttpTransaction> trans(
+      new HttpNetworkTransaction(DEFAULT_PRIORITY,
+                                 CreateSession(&session_deps_)));
+
+  MockConnect mock_connect(ASYNC, ERR_CONNECTION_REFUSED);
+  StaticSocketDataProvider data;
+  data.set_connect_data(mock_connect);
+  session_deps_.socket_factory->AddSocketDataProvider(&data);
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(ERR_CONNECTION_REFUSED, rv);
+
+  EXPECT_EQ(NULL, trans->GetResponseInfo());
+
+  // We don't care whether this succeeds or fails, but it shouldn't crash.
+  HttpRequestHeaders request_headers;
+  trans->GetFullRequestHeaders(&request_headers);
+}
+
+TEST_P(HttpNetworkTransactionTest, HttpSyncWriteError) {
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/");
+  request.load_flags = 0;
+
+  scoped_ptr<HttpTransaction> trans(
+      new HttpNetworkTransaction(DEFAULT_PRIORITY,
+                                 CreateSession(&session_deps_)));
+
+  MockWrite data_writes[] = {
+    MockWrite(SYNCHRONOUS, ERR_CONNECTION_RESET),
+  };
+  MockRead data_reads[] = {
+    MockRead(SYNCHRONOUS, ERR_UNEXPECTED),  // Should not be reached.
+  };
+
+  StaticSocketDataProvider data(data_reads, arraysize(data_reads),
+                                data_writes, arraysize(data_writes));
+  session_deps_.socket_factory->AddSocketDataProvider(&data);
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(ERR_CONNECTION_RESET, rv);
+
+  EXPECT_EQ(NULL, trans->GetResponseInfo());
+
+  HttpRequestHeaders request_headers;
+  EXPECT_TRUE(trans->GetFullRequestHeaders(&request_headers));
+  EXPECT_TRUE(request_headers.HasHeader("Host"));
+}
+
+TEST_P(HttpNetworkTransactionTest, HttpAsyncWriteError) {
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/");
+  request.load_flags = 0;
+
+  scoped_ptr<HttpTransaction> trans(
+      new HttpNetworkTransaction(DEFAULT_PRIORITY,
+                                 CreateSession(&session_deps_)));
+
+  MockWrite data_writes[] = {
+    MockWrite(ASYNC, ERR_CONNECTION_RESET),
+  };
+  MockRead data_reads[] = {
+    MockRead(SYNCHRONOUS, ERR_UNEXPECTED),  // Should not be reached.
+  };
+
+  StaticSocketDataProvider data(data_reads, arraysize(data_reads),
+                                data_writes, arraysize(data_writes));
+  session_deps_.socket_factory->AddSocketDataProvider(&data);
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(ERR_CONNECTION_RESET, rv);
+
+  EXPECT_EQ(NULL, trans->GetResponseInfo());
+
+  HttpRequestHeaders request_headers;
+  EXPECT_TRUE(trans->GetFullRequestHeaders(&request_headers));
+  EXPECT_TRUE(request_headers.HasHeader("Host"));
+}
+
+TEST_P(HttpNetworkTransactionTest, HttpSyncReadError) {
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/");
+  request.load_flags = 0;
+
+  scoped_ptr<HttpTransaction> trans(
+      new HttpNetworkTransaction(DEFAULT_PRIORITY,
+                                 CreateSession(&session_deps_)));
+
+  MockWrite data_writes[] = {
+    MockWrite("GET / HTTP/1.1\r\n"
+              "Host: www.google.com\r\n"
+              "Connection: keep-alive\r\n\r\n"),
+  };
+  MockRead data_reads[] = {
+    MockRead(SYNCHRONOUS, ERR_CONNECTION_RESET),
+  };
+
+  StaticSocketDataProvider data(data_reads, arraysize(data_reads),
+                                data_writes, arraysize(data_writes));
+  session_deps_.socket_factory->AddSocketDataProvider(&data);
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(ERR_CONNECTION_RESET, rv);
+
+  EXPECT_EQ(NULL, trans->GetResponseInfo());
+
+  HttpRequestHeaders request_headers;
+  EXPECT_TRUE(trans->GetFullRequestHeaders(&request_headers));
+  EXPECT_TRUE(request_headers.HasHeader("Host"));
+}
+
+TEST_P(HttpNetworkTransactionTest, HttpAsyncReadError) {
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/");
+  request.load_flags = 0;
+
+  scoped_ptr<HttpTransaction> trans(
+      new HttpNetworkTransaction(DEFAULT_PRIORITY,
+                                 CreateSession(&session_deps_)));
+
+  MockWrite data_writes[] = {
+    MockWrite("GET / HTTP/1.1\r\n"
+              "Host: www.google.com\r\n"
+              "Connection: keep-alive\r\n\r\n"),
+  };
+  MockRead data_reads[] = {
+    MockRead(ASYNC, ERR_CONNECTION_RESET),
+  };
+
+  StaticSocketDataProvider data(data_reads, arraysize(data_reads),
+                                data_writes, arraysize(data_writes));
+  session_deps_.socket_factory->AddSocketDataProvider(&data);
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(ERR_CONNECTION_RESET, rv);
+
+  EXPECT_EQ(NULL, trans->GetResponseInfo());
+
+  HttpRequestHeaders request_headers;
+  EXPECT_TRUE(trans->GetFullRequestHeaders(&request_headers));
+  EXPECT_TRUE(request_headers.HasHeader("Host"));
+}
+
+TEST_P(HttpNetworkTransactionTest, GetFullRequestHeadersIncludesExtraHeader) {
+  HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/");
+  request.load_flags = 0;
+  request.extra_headers.SetHeader("X-Foo", "bar");
+
+  scoped_ptr<HttpTransaction> trans(
+      new HttpNetworkTransaction(DEFAULT_PRIORITY,
+                                 CreateSession(&session_deps_)));
+
+  MockWrite data_writes[] = {
+    MockWrite("GET / HTTP/1.1\r\n"
+              "Host: www.google.com\r\n"
+              "Connection: keep-alive\r\n"
+              "X-Foo: bar\r\n\r\n"),
+  };
+  MockRead data_reads[] = {
+    MockRead("HTTP/1.1 200 OK\r\n"
+             "Content-Length: 5\r\n\r\n"
+             "hello"),
+    MockRead(ASYNC, ERR_UNEXPECTED),
+  };
+
+  StaticSocketDataProvider data(data_reads, arraysize(data_reads),
+                                data_writes, arraysize(data_writes));
+  session_deps_.socket_factory->AddSocketDataProvider(&data);
+
+  TestCompletionCallback callback;
+
+  int rv = trans->Start(&request, callback.callback(), BoundNetLog());
+  EXPECT_EQ(ERR_IO_PENDING, rv);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(OK, rv);
+
+  HttpRequestHeaders request_headers;
+  EXPECT_TRUE(trans->GetFullRequestHeaders(&request_headers));
+  std::string foo;
+  EXPECT_TRUE(request_headers.GetHeader("X-Foo", &foo));
+  EXPECT_EQ("bar", foo);
+}
+
 }  // namespace net