src/net/http/http_pipelined_network_transaction_unittest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include <string>
   6
   7 #include "base/memory/ref_counted.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/memory/scoped_vector.h"
  10 #include "base/strings/stringprintf.h"
  11 #include "base/strings/utf_string_conversions.h"
  12 #include "net/base/address_list.h"
  13 #include "net/base/io_buffer.h"
  14 #include "net/base/net_errors.h"
  15 #include "net/base/net_util.h"
  16 #include "net/base/request_priority.h"
  17 #include "net/dns/host_cache.h"
  18 #include "net/dns/mock_host_resolver.h"
  19 #include "net/http/http_auth_handler_mock.h"
  20 #include "net/http/http_network_session.h"
  21 #include "net/http/http_network_transaction.h"
  22 #include "net/http/http_request_info.h"
  23 #include "net/http/http_server_properties_impl.h"
  24 #include "net/proxy/proxy_config_service.h"
  25 #include "net/proxy/proxy_service.h"
  26 #include "net/socket/client_socket_handle.h"
  27 #include "net/socket/client_socket_pool_histograms.h"
  28 #include "net/socket/client_socket_pool_manager.h"
  29 #include "net/socket/socket_test_util.h"
  30 #include "net/ssl/ssl_config_service_defaults.h"
  31 #include "testing/gmock/include/gmock/gmock.h"
  32 #include "testing/gtest/include/gtest/gtest.h"
  33
  34 using testing::StrEq;
  35
  36 namespace net {
  37
  38 namespace {
  39
  40 class SimpleProxyConfigService : public ProxyConfigService {
  41  public:
  42   virtual void AddObserver(Observer* observer) OVERRIDE {
  43     observer_ = observer;
  44   }
  45
  46   virtual void RemoveObserver(Observer* observer) OVERRIDE {
  47     if (observer_ == observer) {
  48       observer_ = NULL;
  49     }
  50   }
  51
  52   virtual ConfigAvailability GetLatestProxyConfig(
  53       ProxyConfig* config) OVERRIDE {
  54     *config = config_;
  55     return CONFIG_VALID;
  56   }
  57
  58   void IncrementConfigId() {
  59     config_.set_id(config_.id() + 1);
  60     observer_->OnProxyConfigChanged(config_, ProxyConfigService::CONFIG_VALID);
  61   }
  62
  63  private:
  64   ProxyConfig config_;
  65   Observer* observer_;
  66 };
  67
  68 class HttpPipelinedNetworkTransactionTest : public testing::Test {
  69  public:
  70   HttpPipelinedNetworkTransactionTest()
  71       : histograms_("a"),
  72         pool_(1, 1, &histograms_, &factory_) {
  73   }
  74
  75   void Initialize(bool force_http_pipelining) {
  76     // Normally, this code could just go in SetUp(). For a few of these tests,
  77     // we change the default number of sockets per group. That needs to be done
  78     // before we construct the HttpNetworkSession.
  79     proxy_config_service_ = new SimpleProxyConfigService();
  80     proxy_service_.reset(new ProxyService(proxy_config_service_, NULL, NULL));
  81     ssl_config_ = new SSLConfigServiceDefaults;
  82     auth_handler_factory_.reset(new HttpAuthHandlerMock::Factory());
  83
  84     HttpNetworkSession::Params session_params;
  85     session_params.client_socket_factory = &factory_;
  86     session_params.proxy_service = proxy_service_.get();
  87     session_params.host_resolver = &mock_resolver_;
  88     session_params.ssl_config_service = ssl_config_.get();
  89     session_params.http_auth_handler_factory = auth_handler_factory_.get();
  90     session_params.http_server_properties =
  91         http_server_properties_.GetWeakPtr();
  92     session_params.force_http_pipelining = force_http_pipelining;
  93     session_params.http_pipelining_enabled = true;
  94     session_ = new HttpNetworkSession(session_params);
  95   }
  96
  97   void AddExpectedConnection(MockRead* reads, size_t reads_count,
  98                              MockWrite* writes, size_t writes_count) {
  99     DeterministicSocketData* data = new DeterministicSocketData(
 100         reads, reads_count, writes, writes_count);
 101     data->set_connect_data(MockConnect(SYNCHRONOUS, OK));
 102     if (reads_count || writes_count) {
 103       data->StopAfter(reads_count + writes_count);
 104     }
 105     factory_.AddSocketDataProvider(data);
 106     data_vector_.push_back(data);
 107   }
 108
 109   enum RequestInfoOptions {
 110     REQUEST_DEFAULT,
 111     REQUEST_MAIN_RESOURCE,
 112   };
 113
 114   HttpRequestInfo* GetRequestInfo(
 115       const char* filename, RequestInfoOptions options = REQUEST_DEFAULT) {
 116     std::string url = base::StringPrintf("http://localhost/%s", filename);
 117     HttpRequestInfo* request_info = new HttpRequestInfo;
 118     request_info->url = GURL(url);
 119     request_info->method = "GET";
 120     if (options == REQUEST_MAIN_RESOURCE) {
 121       request_info->load_flags = LOAD_MAIN_FRAME;
 122     }
 123     request_info_vector_.push_back(request_info);
 124     return request_info;
 125   }
 126
 127   void ExpectResponse(const std::string& expected,
 128                       HttpNetworkTransaction& transaction,
 129                       IoMode io_mode) {
 130     scoped_refptr<IOBuffer> buffer(new IOBuffer(expected.size()));
 131     if (io_mode == ASYNC) {
 132       EXPECT_EQ(ERR_IO_PENDING, transaction.Read(buffer.get(), expected.size(),
 133                                                  callback_.callback()));
 134       data_vector_[0]->RunFor(1);
 135       EXPECT_EQ(static_cast<int>(expected.length()), callback_.WaitForResult());
 136     } else {
 137       EXPECT_EQ(static_cast<int>(expected.size()),
 138                 transaction.Read(buffer.get(), expected.size(),
 139                                  callback_.callback()));
 140     }
 141     std::string actual(buffer->data(), expected.size());
 142     EXPECT_THAT(actual, StrEq(expected));
 143     EXPECT_EQ(OK, transaction.Read(buffer.get(), expected.size(),
 144                                    callback_.callback()));
 145   }
 146
 147   void CompleteTwoRequests(int data_index, int stop_at_step) {
 148     scoped_ptr<HttpNetworkTransaction> one_transaction(
 149         new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
 150     TestCompletionCallback one_callback;
 151     EXPECT_EQ(ERR_IO_PENDING,
 152               one_transaction->Start(GetRequestInfo("one.html"),
 153                                      one_callback.callback(), BoundNetLog()));
 154     EXPECT_EQ(OK, one_callback.WaitForResult());
 155
 156     HttpNetworkTransaction two_transaction(DEFAULT_PRIORITY, session_.get());
 157     TestCompletionCallback two_callback;
 158     EXPECT_EQ(ERR_IO_PENDING,
 159               two_transaction.Start(GetRequestInfo("two.html"),
 160                                     two_callback.callback(), BoundNetLog()));
 161
 162     TestCompletionCallback one_read_callback;
 163     scoped_refptr<IOBuffer> buffer(new IOBuffer(8));
 164     EXPECT_EQ(ERR_IO_PENDING,
 165               one_transaction->Read(buffer.get(), 8,
 166                                     one_read_callback.callback()));
 167
 168     data_vector_[data_index]->SetStop(stop_at_step);
 169     data_vector_[data_index]->Run();
 170     EXPECT_EQ(8, one_read_callback.WaitForResult());
 171     data_vector_[data_index]->SetStop(10);
 172     std::string actual(buffer->data(), 8);
 173     EXPECT_THAT(actual, StrEq("one.html"));
 174     EXPECT_EQ(OK, one_transaction->Read(buffer.get(), 8,
 175                                         one_read_callback.callback()));
 176
 177     EXPECT_EQ(OK, two_callback.WaitForResult());
 178     ExpectResponse("two.html", two_transaction, SYNCHRONOUS);
 179   }
 180
 181   void CompleteFourRequests(RequestInfoOptions options) {
 182     scoped_ptr<HttpNetworkTransaction> one_transaction(
 183         new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
 184     TestCompletionCallback one_callback;
 185     EXPECT_EQ(ERR_IO_PENDING,
 186               one_transaction->Start(GetRequestInfo("one.html", options),
 187                                      one_callback.callback(), BoundNetLog()));
 188     EXPECT_EQ(OK, one_callback.WaitForResult());
 189
 190     HttpNetworkTransaction two_transaction(DEFAULT_PRIORITY, session_.get());
 191     TestCompletionCallback two_callback;
 192     EXPECT_EQ(ERR_IO_PENDING,
 193               two_transaction.Start(GetRequestInfo("two.html", options),
 194                                     two_callback.callback(), BoundNetLog()));
 195
 196     HttpNetworkTransaction three_transaction(DEFAULT_PRIORITY, session_.get());
 197     TestCompletionCallback three_callback;
 198     EXPECT_EQ(ERR_IO_PENDING,
 199               three_transaction.Start(GetRequestInfo("three.html", options),
 200                                       three_callback.callback(),
 201                                       BoundNetLog()));
 202
 203     HttpNetworkTransaction four_transaction(DEFAULT_PRIORITY, session_.get());
 204     TestCompletionCallback four_callback;
 205     EXPECT_EQ(ERR_IO_PENDING,
 206               four_transaction.Start(GetRequestInfo("four.html", options),
 207                                      four_callback.callback(), BoundNetLog()));
 208
 209     ExpectResponse("one.html", *one_transaction.get(), SYNCHRONOUS);
 210     EXPECT_EQ(OK, two_callback.WaitForResult());
 211     ExpectResponse("two.html", two_transaction, SYNCHRONOUS);
 212     EXPECT_EQ(OK, three_callback.WaitForResult());
 213     ExpectResponse("three.html", three_transaction, SYNCHRONOUS);
 214
 215     one_transaction.reset();
 216     EXPECT_EQ(OK, four_callback.WaitForResult());
 217     ExpectResponse("four.html", four_transaction, SYNCHRONOUS);
 218   }
 219
 220   DeterministicMockClientSocketFactory factory_;
 221   ClientSocketPoolHistograms histograms_;
 222   MockTransportClientSocketPool pool_;
 223   ScopedVector<DeterministicSocketData> data_vector_;
 224   TestCompletionCallback callback_;
 225   ScopedVector<HttpRequestInfo> request_info_vector_;
 226
 227   SimpleProxyConfigService* proxy_config_service_;
 228   scoped_ptr<ProxyService> proxy_service_;
 229   MockHostResolver mock_resolver_;
 230   scoped_refptr<SSLConfigService> ssl_config_;
 231   scoped_ptr<HttpAuthHandlerMock::Factory> auth_handler_factory_;
 232   HttpServerPropertiesImpl http_server_properties_;
 233   scoped_refptr<HttpNetworkSession> session_;
 234 };
 235
 236 TEST_F(HttpPipelinedNetworkTransactionTest, OneRequest) {
 237   Initialize(false);
 238
 239   MockWrite writes[] = {
 240     MockWrite(SYNCHRONOUS, 0, "GET /test.html HTTP/1.1\r\n"
 241               "Host: localhost\r\n"
 242               "Connection: keep-alive\r\n\r\n"),
 243   };
 244   MockRead reads[] = {
 245     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
 246     MockRead(SYNCHRONOUS, 2, "Content-Length: 9\r\n\r\n"),
 247     MockRead(SYNCHRONOUS, 3, "test.html"),
 248   };
 249   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 250
 251   HttpNetworkTransaction transaction(DEFAULT_PRIORITY, session_.get());
 252   EXPECT_EQ(ERR_IO_PENDING,
 253             transaction.Start(GetRequestInfo("test.html"), callback_.callback(),
 254                               BoundNetLog()));
 255   EXPECT_EQ(OK, callback_.WaitForResult());
 256   ExpectResponse("test.html", transaction, SYNCHRONOUS);
 257 }
 258
 259 TEST_F(HttpPipelinedNetworkTransactionTest, ReusePipeline) {
 260   Initialize(false);
 261
 262   MockWrite writes[] = {
 263     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
 264               "Host: localhost\r\n"
 265               "Connection: keep-alive\r\n\r\n"),
 266     MockWrite(SYNCHRONOUS, 3, "GET /two.html HTTP/1.1\r\n"
 267               "Host: localhost\r\n"
 268               "Connection: keep-alive\r\n\r\n"),
 269   };
 270   MockRead reads[] = {
 271     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
 272     MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
 273     MockRead(ASYNC, 4, "one.html"),
 274     MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
 275     MockRead(SYNCHRONOUS, 6, "Content-Length: 8\r\n\r\n"),
 276     MockRead(SYNCHRONOUS, 7, "two.html"),
 277   };
 278   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 279
 280   CompleteTwoRequests(0, 5);
 281 }
 282
 283 TEST_F(HttpPipelinedNetworkTransactionTest, ReusesOnSpaceAvailable) {
 284   int old_max_sockets = ClientSocketPoolManager::max_sockets_per_group(
 285       HttpNetworkSession::NORMAL_SOCKET_POOL);
 286   ClientSocketPoolManager::set_max_sockets_per_group(
 287       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
 288   Initialize(false);
 289
 290   MockWrite writes[] = {
 291     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
 292               "Host: localhost\r\n"
 293               "Connection: keep-alive\r\n\r\n"),
 294     MockWrite(SYNCHRONOUS, 4, "GET /two.html HTTP/1.1\r\n"
 295               "Host: localhost\r\n"
 296               "Connection: keep-alive\r\n\r\n"),
 297     MockWrite(SYNCHRONOUS, 7, "GET /three.html HTTP/1.1\r\n"
 298               "Host: localhost\r\n"
 299               "Connection: keep-alive\r\n\r\n"),
 300     MockWrite(SYNCHRONOUS, 12, "GET /four.html HTTP/1.1\r\n"
 301               "Host: localhost\r\n"
 302               "Connection: keep-alive\r\n\r\n"),
 303   };
 304   MockRead reads[] = {
 305     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
 306     MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
 307     MockRead(SYNCHRONOUS, 3, "one.html"),
 308     MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
 309     MockRead(SYNCHRONOUS, 6, "Content-Length: 8\r\n\r\n"),
 310     MockRead(SYNCHRONOUS, 8, "two.html"),
 311     MockRead(SYNCHRONOUS, 9, "HTTP/1.1 200 OK\r\n"),
 312     MockRead(SYNCHRONOUS, 10, "Content-Length: 10\r\n\r\n"),
 313     MockRead(SYNCHRONOUS, 11, "three.html"),
 314     MockRead(SYNCHRONOUS, 13, "HTTP/1.1 200 OK\r\n"),
 315     MockRead(SYNCHRONOUS, 14, "Content-Length: 9\r\n\r\n"),
 316     MockRead(SYNCHRONOUS, 15, "four.html"),
 317   };
 318   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 319
 320   CompleteFourRequests(REQUEST_DEFAULT);
 321
 322   ClientSocketPoolManager::set_max_sockets_per_group(
 323       HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets);
 324 }
 325
 326 TEST_F(HttpPipelinedNetworkTransactionTest, WontPipelineMainResource) {
 327   int old_max_sockets = ClientSocketPoolManager::max_sockets_per_group(
 328       HttpNetworkSession::NORMAL_SOCKET_POOL);
 329   ClientSocketPoolManager::set_max_sockets_per_group(
 330       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
 331   Initialize(false);
 332
 333   MockWrite writes[] = {
 334     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
 335               "Host: localhost\r\n"
 336               "Connection: keep-alive\r\n\r\n"),
 337     MockWrite(SYNCHRONOUS, 4, "GET /two.html HTTP/1.1\r\n"
 338               "Host: localhost\r\n"
 339               "Connection: keep-alive\r\n\r\n"),
 340     MockWrite(SYNCHRONOUS, 8, "GET /three.html HTTP/1.1\r\n"
 341               "Host: localhost\r\n"
 342               "Connection: keep-alive\r\n\r\n"),
 343     MockWrite(SYNCHRONOUS, 12, "GET /four.html HTTP/1.1\r\n"
 344               "Host: localhost\r\n"
 345               "Connection: keep-alive\r\n\r\n"),
 346   };
 347   MockRead reads[] = {
 348     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
 349     MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
 350     MockRead(SYNCHRONOUS, 3, "one.html"),
 351     MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
 352     MockRead(SYNCHRONOUS, 6, "Content-Length: 8\r\n\r\n"),
 353     MockRead(SYNCHRONOUS, 7, "two.html"),
 354     MockRead(SYNCHRONOUS, 9, "HTTP/1.1 200 OK\r\n"),
 355     MockRead(SYNCHRONOUS, 10, "Content-Length: 10\r\n\r\n"),
 356     MockRead(SYNCHRONOUS, 11, "three.html"),
 357     MockRead(SYNCHRONOUS, 13, "HTTP/1.1 200 OK\r\n"),
 358     MockRead(SYNCHRONOUS, 14, "Content-Length: 9\r\n\r\n"),
 359     MockRead(SYNCHRONOUS, 15, "four.html"),
 360   };
 361   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 362
 363   CompleteFourRequests(REQUEST_MAIN_RESOURCE);
 364
 365   ClientSocketPoolManager::set_max_sockets_per_group(
 366       HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets);
 367 }
 368
 369 TEST_F(HttpPipelinedNetworkTransactionTest, UnknownSizeEvictsToNewPipeline) {
 370   Initialize(false);
 371
 372   MockWrite writes[] = {
 373     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
 374               "Host: localhost\r\n"
 375               "Connection: keep-alive\r\n\r\n"),
 376   };
 377   MockRead reads[] = {
 378     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n\r\n"),
 379     MockRead(ASYNC, 2, "one.html"),
 380     MockRead(SYNCHRONOUS, OK, 3),
 381   };
 382   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 383
 384   MockWrite writes2[] = {
 385     MockWrite(SYNCHRONOUS, 0, "GET /two.html HTTP/1.1\r\n"
 386               "Host: localhost\r\n"
 387               "Connection: keep-alive\r\n\r\n"),
 388   };
 389   MockRead reads2[] = {
 390     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
 391     MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
 392     MockRead(SYNCHRONOUS, 3, "two.html"),
 393   };
 394   AddExpectedConnection(reads2, arraysize(reads2), writes2, arraysize(writes2));
 395
 396   CompleteTwoRequests(0, 3);
 397 }
 398
 399 TEST_F(HttpPipelinedNetworkTransactionTest, ConnectionCloseEvictToNewPipeline) {
 400   Initialize(false);
 401
 402   MockWrite writes[] = {
 403     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
 404               "Host: localhost\r\n"
 405               "Connection: keep-alive\r\n\r\n"),
 406     MockWrite(SYNCHRONOUS, 3, "GET /two.html HTTP/1.1\r\n"
 407               "Host: localhost\r\n"
 408               "Connection: keep-alive\r\n\r\n"),
 409   };
 410   MockRead reads[] = {
 411     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
 412     MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
 413     MockRead(ASYNC, 4, "one.html"),
 414     MockRead(SYNCHRONOUS, ERR_SOCKET_NOT_CONNECTED, 5),
 415   };
 416   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 417
 418   MockWrite writes2[] = {
 419     MockWrite(SYNCHRONOUS, 0, "GET /two.html HTTP/1.1\r\n"
 420               "Host: localhost\r\n"
 421               "Connection: keep-alive\r\n\r\n"),
 422   };
 423   MockRead reads2[] = {
 424     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
 425     MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
 426     MockRead(SYNCHRONOUS, 3, "two.html"),
 427   };
 428   AddExpectedConnection(reads2, arraysize(reads2), writes2, arraysize(writes2));
 429
 430   CompleteTwoRequests(0, 5);
 431 }
 432
 433 TEST_F(HttpPipelinedNetworkTransactionTest, ErrorEvictsToNewPipeline) {
 434   Initialize(false);
 435
 436   MockWrite writes[] = {
 437     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
 438               "Host: localhost\r\n"
 439               "Connection: keep-alive\r\n\r\n"),
 440     MockWrite(SYNCHRONOUS, 3, "GET /two.html HTTP/1.1\r\n"
 441               "Host: localhost\r\n"
 442               "Connection: keep-alive\r\n\r\n"),
 443   };
 444   MockRead reads[] = {
 445     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n\r\n"),
 446     MockRead(SYNCHRONOUS, ERR_FAILED, 2),
 447   };
 448   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 449
 450   MockWrite writes2[] = {
 451     MockWrite(SYNCHRONOUS, 0, "GET /two.html HTTP/1.1\r\n"
 452               "Host: localhost\r\n"
 453               "Connection: keep-alive\r\n\r\n"),
 454   };
 455   MockRead reads2[] = {
 456     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
 457     MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
 458     MockRead(SYNCHRONOUS, 3, "two.html"),
 459   };
 460   AddExpectedConnection(reads2, arraysize(reads2), writes2, arraysize(writes2));
 461
 462   HttpNetworkTransaction one_transaction(DEFAULT_PRIORITY, session_.get());
 463   TestCompletionCallback one_callback;
 464   EXPECT_EQ(ERR_IO_PENDING,
 465             one_transaction.Start(GetRequestInfo("one.html"),
 466                                   one_callback.callback(), BoundNetLog()));
 467   EXPECT_EQ(OK, one_callback.WaitForResult());
 468
 469   HttpNetworkTransaction two_transaction(DEFAULT_PRIORITY, session_.get());
 470   TestCompletionCallback two_callback;
 471   EXPECT_EQ(ERR_IO_PENDING,
 472             two_transaction.Start(GetRequestInfo("two.html"),
 473                                   two_callback.callback(), BoundNetLog()));
 474
 475   scoped_refptr<IOBuffer> buffer(new IOBuffer(1));
 476   EXPECT_EQ(ERR_FAILED,
 477             one_transaction.Read(buffer.get(), 1, callback_.callback()));
 478   EXPECT_EQ(OK, two_callback.WaitForResult());
 479   ExpectResponse("two.html", two_transaction, SYNCHRONOUS);
 480 }
 481
 482 TEST_F(HttpPipelinedNetworkTransactionTest, SendErrorEvictsToNewPipeline) {
 483   Initialize(false);
 484
 485   MockWrite writes[] = {
 486     MockWrite(ASYNC, ERR_FAILED, 0),
 487   };
 488   AddExpectedConnection(NULL, 0, writes, arraysize(writes));
 489
 490   MockWrite writes2[] = {
 491     MockWrite(SYNCHRONOUS, 0, "GET /two.html HTTP/1.1\r\n"
 492               "Host: localhost\r\n"
 493               "Connection: keep-alive\r\n\r\n"),
 494   };
 495   MockRead reads2[] = {
 496     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
 497     MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
 498     MockRead(SYNCHRONOUS, 3, "two.html"),
 499   };
 500   AddExpectedConnection(reads2, arraysize(reads2), writes2, arraysize(writes2));
 501
 502   HttpNetworkTransaction one_transaction(DEFAULT_PRIORITY, session_.get());
 503   TestCompletionCallback one_callback;
 504   EXPECT_EQ(ERR_IO_PENDING,
 505             one_transaction.Start(GetRequestInfo("one.html"),
 506                                   one_callback.callback(), BoundNetLog()));
 507
 508   HttpNetworkTransaction two_transaction(DEFAULT_PRIORITY, session_.get());
 509   TestCompletionCallback two_callback;
 510   EXPECT_EQ(ERR_IO_PENDING,
 511             two_transaction.Start(GetRequestInfo("two.html"),
 512                                   two_callback.callback(), BoundNetLog()));
 513
 514   data_vector_[0]->RunFor(1);
 515   EXPECT_EQ(ERR_FAILED, one_callback.WaitForResult());
 516
 517   EXPECT_EQ(OK, two_callback.WaitForResult());
 518   ExpectResponse("two.html", two_transaction, SYNCHRONOUS);
 519 }
 520
 521 TEST_F(HttpPipelinedNetworkTransactionTest, RedirectDrained) {
 522   Initialize(false);
 523
 524   MockWrite writes[] = {
 525     MockWrite(SYNCHRONOUS, 0, "GET /redirect.html HTTP/1.1\r\n"
 526               "Host: localhost\r\n"
 527               "Connection: keep-alive\r\n\r\n"),
 528     MockWrite(SYNCHRONOUS, 3, "GET /two.html HTTP/1.1\r\n"
 529               "Host: localhost\r\n"
 530               "Connection: keep-alive\r\n\r\n"),
 531   };
 532   MockRead reads[] = {
 533     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 302 OK\r\n"),
 534     MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
 535     MockRead(ASYNC, 4, "redirect"),
 536     MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
 537     MockRead(SYNCHRONOUS, 6, "Content-Length: 8\r\n\r\n"),
 538     MockRead(SYNCHRONOUS, 7, "two.html"),
 539   };
 540   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 541
 542   scoped_ptr<HttpNetworkTransaction> one_transaction(
 543       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
 544   TestCompletionCallback one_callback;
 545   EXPECT_EQ(ERR_IO_PENDING,
 546             one_transaction->Start(GetRequestInfo("redirect.html"),
 547                                    one_callback.callback(), BoundNetLog()));
 548   EXPECT_EQ(OK, one_callback.WaitForResult());
 549
 550   HttpNetworkTransaction two_transaction(DEFAULT_PRIORITY, session_.get());
 551   TestCompletionCallback two_callback;
 552   EXPECT_EQ(ERR_IO_PENDING,
 553             two_transaction.Start(GetRequestInfo("two.html"),
 554                                   two_callback.callback(), BoundNetLog()));
 555
 556   one_transaction.reset();
 557   data_vector_[0]->RunFor(2);
 558   data_vector_[0]->SetStop(10);
 559
 560   EXPECT_EQ(OK, two_callback.WaitForResult());
 561   ExpectResponse("two.html", two_transaction, SYNCHRONOUS);
 562 }
 563
 564 TEST_F(HttpPipelinedNetworkTransactionTest, BasicHttpAuthentication) {
 565   Initialize(false);
 566
 567   MockWrite writes[] = {
 568     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
 569               "Host: localhost\r\n"
 570               "Connection: keep-alive\r\n\r\n"),
 571     MockWrite(SYNCHRONOUS, 5, "GET /one.html HTTP/1.1\r\n"
 572               "Host: localhost\r\n"
 573               "Connection: keep-alive\r\n"
 574               "Authorization: auth_token\r\n\r\n"),
 575   };
 576   MockRead reads[] = {
 577     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 401 Authentication Required\r\n"),
 578     MockRead(SYNCHRONOUS, 2,
 579              "WWW-Authenticate: Basic realm=\"Secure Area\"\r\n"),
 580     MockRead(SYNCHRONOUS, 3, "Content-Length: 20\r\n\r\n"),
 581     MockRead(SYNCHRONOUS, 4, "needs authentication"),
 582     MockRead(SYNCHRONOUS, 6, "HTTP/1.1 200 OK\r\n"),
 583     MockRead(SYNCHRONOUS, 7, "Content-Length: 8\r\n\r\n"),
 584     MockRead(SYNCHRONOUS, 8, "one.html"),
 585   };
 586   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 587
 588   HttpAuthHandlerMock* mock_auth = new HttpAuthHandlerMock;
 589   std::string challenge_text = "Basic";
 590   HttpAuth::ChallengeTokenizer challenge(challenge_text.begin(),
 591                                          challenge_text.end());
 592   GURL origin("localhost");
 593   EXPECT_TRUE(mock_auth->InitFromChallenge(&challenge,
 594                                            HttpAuth::AUTH_SERVER,
 595                                            origin,
 596                                            BoundNetLog()));
 597   auth_handler_factory_->AddMockHandler(mock_auth, HttpAuth::AUTH_SERVER);
 598
 599   HttpNetworkTransaction transaction(DEFAULT_PRIORITY, session_.get());
 600   EXPECT_EQ(ERR_IO_PENDING,
 601             transaction.Start(GetRequestInfo("one.html"),
 602                               callback_.callback(),
 603                               BoundNetLog()));
 604   EXPECT_EQ(OK, callback_.WaitForResult());
 605
 606   AuthCredentials credentials(ASCIIToUTF16("user"), ASCIIToUTF16("pass"));
 607   EXPECT_EQ(OK, transaction.RestartWithAuth(credentials, callback_.callback()));
 608
 609   ExpectResponse("one.html", transaction, SYNCHRONOUS);
 610 }
 611
 612 TEST_F(HttpPipelinedNetworkTransactionTest, OldVersionDisablesPipelining) {
 613   Initialize(false);
 614
 615   MockWrite writes[] = {
 616     MockWrite(SYNCHRONOUS, 0, "GET /pipelined.html HTTP/1.1\r\n"
 617               "Host: localhost\r\n"
 618               "Connection: keep-alive\r\n\r\n"),
 619   };
 620   MockRead reads[] = {
 621     MockRead(SYNCHRONOUS, 1, "HTTP/1.0 200 OK\r\n"),
 622     MockRead(SYNCHRONOUS, 2, "Content-Length: 14\r\n\r\n"),
 623     MockRead(SYNCHRONOUS, 3, "pipelined.html"),
 624   };
 625   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 626
 627   MockWrite writes2[] = {
 628     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
 629               "Host: localhost\r\n"
 630               "Connection: keep-alive\r\n\r\n"),
 631   };
 632   MockRead reads2[] = {
 633     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
 634     MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
 635     MockRead(ASYNC, 3, "one.html"),
 636     MockRead(SYNCHRONOUS, OK, 4),
 637   };
 638   AddExpectedConnection(reads2, arraysize(reads2), writes2, arraysize(writes2));
 639
 640   MockWrite writes3[] = {
 641     MockWrite(SYNCHRONOUS, 0, "GET /two.html HTTP/1.1\r\n"
 642               "Host: localhost\r\n"
 643               "Connection: keep-alive\r\n\r\n"),
 644   };
 645   MockRead reads3[] = {
 646     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
 647     MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
 648     MockRead(SYNCHRONOUS, 3, "two.html"),
 649     MockRead(SYNCHRONOUS, OK, 4),
 650   };
 651   AddExpectedConnection(reads3, arraysize(reads3), writes3, arraysize(writes3));
 652
 653   HttpNetworkTransaction one_transaction(DEFAULT_PRIORITY, session_.get());
 654   TestCompletionCallback one_callback;
 655   EXPECT_EQ(ERR_IO_PENDING,
 656             one_transaction.Start(GetRequestInfo("pipelined.html"),
 657                                   one_callback.callback(), BoundNetLog()));
 658   EXPECT_EQ(OK, one_callback.WaitForResult());
 659   ExpectResponse("pipelined.html", one_transaction, SYNCHRONOUS);
 660
 661   CompleteTwoRequests(1, 4);
 662 }
 663
 664 TEST_F(HttpPipelinedNetworkTransactionTest, PipelinesImmediatelyIfKnownGood) {
 665   // The first request gets us an HTTP/1.1. The next 3 test pipelining. When the
 666   // 3rd request completes, we know pipelining is safe. After the first 4
 667   // complete, the 5th and 6th should then be immediately sent pipelined on a
 668   // new HttpPipelinedConnection.
 669   int old_max_sockets = ClientSocketPoolManager::max_sockets_per_group(
 670       HttpNetworkSession::NORMAL_SOCKET_POOL);
 671   ClientSocketPoolManager::set_max_sockets_per_group(
 672       HttpNetworkSession::NORMAL_SOCKET_POOL, 1);
 673   Initialize(false);
 674
 675   MockWrite writes[] = {
 676     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
 677               "Host: localhost\r\n"
 678               "Connection: keep-alive\r\n\r\n"),
 679     MockWrite(SYNCHRONOUS, 4, "GET /two.html HTTP/1.1\r\n"
 680               "Host: localhost\r\n"
 681               "Connection: keep-alive\r\n\r\n"),
 682     MockWrite(SYNCHRONOUS, 7, "GET /three.html HTTP/1.1\r\n"
 683               "Host: localhost\r\n"
 684               "Connection: keep-alive\r\n\r\n"),
 685     MockWrite(SYNCHRONOUS, 12, "GET /four.html HTTP/1.1\r\n"
 686               "Host: localhost\r\n"
 687               "Connection: keep-alive\r\n\r\n"),
 688     MockWrite(SYNCHRONOUS, 16, "GET /second-pipeline-one.html HTTP/1.1\r\n"
 689               "Host: localhost\r\n"
 690               "Connection: keep-alive\r\n\r\n"),
 691     MockWrite(SYNCHRONOUS, 17, "GET /second-pipeline-two.html HTTP/1.1\r\n"
 692               "Host: localhost\r\n"
 693               "Connection: keep-alive\r\n\r\n"),
 694   };
 695   MockRead reads[] = {
 696     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
 697     MockRead(SYNCHRONOUS, 2, "Content-Length: 8\r\n\r\n"),
 698     MockRead(SYNCHRONOUS, 3, "one.html"),
 699     MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
 700     MockRead(SYNCHRONOUS, 6, "Content-Length: 8\r\n\r\n"),
 701     MockRead(SYNCHRONOUS, 8, "two.html"),
 702     MockRead(SYNCHRONOUS, 9, "HTTP/1.1 200 OK\r\n"),
 703     MockRead(SYNCHRONOUS, 10, "Content-Length: 10\r\n\r\n"),
 704     MockRead(SYNCHRONOUS, 11, "three.html"),
 705     MockRead(SYNCHRONOUS, 13, "HTTP/1.1 200 OK\r\n"),
 706     MockRead(SYNCHRONOUS, 14, "Content-Length: 9\r\n\r\n"),
 707     MockRead(SYNCHRONOUS, 15, "four.html"),
 708     MockRead(ASYNC, 18, "HTTP/1.1 200 OK\r\n"),
 709     MockRead(ASYNC, 19, "Content-Length: 24\r\n\r\n"),
 710     MockRead(SYNCHRONOUS, 20, "second-pipeline-one.html"),
 711     MockRead(SYNCHRONOUS, 21, "HTTP/1.1 200 OK\r\n"),
 712     MockRead(SYNCHRONOUS, 22, "Content-Length: 24\r\n\r\n"),
 713     MockRead(SYNCHRONOUS, 23, "second-pipeline-two.html"),
 714   };
 715   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 716
 717   CompleteFourRequests(REQUEST_DEFAULT);
 718
 719   HttpNetworkTransaction second_one_transaction(
 720       DEFAULT_PRIORITY, session_.get());
 721   TestCompletionCallback second_one_callback;
 722   EXPECT_EQ(ERR_IO_PENDING,
 723             second_one_transaction.Start(
 724                 GetRequestInfo("second-pipeline-one.html"),
 725                 second_one_callback.callback(), BoundNetLog()));
 726   base::MessageLoop::current()->RunUntilIdle();
 727
 728   HttpNetworkTransaction second_two_transaction(
 729       DEFAULT_PRIORITY, session_.get());
 730   TestCompletionCallback second_two_callback;
 731   EXPECT_EQ(ERR_IO_PENDING,
 732             second_two_transaction.Start(
 733                 GetRequestInfo("second-pipeline-two.html"),
 734                 second_two_callback.callback(), BoundNetLog()));
 735
 736   data_vector_[0]->RunFor(3);
 737   EXPECT_EQ(OK, second_one_callback.WaitForResult());
 738   data_vector_[0]->StopAfter(100);
 739   ExpectResponse("second-pipeline-one.html", second_one_transaction,
 740                  SYNCHRONOUS);
 741   EXPECT_EQ(OK, second_two_callback.WaitForResult());
 742   ExpectResponse("second-pipeline-two.html", second_two_transaction,
 743                  SYNCHRONOUS);
 744
 745   ClientSocketPoolManager::set_max_sockets_per_group(
 746       HttpNetworkSession::NORMAL_SOCKET_POOL, old_max_sockets);
 747 }
 748
 749 class DataRunnerObserver : public base::MessageLoop::TaskObserver {
 750  public:
 751   DataRunnerObserver(DeterministicSocketData* data, int run_before_task)
 752       : data_(data),
 753         run_before_task_(run_before_task),
 754         current_task_(0) { }
 755
 756   virtual void WillProcessTask(const base::PendingTask& pending_task) OVERRIDE {
 757     ++current_task_;
 758     if (current_task_ == run_before_task_) {
 759       data_->Run();
 760       base::MessageLoop::current()->RemoveTaskObserver(this);
 761     }
 762   }
 763
 764   virtual void DidProcessTask(const base::PendingTask& pending_task) OVERRIDE {}
 765
 766  private:
 767   DeterministicSocketData* data_;
 768   int run_before_task_;
 769   int current_task_;
 770 };
 771
 772 TEST_F(HttpPipelinedNetworkTransactionTest, OpenPipelinesWhileBinding) {
 773   // There was a racy crash in the pipelining code. This test recreates that
 774   // race. The steps are:
 775   // 1. The first request starts a pipeline and requests headers.
 776   // 2. HttpStreamFactoryImpl::Job tries to bind a pending request to a new
 777   // pipeline and queues a task to do so.
 778   // 3. Before that task runs, the first request receives its headers and
 779   // determines this host is probably capable of pipelining.
 780   // 4. All of the hosts' pipelines are notified they have capacity in a loop.
 781   // 5. On the first iteration, the first pipeline is opened up to accept new
 782   // requests and steals the request from step #2.
 783   // 6. The pipeline from #2 is deleted because it has no streams.
 784   // 7. On the second iteration, the host tries to notify the pipeline from step
 785   // #2 that it has capacity. This is a use-after-free.
 786   Initialize(false);
 787
 788   MockWrite writes[] = {
 789     MockWrite(SYNCHRONOUS, 0, "GET /one.html HTTP/1.1\r\n"
 790               "Host: localhost\r\n"
 791               "Connection: keep-alive\r\n\r\n"),
 792     MockWrite(ASYNC, 3, "GET /two.html HTTP/1.1\r\n"
 793               "Host: localhost\r\n"
 794               "Connection: keep-alive\r\n\r\n"),
 795   };
 796   MockRead reads[] = {
 797     MockRead(SYNCHRONOUS, 1, "HTTP/1.1 200 OK\r\n"),
 798     MockRead(ASYNC, 2, "Content-Length: 8\r\n\r\n"),
 799     MockRead(SYNCHRONOUS, 4, "one.html"),
 800     MockRead(SYNCHRONOUS, 5, "HTTP/1.1 200 OK\r\n"),
 801     MockRead(SYNCHRONOUS, 6, "Content-Length: 8\r\n\r\n"),
 802     MockRead(SYNCHRONOUS, 7, "two.html"),
 803   };
 804   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 805
 806   AddExpectedConnection(NULL, 0, NULL, 0);
 807
 808   HttpNetworkTransaction one_transaction(DEFAULT_PRIORITY, session_.get());
 809   TestCompletionCallback one_callback;
 810   EXPECT_EQ(ERR_IO_PENDING,
 811             one_transaction.Start(GetRequestInfo("one.html"),
 812                                   one_callback.callback(), BoundNetLog()));
 813
 814   data_vector_[0]->SetStop(2);
 815   data_vector_[0]->Run();
 816
 817   HttpNetworkTransaction two_transaction(DEFAULT_PRIORITY, session_.get());
 818   TestCompletionCallback two_callback;
 819   EXPECT_EQ(ERR_IO_PENDING,
 820             two_transaction.Start(GetRequestInfo("two.html"),
 821                                   two_callback.callback(), BoundNetLog()));
 822   // Posted tasks should be:
 823   // 1. MockHostResolverBase::ResolveNow
 824   // 2. HttpStreamFactoryImpl::Job::OnStreamReadyCallback for job 1
 825   // 3. HttpStreamFactoryImpl::Job::OnStreamReadyCallback for job 2
 826   //
 827   // We need to make sure that the response that triggers OnPipelineFeedback(OK)
 828   // is called in between when task #3 is scheduled and when it runs. The
 829   // DataRunnerObserver does that.
 830   DataRunnerObserver observer(data_vector_[0], 3);
 831   base::MessageLoop::current()->AddTaskObserver(&observer);
 832   data_vector_[0]->SetStop(4);
 833   base::MessageLoop::current()->RunUntilIdle();
 834   data_vector_[0]->SetStop(10);
 835
 836   EXPECT_EQ(OK, one_callback.WaitForResult());
 837   ExpectResponse("one.html", one_transaction, SYNCHRONOUS);
 838   EXPECT_EQ(OK, two_callback.WaitForResult());
 839   ExpectResponse("two.html", two_transaction, SYNCHRONOUS);
 840 }
 841
 842 TEST_F(HttpPipelinedNetworkTransactionTest, ProxyChangesWhileConnecting) {
 843   Initialize(false);
 844
 845   DeterministicSocketData data(NULL, 0, NULL, 0);
 846   data.set_connect_data(MockConnect(ASYNC, ERR_CONNECTION_REFUSED));
 847   factory_.AddSocketDataProvider(&data);
 848
 849   DeterministicSocketData data2(NULL, 0, NULL, 0);
 850   data2.set_connect_data(MockConnect(ASYNC, ERR_FAILED));
 851   factory_.AddSocketDataProvider(&data2);
 852
 853   HttpNetworkTransaction transaction(DEFAULT_PRIORITY, session_.get());
 854   EXPECT_EQ(ERR_IO_PENDING,
 855             transaction.Start(GetRequestInfo("test.html"), callback_.callback(),
 856                               BoundNetLog()));
 857
 858   proxy_config_service_->IncrementConfigId();
 859
 860   EXPECT_EQ(ERR_FAILED, callback_.WaitForResult());
 861 }
 862
 863 TEST_F(HttpPipelinedNetworkTransactionTest, ForcedPipelineSharesConnection) {
 864   Initialize(true);
 865
 866   MockWrite writes[] = {
 867     MockWrite(ASYNC, 0, "GET /one.html HTTP/1.1\r\n"
 868               "Host: localhost\r\n"
 869               "Connection: keep-alive\r\n\r\n"
 870               "GET /two.html HTTP/1.1\r\n"
 871               "Host: localhost\r\n"
 872               "Connection: keep-alive\r\n\r\n"),
 873   };
 874   MockRead reads[] = {
 875     MockRead(ASYNC, 1, "HTTP/1.1 200 OK\r\n"),
 876     MockRead(ASYNC, 2, "Content-Length: 8\r\n\r\n"),
 877     MockRead(ASYNC, 3, "one.html"),
 878     MockRead(ASYNC, 4, "HTTP/1.1 200 OK\r\n"),
 879     MockRead(ASYNC, 5, "Content-Length: 8\r\n\r\n"),
 880     MockRead(ASYNC, 6, "two.html"),
 881   };
 882   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 883
 884   scoped_ptr<HttpNetworkTransaction> one_transaction(
 885       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
 886   TestCompletionCallback one_callback;
 887   EXPECT_EQ(ERR_IO_PENDING,
 888             one_transaction->Start(GetRequestInfo("one.html"),
 889                                    one_callback.callback(), BoundNetLog()));
 890
 891   HttpNetworkTransaction two_transaction(DEFAULT_PRIORITY, session_.get());
 892   TestCompletionCallback two_callback;
 893   EXPECT_EQ(ERR_IO_PENDING,
 894             two_transaction.Start(GetRequestInfo("two.html"),
 895                                   two_callback.callback(), BoundNetLog()));
 896
 897   data_vector_[0]->RunFor(3);  // Send + 2 lines of headers.
 898   EXPECT_EQ(OK, one_callback.WaitForResult());
 899   ExpectResponse("one.html", *one_transaction.get(), ASYNC);
 900   one_transaction.reset();
 901
 902   data_vector_[0]->RunFor(2);  // 2 lines of headers.
 903   EXPECT_EQ(OK, two_callback.WaitForResult());
 904   ExpectResponse("two.html", two_transaction, ASYNC);
 905 }
 906
 907 TEST_F(HttpPipelinedNetworkTransactionTest,
 908        ForcedPipelineConnectionErrorFailsBoth) {
 909   Initialize(true);
 910
 911   DeterministicSocketData data(NULL, 0, NULL, 0);
 912   data.set_connect_data(MockConnect(ASYNC, ERR_FAILED));
 913   factory_.AddSocketDataProvider(&data);
 914
 915   scoped_ptr<HttpNetworkTransaction> one_transaction(
 916       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
 917   TestCompletionCallback one_callback;
 918   EXPECT_EQ(ERR_IO_PENDING,
 919             one_transaction->Start(GetRequestInfo("one.html"),
 920                                    one_callback.callback(), BoundNetLog()));
 921
 922   HttpNetworkTransaction two_transaction(DEFAULT_PRIORITY, session_.get());
 923   TestCompletionCallback two_callback;
 924   EXPECT_EQ(ERR_IO_PENDING,
 925             two_transaction.Start(GetRequestInfo("two.html"),
 926                                   two_callback.callback(), BoundNetLog()));
 927
 928   data.Run();
 929   EXPECT_EQ(ERR_FAILED, one_callback.WaitForResult());
 930   EXPECT_EQ(ERR_FAILED, two_callback.WaitForResult());
 931 }
 932
 933 TEST_F(HttpPipelinedNetworkTransactionTest, ForcedPipelineEvictionIsFatal) {
 934   Initialize(true);
 935
 936   MockWrite writes[] = {
 937     MockWrite(ASYNC, 0, "GET /one.html HTTP/1.1\r\n"
 938               "Host: localhost\r\n"
 939               "Connection: keep-alive\r\n\r\n"
 940               "GET /two.html HTTP/1.1\r\n"
 941               "Host: localhost\r\n"
 942               "Connection: keep-alive\r\n\r\n"),
 943   };
 944   MockRead reads[] = {
 945     MockRead(ASYNC, ERR_FAILED, 1),
 946   };
 947   AddExpectedConnection(reads, arraysize(reads), writes, arraysize(writes));
 948
 949   scoped_ptr<HttpNetworkTransaction> one_transaction(
 950       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
 951   TestCompletionCallback one_callback;
 952   EXPECT_EQ(ERR_IO_PENDING,
 953             one_transaction->Start(GetRequestInfo("one.html"),
 954                                    one_callback.callback(), BoundNetLog()));
 955
 956   HttpNetworkTransaction two_transaction(DEFAULT_PRIORITY, session_.get());
 957   TestCompletionCallback two_callback;
 958   EXPECT_EQ(ERR_IO_PENDING,
 959             two_transaction.Start(GetRequestInfo("two.html"),
 960                                   two_callback.callback(), BoundNetLog()));
 961
 962   data_vector_[0]->RunFor(2);
 963   EXPECT_EQ(ERR_FAILED, one_callback.WaitForResult());
 964   one_transaction.reset();
 965   EXPECT_EQ(ERR_PIPELINE_EVICTION, two_callback.WaitForResult());
 966 }
 967
 968 TEST_F(HttpPipelinedNetworkTransactionTest, ForcedPipelineOrder) {
 969   Initialize(true);
 970
 971   MockWrite writes[] = {
 972     MockWrite(ASYNC, 0,
 973               "GET /one.html HTTP/1.1\r\n"
 974               "Host: localhost\r\n"
 975               "Connection: keep-alive\r\n\r\n"
 976               "GET /two.html HTTP/1.1\r\n"
 977               "Host: localhost\r\n"
 978               "Connection: keep-alive\r\n\r\n"
 979               "GET /three.html HTTP/1.1\r\n"
 980               "Host: localhost\r\n"
 981               "Connection: keep-alive\r\n\r\n"
 982               "GET /four.html HTTP/1.1\r\n"
 983               "Host: localhost\r\n"
 984               "Connection: keep-alive\r\n\r\n"
 985               ),
 986   };
 987   MockRead reads[] = {
 988     MockRead(ASYNC, ERR_FAILED, 1),
 989   };
 990   DeterministicSocketData data(
 991       reads, arraysize(reads), writes, arraysize(writes));
 992   data.set_connect_data(MockConnect(ASYNC, OK));
 993   factory_.AddSocketDataProvider(&data);
 994
 995   scoped_ptr<HttpNetworkTransaction> one_transaction(
 996       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
 997   TestCompletionCallback one_callback;
 998   EXPECT_EQ(ERR_IO_PENDING,
 999             one_transaction->Start(GetRequestInfo("one.html"),
1000                                    one_callback.callback(), BoundNetLog()));
1001
1002   scoped_ptr<HttpNetworkTransaction> two_transaction(
1003       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
1004   TestCompletionCallback two_callback;
1005   EXPECT_EQ(ERR_IO_PENDING,
1006             two_transaction->Start(GetRequestInfo("two.html"),
1007                                    two_callback.callback(), BoundNetLog()));
1008
1009   scoped_ptr<HttpNetworkTransaction> three_transaction(
1010       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
1011   TestCompletionCallback three_callback;
1012   EXPECT_EQ(ERR_IO_PENDING,
1013             three_transaction->Start(GetRequestInfo("three.html"),
1014                                      three_callback.callback(), BoundNetLog()));
1015
1016   scoped_ptr<HttpNetworkTransaction> four_transaction(
1017       new HttpNetworkTransaction(DEFAULT_PRIORITY, session_.get()));
1018   TestCompletionCallback four_callback;
1019   EXPECT_EQ(ERR_IO_PENDING,
1020             four_transaction->Start(GetRequestInfo("four.html"),
1021                                     four_callback.callback(), BoundNetLog()));
1022
1023   data.RunFor(3);
1024   EXPECT_EQ(ERR_FAILED, one_callback.WaitForResult());
1025   one_transaction.reset();
1026   EXPECT_EQ(ERR_PIPELINE_EVICTION, two_callback.WaitForResult());
1027   two_transaction.reset();
1028   EXPECT_EQ(ERR_PIPELINE_EVICTION, three_callback.WaitForResult());
1029   three_transaction.reset();
1030   EXPECT_EQ(ERR_PIPELINE_EVICTION, four_callback.WaitForResult());
1031 }
1032
1033 }  // anonymous namespace
1034
1035 }  // namespace net