Add positive and negative test cases for whether we...

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 "base/compiler_specific.h"
 #include "base/platform_test.h"
 #include "net/base/client_socket_factory.h"
 #include "net/base/test_completion_callback.h"
 #include "net/base/upload_data.h"
 #include "net/http/http_network_session.h"
@@ skipping 151 matching lines @@
   return new net::HttpNetworkSession(new NullProxyResolver());
 }
 
 class HttpNetworkTransactionTest : public PlatformTest {
  public:
   virtual void SetUp() {
     PlatformTest::SetUp();
     mock_sockets[0] = NULL;
     mock_sockets_index = 0;
   }
+
+ protected:
+  void KeepAliveConnectionResendRequestTest(const MockRead& read_failure);
 };
 
 struct SimpleGetHelperResult {
   std::string status_line;
   std::string response_data;
 };
 
 SimpleGetHelperResult SimpleGetHelper(MockRead data_reads[]) {
   SimpleGetHelperResult out;
 
@@ skipping 89 matching lines @@
   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[] = {
     { true, 0, "xxxxxHTTP/1.1 404 Not Found\nServer: blah", -1 },
     { false, net::OK, NULL, 0 },
   };
   SimpleGetHelperResult out = SimpleGetHelper(data_reads);
-  EXPECT_TRUE(out.status_line == "HTTP/0.9 200 OK");
-  EXPECT_TRUE(out.response_data == "xxxxxHTTP/1.1 404 Not Found\nServer: blah");
+  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[] = {
     { true, 0, "\n", -1 },
     { true, 0, "\n", -1 },
     { true, 0, "Q", -1 },
     { true, 0, "J", -1 },
     { true, 0, "HTTP/1.0 404 Not Found\nServer: blah\n\nDATA", -1 },
@@ skipping 64 matching lines @@
     int rv = trans->Start(&request, &callback);
     EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
     EXPECT_EQ(net::OK, rv);
 
     const net::HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_TRUE(response != NULL);
 
     EXPECT_TRUE(response->headers != NULL);
-    EXPECT_TRUE(response->headers->GetStatusLine() == "HTTP/1.1 200 OK");
+    EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
     rv = ReadTransaction(trans, &response_data);
     EXPECT_EQ(net::OK, rv);
-    EXPECT_TRUE(response_data == kExpectedResponseData[i]);
+    EXPECT_EQ(kExpectedResponseData[i], response_data);
 
     trans->Destroy();
 
     // Empty the current queue.
     MessageLoop::current()->RunAllPending();
   }
 }
 
 TEST_F(HttpNetworkTransactionTest, Ignores100) {
   net::HttpTransaction* trans = new net::HttpNetworkTransaction(
@@ skipping 24 matching lines @@
   int rv = trans->Start(&request, &callback);
   EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
   rv = callback.WaitForResult();
   EXPECT_EQ(net::OK, rv);
 
   const net::HttpResponseInfo* response = trans->GetResponseInfo();
   EXPECT_TRUE(response != NULL);
 
   EXPECT_TRUE(response->headers != NULL);
-  EXPECT_TRUE(response->headers->GetStatusLine() == "HTTP/1.0 200 OK");
+  EXPECT_EQ("HTTP/1.0 200 OK", response->headers->GetStatusLine());
 
   std::string response_data;
   rv = ReadTransaction(trans, &response_data);
   EXPECT_EQ(net::OK, rv);
-  EXPECT_TRUE(response_data == "hello world");
+  EXPECT_EQ("hello world", response_data);
 
   trans->Destroy();
 
   // Empty the current queue.
   MessageLoop::current()->RunAllPending();
 }
 
-TEST_F(HttpNetworkTransactionTest, KeepAliveConnectionReset) {
+// read_failure specifies a read failure that should cause the network
+// transaction to resend the request.
+void HttpNetworkTransactionTest::KeepAliveConnectionResendRequestTest(
+    const MockRead& read_failure) {
   scoped_refptr<net::HttpNetworkSession> session = CreateSession();
 
   net::HttpRequestInfo request;
   request.method = "GET";
   request.url = GURL("http://www.foo.com/");
   request.load_flags = 0;
 
   MockRead data1_reads[] = {
     { true, 0, "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n", -1 },
     { true, 0, "hello", -1 },
-    { true, net::ERR_CONNECTION_RESET, NULL, 0 },
+    read_failure,  // Now, we reuse the connection and fail the first read.
   };
   MockSocket data1;
   data1.connect.async = true;
   data1.connect.result = net::OK;
   data1.reads = data1_reads;
   mock_sockets[0] = &data1;
 
   MockRead data2_reads[] = {
     { true, 0, "HTTP/1.1 200 OK\r\nContent-Length: 5\r\n\r\n", -1 },
     { true, 0, "world", -1 },
@@ skipping 18 matching lines @@
     int rv = trans->Start(&request, &callback);
     EXPECT_EQ(net::ERR_IO_PENDING, rv);
 
     rv = callback.WaitForResult();
     EXPECT_EQ(net::OK, rv);
 
     const net::HttpResponseInfo* response = trans->GetResponseInfo();
     EXPECT_TRUE(response != NULL);
 
     EXPECT_TRUE(response->headers != NULL);
-    EXPECT_TRUE(response->headers->GetStatusLine() == "HTTP/1.1 200 OK");
+    EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 
     std::string response_data;
     rv = ReadTransaction(trans, &response_data);
     EXPECT_EQ(net::OK, rv);
-    EXPECT_TRUE(response_data == kExpectedResponseData[i]);
+    EXPECT_EQ(kExpectedResponseData[i], response_data);
 
     trans->Destroy();
 
     // Empty the current queue.
     MessageLoop::current()->RunAllPending();
   }
 }
+
+TEST_F(HttpNetworkTransactionTest, KeepAliveConnectionReset) {
+  MockRead read_failure = { true, net::ERR_CONNECTION_RESET, NULL, 0 };
+  KeepAliveConnectionResendRequestTest(read_failure);
+}
+
+TEST_F(HttpNetworkTransactionTest, KeepAliveConnectionEOF) {
+  MockRead read_failure = { false, net::OK, NULL, 0 };  // EOF
+  KeepAliveConnectionResendRequestTest(read_failure);
+}
+
+TEST_F(HttpNetworkTransactionTest, NonKeepAliveConnectionReset) {
+  net::HttpTransaction* trans = new net::HttpNetworkTransaction(
+      CreateSession(), &mock_socket_factory);
+
+  net::HttpRequestInfo request;
+  request.method = "GET";
+  request.url = GURL("http://www.google.com/");
+  request.load_flags = 0;
+
+  MockRead data_reads[] = {
+    { true, net::ERR_CONNECTION_RESET, NULL, 0 },
+    { true, 0, "HTTP/1.0 200 OK\r\n\r\n", -1 },  // Should not be used
+    { true, 0, "hello world", -1 },
+    { false, net::OK, NULL, 0 },
+  };
+  MockSocket data;
+  data.connect.async = true;
+  data.connect.result = net::OK;
+  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);
+
+  rv = callback.WaitForResult();
+  EXPECT_EQ(net::ERR_CONNECTION_RESET, rv);
+
+  const net::HttpResponseInfo* response = trans->GetResponseInfo();
+  EXPECT_TRUE(response == NULL);
+
+  trans->Destroy();
+
+  // Empty the current queue.
+  MessageLoop::current()->RunAllPending();
+}
+
+// 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: blank page
+TEST_F(HttpNetworkTransactionTest, NonKeepAliveConnectionEOF) {
+  MockRead data_reads[] = {
+    { false, net::OK, NULL, 0 },  // EOF
+    { true, 0, "HTTP/1.0 200 OK\r\n\r\n", -1 },  // Should not be used
+    { true, 0, "hello world", -1 },
+    { false, net::OK, NULL, 0 },
+  };
+  SimpleGetHelperResult out = SimpleGetHelper(data_reads);
+  EXPECT_EQ("HTTP/0.9 200 OK", out.status_line);
+  EXPECT_EQ("", out.response_data);
+}