Add a force pipelining option to load flags.

net/http/http_pipelined_network_transaction_unittest.cc

 // Copyright (c) 2012 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 <string>
 
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
@@ skipping 34 matching lines @@
     default_pipelining_enabled_ = HttpStreamFactory::http_pipelining_enabled();
     HttpStreamFactory::set_http_pipelining_enabled(true);
   }
 
   virtual void TearDown() OVERRIDE {
     MessageLoop::current()->RunAllPending();
     HttpStreamFactory::set_http_pipelining_enabled(default_pipelining_enabled_);
   }
 
   void Initialize() {
+    // Normally, this code could just go in SetUp(). For a few of these tests,
+    // we change the default number of sockets per group. That needs to be done
+    // before we construct the HttpNetworkSession.
     proxy_service_.reset(ProxyService::CreateDirect());
     ssl_config_ = new SSLConfigServiceDefaults;
     auth_handler_factory_.reset(new HttpAuthHandlerMock::Factory());
 
     HttpNetworkSession::Params session_params;
     session_params.client_socket_factory = &factory_;
     session_params.proxy_service = proxy_service_.get();
     session_params.host_resolver = &mock_resolver_;
     session_params.ssl_config_service = ssl_config_.get();
     session_params.http_auth_handler_factory = auth_handler_factory_.get();
     session_params.http_server_properties = &http_server_properties_;
     session_ = new HttpNetworkSession(session_params);
   }
 
   void AddExpectedConnection(MockRead* reads, size_t reads_count,
                              MockWrite* writes, size_t writes_count) {
     DeterministicSocketData* data = new DeterministicSocketData(
         reads, reads_count, writes, writes_count);
     data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
     if (reads_count || writes_count) {
       data->StopAfter(reads_count + writes_count);
     }
     factory_.AddSocketDataProvider(data);
     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);
     request_info->method = "GET";
     request_info_vector_.push_back(request_info);
     return request_info;
   }
 
   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(),
                                    callback_.callback()));
   }
 
   void CompleteTwoRequests(int data_index, int stop_at_step) {
     scoped_ptr<HttpNetworkTransaction> one_transaction(
         new HttpNetworkTransaction(session_.get()));
     TestCompletionCallback one_callback;
@@ skipping 17 matching lines @@
     data_vector_[data_index]->SetStop(stop_at_step);
     data_vector_[data_index]->Run();
     EXPECT_EQ(8, one_read_callback.WaitForResult());
     data_vector_[data_index]->SetStop(10);
     std::string actual(buffer->data(), 8);
     EXPECT_THAT(actual, StrEq("one.html"));
     EXPECT_EQ(OK, one_transaction->Read(buffer.get(), 8,
                                         one_read_callback.callback()));
 
     EXPECT_EQ(OK, two_callback.WaitForResult());
-    ExpectResponse("two.html", two_transaction);
+    ExpectResponse("two.html", two_transaction, false);
   }
 
   void CompleteFourRequests() {
     scoped_ptr<HttpNetworkTransaction> one_transaction(
         new HttpNetworkTransaction(session_.get()));
     TestCompletionCallback one_callback;
     EXPECT_EQ(ERR_IO_PENDING,
               one_transaction->Start(GetRequestInfo("one.html"),
                                      one_callback.callback(), BoundNetLog()));
     EXPECT_EQ(OK, one_callback.WaitForResult());
@@ skipping 10 matching lines @@
               three_transaction.Start(GetRequestInfo("three.html"),
                                       three_callback.callback(),
                                       BoundNetLog()));
 
     HttpNetworkTransaction four_transaction(session_.get());
     TestCompletionCallback four_callback;
     EXPECT_EQ(ERR_IO_PENDING,
               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_;
   ClientSocketPoolHistograms histograms_;
   MockTransportClientSocketPool pool_;
   std::vector<scoped_refptr<DeterministicSocketData> > data_vector_;
   TestCompletionCallback callback_;
   ScopedVector<HttpRequestInfo> request_info_vector_;
   bool default_pipelining_enabled_;
 
@@ skipping 18 matching lines @@
     MockRead(false, 2, "Content-Length: 9\r\n\r\n"),
     MockRead(false, 3, "test.html"),
   };
   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 
   HttpNetworkTransaction transaction(session_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             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) {
   Initialize();
 
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
     MockWrite(false, 3, "GET /two.html HTTP/1.1\r\n"
@@ skipping 156 matching lines @@
   HttpNetworkTransaction two_transaction(session_.get());
   TestCompletionCallback two_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             two_transaction.Start(GetRequestInfo("two.html"),
                                   two_callback.callback(), BoundNetLog()));
 
   scoped_refptr<IOBuffer> buffer(new IOBuffer(1));
   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) {
   Initialize();
 
   MockWrite writes[] = {
     MockWrite(true, ERR_FAILED, 0),
   };
   AddExpectedConnection(NULL, 0, writes, arraysize(writes));
 
@@ skipping 18 matching lines @@
   HttpNetworkTransaction two_transaction(session_.get());
   TestCompletionCallback two_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             two_transaction.Start(GetRequestInfo("two.html"),
                                   two_callback.callback(), BoundNetLog()));
 
   data_vector_[0]->RunFor(1);
   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) {
   Initialize();
 
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /redirect.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
     MockWrite(false, 3, "GET /two.html HTTP/1.1\r\n"
@@ skipping 22 matching lines @@
   TestCompletionCallback two_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             two_transaction.Start(GetRequestInfo("two.html"),
                                   two_callback.callback(), BoundNetLog()));
 
   one_transaction.reset();
   data_vector_[0]->RunFor(2);
   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) {
   Initialize();
 
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /one.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
     MockWrite(false, 5, "GET /one.html HTTP/1.1\r\n"
@@ skipping 25 matching lines @@
 
   HttpNetworkTransaction transaction(session_.get());
   EXPECT_EQ(ERR_IO_PENDING,
             transaction.Start(GetRequestInfo("one.html"), callback_.callback(),
                               BoundNetLog()));
   EXPECT_EQ(OK, callback_.WaitForResult());
 
   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) {
   Initialize();
 
   MockWrite writes[] = {
     MockWrite(false, 0, "GET /pipelined.html HTTP/1.1\r\n"
               "Host: localhost\r\n"
               "Connection: keep-alive\r\n\r\n"),
   };
@@ skipping 29 matching lines @@
     MockRead(false, OK, 4),
   };
   AddExpectedConnection(reads3, arraysize(reads3), writes3, arraysize(writes3));
 
   HttpNetworkTransaction one_transaction(session_.get());
   TestCompletionCallback one_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             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);
 }
 
 TEST_F(HttpPipelinedNetworkTransactionTest, PipelinesImmediatelyIfKnownGood) {
   // The first request gets us an HTTP/1.1. The next 3 test pipelining. When the
   // 3rd request completes, we know pipelining is safe. After the first 4
   // complete, the 5th and 6th should then be immediately sent pipelined on a
   // new HttpPipelinedConnection.
   int old_max_sockets = ClientSocketPoolManager::max_sockets_per_group();
@@ skipping 55 matching lines @@
   HttpNetworkTransaction second_two_transaction(session_.get());
   TestCompletionCallback second_two_callback;
   EXPECT_EQ(ERR_IO_PENDING,
             second_two_transaction.Start(
                 GetRequestInfo("second-pipeline-two.html"),
                 second_two_callback.callback(), BoundNetLog()));
 
   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);
 }
 
 class DataRunnerObserver : public MessageLoop::TaskObserver {
  public:
   DataRunnerObserver(DeterministicSocketData* data, int run_before_task)
       : data_(data),
         run_before_task_(run_before_task),
         current_task_(0) { }
@@ skipping 72 matching lines @@
   // We need to make sure that the response that triggers OnPipelineFeedback(OK)
   // is called in between when task #3 is scheduled and when it runs. The
   // DataRunnerObserver does that.
   DataRunnerObserver observer(data_vector_[0].get(), 3);
   MessageLoop::current()->AddTaskObserver(&observer);
   data_vector_[0]->SetStop(4);
   MessageLoop::current()->RunAllPending();
   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);
+  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);  // Send + 2 lines of headers.
+  EXPECT_EQ(OK, one_callback.WaitForResult());
+  ExpectResponse("one.html", *one_transaction.get(), true);
+  one_transaction.reset();
+
+  data_vector_[0]->RunFor(2);  // 2 lines of headers.
+  EXPECT_EQ(OK, two_callback.WaitForResult());
+  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());
+}
+
+TEST_F(HttpPipelinedNetworkTransactionTest, ForcedPipelineEvictionIsFatal) {
+  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, ERR_FAILED, 1),
+  };
+  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(2);
+  EXPECT_EQ(ERR_FAILED, one_callback.WaitForResult());
+  one_transaction.reset();
+  EXPECT_EQ(ERR_PIPELINE_EVICTION, two_callback.WaitForResult());
 }
 
 }  // anonymous namespace
 
 }  // namespace net