Add a force pipelining option to load flags.

net/http/http_pipelined_network_transaction_unittest.cc

Index: net/http/http_pipelined_network_transaction_unittest.cc
diff --git a/net/http/http_pipelined_network_transaction_unittest.cc b/net/http/http_pipelined_network_transaction_unittest.cc
index c4e42a0fa16edbc6a6cc4ce193d20b0c251aef3a..f1a364f81660094a74832305d25b13f9d2546de5 100644
--- a/net/http/http_pipelined_network_transaction_unittest.cc
+++ b/net/http/http_pipelined_network_transaction_unittest.cc
@@ -78,7 +78,7 @@ class HttpPipelinedNetworkTransactionTest : public testing::Test {
     data_vector_.push_back(data);
   }
 
-  const HttpRequestInfo* GetRequestInfo(const char* filename) {
+  HttpRequestInfo* GetRequestInfo(const char* filename) {
     std::string url = StringPrintf("http://localhost/%s", filename);
     HttpRequestInfo* request_info = new HttpRequestInfo;
     request_info->url = GURL(url);
@@ -88,11 +88,19 @@ class HttpPipelinedNetworkTransactionTest : public testing::Test {
   }
 
   void ExpectResponse(const std::string& expected,
-                      HttpNetworkTransaction& transaction) {
+                      HttpNetworkTransaction& transaction,
+                      bool async) {
     scoped_refptr<IOBuffer> buffer(new IOBuffer(expected.size()));
-    EXPECT_EQ(static_cast<int>(expected.size()),
-              transaction.Read(buffer.get(), expected.size(),
-                               callback_.callback()));
+    if (async) {
+      EXPECT_EQ(ERR_IO_PENDING, transaction.Read(buffer.get(), expected.size(),
+                                                 callback_.callback()));
+      data_vector_[0]->RunFor(1);
+      EXPECT_EQ(static_cast<int>(expected.length()), callback_.WaitForResult());
+    } else {
+      EXPECT_EQ(static_cast<int>(expected.size()),
+                transaction.Read(buffer.get(), expected.size(),
+                                 callback_.callback()));
+    }
     std::string actual(buffer->data(), expected.size());
     EXPECT_THAT(actual, StrEq(expected));
     EXPECT_EQ(OK, transaction.Read(buffer.get(), expected.size(),
@@ -130,7 +138,7 @@ class HttpPipelinedNetworkTransactionTest : public testing::Test {
                                         one_read_callback.callback()));
 
     EXPECT_EQ(OK, two_callback.WaitForResult());
-    ExpectResponse("two.html", two_transaction);
+    ExpectResponse("two.html", two_transaction, false);
   }
 
   void CompleteFourRequests() {
@@ -161,15 +169,15 @@ class HttpPipelinedNetworkTransactionTest : public testing::Test {
               four_transaction.Start(GetRequestInfo("four.html"),
                                      four_callback.callback(), BoundNetLog()));
 
-    ExpectResponse("one.html", *one_transaction.get());
+    ExpectResponse("one.html", *one_transaction.get(), false);
     EXPECT_EQ(OK, two_callback.WaitForResult());
-    ExpectResponse("two.html", two_transaction);
+    ExpectResponse("two.html", two_transaction, false);
     EXPECT_EQ(OK, three_callback.WaitForResult());
-    ExpectResponse("three.html", three_transaction);
+    ExpectResponse("three.html", three_transaction, false);
 
     one_transaction.reset();
     EXPECT_EQ(OK, four_callback.WaitForResult());
-    ExpectResponse("four.html", four_transaction);
+    ExpectResponse("four.html", four_transaction, false);
   }
 
   DeterministicMockClientSocketFactory factory_;
@@ -208,7 +216,7 @@ TEST_F(HttpPipelinedNetworkTransactionTest, OneRequest) {
             transaction.Start(GetRequestInfo("test.html"), callback_.callback(),
                               BoundNetLog()));
   EXPECT_EQ(OK, callback_.WaitForResult());
-  ExpectResponse("test.html", transaction);
+  ExpectResponse("test.html", transaction, false);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, ReusePipeline) {
@@ -385,7 +393,7 @@ TEST_F(HttpPipelinedNetworkTransactionTest, ErrorEvictsToNewPipeline) {
   EXPECT_EQ(ERR_FAILED,
             one_transaction.Read(buffer.get(), 1, callback_.callback()));
   EXPECT_EQ(OK, two_callback.WaitForResult());
-  ExpectResponse("two.html", two_transaction);
+  ExpectResponse("two.html", two_transaction, false);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, SendErrorEvictsToNewPipeline) {
@@ -424,7 +432,7 @@ TEST_F(HttpPipelinedNetworkTransactionTest, SendErrorEvictsToNewPipeline) {
   EXPECT_EQ(ERR_FAILED, one_callback.WaitForResult());
 
   EXPECT_EQ(OK, two_callback.WaitForResult());
-  ExpectResponse("two.html", two_transaction);
+  ExpectResponse("two.html", two_transaction, false);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, RedirectDrained) {
@@ -467,7 +475,7 @@ TEST_F(HttpPipelinedNetworkTransactionTest, RedirectDrained) {
   data_vector_[0]->SetStop(10);
 
   EXPECT_EQ(OK, two_callback.WaitForResult());
-  ExpectResponse("two.html", two_transaction);
+  ExpectResponse("two.html", two_transaction, false);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, BasicHttpAuthentication) {
@@ -513,7 +521,7 @@ TEST_F(HttpPipelinedNetworkTransactionTest, BasicHttpAuthentication) {
   AuthCredentials credentials(ASCIIToUTF16("user"), ASCIIToUTF16("pass"));
   EXPECT_EQ(OK, transaction.RestartWithAuth(credentials, callback_.callback()));
 
-  ExpectResponse("one.html", transaction);
+  ExpectResponse("one.html", transaction, false);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, OldVersionDisablesPipelining) {
@@ -563,7 +571,7 @@ TEST_F(HttpPipelinedNetworkTransactionTest, OldVersionDisablesPipelining) {
             one_transaction.Start(GetRequestInfo("pipelined.html"),
                                   one_callback.callback(), BoundNetLog()));
   EXPECT_EQ(OK, one_callback.WaitForResult());
-  ExpectResponse("pipelined.html", one_transaction);
+  ExpectResponse("pipelined.html", one_transaction, false);
 
   CompleteTwoRequests(1, 4);
 }
@@ -639,9 +647,9 @@ TEST_F(HttpPipelinedNetworkTransactionTest, PipelinesImmediatelyIfKnownGood) {
   data_vector_[0]->RunFor(3);
   EXPECT_EQ(OK, second_one_callback.WaitForResult());
   data_vector_[0]->StopAfter(100);
-  ExpectResponse("second-pipeline-one.html", second_one_transaction);
+  ExpectResponse("second-pipeline-one.html", second_one_transaction, false);
   EXPECT_EQ(OK, second_two_callback.WaitForResult());
-  ExpectResponse("second-pipeline-two.html", second_two_transaction);
+  ExpectResponse("second-pipeline-two.html", second_two_transaction, false);
 
   ClientSocketPoolManager::set_max_sockets_per_group(old_max_sockets);
 }
@@ -734,9 +742,88 @@ TEST_F(HttpPipelinedNetworkTransactionTest, OpenPipelinesWhileBinding) {
   data_vector_[0]->SetStop(10);
 
   EXPECT_EQ(OK, one_callback.WaitForResult());
-  ExpectResponse("one.html", one_transaction);
+  ExpectResponse("one.html", one_transaction, false);
+  EXPECT_EQ(OK, two_callback.WaitForResult());
+  ExpectResponse("two.html", two_transaction, false);
+}
+
+TEST_F(HttpPipelinedNetworkTransactionTest, ForcedPipelineSharesConnection) {
+  Initialize();
+
+  MockWrite writes[] = {
+    MockWrite(true, 0, "GET /one.html HTTP/1.1\r\n"
+              "Host: localhost\r\n"
+              "Connection: keep-alive\r\n\r\n"
+              "GET /two.html HTTP/1.1\r\n"
+              "Host: localhost\r\n"
+              "Connection: keep-alive\r\n\r\n"),
+  };
+  MockRead reads[] = {
+    MockRead(true, 1, "HTTP/1.1 200 OK\r\n"),
+    MockRead(true, 2, "Content-Length: 8\r\n\r\n"),
+    MockRead(true, 3, "one.html"),
+    MockRead(true, 4, "HTTP/1.1 200 OK\r\n"),
+    MockRead(true, 5, "Content-Length: 8\r\n\r\n"),
+    MockRead(true, 6, "two.html"),
+  };
+  AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
+
+  scoped_ptr<HttpNetworkTransaction> one_transaction(
+      new HttpNetworkTransaction(session_.get()));
+  TestCompletionCallback one_callback;
+  HttpRequestInfo* one_info = GetRequestInfo("one.html");
+  one_info->load_flags |= LOAD_FORCE_HTTP_PIPELINING;
+  EXPECT_EQ(ERR_IO_PENDING,
+            one_transaction->Start(one_info,
+                                   one_callback.callback(), BoundNetLog()));
+
+  HttpNetworkTransaction two_transaction(session_.get());
+  TestCompletionCallback two_callback;
+  HttpRequestInfo* two_info = GetRequestInfo("two.html");
+  two_info->load_flags |= LOAD_FORCE_HTTP_PIPELINING;
+  EXPECT_EQ(ERR_IO_PENDING,
+            two_transaction.Start(two_info,
+                                  two_callback.callback(), BoundNetLog()));
+
+  data_vector_[0]->RunFor(3);

[mmenke, 2012/02/23 18:54:58]

Why is this 3 and the one below 2?  I'd think they should both be 2.

[James Simonsen, 2012/02/23 23:49:46]

The initial write is also async and is only included in the first one. I added a
comment.

[mmenke, 2012/02/24 00:20:14]

But it's event 0, not event 1, so it doesn't look like it should count.

First call to RunFor runs SetStop(sequence_number_ + seq), which is 3.  Next
call increases it by 1 to 4, then we increase it by 2 to 6, and then we increase
it by 1 to 7.

So for the first call of ExpectResponse(), we're at 3 and increment it to 4, but
the second call we're at 6 and increment it to 7.

Erm...Nevermind.  That makes sense.  Was thinking 3 and 7, rather than 3 and 6.

+  EXPECT_EQ(OK, one_callback.WaitForResult());
+  ExpectResponse("one.html", *one_transaction.get(), true);
+  one_transaction.reset();
+
+  data_vector_[0]->RunFor(2);
   EXPECT_EQ(OK, two_callback.WaitForResult());
-  ExpectResponse("two.html", two_transaction);
+  ExpectResponse("two.html", two_transaction, true);
+}
+
+TEST_F(HttpPipelinedNetworkTransactionTest,
+       ForcedPipelineConnectionErrorFailsBoth) {
+  Initialize();
+
+  scoped_refptr<DeterministicSocketData> data(
+      new DeterministicSocketData(NULL, 0, NULL, 0));
+  data->set_connect_data(MockConnect(ASYNC, ERR_FAILED));
+  factory_.AddSocketDataProvider(data);
+
+  scoped_ptr<HttpNetworkTransaction> one_transaction(
+      new HttpNetworkTransaction(session_.get()));
+  TestCompletionCallback one_callback;
+  HttpRequestInfo* one_info = GetRequestInfo("one.html");
+  one_info->load_flags |= LOAD_FORCE_HTTP_PIPELINING;
+  EXPECT_EQ(ERR_IO_PENDING,
+            one_transaction->Start(one_info,
+                                   one_callback.callback(), BoundNetLog()));
+
+  HttpNetworkTransaction two_transaction(session_.get());
+  TestCompletionCallback two_callback;
+  HttpRequestInfo* two_info = GetRequestInfo("two.html");
+  two_info->load_flags |= LOAD_FORCE_HTTP_PIPELINING;
+  EXPECT_EQ(ERR_IO_PENDING,
+            two_transaction.Start(two_info,
+                                  two_callback.callback(), BoundNetLog()));
+
+  data->Run();
+  EXPECT_EQ(ERR_FAILED, one_callback.WaitForResult());
+  EXPECT_EQ(ERR_FAILED, two_callback.WaitForResult());
 }

[mmenke, 2012/02/23 18:54:58]

Suggest you also have a test where we get ERR_PIPELINED_EVICTED as the final
result.

[James Simonsen, 2012/02/23 23:49:46]

Done.

 
 }  // anonymous namespace