net/spdy/spdy_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 #include <vector>
   7
   8 #include "base/bind.h"
   9 #include "base/bind_helpers.h"
  10 #include "base/files/file_util.h"
  11 #include "base/files/scoped_temp_dir.h"
  12 #include "base/memory/scoped_vector.h"
  13 #include "base/run_loop.h"
  14 #include "base/stl_util.h"
  15 #include "base/strings/string_piece.h"
  16 #include "base/test/test_file_util.h"
  17 #include "net/base/auth.h"
  18 #include "net/base/chunked_upload_data_stream.h"
  19 #include "net/base/elements_upload_data_stream.h"
  20 #include "net/base/net_log_unittest.h"
  21 #include "net/base/request_priority.h"
  22 #include "net/base/upload_bytes_element_reader.h"
  23 #include "net/base/upload_file_element_reader.h"
  24 #include "net/http/http_network_session_peer.h"
  25 #include "net/http/http_network_transaction.h"
  26 #include "net/http/http_server_properties.h"
  27 #include "net/http/http_transaction_test_util.h"
  28 #include "net/socket/client_socket_pool_base.h"
  29 #include "net/socket/next_proto.h"
  30 #include "net/spdy/buffered_spdy_framer.h"
  31 #include "net/spdy/spdy_http_stream.h"
  32 #include "net/spdy/spdy_http_utils.h"
  33 #include "net/spdy/spdy_session.h"
  34 #include "net/spdy/spdy_session_pool.h"
  35 #include "net/spdy/spdy_test_util_common.h"
  36 #include "net/spdy/spdy_test_utils.h"
  37 #include "net/ssl/ssl_connection_status_flags.h"
  38 #include "net/url_request/url_request_test_util.h"
  39 #include "testing/gmock/include/gmock/gmock.h"
  40 #include "testing/platform_test.h"
  41
  42 //-----------------------------------------------------------------------------
  43
  44 namespace net {
  45
  46 namespace {
  47
  48 using testing::Each;
  49 using testing::Eq;
  50
  51 const char kRequestUrl[] = "http://www.google.com/";
  52
  53 enum SpdyNetworkTransactionTestSSLType {
  54   SPDYNPN,
  55   SPDYNOSSL,
  56   SPDYSSL,
  57 };
  58
  59 struct SpdyNetworkTransactionTestParams {
  60   SpdyNetworkTransactionTestParams()
  61       : protocol(kProtoSPDY31),
  62         ssl_type(SPDYNPN) {}
  63
  64   SpdyNetworkTransactionTestParams(
  65       NextProto protocol,
  66       SpdyNetworkTransactionTestSSLType ssl_type)
  67       : protocol(protocol),
  68         ssl_type(ssl_type) {}
  69
  70   NextProto protocol;
  71   SpdyNetworkTransactionTestSSLType ssl_type;
  72 };
  73
  74 void UpdateSpdySessionDependencies(
  75     SpdyNetworkTransactionTestParams test_params,
  76     SpdySessionDependencies* session_deps) {
  77   switch (test_params.ssl_type) {
  78     case SPDYNPN:
  79       session_deps->http_server_properties.SetAlternateProtocol(
  80           HostPortPair("www.google.com", 80), 443,
  81           AlternateProtocolFromNextProto(test_params.protocol), 1);
  82       session_deps->use_alternate_protocols = true;
  83       session_deps->next_protos = SpdyNextProtos();
  84       break;
  85     case SPDYNOSSL:
  86       session_deps->force_spdy_over_ssl = false;
  87       session_deps->force_spdy_always = true;
  88       break;
  89     case SPDYSSL:
  90       session_deps->force_spdy_over_ssl = true;
  91       session_deps->force_spdy_always = true;
  92       break;
  93     default:
  94       NOTREACHED();
  95   }
  96 }
  97
  98 SpdySessionDependencies* CreateSpdySessionDependencies(
  99     SpdyNetworkTransactionTestParams test_params) {
 100   SpdySessionDependencies* session_deps =
 101       new SpdySessionDependencies(test_params.protocol);
 102   UpdateSpdySessionDependencies(test_params, session_deps);
 103   return session_deps;
 104 }
 105
 106 SpdySessionDependencies* CreateSpdySessionDependencies(
 107     SpdyNetworkTransactionTestParams test_params,
 108     ProxyService* proxy_service) {
 109   SpdySessionDependencies* session_deps =
 110       new SpdySessionDependencies(test_params.protocol, proxy_service);
 111   UpdateSpdySessionDependencies(test_params, session_deps);
 112   return session_deps;
 113 }
 114
 115 }  // namespace
 116
 117 class SpdyNetworkTransactionTest
 118     : public ::testing::TestWithParam<SpdyNetworkTransactionTestParams> {
 119  protected:
 120   SpdyNetworkTransactionTest() : spdy_util_(GetParam().protocol) {
 121   }
 122
 123   virtual ~SpdyNetworkTransactionTest() {
 124     // UploadDataStream may post a deletion tasks back to the message loop on
 125     // destruction.
 126     upload_data_stream_.reset();
 127     base::RunLoop().RunUntilIdle();
 128   }
 129
 130   void SetUp() override {
 131     google_get_request_initialized_ = false;
 132     google_post_request_initialized_ = false;
 133     google_chunked_post_request_initialized_ = false;
 134     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 135   }
 136
 137   struct TransactionHelperResult {
 138     int rv;
 139     std::string status_line;
 140     std::string response_data;
 141     HttpResponseInfo response_info;
 142   };
 143
 144   // A helper class that handles all the initial npn/ssl setup.
 145   class NormalSpdyTransactionHelper {
 146    public:
 147     NormalSpdyTransactionHelper(const HttpRequestInfo& request,
 148                                 RequestPriority priority,
 149                                 const BoundNetLog& log,
 150                                 SpdyNetworkTransactionTestParams test_params,
 151                                 SpdySessionDependencies* session_deps)
 152         : request_(request),
 153           priority_(priority),
 154           session_deps_(session_deps == NULL ?
 155                         CreateSpdySessionDependencies(test_params) :
 156                         session_deps),
 157           session_(SpdySessionDependencies::SpdyCreateSession(
 158                        session_deps_.get())),
 159           log_(log),
 160           test_params_(test_params),
 161           deterministic_(false),
 162           spdy_enabled_(true) {
 163       switch (test_params_.ssl_type) {
 164         case SPDYNOSSL:
 165         case SPDYSSL:
 166           port_ = 80;
 167           break;
 168         case SPDYNPN:
 169           port_ = 443;
 170           break;
 171         default:
 172           NOTREACHED();
 173       }
 174     }
 175
 176     ~NormalSpdyTransactionHelper() {
 177       // Any test which doesn't close the socket by sending it an EOF will
 178       // have a valid session left open, which leaks the entire session pool.
 179       // This is just fine - in fact, some of our tests intentionally do this
 180       // so that we can check consistency of the SpdySessionPool as the test
 181       // finishes.  If we had put an EOF on the socket, the SpdySession would
 182       // have closed and we wouldn't be able to check the consistency.
 183
 184       // Forcefully close existing sessions here.
 185       session()->spdy_session_pool()->CloseAllSessions();
 186     }
 187
 188     void SetDeterministic() {
 189       session_ = SpdySessionDependencies::SpdyCreateSessionDeterministic(
 190           session_deps_.get());
 191       deterministic_ = true;
 192     }
 193
 194     void SetSpdyDisabled() {
 195       spdy_enabled_ = false;
 196       port_ = 80;
 197     }
 198
 199     void RunPreTestSetup() {
 200       if (!session_deps_.get())
 201         session_deps_.reset(CreateSpdySessionDependencies(test_params_));
 202       if (!session_.get()) {
 203         session_ = SpdySessionDependencies::SpdyCreateSession(
 204             session_deps_.get());
 205       }
 206
 207       // We're now ready to use SSL-npn SPDY.
 208       trans_.reset(new HttpNetworkTransaction(priority_, session_.get()));
 209     }
 210
 211     // Start the transaction, read some data, finish.
 212     void RunDefaultTest() {
 213       if (!StartDefaultTest())
 214         return;
 215       FinishDefaultTest();
 216     }
 217
 218     bool StartDefaultTest() {
 219       output_.rv = trans_->Start(&request_, callback_.callback(), log_);
 220
 221       // We expect an IO Pending or some sort of error.
 222       EXPECT_LT(output_.rv, 0);
 223       return output_.rv == ERR_IO_PENDING;
 224     }
 225
 226     void FinishDefaultTest() {
 227       output_.rv = callback_.WaitForResult();
 228       if (output_.rv != OK) {
 229         session_->spdy_session_pool()->CloseCurrentSessions(net::ERR_ABORTED);
 230         return;
 231       }
 232
 233       // Verify responses.
 234       const HttpResponseInfo* response = trans_->GetResponseInfo();
 235       ASSERT_TRUE(response != NULL);
 236       ASSERT_TRUE(response->headers.get() != NULL);
 237       EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
 238       EXPECT_EQ(spdy_enabled_, response->was_fetched_via_spdy);
 239       if (HttpStreamFactory::spdy_enabled()) {
 240         EXPECT_EQ(
 241             HttpResponseInfo::ConnectionInfoFromNextProto(
 242                 test_params_.protocol),
 243             response->connection_info);
 244       } else {
 245         EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1,
 246                   response->connection_info);
 247       }
 248       if (test_params_.ssl_type == SPDYNPN && spdy_enabled_) {
 249         EXPECT_TRUE(response->was_npn_negotiated);
 250       } else {
 251         EXPECT_TRUE(!response->was_npn_negotiated);
 252       }
 253       // If SPDY is not enabled, a HTTP request should not be diverted
 254       // over a SSL session.
 255       if (!spdy_enabled_) {
 256         EXPECT_EQ(request_.url.SchemeIs("https"),
 257                   response->was_npn_negotiated);
 258       }
 259       EXPECT_EQ("127.0.0.1", response->socket_address.host());
 260       EXPECT_EQ(port_, response->socket_address.port());
 261       output_.status_line = response->headers->GetStatusLine();
 262       output_.response_info = *response;  // Make a copy so we can verify.
 263       output_.rv = ReadTransaction(trans_.get(), &output_.response_data);
 264     }
 265
 266     void FinishDefaultTestWithoutVerification() {
 267       output_.rv = callback_.WaitForResult();
 268       if (output_.rv != OK)
 269         session_->spdy_session_pool()->CloseCurrentSessions(net::ERR_ABORTED);
 270     }
 271
 272     // Most tests will want to call this function. In particular, the MockReads
 273     // should end with an empty read, and that read needs to be processed to
 274     // ensure proper deletion of the spdy_session_pool.
 275     void VerifyDataConsumed() {
 276       for (DataVector::iterator it = data_vector_.begin();
 277           it != data_vector_.end(); ++it) {
 278         EXPECT_TRUE((*it)->at_read_eof()) << "Read count: "
 279                                           << (*it)->read_count()
 280                                           << " Read index: "
 281                                           << (*it)->read_index();
 282         EXPECT_TRUE((*it)->at_write_eof()) << "Write count: "
 283                                            << (*it)->write_count()
 284                                            << " Write index: "
 285                                            << (*it)->write_index();
 286       }
 287     }
 288
 289     // Occasionally a test will expect to error out before certain reads are
 290     // processed. In that case we want to explicitly ensure that the reads were
 291     // not processed.
 292     void VerifyDataNotConsumed() {
 293       for (DataVector::iterator it = data_vector_.begin();
 294           it != data_vector_.end(); ++it) {
 295         EXPECT_TRUE(!(*it)->at_read_eof()) << "Read count: "
 296                                            << (*it)->read_count()
 297                                            << " Read index: "
 298                                            << (*it)->read_index();
 299         EXPECT_TRUE(!(*it)->at_write_eof()) << "Write count: "
 300                                             << (*it)->write_count()
 301                                             << " Write index: "
 302                                             << (*it)->write_index();
 303       }
 304     }
 305
 306     void RunToCompletion(StaticSocketDataProvider* data) {
 307       RunPreTestSetup();
 308       AddData(data);
 309       RunDefaultTest();
 310       VerifyDataConsumed();
 311     }
 312
 313     void RunToCompletionWithSSLData(
 314         StaticSocketDataProvider* data,
 315         scoped_ptr<SSLSocketDataProvider> ssl_provider) {
 316       RunPreTestSetup();
 317       AddDataWithSSLSocketDataProvider(data, ssl_provider.Pass());
 318       RunDefaultTest();
 319       VerifyDataConsumed();
 320     }
 321
 322     void AddData(StaticSocketDataProvider* data) {
 323       scoped_ptr<SSLSocketDataProvider> ssl_provider(
 324           new SSLSocketDataProvider(ASYNC, OK));
 325       AddDataWithSSLSocketDataProvider(data, ssl_provider.Pass());
 326     }
 327
 328     void AddDataWithSSLSocketDataProvider(
 329         StaticSocketDataProvider* data,
 330         scoped_ptr<SSLSocketDataProvider> ssl_provider) {
 331       DCHECK(!deterministic_);
 332       data_vector_.push_back(data);
 333       if (test_params_.ssl_type == SPDYNPN)
 334         ssl_provider->SetNextProto(test_params_.protocol);
 335
 336       if (test_params_.ssl_type == SPDYNPN ||
 337           test_params_.ssl_type == SPDYSSL) {
 338         session_deps_->socket_factory->AddSSLSocketDataProvider(
 339             ssl_provider.get());
 340       }
 341       ssl_vector_.push_back(ssl_provider.release());
 342
 343       session_deps_->socket_factory->AddSocketDataProvider(data);
 344       if (test_params_.ssl_type == SPDYNPN) {
 345         MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
 346         StaticSocketDataProvider* hanging_non_alternate_protocol_socket =
 347             new StaticSocketDataProvider(NULL, 0, NULL, 0);
 348         hanging_non_alternate_protocol_socket->set_connect_data(
 349             never_finishing_connect);
 350         session_deps_->socket_factory->AddSocketDataProvider(
 351             hanging_non_alternate_protocol_socket);
 352         alternate_vector_.push_back(hanging_non_alternate_protocol_socket);
 353       }
 354     }
 355
 356     void AddDeterministicData(DeterministicSocketData* data) {
 357       DCHECK(deterministic_);
 358       data_vector_.push_back(data);
 359       SSLSocketDataProvider* ssl_provider =
 360           new SSLSocketDataProvider(ASYNC, OK);
 361       if (test_params_.ssl_type == SPDYNPN)
 362         ssl_provider->SetNextProto(test_params_.protocol);
 363
 364       ssl_vector_.push_back(ssl_provider);
 365       if (test_params_.ssl_type == SPDYNPN ||
 366           test_params_.ssl_type == SPDYSSL) {
 367         session_deps_->deterministic_socket_factory->
 368             AddSSLSocketDataProvider(ssl_provider);
 369       }
 370       session_deps_->deterministic_socket_factory->AddSocketDataProvider(data);
 371       if (test_params_.ssl_type == SPDYNPN) {
 372         MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
 373         DeterministicSocketData* hanging_non_alternate_protocol_socket =
 374             new DeterministicSocketData(NULL, 0, NULL, 0);
 375         hanging_non_alternate_protocol_socket->set_connect_data(
 376             never_finishing_connect);
 377         session_deps_->deterministic_socket_factory->AddSocketDataProvider(
 378             hanging_non_alternate_protocol_socket);
 379         alternate_deterministic_vector_.push_back(
 380             hanging_non_alternate_protocol_socket);
 381       }
 382     }
 383
 384     void SetSession(const scoped_refptr<HttpNetworkSession>& session) {
 385       session_ = session;
 386     }
 387     HttpNetworkTransaction* trans() { return trans_.get(); }
 388     void ResetTrans() { trans_.reset(); }
 389     TransactionHelperResult& output() { return output_; }
 390     const HttpRequestInfo& request() const { return request_; }
 391     const scoped_refptr<HttpNetworkSession>& session() const {
 392       return session_;
 393     }
 394     scoped_ptr<SpdySessionDependencies>& session_deps() {
 395       return session_deps_;
 396     }
 397     int port() const { return port_; }
 398     SpdyNetworkTransactionTestParams test_params() const {
 399       return test_params_;
 400     }
 401
 402    private:
 403     typedef std::vector<StaticSocketDataProvider*> DataVector;
 404     typedef ScopedVector<SSLSocketDataProvider> SSLVector;
 405     typedef ScopedVector<StaticSocketDataProvider> AlternateVector;
 406     typedef ScopedVector<DeterministicSocketData> AlternateDeterministicVector;
 407     HttpRequestInfo request_;
 408     RequestPriority priority_;
 409     scoped_ptr<SpdySessionDependencies> session_deps_;
 410     scoped_refptr<HttpNetworkSession> session_;
 411     TransactionHelperResult output_;
 412     scoped_ptr<StaticSocketDataProvider> first_transaction_;
 413     SSLVector ssl_vector_;
 414     TestCompletionCallback callback_;
 415     scoped_ptr<HttpNetworkTransaction> trans_;
 416     scoped_ptr<HttpNetworkTransaction> trans_http_;
 417     DataVector data_vector_;
 418     AlternateVector alternate_vector_;
 419     AlternateDeterministicVector alternate_deterministic_vector_;
 420     const BoundNetLog log_;
 421     SpdyNetworkTransactionTestParams test_params_;
 422     int port_;
 423     bool deterministic_;
 424     bool spdy_enabled_;
 425   };
 426
 427   void ConnectStatusHelperWithExpectedStatus(const MockRead& status,
 428                                              int expected_status);
 429
 430   void ConnectStatusHelper(const MockRead& status);
 431
 432   const HttpRequestInfo& CreateGetPushRequest() {
 433     google_get_push_request_.method = "GET";
 434     google_get_push_request_.url = GURL("http://www.google.com/foo.dat");
 435     google_get_push_request_.load_flags = 0;
 436     return google_get_push_request_;
 437   }
 438
 439   const HttpRequestInfo& CreateGetRequest() {
 440     if (!google_get_request_initialized_) {
 441       google_get_request_.method = "GET";
 442       google_get_request_.url = GURL(kDefaultURL);
 443       google_get_request_.load_flags = 0;
 444       google_get_request_initialized_ = true;
 445     }
 446     return google_get_request_;
 447   }
 448
 449   const HttpRequestInfo& CreateGetRequestWithUserAgent() {
 450     if (!google_get_request_initialized_) {
 451       google_get_request_.method = "GET";
 452       google_get_request_.url = GURL(kDefaultURL);
 453       google_get_request_.load_flags = 0;
 454       google_get_request_.extra_headers.SetHeader("User-Agent", "Chrome");
 455       google_get_request_initialized_ = true;
 456     }
 457     return google_get_request_;
 458   }
 459
 460   const HttpRequestInfo& CreatePostRequest() {
 461     if (!google_post_request_initialized_) {
 462       ScopedVector<UploadElementReader> element_readers;
 463       element_readers.push_back(
 464           new UploadBytesElementReader(kUploadData, kUploadDataSize));
 465       upload_data_stream_.reset(
 466           new ElementsUploadDataStream(element_readers.Pass(), 0));
 467
 468       google_post_request_.method = "POST";
 469       google_post_request_.url = GURL(kDefaultURL);
 470       google_post_request_.upload_data_stream = upload_data_stream_.get();
 471       google_post_request_initialized_ = true;
 472     }
 473     return google_post_request_;
 474   }
 475
 476   const HttpRequestInfo& CreateFilePostRequest() {
 477     if (!google_post_request_initialized_) {
 478       base::FilePath file_path;
 479       CHECK(base::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
 480       CHECK_EQ(static_cast<int>(kUploadDataSize),
 481                base::WriteFile(file_path, kUploadData, kUploadDataSize));
 482
 483       ScopedVector<UploadElementReader> element_readers;
 484       element_readers.push_back(
 485           new UploadFileElementReader(base::MessageLoopProxy::current().get(),
 486                                       file_path,
 487                                       0,
 488                                       kUploadDataSize,
 489                                       base::Time()));
 490       upload_data_stream_.reset(
 491           new ElementsUploadDataStream(element_readers.Pass(), 0));
 492
 493       google_post_request_.method = "POST";
 494       google_post_request_.url = GURL(kDefaultURL);
 495       google_post_request_.upload_data_stream = upload_data_stream_.get();
 496       google_post_request_initialized_ = true;
 497     }
 498     return google_post_request_;
 499   }
 500
 501   const HttpRequestInfo& CreateUnreadableFilePostRequest() {
 502     if (google_post_request_initialized_)
 503       return google_post_request_;
 504
 505     base::FilePath file_path;
 506     CHECK(base::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
 507     CHECK_EQ(static_cast<int>(kUploadDataSize),
 508              base::WriteFile(file_path, kUploadData, kUploadDataSize));
 509     CHECK(base::MakeFileUnreadable(file_path));
 510
 511     ScopedVector<UploadElementReader> element_readers;
 512     element_readers.push_back(
 513         new UploadFileElementReader(base::MessageLoopProxy::current().get(),
 514                                     file_path,
 515                                     0,
 516                                     kUploadDataSize,
 517                                     base::Time()));
 518     upload_data_stream_.reset(
 519         new ElementsUploadDataStream(element_readers.Pass(), 0));
 520
 521     google_post_request_.method = "POST";
 522     google_post_request_.url = GURL(kDefaultURL);
 523     google_post_request_.upload_data_stream = upload_data_stream_.get();
 524     google_post_request_initialized_ = true;
 525     return google_post_request_;
 526   }
 527
 528   const HttpRequestInfo& CreateComplexPostRequest() {
 529     if (!google_post_request_initialized_) {
 530       const int kFileRangeOffset = 1;
 531       const int kFileRangeLength = 3;
 532       CHECK_LT(kFileRangeOffset + kFileRangeLength, kUploadDataSize);
 533
 534       base::FilePath file_path;
 535       CHECK(base::CreateTemporaryFileInDir(temp_dir_.path(), &file_path));
 536       CHECK_EQ(static_cast<int>(kUploadDataSize),
 537                base::WriteFile(file_path, kUploadData, kUploadDataSize));
 538
 539       ScopedVector<UploadElementReader> element_readers;
 540       element_readers.push_back(
 541           new UploadBytesElementReader(kUploadData, kFileRangeOffset));
 542       element_readers.push_back(
 543           new UploadFileElementReader(base::MessageLoopProxy::current().get(),
 544                                       file_path,
 545                                       kFileRangeOffset,
 546                                       kFileRangeLength,
 547                                       base::Time()));
 548       element_readers.push_back(new UploadBytesElementReader(
 549           kUploadData + kFileRangeOffset + kFileRangeLength,
 550           kUploadDataSize - (kFileRangeOffset + kFileRangeLength)));
 551       upload_data_stream_.reset(
 552           new ElementsUploadDataStream(element_readers.Pass(), 0));
 553
 554       google_post_request_.method = "POST";
 555       google_post_request_.url = GURL(kDefaultURL);
 556       google_post_request_.upload_data_stream = upload_data_stream_.get();
 557       google_post_request_initialized_ = true;
 558     }
 559     return google_post_request_;
 560   }
 561
 562   const HttpRequestInfo& CreateChunkedPostRequest() {
 563     if (!google_chunked_post_request_initialized_) {
 564       upload_chunked_data_stream_.reset(new ChunkedUploadDataStream(0));
 565       google_chunked_post_request_.method = "POST";
 566       google_chunked_post_request_.url = GURL(kDefaultURL);
 567       google_chunked_post_request_.upload_data_stream =
 568           upload_chunked_data_stream_.get();
 569       google_chunked_post_request_initialized_ = true;
 570     }
 571     return google_chunked_post_request_;
 572   }
 573
 574   // Read the result of a particular transaction, knowing that we've got
 575   // multiple transactions in the read pipeline; so as we read, we may have
 576   // to skip over data destined for other transactions while we consume
 577   // the data for |trans|.
 578   int ReadResult(HttpNetworkTransaction* trans,
 579                  StaticSocketDataProvider* data,
 580                  std::string* result) {
 581     const int kSize = 3000;
 582
 583     int bytes_read = 0;
 584     scoped_refptr<net::IOBufferWithSize> buf(new net::IOBufferWithSize(kSize));
 585     TestCompletionCallback callback;
 586     while (true) {
 587       int rv = trans->Read(buf.get(), kSize, callback.callback());
 588       if (rv == ERR_IO_PENDING) {
 589         // Multiple transactions may be in the data set.  Keep pulling off
 590         // reads until we complete our callback.
 591         while (!callback.have_result()) {
 592           data->CompleteRead();
 593           base::RunLoop().RunUntilIdle();
 594         }
 595         rv = callback.WaitForResult();
 596       } else if (rv <= 0) {
 597         break;
 598       }
 599       result->append(buf->data(), rv);
 600       bytes_read += rv;
 601     }
 602     return bytes_read;
 603   }
 604
 605   void VerifyStreamsClosed(const NormalSpdyTransactionHelper& helper) {
 606     // This lengthy block is reaching into the pool to dig out the active
 607     // session.  Once we have the session, we verify that the streams are
 608     // all closed and not leaked at this point.
 609     const GURL& url = helper.request().url;
 610     int port = helper.test_params().ssl_type == SPDYNPN ? 443 : 80;
 611     HostPortPair host_port_pair(url.host(), port);
 612     SpdySessionKey key(host_port_pair, ProxyServer::Direct(),
 613                        PRIVACY_MODE_DISABLED);
 614     BoundNetLog log;
 615     const scoped_refptr<HttpNetworkSession>& session = helper.session();
 616     base::WeakPtr<SpdySession> spdy_session =
 617         session->spdy_session_pool()->FindAvailableSession(key, log);
 618     ASSERT_TRUE(spdy_session != NULL);
 619     EXPECT_EQ(0u, spdy_session->num_active_streams());
 620     EXPECT_EQ(0u, spdy_session->num_unclaimed_pushed_streams());
 621   }
 622
 623   void RunServerPushTest(OrderedSocketData* data,
 624                          HttpResponseInfo* response,
 625                          HttpResponseInfo* push_response,
 626                          const std::string& expected) {
 627     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
 628                                        BoundNetLog(), GetParam(), NULL);
 629     helper.RunPreTestSetup();
 630     helper.AddData(data);
 631
 632     HttpNetworkTransaction* trans = helper.trans();
 633
 634     // Start the transaction with basic parameters.
 635     TestCompletionCallback callback;
 636     int rv = trans->Start(
 637         &CreateGetRequest(), callback.callback(), BoundNetLog());
 638     EXPECT_EQ(ERR_IO_PENDING, rv);
 639     rv = callback.WaitForResult();
 640
 641     // Request the pushed path.
 642     scoped_ptr<HttpNetworkTransaction> trans2(
 643         new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 644     rv = trans2->Start(
 645         &CreateGetPushRequest(), callback.callback(), BoundNetLog());
 646     EXPECT_EQ(ERR_IO_PENDING, rv);
 647     base::RunLoop().RunUntilIdle();
 648
 649     // The data for the pushed path may be coming in more than 1 frame. Compile
 650     // the results into a single string.
 651
 652     // Read the server push body.
 653     std::string result2;
 654     ReadResult(trans2.get(), data, &result2);
 655     // Read the response body.
 656     std::string result;
 657     ReadResult(trans, data, &result);
 658
 659     // Verify that we consumed all test data.
 660     EXPECT_TRUE(data->at_read_eof());
 661     EXPECT_TRUE(data->at_write_eof());
 662
 663     // Verify that the received push data is same as the expected push data.
 664     EXPECT_EQ(result2.compare(expected), 0) << "Received data: "
 665                                             << result2
 666                                             << "||||| Expected data: "
 667                                             << expected;
 668
 669     // Verify the SYN_REPLY.
 670     // Copy the response info, because trans goes away.
 671     *response = *trans->GetResponseInfo();
 672     *push_response = *trans2->GetResponseInfo();
 673
 674     VerifyStreamsClosed(helper);
 675   }
 676
 677   static void DeleteSessionCallback(NormalSpdyTransactionHelper* helper,
 678                                     int result) {
 679     helper->ResetTrans();
 680   }
 681
 682   static void StartTransactionCallback(
 683       const scoped_refptr<HttpNetworkSession>& session,
 684       int result) {
 685     scoped_ptr<HttpNetworkTransaction> trans(
 686         new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 687     TestCompletionCallback callback;
 688     HttpRequestInfo request;
 689     request.method = "GET";
 690     request.url = GURL("http://www.google.com/");
 691     request.load_flags = 0;
 692     int rv = trans->Start(&request, callback.callback(), BoundNetLog());
 693     EXPECT_EQ(ERR_IO_PENDING, rv);
 694     callback.WaitForResult();
 695   }
 696
 697   ChunkedUploadDataStream* upload_chunked_data_stream() const {
 698     return upload_chunked_data_stream_.get();
 699   }
 700
 701   SpdyTestUtil spdy_util_;
 702
 703  private:
 704   scoped_ptr<ChunkedUploadDataStream> upload_chunked_data_stream_;
 705   scoped_ptr<UploadDataStream> upload_data_stream_;
 706   bool google_get_request_initialized_;
 707   bool google_post_request_initialized_;
 708   bool google_chunked_post_request_initialized_;
 709   HttpRequestInfo google_get_request_;
 710   HttpRequestInfo google_post_request_;
 711   HttpRequestInfo google_chunked_post_request_;
 712   HttpRequestInfo google_get_push_request_;
 713   base::ScopedTempDir temp_dir_;
 714 };
 715
 716 //-----------------------------------------------------------------------------
 717 // All tests are run with three different connection types: SPDY after NPN
 718 // negotiation, SPDY without SSL, and SPDY with SSL.
 719 //
 720 // TODO(akalin): Use ::testing::Combine() when we are able to use
 721 // <tr1/tuple>.
 722 INSTANTIATE_TEST_CASE_P(
 723     Spdy,
 724     SpdyNetworkTransactionTest,
 725     ::testing::Values(
 726         SpdyNetworkTransactionTestParams(kProtoSPDY31, SPDYNOSSL),
 727         SpdyNetworkTransactionTestParams(kProtoSPDY31, SPDYSSL),
 728         SpdyNetworkTransactionTestParams(kProtoSPDY31, SPDYNPN),
 729         SpdyNetworkTransactionTestParams(kProtoSPDY4_14, SPDYNOSSL),
 730         SpdyNetworkTransactionTestParams(kProtoSPDY4_14, SPDYSSL),
 731         SpdyNetworkTransactionTestParams(kProtoSPDY4_14, SPDYNPN),
 732         SpdyNetworkTransactionTestParams(kProtoSPDY4_15, SPDYNOSSL),
 733         SpdyNetworkTransactionTestParams(kProtoSPDY4_15, SPDYSSL),
 734         SpdyNetworkTransactionTestParams(kProtoSPDY4_15, SPDYNPN)));
 735
 736 // Verify HttpNetworkTransaction constructor.
 737 TEST_P(SpdyNetworkTransactionTest, Constructor) {
 738   scoped_ptr<SpdySessionDependencies> session_deps(
 739       CreateSpdySessionDependencies(GetParam()));
 740   scoped_refptr<HttpNetworkSession> session(
 741       SpdySessionDependencies::SpdyCreateSession(session_deps.get()));
 742   scoped_ptr<HttpTransaction> trans(
 743       new HttpNetworkTransaction(DEFAULT_PRIORITY, session.get()));
 744 }
 745
 746 TEST_P(SpdyNetworkTransactionTest, Get) {
 747   // Construct the request.
 748   scoped_ptr<SpdyFrame> req(
 749       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
 750   MockWrite writes[] = { CreateMockWrite(*req) };
 751
 752   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 753   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
 754   MockRead reads[] = {
 755     CreateMockRead(*resp),
 756     CreateMockRead(*body),
 757     MockRead(ASYNC, 0, 0)  // EOF
 758   };
 759
 760   DelayedSocketData data(1, reads, arraysize(reads),
 761                          writes, arraysize(writes));
 762   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
 763                                      BoundNetLog(), GetParam(), NULL);
 764   helper.RunToCompletion(&data);
 765   TransactionHelperResult out = helper.output();
 766   EXPECT_EQ(OK, out.rv);
 767   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
 768   EXPECT_EQ("hello!", out.response_data);
 769 }
 770
 771 TEST_P(SpdyNetworkTransactionTest, GetAtEachPriority) {
 772   for (RequestPriority p = MINIMUM_PRIORITY; p <= MAXIMUM_PRIORITY;
 773        p = RequestPriority(p + 1)) {
 774     // Construct the request.
 775     scoped_ptr<SpdyFrame> req(
 776         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, p, true));
 777     MockWrite writes[] = { CreateMockWrite(*req) };
 778
 779     SpdyPriority spdy_prio = 0;
 780     EXPECT_TRUE(GetSpdyPriority(spdy_util_.spdy_version(), *req, &spdy_prio));
 781     // this repeats the RequestPriority-->SpdyPriority mapping from
 782     // SpdyFramer::ConvertRequestPriorityToSpdyPriority to make
 783     // sure it's being done right.
 784     if (spdy_util_.spdy_version() < SPDY3) {
 785       switch (p) {
 786         case HIGHEST:
 787           EXPECT_EQ(0, spdy_prio);
 788           break;
 789         case MEDIUM:
 790           EXPECT_EQ(1, spdy_prio);
 791           break;
 792         case LOW:
 793         case LOWEST:
 794           EXPECT_EQ(2, spdy_prio);
 795           break;
 796         case IDLE:
 797           EXPECT_EQ(3, spdy_prio);
 798           break;
 799         default:
 800           FAIL();
 801       }
 802     } else {
 803       switch(p) {
 804         case HIGHEST:
 805           EXPECT_EQ(0, spdy_prio);
 806           break;
 807         case MEDIUM:
 808           EXPECT_EQ(1, spdy_prio);
 809           break;
 810         case LOW:
 811           EXPECT_EQ(2, spdy_prio);
 812           break;
 813         case LOWEST:
 814           EXPECT_EQ(3, spdy_prio);
 815           break;
 816         case IDLE:
 817           EXPECT_EQ(4, spdy_prio);
 818           break;
 819         default:
 820           FAIL();
 821       }
 822     }
 823
 824     scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 825     scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
 826     MockRead reads[] = {
 827       CreateMockRead(*resp),
 828       CreateMockRead(*body),
 829       MockRead(ASYNC, 0, 0)  // EOF
 830     };
 831
 832     DelayedSocketData data(1, reads, arraysize(reads),
 833                               writes, arraysize(writes));
 834     HttpRequestInfo http_req = CreateGetRequest();
 835
 836     NormalSpdyTransactionHelper helper(http_req, p, BoundNetLog(),
 837                                        GetParam(), NULL);
 838     helper.RunToCompletion(&data);
 839     TransactionHelperResult out = helper.output();
 840     EXPECT_EQ(OK, out.rv);
 841     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
 842     EXPECT_EQ("hello!", out.response_data);
 843   }
 844 }
 845
 846 // Start three gets simultaniously; making sure that multiplexed
 847 // streams work properly.
 848
 849 // This can't use the TransactionHelper method, since it only
 850 // handles a single transaction, and finishes them as soon
 851 // as it launches them.
 852
 853 // TODO(gavinp): create a working generalized TransactionHelper that
 854 // can allow multiple streams in flight.
 855
 856 TEST_P(SpdyNetworkTransactionTest, ThreeGets) {
 857   scoped_ptr<SpdyFrame> req(
 858       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
 859   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 860   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
 861   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
 862
 863   scoped_ptr<SpdyFrame> req2(
 864       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
 865   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
 866   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, false));
 867   scoped_ptr<SpdyFrame> fbody2(spdy_util_.ConstructSpdyBodyFrame(3, true));
 868
 869   scoped_ptr<SpdyFrame> req3(
 870       spdy_util_.ConstructSpdyGet(NULL, 0, false, 5, LOWEST, true));
 871   scoped_ptr<SpdyFrame> resp3(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 5));
 872   scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(5, false));
 873   scoped_ptr<SpdyFrame> fbody3(spdy_util_.ConstructSpdyBodyFrame(5, true));
 874
 875   MockWrite writes[] = {
 876     CreateMockWrite(*req),
 877     CreateMockWrite(*req2),
 878     CreateMockWrite(*req3),
 879   };
 880   MockRead reads[] = {
 881     CreateMockRead(*resp, 1),
 882     CreateMockRead(*body),
 883     CreateMockRead(*resp2, 4),
 884     CreateMockRead(*body2),
 885     CreateMockRead(*resp3, 7),
 886     CreateMockRead(*body3),
 887
 888     CreateMockRead(*fbody),
 889     CreateMockRead(*fbody2),
 890     CreateMockRead(*fbody3),
 891
 892     MockRead(ASYNC, 0, 0),  // EOF
 893   };
 894   OrderedSocketData data(reads, arraysize(reads),
 895                          writes, arraysize(writes));
 896   OrderedSocketData data_placeholder(NULL, 0, NULL, 0);
 897
 898   BoundNetLog log;
 899   TransactionHelperResult out;
 900   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
 901                                      BoundNetLog(), GetParam(), NULL);
 902   helper.RunPreTestSetup();
 903   helper.AddData(&data);
 904   // We require placeholder data because three get requests are sent out, so
 905   // there needs to be three sets of SSL connection data.
 906   helper.AddData(&data_placeholder);
 907   helper.AddData(&data_placeholder);
 908   scoped_ptr<HttpNetworkTransaction> trans1(
 909       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 910   scoped_ptr<HttpNetworkTransaction> trans2(
 911       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 912   scoped_ptr<HttpNetworkTransaction> trans3(
 913       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 914
 915   TestCompletionCallback callback1;
 916   TestCompletionCallback callback2;
 917   TestCompletionCallback callback3;
 918
 919   HttpRequestInfo httpreq1 = CreateGetRequest();
 920   HttpRequestInfo httpreq2 = CreateGetRequest();
 921   HttpRequestInfo httpreq3 = CreateGetRequest();
 922
 923   out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
 924   ASSERT_EQ(ERR_IO_PENDING, out.rv);
 925   out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
 926   ASSERT_EQ(ERR_IO_PENDING, out.rv);
 927   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
 928   ASSERT_EQ(ERR_IO_PENDING, out.rv);
 929
 930   out.rv = callback1.WaitForResult();
 931   ASSERT_EQ(OK, out.rv);
 932   out.rv = callback3.WaitForResult();
 933   ASSERT_EQ(OK, out.rv);
 934
 935   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
 936   EXPECT_TRUE(response1->headers.get() != NULL);
 937   EXPECT_TRUE(response1->was_fetched_via_spdy);
 938   out.status_line = response1->headers->GetStatusLine();
 939   out.response_info = *response1;
 940
 941   trans2->GetResponseInfo();
 942
 943   out.rv = ReadTransaction(trans1.get(), &out.response_data);
 944   helper.VerifyDataConsumed();
 945   EXPECT_EQ(OK, out.rv);
 946
 947   EXPECT_EQ(OK, out.rv);
 948   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
 949   EXPECT_EQ("hello!hello!", out.response_data);
 950 }
 951
 952 TEST_P(SpdyNetworkTransactionTest, TwoGetsLateBinding) {
 953   scoped_ptr<SpdyFrame> req(
 954       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
 955   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
 956   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
 957   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
 958
 959   scoped_ptr<SpdyFrame> req2(
 960       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
 961   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
 962   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, false));
 963   scoped_ptr<SpdyFrame> fbody2(spdy_util_.ConstructSpdyBodyFrame(3, true));
 964
 965   MockWrite writes[] = {
 966     CreateMockWrite(*req),
 967     CreateMockWrite(*req2),
 968   };
 969   MockRead reads[] = {
 970     CreateMockRead(*resp, 1),
 971     CreateMockRead(*body),
 972     CreateMockRead(*resp2, 4),
 973     CreateMockRead(*body2),
 974     CreateMockRead(*fbody),
 975     CreateMockRead(*fbody2),
 976     MockRead(ASYNC, 0, 0),  // EOF
 977   };
 978   OrderedSocketData data(reads, arraysize(reads),
 979                          writes, arraysize(writes));
 980
 981   MockConnect never_finishing_connect(SYNCHRONOUS, ERR_IO_PENDING);
 982
 983   OrderedSocketData data_placeholder(NULL, 0, NULL, 0);
 984   data_placeholder.set_connect_data(never_finishing_connect);
 985
 986   BoundNetLog log;
 987   TransactionHelperResult out;
 988   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
 989                                      BoundNetLog(), GetParam(), NULL);
 990   helper.RunPreTestSetup();
 991   helper.AddData(&data);
 992   // We require placeholder data because two get requests are sent out, so
 993   // there needs to be two sets of SSL connection data.
 994   helper.AddData(&data_placeholder);
 995   scoped_ptr<HttpNetworkTransaction> trans1(
 996       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 997   scoped_ptr<HttpNetworkTransaction> trans2(
 998       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
 999
1000   TestCompletionCallback callback1;
1001   TestCompletionCallback callback2;
1002
1003   HttpRequestInfo httpreq1 = CreateGetRequest();
1004   HttpRequestInfo httpreq2 = CreateGetRequest();
1005
1006   out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
1007   ASSERT_EQ(ERR_IO_PENDING, out.rv);
1008   out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
1009   ASSERT_EQ(ERR_IO_PENDING, out.rv);
1010
1011   out.rv = callback1.WaitForResult();
1012   ASSERT_EQ(OK, out.rv);
1013   out.rv = callback2.WaitForResult();
1014   ASSERT_EQ(OK, out.rv);
1015
1016   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
1017   EXPECT_TRUE(response1->headers.get() != NULL);
1018   EXPECT_TRUE(response1->was_fetched_via_spdy);
1019   out.status_line = response1->headers->GetStatusLine();
1020   out.response_info = *response1;
1021   out.rv = ReadTransaction(trans1.get(), &out.response_data);
1022   EXPECT_EQ(OK, out.rv);
1023   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1024   EXPECT_EQ("hello!hello!", out.response_data);
1025
1026   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
1027   EXPECT_TRUE(response2->headers.get() != NULL);
1028   EXPECT_TRUE(response2->was_fetched_via_spdy);
1029   out.status_line = response2->headers->GetStatusLine();
1030   out.response_info = *response2;
1031   out.rv = ReadTransaction(trans2.get(), &out.response_data);
1032   EXPECT_EQ(OK, out.rv);
1033   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1034   EXPECT_EQ("hello!hello!", out.response_data);
1035
1036   helper.VerifyDataConsumed();
1037 }
1038
1039 TEST_P(SpdyNetworkTransactionTest, TwoGetsLateBindingFromPreconnect) {
1040   scoped_ptr<SpdyFrame> req(
1041       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
1042   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
1043   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
1044   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
1045
1046   scoped_ptr<SpdyFrame> req2(
1047       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
1048   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
1049   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, false));
1050   scoped_ptr<SpdyFrame> fbody2(spdy_util_.ConstructSpdyBodyFrame(3, true));
1051
1052   MockWrite writes[] = {
1053     CreateMockWrite(*req),
1054     CreateMockWrite(*req2),
1055   };
1056   MockRead reads[] = {
1057     CreateMockRead(*resp, 1),
1058     CreateMockRead(*body),
1059     CreateMockRead(*resp2, 4),
1060     CreateMockRead(*body2),
1061     CreateMockRead(*fbody),
1062     CreateMockRead(*fbody2),
1063     MockRead(ASYNC, 0, 0),  // EOF
1064   };
1065   OrderedSocketData preconnect_data(reads, arraysize(reads),
1066                                     writes, arraysize(writes));
1067
1068   MockConnect never_finishing_connect(ASYNC, ERR_IO_PENDING);
1069
1070   OrderedSocketData data_placeholder(NULL, 0, NULL, 0);
1071   data_placeholder.set_connect_data(never_finishing_connect);
1072
1073   BoundNetLog log;
1074   TransactionHelperResult out;
1075   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
1076                                      BoundNetLog(), GetParam(), NULL);
1077   helper.RunPreTestSetup();
1078   helper.AddData(&preconnect_data);
1079   // We require placeholder data because 3 connections are attempted (first is
1080   // the preconnect, 2nd and 3rd are the never finished connections.
1081   helper.AddData(&data_placeholder);
1082   helper.AddData(&data_placeholder);
1083
1084   scoped_ptr<HttpNetworkTransaction> trans1(
1085       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
1086   scoped_ptr<HttpNetworkTransaction> trans2(
1087       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
1088
1089   TestCompletionCallback callback1;
1090   TestCompletionCallback callback2;
1091
1092   HttpRequestInfo httpreq = CreateGetRequest();
1093
1094   // Preconnect the first.
1095   SSLConfig preconnect_ssl_config;
1096   helper.session()->ssl_config_service()->GetSSLConfig(&preconnect_ssl_config);
1097   HttpStreamFactory* http_stream_factory =
1098       helper.session()->http_stream_factory();
1099   helper.session()->GetNextProtos(&preconnect_ssl_config.next_protos);
1100
1101   http_stream_factory->PreconnectStreams(
1102       1, httpreq, DEFAULT_PRIORITY,
1103       preconnect_ssl_config, preconnect_ssl_config);
1104
1105   out.rv = trans1->Start(&httpreq, callback1.callback(), log);
1106   ASSERT_EQ(ERR_IO_PENDING, out.rv);
1107   out.rv = trans2->Start(&httpreq, callback2.callback(), log);
1108   ASSERT_EQ(ERR_IO_PENDING, out.rv);
1109
1110   out.rv = callback1.WaitForResult();
1111   ASSERT_EQ(OK, out.rv);
1112   out.rv = callback2.WaitForResult();
1113   ASSERT_EQ(OK, out.rv);
1114
1115   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
1116   EXPECT_TRUE(response1->headers.get() != NULL);
1117   EXPECT_TRUE(response1->was_fetched_via_spdy);
1118   out.status_line = response1->headers->GetStatusLine();
1119   out.response_info = *response1;
1120   out.rv = ReadTransaction(trans1.get(), &out.response_data);
1121   EXPECT_EQ(OK, out.rv);
1122   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1123   EXPECT_EQ("hello!hello!", out.response_data);
1124
1125   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
1126   EXPECT_TRUE(response2->headers.get() != NULL);
1127   EXPECT_TRUE(response2->was_fetched_via_spdy);
1128   out.status_line = response2->headers->GetStatusLine();
1129   out.response_info = *response2;
1130   out.rv = ReadTransaction(trans2.get(), &out.response_data);
1131   EXPECT_EQ(OK, out.rv);
1132   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1133   EXPECT_EQ("hello!hello!", out.response_data);
1134
1135   helper.VerifyDataConsumed();
1136 }
1137
1138 // Similar to ThreeGets above, however this test adds a SETTINGS
1139 // frame.  The SETTINGS frame is read during the IO loop waiting on
1140 // the first transaction completion, and sets a maximum concurrent
1141 // stream limit of 1.  This means that our IO loop exists after the
1142 // second transaction completes, so we can assert on read_index().
1143 TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrent) {
1144   // Construct the request.
1145   scoped_ptr<SpdyFrame> req(
1146       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
1147   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
1148   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
1149   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
1150
1151   scoped_ptr<SpdyFrame> req2(
1152       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
1153   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
1154   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, false));
1155   scoped_ptr<SpdyFrame> fbody2(spdy_util_.ConstructSpdyBodyFrame(3, true));
1156
1157   scoped_ptr<SpdyFrame> req3(
1158       spdy_util_.ConstructSpdyGet(NULL, 0, false, 5, LOWEST, true));
1159   scoped_ptr<SpdyFrame> resp3(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 5));
1160   scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(5, false));
1161   scoped_ptr<SpdyFrame> fbody3(spdy_util_.ConstructSpdyBodyFrame(5, true));
1162
1163   SettingsMap settings;
1164   const uint32 max_concurrent_streams = 1;
1165   settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
1166       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
1167   scoped_ptr<SpdyFrame> settings_frame(
1168       spdy_util_.ConstructSpdySettings(settings));
1169   scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
1170
1171   MockWrite writes[] = {
1172     CreateMockWrite(*req),
1173     CreateMockWrite(*settings_ack, 2),
1174     CreateMockWrite(*req2),
1175     CreateMockWrite(*req3),
1176   };
1177
1178   MockRead reads[] = {
1179     CreateMockRead(*settings_frame, 1),
1180     CreateMockRead(*resp),
1181     CreateMockRead(*body),
1182     CreateMockRead(*fbody),
1183     CreateMockRead(*resp2, 8),
1184     CreateMockRead(*body2),
1185     CreateMockRead(*fbody2),
1186     CreateMockRead(*resp3, 13),
1187     CreateMockRead(*body3),
1188     CreateMockRead(*fbody3),
1189
1190     MockRead(ASYNC, 0, 0),  // EOF
1191   };
1192
1193   OrderedSocketData data(reads, arraysize(reads),
1194                          writes, arraysize(writes));
1195   OrderedSocketData data_placeholder(NULL, 0, NULL, 0);
1196
1197   BoundNetLog log;
1198   TransactionHelperResult out;
1199   {
1200     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
1201                                        BoundNetLog(), GetParam(), NULL);
1202     helper.RunPreTestSetup();
1203     helper.AddData(&data);
1204     // We require placeholder data because three get requests are sent out, so
1205     // there needs to be three sets of SSL connection data.
1206     helper.AddData(&data_placeholder);
1207     helper.AddData(&data_placeholder);
1208     scoped_ptr<HttpNetworkTransaction> trans1(
1209         new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
1210     scoped_ptr<HttpNetworkTransaction> trans2(
1211         new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
1212     scoped_ptr<HttpNetworkTransaction> trans3(
1213         new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
1214
1215     TestCompletionCallback callback1;
1216     TestCompletionCallback callback2;
1217     TestCompletionCallback callback3;
1218
1219     HttpRequestInfo httpreq1 = CreateGetRequest();
1220     HttpRequestInfo httpreq2 = CreateGetRequest();
1221     HttpRequestInfo httpreq3 = CreateGetRequest();
1222
1223     out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
1224     ASSERT_EQ(out.rv, ERR_IO_PENDING);
1225     // Run transaction 1 through quickly to force a read of our SETTINGS
1226     // frame.
1227     out.rv = callback1.WaitForResult();
1228     ASSERT_EQ(OK, out.rv);
1229
1230     out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
1231     ASSERT_EQ(out.rv, ERR_IO_PENDING);
1232     out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
1233     ASSERT_EQ(out.rv, ERR_IO_PENDING);
1234     out.rv = callback2.WaitForResult();
1235     ASSERT_EQ(OK, out.rv);
1236     EXPECT_EQ(7U, data.read_index());  // i.e. the third trans was queued
1237
1238     out.rv = callback3.WaitForResult();
1239     ASSERT_EQ(OK, out.rv);
1240
1241     const HttpResponseInfo* response1 = trans1->GetResponseInfo();
1242     ASSERT_TRUE(response1 != NULL);
1243     EXPECT_TRUE(response1->headers.get() != NULL);
1244     EXPECT_TRUE(response1->was_fetched_via_spdy);
1245     out.status_line = response1->headers->GetStatusLine();
1246     out.response_info = *response1;
1247     out.rv = ReadTransaction(trans1.get(), &out.response_data);
1248     EXPECT_EQ(OK, out.rv);
1249     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1250     EXPECT_EQ("hello!hello!", out.response_data);
1251
1252     const HttpResponseInfo* response2 = trans2->GetResponseInfo();
1253     out.status_line = response2->headers->GetStatusLine();
1254     out.response_info = *response2;
1255     out.rv = ReadTransaction(trans2.get(), &out.response_data);
1256     EXPECT_EQ(OK, out.rv);
1257     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1258     EXPECT_EQ("hello!hello!", out.response_data);
1259
1260     const HttpResponseInfo* response3 = trans3->GetResponseInfo();
1261     out.status_line = response3->headers->GetStatusLine();
1262     out.response_info = *response3;
1263     out.rv = ReadTransaction(trans3.get(), &out.response_data);
1264     EXPECT_EQ(OK, out.rv);
1265     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1266     EXPECT_EQ("hello!hello!", out.response_data);
1267
1268     helper.VerifyDataConsumed();
1269   }
1270   EXPECT_EQ(OK, out.rv);
1271 }
1272
1273 // Similar to ThreeGetsWithMaxConcurrent above, however this test adds
1274 // a fourth transaction.  The third and fourth transactions have
1275 // different data ("hello!" vs "hello!hello!") and because of the
1276 // user specified priority, we expect to see them inverted in
1277 // the response from the server.
1278 TEST_P(SpdyNetworkTransactionTest, FourGetsWithMaxConcurrentPriority) {
1279   // Construct the request.
1280   scoped_ptr<SpdyFrame> req(
1281       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
1282   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
1283   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
1284   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
1285
1286   scoped_ptr<SpdyFrame> req2(
1287       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
1288   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
1289   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, false));
1290   scoped_ptr<SpdyFrame> fbody2(spdy_util_.ConstructSpdyBodyFrame(3, true));
1291
1292   scoped_ptr<SpdyFrame> req4(
1293       spdy_util_.ConstructSpdyGet(NULL, 0, false, 5, HIGHEST, true));
1294   scoped_ptr<SpdyFrame> resp4(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 5));
1295   scoped_ptr<SpdyFrame> fbody4(spdy_util_.ConstructSpdyBodyFrame(5, true));
1296
1297   scoped_ptr<SpdyFrame> req3(
1298       spdy_util_.ConstructSpdyGet(NULL, 0, false, 7, LOWEST, true));
1299   scoped_ptr<SpdyFrame> resp3(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 7));
1300   scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(7, false));
1301   scoped_ptr<SpdyFrame> fbody3(spdy_util_.ConstructSpdyBodyFrame(7, true));
1302
1303   SettingsMap settings;
1304   const uint32 max_concurrent_streams = 1;
1305   settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
1306       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
1307   scoped_ptr<SpdyFrame> settings_frame(
1308       spdy_util_.ConstructSpdySettings(settings));
1309   scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
1310
1311   MockWrite writes[] = { CreateMockWrite(*req),
1312     CreateMockWrite(*settings_ack, 2),
1313     CreateMockWrite(*req2),
1314     CreateMockWrite(*req4),
1315     CreateMockWrite(*req3),
1316   };
1317   MockRead reads[] = {
1318     CreateMockRead(*settings_frame, 1),
1319     CreateMockRead(*resp),
1320     CreateMockRead(*body),
1321     CreateMockRead(*fbody),
1322     CreateMockRead(*resp2, 8),
1323     CreateMockRead(*body2),
1324     CreateMockRead(*fbody2),
1325     CreateMockRead(*resp4, 14),
1326     CreateMockRead(*fbody4),
1327     CreateMockRead(*resp3, 17),
1328     CreateMockRead(*body3),
1329     CreateMockRead(*fbody3),
1330
1331     MockRead(ASYNC, 0, 0),  // EOF
1332   };
1333
1334   OrderedSocketData data(reads, arraysize(reads),
1335                          writes, arraysize(writes));
1336   OrderedSocketData data_placeholder(NULL, 0, NULL, 0);
1337
1338   BoundNetLog log;
1339   TransactionHelperResult out;
1340   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
1341                                      BoundNetLog(), GetParam(), NULL);
1342   helper.RunPreTestSetup();
1343   helper.AddData(&data);
1344   // We require placeholder data because four get requests are sent out, so
1345   // there needs to be four sets of SSL connection data.
1346   helper.AddData(&data_placeholder);
1347   helper.AddData(&data_placeholder);
1348   helper.AddData(&data_placeholder);
1349   scoped_ptr<HttpNetworkTransaction> trans1(
1350       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
1351   scoped_ptr<HttpNetworkTransaction> trans2(
1352       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
1353   scoped_ptr<HttpNetworkTransaction> trans3(
1354       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
1355   scoped_ptr<HttpNetworkTransaction> trans4(
1356       new HttpNetworkTransaction(HIGHEST, helper.session().get()));
1357
1358   TestCompletionCallback callback1;
1359   TestCompletionCallback callback2;
1360   TestCompletionCallback callback3;
1361   TestCompletionCallback callback4;
1362
1363   HttpRequestInfo httpreq1 = CreateGetRequest();
1364   HttpRequestInfo httpreq2 = CreateGetRequest();
1365   HttpRequestInfo httpreq3 = CreateGetRequest();
1366   HttpRequestInfo httpreq4 = CreateGetRequest();
1367
1368   out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
1369   ASSERT_EQ(ERR_IO_PENDING, out.rv);
1370   // Run transaction 1 through quickly to force a read of our SETTINGS frame.
1371   out.rv = callback1.WaitForResult();
1372   ASSERT_EQ(OK, out.rv);
1373
1374   out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
1375   ASSERT_EQ(ERR_IO_PENDING, out.rv);
1376   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
1377   ASSERT_EQ(ERR_IO_PENDING, out.rv);
1378   out.rv = trans4->Start(&httpreq4, callback4.callback(), log);
1379   ASSERT_EQ(ERR_IO_PENDING, out.rv);
1380
1381   out.rv = callback2.WaitForResult();
1382   ASSERT_EQ(OK, out.rv);
1383   EXPECT_EQ(data.read_index(), 7U);  // i.e. the third & fourth trans queued
1384
1385   out.rv = callback3.WaitForResult();
1386   ASSERT_EQ(OK, out.rv);
1387
1388   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
1389   EXPECT_TRUE(response1->headers.get() != NULL);
1390   EXPECT_TRUE(response1->was_fetched_via_spdy);
1391   out.status_line = response1->headers->GetStatusLine();
1392   out.response_info = *response1;
1393   out.rv = ReadTransaction(trans1.get(), &out.response_data);
1394   EXPECT_EQ(OK, out.rv);
1395   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1396   EXPECT_EQ("hello!hello!", out.response_data);
1397
1398   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
1399   out.status_line = response2->headers->GetStatusLine();
1400   out.response_info = *response2;
1401   out.rv = ReadTransaction(trans2.get(), &out.response_data);
1402   EXPECT_EQ(OK, out.rv);
1403   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1404   EXPECT_EQ("hello!hello!", out.response_data);
1405
1406   // notice: response3 gets two hellos, response4 gets one
1407   // hello, so we know dequeuing priority was respected.
1408   const HttpResponseInfo* response3 = trans3->GetResponseInfo();
1409   out.status_line = response3->headers->GetStatusLine();
1410   out.response_info = *response3;
1411   out.rv = ReadTransaction(trans3.get(), &out.response_data);
1412   EXPECT_EQ(OK, out.rv);
1413   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1414   EXPECT_EQ("hello!hello!", out.response_data);
1415
1416   out.rv = callback4.WaitForResult();
1417   EXPECT_EQ(OK, out.rv);
1418   const HttpResponseInfo* response4 = trans4->GetResponseInfo();
1419   out.status_line = response4->headers->GetStatusLine();
1420   out.response_info = *response4;
1421   out.rv = ReadTransaction(trans4.get(), &out.response_data);
1422   EXPECT_EQ(OK, out.rv);
1423   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1424   EXPECT_EQ("hello!", out.response_data);
1425   helper.VerifyDataConsumed();
1426   EXPECT_EQ(OK, out.rv);
1427 }
1428
1429 // Similar to ThreeGetsMaxConcurrrent above, however, this test
1430 // deletes a session in the middle of the transaction to insure
1431 // that we properly remove pendingcreatestream objects from
1432 // the spdy_session
1433 TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrentDelete) {
1434   // Construct the request.
1435   scoped_ptr<SpdyFrame> req(
1436       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
1437   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
1438   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
1439   scoped_ptr<SpdyFrame> fbody(spdy_util_.ConstructSpdyBodyFrame(1, true));
1440
1441   scoped_ptr<SpdyFrame> req2(
1442       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
1443   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
1444   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, false));
1445   scoped_ptr<SpdyFrame> fbody2(spdy_util_.ConstructSpdyBodyFrame(3, true));
1446
1447   SettingsMap settings;
1448   const uint32 max_concurrent_streams = 1;
1449   settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
1450       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
1451   scoped_ptr<SpdyFrame> settings_frame(
1452       spdy_util_.ConstructSpdySettings(settings));
1453   scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
1454
1455   MockWrite writes[] = {
1456     CreateMockWrite(*req),
1457     CreateMockWrite(*settings_ack, 2),
1458     CreateMockWrite(*req2),
1459   };
1460   MockRead reads[] = {
1461     CreateMockRead(*settings_frame, 1),
1462     CreateMockRead(*resp),
1463     CreateMockRead(*body),
1464     CreateMockRead(*fbody),
1465     CreateMockRead(*resp2, 8),
1466     CreateMockRead(*body2),
1467     CreateMockRead(*fbody2),
1468     MockRead(ASYNC, 0, 0),  // EOF
1469   };
1470
1471   OrderedSocketData data(reads, arraysize(reads),
1472                          writes, arraysize(writes));
1473   OrderedSocketData data_placeholder(NULL, 0, NULL, 0);
1474
1475   BoundNetLog log;
1476   TransactionHelperResult out;
1477   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
1478                                      BoundNetLog(), GetParam(), NULL);
1479   helper.RunPreTestSetup();
1480   helper.AddData(&data);
1481   // We require placeholder data because three get requests are sent out, so
1482   // there needs to be three sets of SSL connection data.
1483   helper.AddData(&data_placeholder);
1484   helper.AddData(&data_placeholder);
1485   scoped_ptr<HttpNetworkTransaction> trans1(
1486       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
1487   scoped_ptr<HttpNetworkTransaction> trans2(
1488       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
1489   scoped_ptr<HttpNetworkTransaction> trans3(
1490       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
1491
1492   TestCompletionCallback callback1;
1493   TestCompletionCallback callback2;
1494   TestCompletionCallback callback3;
1495
1496   HttpRequestInfo httpreq1 = CreateGetRequest();
1497   HttpRequestInfo httpreq2 = CreateGetRequest();
1498   HttpRequestInfo httpreq3 = CreateGetRequest();
1499
1500   out.rv = trans1->Start(&httpreq1, callback1.callback(), log);
1501   ASSERT_EQ(out.rv, ERR_IO_PENDING);
1502   // Run transaction 1 through quickly to force a read of our SETTINGS frame.
1503   out.rv = callback1.WaitForResult();
1504   ASSERT_EQ(OK, out.rv);
1505
1506   out.rv = trans2->Start(&httpreq2, callback2.callback(), log);
1507   ASSERT_EQ(out.rv, ERR_IO_PENDING);
1508   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
1509   delete trans3.release();
1510   ASSERT_EQ(out.rv, ERR_IO_PENDING);
1511   out.rv = callback2.WaitForResult();
1512   ASSERT_EQ(OK, out.rv);
1513
1514   EXPECT_EQ(8U, data.read_index());
1515
1516   const HttpResponseInfo* response1 = trans1->GetResponseInfo();
1517   ASSERT_TRUE(response1 != NULL);
1518   EXPECT_TRUE(response1->headers.get() != NULL);
1519   EXPECT_TRUE(response1->was_fetched_via_spdy);
1520   out.status_line = response1->headers->GetStatusLine();
1521   out.response_info = *response1;
1522   out.rv = ReadTransaction(trans1.get(), &out.response_data);
1523   EXPECT_EQ(OK, out.rv);
1524   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1525   EXPECT_EQ("hello!hello!", out.response_data);
1526
1527   const HttpResponseInfo* response2 = trans2->GetResponseInfo();
1528   ASSERT_TRUE(response2 != NULL);
1529   out.status_line = response2->headers->GetStatusLine();
1530   out.response_info = *response2;
1531   out.rv = ReadTransaction(trans2.get(), &out.response_data);
1532   EXPECT_EQ(OK, out.rv);
1533   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1534   EXPECT_EQ("hello!hello!", out.response_data);
1535   helper.VerifyDataConsumed();
1536   EXPECT_EQ(OK, out.rv);
1537 }
1538
1539 namespace {
1540
1541 // The KillerCallback will delete the transaction on error as part of the
1542 // callback.
1543 class KillerCallback : public TestCompletionCallbackBase {
1544  public:
1545   explicit KillerCallback(HttpNetworkTransaction* transaction)
1546       : transaction_(transaction),
1547         callback_(base::Bind(&KillerCallback::OnComplete,
1548                              base::Unretained(this))) {
1549   }
1550
1551   ~KillerCallback() override {}
1552
1553   const CompletionCallback& callback() const { return callback_; }
1554
1555  private:
1556   void OnComplete(int result) {
1557     if (result < 0)
1558       delete transaction_;
1559
1560     SetResult(result);
1561   }
1562
1563   HttpNetworkTransaction* transaction_;
1564   CompletionCallback callback_;
1565 };
1566
1567 }  // namespace
1568
1569 // Similar to ThreeGetsMaxConcurrrentDelete above, however, this test
1570 // closes the socket while we have a pending transaction waiting for
1571 // a pending stream creation.  http://crbug.com/52901
1572 TEST_P(SpdyNetworkTransactionTest, ThreeGetsWithMaxConcurrentSocketClose) {
1573   // Construct the request.
1574   scoped_ptr<SpdyFrame> req(
1575       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
1576   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
1577   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, false));
1578   scoped_ptr<SpdyFrame> fin_body(spdy_util_.ConstructSpdyBodyFrame(1, true));
1579
1580   scoped_ptr<SpdyFrame> req2(
1581       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
1582   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
1583
1584   SettingsMap settings;
1585   const uint32 max_concurrent_streams = 1;
1586   settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
1587       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, max_concurrent_streams);
1588   scoped_ptr<SpdyFrame> settings_frame(
1589       spdy_util_.ConstructSpdySettings(settings));
1590   scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
1591
1592   MockWrite writes[] = {
1593     CreateMockWrite(*req),
1594     CreateMockWrite(*settings_ack, 2),
1595     CreateMockWrite(*req2),
1596   };
1597   MockRead reads[] = {
1598     CreateMockRead(*settings_frame, 1),
1599     CreateMockRead(*resp),
1600     CreateMockRead(*body),
1601     CreateMockRead(*fin_body),
1602     CreateMockRead(*resp2, 8),
1603     MockRead(ASYNC, ERR_CONNECTION_RESET, 0),  // Abort!
1604   };
1605
1606   OrderedSocketData data(reads, arraysize(reads),
1607                          writes, arraysize(writes));
1608   OrderedSocketData data_placeholder(NULL, 0, NULL, 0);
1609
1610   BoundNetLog log;
1611   TransactionHelperResult out;
1612   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
1613                                      BoundNetLog(), GetParam(), NULL);
1614   helper.RunPreTestSetup();
1615   helper.AddData(&data);
1616   // We require placeholder data because three get requests are sent out, so
1617   // there needs to be three sets of SSL connection data.
1618   helper.AddData(&data_placeholder);
1619   helper.AddData(&data_placeholder);
1620   HttpNetworkTransaction trans1(DEFAULT_PRIORITY, helper.session().get());
1621   HttpNetworkTransaction trans2(DEFAULT_PRIORITY, helper.session().get());
1622   HttpNetworkTransaction* trans3(
1623       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
1624
1625   TestCompletionCallback callback1;
1626   TestCompletionCallback callback2;
1627   KillerCallback callback3(trans3);
1628
1629   HttpRequestInfo httpreq1 = CreateGetRequest();
1630   HttpRequestInfo httpreq2 = CreateGetRequest();
1631   HttpRequestInfo httpreq3 = CreateGetRequest();
1632
1633   out.rv = trans1.Start(&httpreq1, callback1.callback(), log);
1634   ASSERT_EQ(out.rv, ERR_IO_PENDING);
1635   // Run transaction 1 through quickly to force a read of our SETTINGS frame.
1636   out.rv = callback1.WaitForResult();
1637   ASSERT_EQ(OK, out.rv);
1638
1639   out.rv = trans2.Start(&httpreq2, callback2.callback(), log);
1640   ASSERT_EQ(out.rv, ERR_IO_PENDING);
1641   out.rv = trans3->Start(&httpreq3, callback3.callback(), log);
1642   ASSERT_EQ(out.rv, ERR_IO_PENDING);
1643   out.rv = callback3.WaitForResult();
1644   ASSERT_EQ(ERR_ABORTED, out.rv);
1645
1646   EXPECT_EQ(6U, data.read_index());
1647
1648   const HttpResponseInfo* response1 = trans1.GetResponseInfo();
1649   ASSERT_TRUE(response1 != NULL);
1650   EXPECT_TRUE(response1->headers.get() != NULL);
1651   EXPECT_TRUE(response1->was_fetched_via_spdy);
1652   out.status_line = response1->headers->GetStatusLine();
1653   out.response_info = *response1;
1654   out.rv = ReadTransaction(&trans1, &out.response_data);
1655   EXPECT_EQ(OK, out.rv);
1656
1657   const HttpResponseInfo* response2 = trans2.GetResponseInfo();
1658   ASSERT_TRUE(response2 != NULL);
1659   out.status_line = response2->headers->GetStatusLine();
1660   out.response_info = *response2;
1661   out.rv = ReadTransaction(&trans2, &out.response_data);
1662   EXPECT_EQ(ERR_CONNECTION_RESET, out.rv);
1663
1664   helper.VerifyDataConsumed();
1665 }
1666
1667 // Test that a simple PUT request works.
1668 TEST_P(SpdyNetworkTransactionTest, Put) {
1669   // Setup the request
1670   HttpRequestInfo request;
1671   request.method = "PUT";
1672   request.url = GURL("http://www.google.com/");
1673
1674   scoped_ptr<SpdyHeaderBlock> put_headers(
1675       spdy_util_.ConstructPutHeaderBlock("http://www.google.com", 0));
1676   scoped_ptr<SpdyFrame> req(
1677       spdy_util_.ConstructSpdySyn(1, *put_headers, LOWEST, false, true));
1678   MockWrite writes[] = {
1679     CreateMockWrite(*req),
1680   };
1681
1682   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
1683   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
1684   MockRead reads[] = {
1685     CreateMockRead(*resp),
1686     CreateMockRead(*body),
1687     MockRead(ASYNC, 0, 0)  // EOF
1688   };
1689
1690   DelayedSocketData data(1, reads, arraysize(reads),
1691                          writes, arraysize(writes));
1692   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
1693                                      BoundNetLog(), GetParam(), NULL);
1694   helper.RunToCompletion(&data);
1695   TransactionHelperResult out = helper.output();
1696
1697   EXPECT_EQ(OK, out.rv);
1698   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1699 }
1700
1701 // Test that a simple HEAD request works.
1702 TEST_P(SpdyNetworkTransactionTest, Head) {
1703   // Setup the request
1704   HttpRequestInfo request;
1705   request.method = "HEAD";
1706   request.url = GURL("http://www.google.com/");
1707
1708   scoped_ptr<SpdyHeaderBlock> head_headers(
1709       spdy_util_.ConstructHeadHeaderBlock("http://www.google.com", 0));
1710   scoped_ptr<SpdyFrame> req(
1711       spdy_util_.ConstructSpdySyn(1, *head_headers, LOWEST, false, true));
1712   MockWrite writes[] = {
1713     CreateMockWrite(*req),
1714   };
1715
1716   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
1717   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
1718   MockRead reads[] = {
1719     CreateMockRead(*resp),
1720     CreateMockRead(*body),
1721     MockRead(ASYNC, 0, 0)  // EOF
1722   };
1723
1724   DelayedSocketData data(1, reads, arraysize(reads),
1725                          writes, arraysize(writes));
1726   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
1727                                      BoundNetLog(), GetParam(), NULL);
1728   helper.RunToCompletion(&data);
1729   TransactionHelperResult out = helper.output();
1730
1731   EXPECT_EQ(OK, out.rv);
1732   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1733 }
1734
1735 // Test that a simple POST works.
1736 TEST_P(SpdyNetworkTransactionTest, Post) {
1737   scoped_ptr<SpdyFrame> req(
1738       spdy_util_.ConstructSpdyPost(
1739           kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
1740   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
1741   MockWrite writes[] = {
1742     CreateMockWrite(*req),
1743     CreateMockWrite(*body),  // POST upload frame
1744   };
1745
1746   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
1747   MockRead reads[] = {
1748     CreateMockRead(*resp),
1749     CreateMockRead(*body),
1750     MockRead(ASYNC, 0, 0)  // EOF
1751   };
1752
1753   DelayedSocketData data(2, reads, arraysize(reads),
1754                          writes, arraysize(writes));
1755   NormalSpdyTransactionHelper helper(CreatePostRequest(), DEFAULT_PRIORITY,
1756                                      BoundNetLog(), GetParam(), NULL);
1757   helper.RunToCompletion(&data);
1758   TransactionHelperResult out = helper.output();
1759   EXPECT_EQ(OK, out.rv);
1760   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1761   EXPECT_EQ("hello!", out.response_data);
1762 }
1763
1764 // Test that a POST with a file works.
1765 TEST_P(SpdyNetworkTransactionTest, FilePost) {
1766   scoped_ptr<SpdyFrame> req(
1767       spdy_util_.ConstructSpdyPost(
1768           kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
1769   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
1770   MockWrite writes[] = {
1771     CreateMockWrite(*req),
1772     CreateMockWrite(*body),  // POST upload frame
1773   };
1774
1775   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
1776   MockRead reads[] = {
1777     CreateMockRead(*resp),
1778     CreateMockRead(*body),
1779     MockRead(ASYNC, 0, 0)  // EOF
1780   };
1781
1782   DelayedSocketData data(2, reads, arraysize(reads),
1783                          writes, arraysize(writes));
1784   NormalSpdyTransactionHelper helper(CreateFilePostRequest(), DEFAULT_PRIORITY,
1785                                      BoundNetLog(), GetParam(), NULL);
1786   helper.RunToCompletion(&data);
1787   TransactionHelperResult out = helper.output();
1788   EXPECT_EQ(OK, out.rv);
1789   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1790   EXPECT_EQ("hello!", out.response_data);
1791 }
1792
1793 // Test that a POST with a unreadable file fails.
1794 TEST_P(SpdyNetworkTransactionTest, UnreadableFilePost) {
1795   MockWrite writes[] = {
1796     MockWrite(ASYNC, 0, 0)  // EOF
1797   };
1798   MockRead reads[] = {
1799     MockRead(ASYNC, 0, 0)  // EOF
1800   };
1801
1802   DelayedSocketData data(1, reads, arraysize(reads), writes, arraysize(writes));
1803   NormalSpdyTransactionHelper helper(CreateUnreadableFilePostRequest(),
1804                                      DEFAULT_PRIORITY,
1805                                      BoundNetLog(), GetParam(), NULL);
1806   helper.RunPreTestSetup();
1807   helper.AddData(&data);
1808   helper.RunDefaultTest();
1809
1810   base::RunLoop().RunUntilIdle();
1811   helper.VerifyDataNotConsumed();
1812   EXPECT_EQ(ERR_ACCESS_DENIED, helper.output().rv);
1813 }
1814
1815 // Test that a complex POST works.
1816 TEST_P(SpdyNetworkTransactionTest, ComplexPost) {
1817   scoped_ptr<SpdyFrame> req(
1818       spdy_util_.ConstructSpdyPost(
1819           kRequestUrl, 1, kUploadDataSize, LOWEST, NULL, 0));
1820   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
1821   MockWrite writes[] = {
1822     CreateMockWrite(*req),
1823     CreateMockWrite(*body),  // POST upload frame
1824   };
1825
1826   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
1827   MockRead reads[] = {
1828     CreateMockRead(*resp),
1829     CreateMockRead(*body),
1830     MockRead(ASYNC, 0, 0)  // EOF
1831   };
1832
1833   DelayedSocketData data(2, reads, arraysize(reads),
1834                          writes, arraysize(writes));
1835   NormalSpdyTransactionHelper helper(CreateComplexPostRequest(),
1836                                      DEFAULT_PRIORITY,
1837                                      BoundNetLog(), GetParam(), NULL);
1838   helper.RunToCompletion(&data);
1839   TransactionHelperResult out = helper.output();
1840   EXPECT_EQ(OK, out.rv);
1841   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1842   EXPECT_EQ("hello!", out.response_data);
1843 }
1844
1845 // Test that a chunked POST works.
1846 TEST_P(SpdyNetworkTransactionTest, ChunkedPost) {
1847   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
1848   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
1849   MockWrite writes[] = {
1850     CreateMockWrite(*req),
1851     CreateMockWrite(*body),
1852   };
1853
1854   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
1855   MockRead reads[] = {
1856     CreateMockRead(*resp),
1857     CreateMockRead(*body),
1858     MockRead(ASYNC, 0, 0)  // EOF
1859   };
1860
1861   DelayedSocketData data(2, reads, arraysize(reads),
1862                          writes, arraysize(writes));
1863   NormalSpdyTransactionHelper helper(CreateChunkedPostRequest(),
1864                                      DEFAULT_PRIORITY,
1865                                      BoundNetLog(), GetParam(), NULL);
1866
1867   // These chunks get merged into a single frame when being sent.
1868   const int kFirstChunkSize = kUploadDataSize/2;
1869   upload_chunked_data_stream()->AppendData(kUploadData, kFirstChunkSize, false);
1870   upload_chunked_data_stream()->AppendData(
1871       kUploadData + kFirstChunkSize, kUploadDataSize - kFirstChunkSize, true);
1872
1873   helper.RunToCompletion(&data);
1874   TransactionHelperResult out = helper.output();
1875   EXPECT_EQ(OK, out.rv);
1876   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1877   EXPECT_EQ(kUploadData, out.response_data);
1878 }
1879
1880 // Test that a chunked POST works with chunks appended after transaction starts.
1881 TEST_P(SpdyNetworkTransactionTest, DelayedChunkedPost) {
1882   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
1883   scoped_ptr<SpdyFrame> chunk1(spdy_util_.ConstructSpdyBodyFrame(1, false));
1884   scoped_ptr<SpdyFrame> chunk2(spdy_util_.ConstructSpdyBodyFrame(1, false));
1885   scoped_ptr<SpdyFrame> chunk3(spdy_util_.ConstructSpdyBodyFrame(1, true));
1886   MockWrite writes[] = {
1887     CreateMockWrite(*req),
1888     CreateMockWrite(*chunk1),
1889     CreateMockWrite(*chunk2),
1890     CreateMockWrite(*chunk3),
1891   };
1892
1893   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
1894   MockRead reads[] = {
1895     CreateMockRead(*resp),
1896     CreateMockRead(*chunk1),
1897     CreateMockRead(*chunk2),
1898     CreateMockRead(*chunk3),
1899     MockRead(ASYNC, 0, 0)  // EOF
1900   };
1901
1902   DelayedSocketData data(4, reads, arraysize(reads),
1903                          writes, arraysize(writes));
1904   NormalSpdyTransactionHelper helper(CreateChunkedPostRequest(),
1905                                      DEFAULT_PRIORITY,
1906                                      BoundNetLog(), GetParam(), NULL);
1907
1908   upload_chunked_data_stream()->AppendData(kUploadData, kUploadDataSize, false);
1909
1910   helper.RunPreTestSetup();
1911   helper.AddData(&data);
1912   ASSERT_TRUE(helper.StartDefaultTest());
1913
1914   base::RunLoop().RunUntilIdle();
1915   upload_chunked_data_stream()->AppendData(kUploadData, kUploadDataSize, false);
1916   base::RunLoop().RunUntilIdle();
1917   upload_chunked_data_stream()->AppendData(kUploadData, kUploadDataSize, true);
1918
1919   helper.FinishDefaultTest();
1920   helper.VerifyDataConsumed();
1921
1922   std::string expected_response;
1923   expected_response += kUploadData;
1924   expected_response += kUploadData;
1925   expected_response += kUploadData;
1926
1927   TransactionHelperResult out = helper.output();
1928   EXPECT_EQ(OK, out.rv);
1929   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1930   EXPECT_EQ(expected_response, out.response_data);
1931 }
1932
1933 // Test that a POST without any post data works.
1934 TEST_P(SpdyNetworkTransactionTest, NullPost) {
1935   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
1936   // Setup the request
1937   HttpRequestInfo request;
1938   request.method = "POST";
1939   request.url = GURL(kRequestUrl);
1940   // Create an empty UploadData.
1941   request.upload_data_stream = NULL;
1942
1943   // When request.upload_data_stream is NULL for post, content-length is
1944   // expected to be 0.
1945   scoped_ptr<SpdyHeaderBlock> req_block(
1946       spdy_util_.ConstructPostHeaderBlock(kRequestUrl, 0));
1947   scoped_ptr<SpdyFrame> req(
1948       spdy_util_.ConstructSpdySyn(1, *req_block, LOWEST, false, true));
1949
1950   MockWrite writes[] = {
1951     CreateMockWrite(*req),
1952   };
1953
1954   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
1955   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
1956   MockRead reads[] = {
1957     CreateMockRead(*resp),
1958     CreateMockRead(*body),
1959     MockRead(ASYNC, 0, 0)  // EOF
1960   };
1961
1962   DelayedSocketData data(1, reads, arraysize(reads),
1963                          writes, arraysize(writes));
1964
1965   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
1966                                      BoundNetLog(), GetParam(), NULL);
1967   helper.RunToCompletion(&data);
1968   TransactionHelperResult out = helper.output();
1969   EXPECT_EQ(OK, out.rv);
1970   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
1971   EXPECT_EQ("hello!", out.response_data);
1972 }
1973
1974 // Test that a simple POST works.
1975 TEST_P(SpdyNetworkTransactionTest, EmptyPost) {
1976   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
1977   // Create an empty UploadDataStream.
1978   ScopedVector<UploadElementReader> element_readers;
1979   ElementsUploadDataStream stream(element_readers.Pass(), 0);
1980
1981   // Setup the request
1982   HttpRequestInfo request;
1983   request.method = "POST";
1984   request.url = GURL(kRequestUrl);
1985   request.upload_data_stream = &stream;
1986
1987   const uint64 kContentLength = 0;
1988
1989   scoped_ptr<SpdyHeaderBlock> req_block(
1990       spdy_util_.ConstructPostHeaderBlock(kRequestUrl, kContentLength));
1991   scoped_ptr<SpdyFrame> req(
1992       spdy_util_.ConstructSpdySyn(1, *req_block, LOWEST, false, true));
1993
1994   MockWrite writes[] = {
1995     CreateMockWrite(*req),
1996   };
1997
1998   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
1999   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
2000   MockRead reads[] = {
2001     CreateMockRead(*resp),
2002     CreateMockRead(*body),
2003     MockRead(ASYNC, 0, 0)  // EOF
2004   };
2005
2006   DelayedSocketData data(1, reads, arraysize(reads), writes, arraysize(writes));
2007
2008   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
2009                                      BoundNetLog(), GetParam(), NULL);
2010   helper.RunToCompletion(&data);
2011   TransactionHelperResult out = helper.output();
2012   EXPECT_EQ(OK, out.rv);
2013   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
2014   EXPECT_EQ("hello!", out.response_data);
2015 }
2016
2017 // While we're doing a post, the server sends the reply before upload completes.
2018 TEST_P(SpdyNetworkTransactionTest, ResponseBeforePostCompletes) {
2019   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructChunkedSpdyPost(NULL, 0));
2020   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
2021   MockWrite writes[] = {
2022     CreateMockWrite(*req, 0),
2023     CreateMockWrite(*body, 3),
2024   };
2025   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
2026   MockRead reads[] = {
2027     CreateMockRead(*resp, 1),
2028     CreateMockRead(*body, 2),
2029     MockRead(ASYNC, 0, 4)  // EOF
2030   };
2031
2032   // Write the request headers, and read the complete response
2033   // while still waiting for chunked request data.
2034   DeterministicSocketData data(reads, arraysize(reads),
2035                                writes, arraysize(writes));
2036   NormalSpdyTransactionHelper helper(CreateChunkedPostRequest(),
2037                                      DEFAULT_PRIORITY,
2038                                      BoundNetLog(), GetParam(), NULL);
2039   helper.SetDeterministic();
2040   helper.RunPreTestSetup();
2041   helper.AddDeterministicData(&data);
2042
2043   ASSERT_TRUE(helper.StartDefaultTest());
2044
2045   // Process the request headers, SYN_REPLY, and response body.
2046   // The request body is still in flight.
2047   data.RunFor(3);
2048
2049   const HttpResponseInfo* response = helper.trans()->GetResponseInfo();
2050   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
2051
2052   // Finish sending the request body.
2053   upload_chunked_data_stream()->AppendData(kUploadData, kUploadDataSize, true);
2054   data.RunFor(2);
2055
2056   std::string response_body;
2057   EXPECT_EQ(OK, ReadTransaction(helper.trans(), &response_body));
2058   EXPECT_EQ(kUploadData, response_body);
2059   helper.VerifyDataConsumed();
2060 }
2061
2062 // The client upon cancellation tries to send a RST_STREAM frame. The mock
2063 // socket causes the TCP write to return zero. This test checks that the client
2064 // tries to queue up the RST_STREAM frame again.
2065 TEST_P(SpdyNetworkTransactionTest, SocketWriteReturnsZero) {
2066   scoped_ptr<SpdyFrame> req(
2067       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2068   scoped_ptr<SpdyFrame> rst(
2069       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
2070   MockWrite writes[] = {
2071     CreateMockWrite(*req.get(), 0, SYNCHRONOUS),
2072     MockWrite(SYNCHRONOUS, 0, 0, 2),
2073     CreateMockWrite(*rst.get(), 3, SYNCHRONOUS),
2074   };
2075
2076   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2077   MockRead reads[] = {
2078     CreateMockRead(*resp.get(), 1, ASYNC),
2079     MockRead(ASYNC, 0, 0, 4)  // EOF
2080   };
2081
2082   DeterministicSocketData data(reads, arraysize(reads),
2083                                writes, arraysize(writes));
2084   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
2085                                      BoundNetLog(), GetParam(), NULL);
2086   helper.SetDeterministic();
2087   helper.RunPreTestSetup();
2088   helper.AddDeterministicData(&data);
2089   HttpNetworkTransaction* trans = helper.trans();
2090
2091   TestCompletionCallback callback;
2092   int rv = trans->Start(
2093       &CreateGetRequest(), callback.callback(), BoundNetLog());
2094   EXPECT_EQ(ERR_IO_PENDING, rv);
2095
2096   data.SetStop(2);
2097   data.Run();
2098   helper.ResetTrans();
2099   data.SetStop(20);
2100   data.Run();
2101
2102   helper.VerifyDataConsumed();
2103 }
2104
2105 // Test that the transaction doesn't crash when we don't have a reply.
2106 TEST_P(SpdyNetworkTransactionTest, ResponseWithoutSynReply) {
2107   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
2108   MockRead reads[] = {
2109     CreateMockRead(*body),
2110     MockRead(ASYNC, 0, 0)  // EOF
2111   };
2112
2113   DelayedSocketData data(1, reads, arraysize(reads), NULL, 0);
2114   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
2115                                      BoundNetLog(), GetParam(), NULL);
2116   helper.RunToCompletion(&data);
2117   TransactionHelperResult out = helper.output();
2118   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
2119 }
2120
2121 // Test that the transaction doesn't crash when we get two replies on the same
2122 // stream ID. See http://crbug.com/45639.
2123 TEST_P(SpdyNetworkTransactionTest, ResponseWithTwoSynReplies) {
2124   scoped_ptr<SpdyFrame> req(
2125       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2126   scoped_ptr<SpdyFrame> rst(
2127       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
2128   MockWrite writes[] = {
2129     CreateMockWrite(*req),
2130     CreateMockWrite(*rst),
2131   };
2132
2133   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2134   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
2135   MockRead reads[] = {
2136     CreateMockRead(*resp),
2137     CreateMockRead(*resp),
2138     CreateMockRead(*body),
2139     MockRead(ASYNC, 0, 0)  // EOF
2140   };
2141
2142   DelayedSocketData data(1, reads, arraysize(reads),
2143                          writes, arraysize(writes));
2144
2145   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
2146                                      BoundNetLog(), GetParam(), NULL);
2147   helper.RunPreTestSetup();
2148   helper.AddData(&data);
2149
2150   HttpNetworkTransaction* trans = helper.trans();
2151
2152   TestCompletionCallback callback;
2153   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
2154   EXPECT_EQ(ERR_IO_PENDING, rv);
2155   rv = callback.WaitForResult();
2156   EXPECT_EQ(OK, rv);
2157
2158   const HttpResponseInfo* response = trans->GetResponseInfo();
2159   ASSERT_TRUE(response != NULL);
2160   EXPECT_TRUE(response->headers.get() != NULL);
2161   EXPECT_TRUE(response->was_fetched_via_spdy);
2162   std::string response_data;
2163   rv = ReadTransaction(trans, &response_data);
2164   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, rv);
2165
2166   helper.VerifyDataConsumed();
2167 }
2168
2169 TEST_P(SpdyNetworkTransactionTest, ResetReplyWithTransferEncoding) {
2170   // Construct the request.
2171   scoped_ptr<SpdyFrame> req(
2172       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2173   scoped_ptr<SpdyFrame> rst(
2174       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
2175   MockWrite writes[] = {
2176     CreateMockWrite(*req),
2177     CreateMockWrite(*rst),
2178   };
2179
2180   const char* const headers[] = {
2181     "transfer-encoding", "chunked"
2182   };
2183   scoped_ptr<SpdyFrame> resp(
2184       spdy_util_.ConstructSpdyGetSynReply(headers, 1, 1));
2185   scoped_ptr<SpdyFrame> body(
2186       spdy_util_.ConstructSpdyBodyFrame(1, true));
2187   MockRead reads[] = {
2188     CreateMockRead(*resp),
2189     CreateMockRead(*body),
2190     MockRead(ASYNC, 0, 0)  // EOF
2191   };
2192
2193   DelayedSocketData data(1, reads, arraysize(reads),
2194                          writes, arraysize(writes));
2195   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
2196                                      BoundNetLog(), GetParam(), NULL);
2197   helper.RunToCompletion(&data);
2198   TransactionHelperResult out = helper.output();
2199   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
2200
2201   helper.session()->spdy_session_pool()->CloseAllSessions();
2202   helper.VerifyDataConsumed();
2203 }
2204
2205 TEST_P(SpdyNetworkTransactionTest, ResetPushWithTransferEncoding) {
2206   // Construct the request.
2207   scoped_ptr<SpdyFrame> req(
2208       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2209   scoped_ptr<SpdyFrame> rst(
2210       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
2211   MockWrite writes[] = {
2212     CreateMockWrite(*req),
2213     CreateMockWrite(*rst),
2214   };
2215
2216   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2217   const char* const headers[] = {
2218     "transfer-encoding", "chunked"
2219   };
2220   scoped_ptr<SpdyFrame> push(
2221       spdy_util_.ConstructSpdyPush(headers, arraysize(headers) / 2,
2222                                    2, 1, "http://www.google.com/1"));
2223   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
2224   MockRead reads[] = {
2225     CreateMockRead(*resp),
2226     CreateMockRead(*push),
2227     CreateMockRead(*body),
2228     MockRead(ASYNC, 0, 0)  // EOF
2229   };
2230
2231   DelayedSocketData data(1, reads, arraysize(reads),
2232                          writes, arraysize(writes));
2233   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
2234                                      BoundNetLog(), GetParam(), NULL);
2235   helper.RunToCompletion(&data);
2236   TransactionHelperResult out = helper.output();
2237   EXPECT_EQ(OK, out.rv);
2238   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
2239   EXPECT_EQ("hello!", out.response_data);
2240
2241   helper.session()->spdy_session_pool()->CloseAllSessions();
2242   helper.VerifyDataConsumed();
2243 }
2244
2245 TEST_P(SpdyNetworkTransactionTest, CancelledTransaction) {
2246   // Construct the request.
2247   scoped_ptr<SpdyFrame> req(
2248       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2249   MockWrite writes[] = {
2250     CreateMockWrite(*req),
2251   };
2252
2253   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2254   MockRead reads[] = {
2255     CreateMockRead(*resp),
2256     // This following read isn't used by the test, except during the
2257     // RunUntilIdle() call at the end since the SpdySession survives the
2258     // HttpNetworkTransaction and still tries to continue Read()'ing.  Any
2259     // MockRead will do here.
2260     MockRead(ASYNC, 0, 0)  // EOF
2261   };
2262
2263   StaticSocketDataProvider data(reads, arraysize(reads),
2264                                 writes, arraysize(writes));
2265
2266   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
2267                                      BoundNetLog(), GetParam(), NULL);
2268   helper.RunPreTestSetup();
2269   helper.AddData(&data);
2270   HttpNetworkTransaction* trans = helper.trans();
2271
2272   TestCompletionCallback callback;
2273   int rv = trans->Start(
2274       &CreateGetRequest(), callback.callback(), BoundNetLog());
2275   EXPECT_EQ(ERR_IO_PENDING, rv);
2276   helper.ResetTrans();  // Cancel the transaction.
2277
2278   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
2279   // MockClientSocketFactory) are still alive.
2280   base::RunLoop().RunUntilIdle();
2281   helper.VerifyDataNotConsumed();
2282 }
2283
2284 // Verify that the client sends a Rst Frame upon cancelling the stream.
2285 TEST_P(SpdyNetworkTransactionTest, CancelledTransactionSendRst) {
2286   scoped_ptr<SpdyFrame> req(
2287       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2288   scoped_ptr<SpdyFrame> rst(
2289       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
2290   MockWrite writes[] = {
2291     CreateMockWrite(*req, 0, SYNCHRONOUS),
2292     CreateMockWrite(*rst, 2, SYNCHRONOUS),
2293   };
2294
2295   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2296   MockRead reads[] = {
2297     CreateMockRead(*resp, 1, ASYNC),
2298     MockRead(ASYNC, 0, 0, 3)  // EOF
2299   };
2300
2301   DeterministicSocketData data(reads, arraysize(reads),
2302                                writes, arraysize(writes));
2303
2304   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
2305                                      BoundNetLog(),
2306                                      GetParam(), NULL);
2307   helper.SetDeterministic();
2308   helper.RunPreTestSetup();
2309   helper.AddDeterministicData(&data);
2310   HttpNetworkTransaction* trans = helper.trans();
2311
2312   TestCompletionCallback callback;
2313
2314   int rv = trans->Start(
2315       &CreateGetRequest(), callback.callback(), BoundNetLog());
2316   EXPECT_EQ(ERR_IO_PENDING, rv);
2317
2318   data.SetStop(2);
2319   data.Run();
2320   helper.ResetTrans();
2321   data.SetStop(20);
2322   data.Run();
2323
2324   helper.VerifyDataConsumed();
2325 }
2326
2327 // Verify that the client can correctly deal with the user callback attempting
2328 // to start another transaction on a session that is closing down. See
2329 // http://crbug.com/47455
2330 TEST_P(SpdyNetworkTransactionTest, StartTransactionOnReadCallback) {
2331   scoped_ptr<SpdyFrame> req(
2332       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2333   MockWrite writes[] = { CreateMockWrite(*req) };
2334   MockWrite writes2[] = { CreateMockWrite(*req) };
2335
2336   // The indicated length of this frame is longer than its actual length. When
2337   // the session receives an empty frame after this one, it shuts down the
2338   // session, and calls the read callback with the incomplete data.
2339   const uint8 kGetBodyFrame2[] = {
2340     0x00, 0x00, 0x00, 0x01,
2341     0x01, 0x00, 0x00, 0x07,
2342     'h', 'e', 'l', 'l', 'o', '!',
2343   };
2344
2345   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2346   MockRead reads[] = {
2347     CreateMockRead(*resp, 2),
2348     MockRead(ASYNC, ERR_IO_PENDING, 3),  // Force a pause
2349     MockRead(ASYNC, reinterpret_cast<const char*>(kGetBodyFrame2),
2350              arraysize(kGetBodyFrame2), 4),
2351     MockRead(ASYNC, ERR_IO_PENDING, 5),  // Force a pause
2352     MockRead(ASYNC, 0, 0, 6),  // EOF
2353   };
2354   MockRead reads2[] = {
2355     CreateMockRead(*resp, 2),
2356     MockRead(ASYNC, 0, 0, 3),  // EOF
2357   };
2358
2359   OrderedSocketData data(reads, arraysize(reads),
2360                          writes, arraysize(writes));
2361   DelayedSocketData data2(1, reads2, arraysize(reads2),
2362                           writes2, arraysize(writes2));
2363
2364   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
2365                                      BoundNetLog(), GetParam(), NULL);
2366   helper.RunPreTestSetup();
2367   helper.AddData(&data);
2368   helper.AddData(&data2);
2369   HttpNetworkTransaction* trans = helper.trans();
2370
2371   // Start the transaction with basic parameters.
2372   TestCompletionCallback callback;
2373   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
2374   EXPECT_EQ(ERR_IO_PENDING, rv);
2375   rv = callback.WaitForResult();
2376
2377   const int kSize = 3000;
2378   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
2379   rv = trans->Read(
2380       buf.get(),
2381       kSize,
2382       base::Bind(&SpdyNetworkTransactionTest::StartTransactionCallback,
2383                  helper.session()));
2384   // This forces an err_IO_pending, which sets the callback.
2385   data.CompleteRead();
2386   // This finishes the read.
2387   data.CompleteRead();
2388   helper.VerifyDataConsumed();
2389 }
2390
2391 // Verify that the client can correctly deal with the user callback deleting the
2392 // transaction. Failures will usually be valgrind errors. See
2393 // http://crbug.com/46925
2394 TEST_P(SpdyNetworkTransactionTest, DeleteSessionOnReadCallback) {
2395   scoped_ptr<SpdyFrame> req(
2396       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2397   MockWrite writes[] = { CreateMockWrite(*req) };
2398
2399   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2400   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
2401   MockRead reads[] = {
2402     CreateMockRead(*resp.get(), 2),
2403     MockRead(ASYNC, ERR_IO_PENDING, 3),  // Force a pause
2404     CreateMockRead(*body.get(), 4),
2405     MockRead(ASYNC, 0, 0, 5),  // EOF
2406   };
2407
2408   OrderedSocketData data(reads, arraysize(reads),
2409                          writes, arraysize(writes));
2410
2411   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
2412                                      BoundNetLog(), GetParam(), NULL);
2413   helper.RunPreTestSetup();
2414   helper.AddData(&data);
2415   HttpNetworkTransaction* trans = helper.trans();
2416
2417   // Start the transaction with basic parameters.
2418   TestCompletionCallback callback;
2419   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
2420   EXPECT_EQ(ERR_IO_PENDING, rv);
2421   rv = callback.WaitForResult();
2422
2423   // Setup a user callback which will delete the session, and clear out the
2424   // memory holding the stream object. Note that the callback deletes trans.
2425   const int kSize = 3000;
2426   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSize));
2427   rv = trans->Read(
2428       buf.get(),
2429       kSize,
2430       base::Bind(&SpdyNetworkTransactionTest::DeleteSessionCallback,
2431                  base::Unretained(&helper)));
2432   ASSERT_EQ(ERR_IO_PENDING, rv);
2433   data.CompleteRead();
2434
2435   // Finish running rest of tasks.
2436   base::RunLoop().RunUntilIdle();
2437   helper.VerifyDataConsumed();
2438 }
2439
2440 // Send a spdy request to www.google.com that gets redirected to www.foo.com.
2441 TEST_P(SpdyNetworkTransactionTest, RedirectGetRequest) {
2442   scoped_ptr<SpdyHeaderBlock> headers(
2443       spdy_util_.ConstructGetHeaderBlock("http://www.google.com/"));
2444   (*headers)["user-agent"] = "";
2445   (*headers)["accept-encoding"] = "gzip, deflate";
2446   scoped_ptr<SpdyHeaderBlock> headers2(
2447       spdy_util_.ConstructGetHeaderBlock("http://www.foo.com/index.php"));
2448   (*headers2)["user-agent"] = "";
2449   (*headers2)["accept-encoding"] = "gzip, deflate";
2450
2451   // Setup writes/reads to www.google.com
2452   scoped_ptr<SpdyFrame> req(
2453       spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, false, true));
2454   scoped_ptr<SpdyFrame> req2(
2455       spdy_util_.ConstructSpdySyn(1, *headers2, LOWEST, false, true));
2456   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReplyRedirect(1));
2457   MockWrite writes[] = {
2458     CreateMockWrite(*req, 1),
2459   };
2460   MockRead reads[] = {
2461     CreateMockRead(*resp, 2),
2462     MockRead(ASYNC, 0, 0, 3)  // EOF
2463   };
2464
2465   // Setup writes/reads to www.foo.com
2466   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2467   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true));
2468   MockWrite writes2[] = {
2469     CreateMockWrite(*req2, 1),
2470   };
2471   MockRead reads2[] = {
2472     CreateMockRead(*resp2, 2),
2473     CreateMockRead(*body2, 3),
2474     MockRead(ASYNC, 0, 0, 4)  // EOF
2475   };
2476   OrderedSocketData data(reads, arraysize(reads),
2477                          writes, arraysize(writes));
2478   OrderedSocketData data2(reads2, arraysize(reads2),
2479                           writes2, arraysize(writes2));
2480
2481   // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
2482   TestDelegate d;
2483   {
2484     SpdyURLRequestContext spdy_url_request_context(
2485         GetParam().protocol,
2486         false  /* force_spdy_over_ssl*/,
2487         true  /* force_spdy_always */);
2488     scoped_ptr<URLRequest> r(
2489         spdy_url_request_context.CreateRequest(GURL("http://www.google.com/"),
2490                                                DEFAULT_PRIORITY,
2491                                                &d,
2492                                                NULL));
2493     spdy_url_request_context.socket_factory().
2494         AddSocketDataProvider(&data);
2495     spdy_url_request_context.socket_factory().
2496         AddSocketDataProvider(&data2);
2497
2498     d.set_quit_on_redirect(true);
2499     r->Start();
2500     base::RunLoop().Run();
2501
2502     EXPECT_EQ(1, d.received_redirect_count());
2503
2504     r->FollowDeferredRedirect();
2505     base::RunLoop().Run();
2506     EXPECT_EQ(1, d.response_started_count());
2507     EXPECT_FALSE(d.received_data_before_response());
2508     EXPECT_EQ(net::URLRequestStatus::SUCCESS, r->status().status());
2509     std::string contents("hello!");
2510     EXPECT_EQ(contents, d.data_received());
2511   }
2512   EXPECT_TRUE(data.at_read_eof());
2513   EXPECT_TRUE(data.at_write_eof());
2514   EXPECT_TRUE(data2.at_read_eof());
2515   EXPECT_TRUE(data2.at_write_eof());
2516 }
2517
2518 // Send a spdy request to www.google.com. Get a pushed stream that redirects to
2519 // www.foo.com.
2520 TEST_P(SpdyNetworkTransactionTest, RedirectServerPush) {
2521   scoped_ptr<SpdyHeaderBlock> headers(
2522       spdy_util_.ConstructGetHeaderBlock("http://www.google.com/"));
2523   (*headers)["user-agent"] = "";
2524   (*headers)["accept-encoding"] = "gzip, deflate";
2525
2526   // Setup writes/reads to www.google.com
2527   scoped_ptr<SpdyFrame> req(
2528       spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, false, true));
2529   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2530   scoped_ptr<SpdyFrame> rep(
2531       spdy_util_.ConstructSpdyPush(NULL,
2532                         0,
2533                         2,
2534                         1,
2535                         "http://www.google.com/foo.dat",
2536                         "301 Moved Permanently",
2537                         "http://www.foo.com/index.php"));
2538   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
2539   scoped_ptr<SpdyFrame> rst(
2540       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_CANCEL));
2541   MockWrite writes[] = {
2542     CreateMockWrite(*req, 1),
2543     CreateMockWrite(*rst, 6),
2544   };
2545   MockRead reads[] = {
2546     CreateMockRead(*resp, 2),
2547     CreateMockRead(*rep, 3),
2548     CreateMockRead(*body, 4),
2549     MockRead(ASYNC, ERR_IO_PENDING, 5),  // Force a pause
2550     MockRead(ASYNC, 0, 0, 7)  // EOF
2551   };
2552
2553   // Setup writes/reads to www.foo.com
2554   scoped_ptr<SpdyHeaderBlock> headers2(
2555       spdy_util_.ConstructGetHeaderBlock("http://www.foo.com/index.php"));
2556   (*headers2)["user-agent"] = "";
2557   (*headers2)["accept-encoding"] = "gzip, deflate";
2558   scoped_ptr<SpdyFrame> req2(
2559       spdy_util_.ConstructSpdySyn(1, *headers2, LOWEST, false, true));
2560   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2561   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true));
2562   MockWrite writes2[] = {
2563     CreateMockWrite(*req2, 1),
2564   };
2565   MockRead reads2[] = {
2566     CreateMockRead(*resp2, 2),
2567     CreateMockRead(*body2, 3),
2568     MockRead(ASYNC, 0, 0, 5)  // EOF
2569   };
2570   OrderedSocketData data(reads, arraysize(reads),
2571                          writes, arraysize(writes));
2572   OrderedSocketData data2(reads2, arraysize(reads2),
2573                           writes2, arraysize(writes2));
2574
2575   // TODO(erikchen): Make test support SPDYSSL, SPDYNPN
2576   TestDelegate d;
2577   TestDelegate d2;
2578   SpdyURLRequestContext spdy_url_request_context(
2579       GetParam().protocol,
2580       false  /* force_spdy_over_ssl*/,
2581       true  /* force_spdy_always */);
2582   {
2583     scoped_ptr<URLRequest> r(
2584         spdy_url_request_context.CreateRequest(GURL("http://www.google.com/"),
2585                                                DEFAULT_PRIORITY,
2586                                                &d,
2587                                                NULL));
2588     spdy_url_request_context.socket_factory().
2589         AddSocketDataProvider(&data);
2590
2591     r->Start();
2592     base::RunLoop().Run();
2593
2594     EXPECT_EQ(0, d.received_redirect_count());
2595     std::string contents("hello!");
2596     EXPECT_EQ(contents, d.data_received());
2597
2598     scoped_ptr<URLRequest> r2(
2599         spdy_url_request_context.CreateRequest(
2600             GURL("http://www.google.com/foo.dat"),
2601             DEFAULT_PRIORITY,
2602             &d2,
2603             NULL));
2604     spdy_url_request_context.socket_factory().
2605         AddSocketDataProvider(&data2);
2606
2607     d2.set_quit_on_redirect(true);
2608     r2->Start();
2609     base::RunLoop().Run();
2610     EXPECT_EQ(1, d2.received_redirect_count());
2611
2612     r2->FollowDeferredRedirect();
2613     base::RunLoop().Run();
2614     EXPECT_EQ(1, d2.response_started_count());
2615     EXPECT_FALSE(d2.received_data_before_response());
2616     EXPECT_EQ(net::URLRequestStatus::SUCCESS, r2->status().status());
2617     std::string contents2("hello!");
2618     EXPECT_EQ(contents2, d2.data_received());
2619   }
2620   data.CompleteRead();
2621   data2.CompleteRead();
2622   EXPECT_TRUE(data.at_read_eof());
2623   EXPECT_TRUE(data.at_write_eof());
2624   EXPECT_TRUE(data2.at_read_eof());
2625   EXPECT_TRUE(data2.at_write_eof());
2626 }
2627
2628 TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame) {
2629   scoped_ptr<SpdyFrame> stream1_syn(
2630       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2631   scoped_ptr<SpdyFrame> stream1_body(
2632       spdy_util_.ConstructSpdyBodyFrame(1, true));
2633   MockWrite writes[] = {
2634     CreateMockWrite(*stream1_syn, 1),
2635   };
2636
2637   scoped_ptr<SpdyFrame>
2638       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2639   scoped_ptr<SpdyFrame>
2640       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
2641                                     0,
2642                                     2,
2643                                     1,
2644                                     "http://www.google.com/foo.dat"));
2645   const char kPushedData[] = "pushed";
2646   scoped_ptr<SpdyFrame> stream2_body(
2647       spdy_util_.ConstructSpdyBodyFrame(
2648           2, kPushedData, strlen(kPushedData), true));
2649   MockRead reads[] = {
2650     CreateMockRead(*stream1_reply, 2),
2651     CreateMockRead(*stream2_syn, 3),
2652     CreateMockRead(*stream1_body, 4, SYNCHRONOUS),
2653     CreateMockRead(*stream2_body, 5),
2654     MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
2655   };
2656
2657   HttpResponseInfo response;
2658   HttpResponseInfo response2;
2659   std::string expected_push_result("pushed");
2660   OrderedSocketData data(reads, arraysize(reads),
2661                          writes, arraysize(writes));
2662   RunServerPushTest(&data,
2663                     &response,
2664                     &response2,
2665                     expected_push_result);
2666
2667   // Verify the SYN_REPLY.
2668   EXPECT_TRUE(response.headers.get() != NULL);
2669   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
2670
2671   // Verify the pushed stream.
2672   EXPECT_TRUE(response2.headers.get() != NULL);
2673   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
2674 }
2675
2676 TEST_P(SpdyNetworkTransactionTest, ServerPushBeforeSynReply) {
2677   scoped_ptr<SpdyFrame> stream1_syn(
2678       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2679   scoped_ptr<SpdyFrame> stream1_body(
2680       spdy_util_.ConstructSpdyBodyFrame(1, true));
2681   MockWrite writes[] = {
2682     CreateMockWrite(*stream1_syn, 1),
2683   };
2684
2685   scoped_ptr<SpdyFrame>
2686       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2687   scoped_ptr<SpdyFrame>
2688       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
2689                                     0,
2690                                     2,
2691                                     1,
2692                                     "http://www.google.com/foo.dat"));
2693   const char kPushedData[] = "pushed";
2694   scoped_ptr<SpdyFrame> stream2_body(
2695       spdy_util_.ConstructSpdyBodyFrame(
2696           2, kPushedData, strlen(kPushedData), true));
2697   MockRead reads[] = {
2698     CreateMockRead(*stream2_syn, 2),
2699     CreateMockRead(*stream1_reply, 3),
2700     CreateMockRead(*stream1_body, 4, SYNCHRONOUS),
2701     CreateMockRead(*stream2_body, 5),
2702     MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
2703   };
2704
2705   HttpResponseInfo response;
2706   HttpResponseInfo response2;
2707   std::string expected_push_result("pushed");
2708   OrderedSocketData data(reads, arraysize(reads),
2709                          writes, arraysize(writes));
2710   RunServerPushTest(&data,
2711                     &response,
2712                     &response2,
2713                     expected_push_result);
2714
2715   // Verify the SYN_REPLY.
2716   EXPECT_TRUE(response.headers.get() != NULL);
2717   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
2718
2719   // Verify the pushed stream.
2720   EXPECT_TRUE(response2.headers.get() != NULL);
2721   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
2722 }
2723
2724 TEST_P(SpdyNetworkTransactionTest, ServerPushSingleDataFrame2) {
2725   scoped_ptr<SpdyFrame> stream1_syn(
2726       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2727   MockWrite writes[] = { CreateMockWrite(*stream1_syn, 1), };
2728
2729   scoped_ptr<SpdyFrame>
2730       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2731   scoped_ptr<SpdyFrame>
2732       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
2733                                     0,
2734                                     2,
2735                                     1,
2736                                     "http://www.google.com/foo.dat"));
2737   const char kPushedData[] = "pushed";
2738   scoped_ptr<SpdyFrame> stream2_body(
2739       spdy_util_.ConstructSpdyBodyFrame(
2740           2, kPushedData, strlen(kPushedData), true));
2741   scoped_ptr<SpdyFrame>
2742       stream1_body(spdy_util_.ConstructSpdyBodyFrame(1, true));
2743   MockRead reads[] = {
2744     CreateMockRead(*stream1_reply, 2),
2745     CreateMockRead(*stream2_syn, 3),
2746     CreateMockRead(*stream2_body, 4),
2747     CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
2748     MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
2749   };
2750
2751   HttpResponseInfo response;
2752   HttpResponseInfo response2;
2753   std::string expected_push_result("pushed");
2754   OrderedSocketData data(reads, arraysize(reads),
2755                          writes, arraysize(writes));
2756   RunServerPushTest(&data,
2757                     &response,
2758                     &response2,
2759                     expected_push_result);
2760
2761   // Verify the SYN_REPLY.
2762   EXPECT_TRUE(response.headers.get() != NULL);
2763   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
2764
2765   // Verify the pushed stream.
2766   EXPECT_TRUE(response2.headers.get() != NULL);
2767   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
2768 }
2769
2770 TEST_P(SpdyNetworkTransactionTest, ServerPushServerAborted) {
2771   scoped_ptr<SpdyFrame> stream1_syn(
2772       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2773   scoped_ptr<SpdyFrame> stream1_body(
2774       spdy_util_.ConstructSpdyBodyFrame(1, true));
2775   MockWrite writes[] = {
2776     CreateMockWrite(*stream1_syn, 1),
2777   };
2778
2779   scoped_ptr<SpdyFrame>
2780       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2781   scoped_ptr<SpdyFrame>
2782       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
2783                                     0,
2784                                     2,
2785                                     1,
2786                                     "http://www.google.com/foo.dat"));
2787   scoped_ptr<SpdyFrame> stream2_rst(
2788       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
2789   MockRead reads[] = {
2790     CreateMockRead(*stream1_reply, 2),
2791     CreateMockRead(*stream2_syn, 3),
2792     CreateMockRead(*stream2_rst, 4),
2793     CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
2794     MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
2795   };
2796
2797   OrderedSocketData data(reads, arraysize(reads),
2798                          writes, arraysize(writes));
2799   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
2800                                      BoundNetLog(), GetParam(), NULL);
2801
2802   helper.RunPreTestSetup();
2803   helper.AddData(&data);
2804
2805   HttpNetworkTransaction* trans = helper.trans();
2806
2807   // Start the transaction with basic parameters.
2808   TestCompletionCallback callback;
2809   int rv = trans->Start(
2810       &CreateGetRequest(), callback.callback(), BoundNetLog());
2811   EXPECT_EQ(ERR_IO_PENDING, rv);
2812   rv = callback.WaitForResult();
2813   EXPECT_EQ(OK, rv);
2814
2815   // Verify that we consumed all test data.
2816   EXPECT_TRUE(data.at_read_eof()) << "Read count: "
2817                                    << data.read_count()
2818                                    << " Read index: "
2819                                    << data.read_index();
2820   EXPECT_TRUE(data.at_write_eof()) << "Write count: "
2821                                     << data.write_count()
2822                                     << " Write index: "
2823                                     << data.write_index();
2824
2825   // Verify the SYN_REPLY.
2826   HttpResponseInfo response = *trans->GetResponseInfo();
2827   EXPECT_TRUE(response.headers.get() != NULL);
2828   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
2829 }
2830
2831 // Verify that we don't leak streams and that we properly send a reset
2832 // if the server pushes the same stream twice.
2833 TEST_P(SpdyNetworkTransactionTest, ServerPushDuplicate) {
2834   scoped_ptr<SpdyFrame> stream1_syn(
2835       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2836   scoped_ptr<SpdyFrame> stream1_body(
2837       spdy_util_.ConstructSpdyBodyFrame(1, true));
2838   scoped_ptr<SpdyFrame> stream3_rst(
2839       spdy_util_.ConstructSpdyRstStream(4, RST_STREAM_PROTOCOL_ERROR));
2840   MockWrite writes[] = {
2841     CreateMockWrite(*stream1_syn, 1),
2842     CreateMockWrite(*stream3_rst, 5),
2843   };
2844
2845   scoped_ptr<SpdyFrame>
2846       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2847   scoped_ptr<SpdyFrame>
2848       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
2849                                     0,
2850                                     2,
2851                                     1,
2852                                     "http://www.google.com/foo.dat"));
2853   const char kPushedData[] = "pushed";
2854   scoped_ptr<SpdyFrame> stream2_body(
2855       spdy_util_.ConstructSpdyBodyFrame(
2856           2, kPushedData, strlen(kPushedData), true));
2857   scoped_ptr<SpdyFrame>
2858       stream3_syn(spdy_util_.ConstructSpdyPush(NULL,
2859                                     0,
2860                                     4,
2861                                     1,
2862                                     "http://www.google.com/foo.dat"));
2863   MockRead reads[] = {
2864     CreateMockRead(*stream1_reply, 2),
2865     CreateMockRead(*stream2_syn, 3),
2866     CreateMockRead(*stream3_syn, 4),
2867     CreateMockRead(*stream1_body, 6, SYNCHRONOUS),
2868     CreateMockRead(*stream2_body, 7),
2869     MockRead(ASYNC, ERR_IO_PENDING, 8),  // Force a pause
2870   };
2871
2872   HttpResponseInfo response;
2873   HttpResponseInfo response2;
2874   std::string expected_push_result("pushed");
2875   OrderedSocketData data(reads, arraysize(reads),
2876                          writes, arraysize(writes));
2877   RunServerPushTest(&data,
2878                     &response,
2879                     &response2,
2880                     expected_push_result);
2881
2882   // Verify the SYN_REPLY.
2883   EXPECT_TRUE(response.headers.get() != NULL);
2884   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
2885
2886   // Verify the pushed stream.
2887   EXPECT_TRUE(response2.headers.get() != NULL);
2888   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
2889 }
2890
2891 TEST_P(SpdyNetworkTransactionTest, ServerPushMultipleDataFrame) {
2892   scoped_ptr<SpdyFrame> stream1_syn(
2893       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2894   scoped_ptr<SpdyFrame> stream1_body(
2895       spdy_util_.ConstructSpdyBodyFrame(1, true));
2896   MockWrite writes[] = {
2897     CreateMockWrite(*stream1_syn, 1),
2898   };
2899
2900   scoped_ptr<SpdyFrame>
2901       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2902   scoped_ptr<SpdyFrame>
2903       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
2904                                     0,
2905                                     2,
2906                                     1,
2907                                     "http://www.google.com/foo.dat"));
2908   static const char kPushedData[] = "pushed my darling hello my baby";
2909   scoped_ptr<SpdyFrame> stream2_body_base(
2910       spdy_util_.ConstructSpdyBodyFrame(
2911           2, kPushedData, strlen(kPushedData), true));
2912   const size_t kChunkSize = strlen(kPushedData) / 4;
2913   scoped_ptr<SpdyFrame> stream2_body1(
2914       new SpdyFrame(stream2_body_base->data(), kChunkSize, false));
2915   scoped_ptr<SpdyFrame> stream2_body2(
2916       new SpdyFrame(stream2_body_base->data() + kChunkSize, kChunkSize, false));
2917   scoped_ptr<SpdyFrame> stream2_body3(
2918       new SpdyFrame(stream2_body_base->data() + 2 * kChunkSize,
2919                     kChunkSize, false));
2920   scoped_ptr<SpdyFrame> stream2_body4(
2921       new SpdyFrame(stream2_body_base->data() + 3 * kChunkSize,
2922                     stream2_body_base->size() - 3 * kChunkSize, false));
2923   MockRead reads[] = {
2924     CreateMockRead(*stream1_reply, 2),
2925     CreateMockRead(*stream2_syn, 3),
2926     CreateMockRead(*stream2_body1, 4),
2927     CreateMockRead(*stream2_body2, 5),
2928     CreateMockRead(*stream2_body3, 6),
2929     CreateMockRead(*stream2_body4, 7),
2930     CreateMockRead(*stream1_body, 8, SYNCHRONOUS),
2931     MockRead(ASYNC, ERR_IO_PENDING, 9),  // Force a pause
2932   };
2933
2934   HttpResponseInfo response;
2935   HttpResponseInfo response2;
2936   std::string expected_push_result("pushed my darling hello my baby");
2937   OrderedSocketData data(reads, arraysize(reads),
2938                          writes, arraysize(writes));
2939   RunServerPushTest(&data, &response, &response2, kPushedData);
2940
2941   // Verify the SYN_REPLY.
2942   EXPECT_TRUE(response.headers.get() != NULL);
2943   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
2944
2945   // Verify the pushed stream.
2946   EXPECT_TRUE(response2.headers.get() != NULL);
2947   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
2948 }
2949
2950 TEST_P(SpdyNetworkTransactionTest, ServerPushMultipleDataFrameInterrupted) {
2951   scoped_ptr<SpdyFrame> stream1_syn(
2952       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
2953   scoped_ptr<SpdyFrame> stream1_body(
2954       spdy_util_.ConstructSpdyBodyFrame(1, true));
2955   MockWrite writes[] = {
2956     CreateMockWrite(*stream1_syn, 1),
2957   };
2958
2959   scoped_ptr<SpdyFrame>
2960       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
2961   scoped_ptr<SpdyFrame>
2962       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
2963                                     0,
2964                                     2,
2965                                     1,
2966                                     "http://www.google.com/foo.dat"));
2967   static const char kPushedData[] = "pushed my darling hello my baby";
2968   scoped_ptr<SpdyFrame> stream2_body_base(
2969       spdy_util_.ConstructSpdyBodyFrame(
2970           2, kPushedData, strlen(kPushedData), true));
2971   const size_t kChunkSize = strlen(kPushedData) / 4;
2972   scoped_ptr<SpdyFrame> stream2_body1(
2973       new SpdyFrame(stream2_body_base->data(), kChunkSize, false));
2974   scoped_ptr<SpdyFrame> stream2_body2(
2975       new SpdyFrame(stream2_body_base->data() + kChunkSize, kChunkSize, false));
2976   scoped_ptr<SpdyFrame> stream2_body3(
2977       new SpdyFrame(stream2_body_base->data() + 2 * kChunkSize,
2978                     kChunkSize, false));
2979   scoped_ptr<SpdyFrame> stream2_body4(
2980       new SpdyFrame(stream2_body_base->data() + 3 * kChunkSize,
2981                     stream2_body_base->size() - 3 * kChunkSize, false));
2982   MockRead reads[] = {
2983     CreateMockRead(*stream1_reply, 2),
2984     CreateMockRead(*stream2_syn, 3),
2985     CreateMockRead(*stream2_body1, 4),
2986     CreateMockRead(*stream2_body2, 5),
2987     MockRead(ASYNC, ERR_IO_PENDING, 6),  // Force a pause
2988     CreateMockRead(*stream2_body3, 7),
2989     CreateMockRead(*stream2_body4, 8),
2990     CreateMockRead(*stream1_body.get(), 9, SYNCHRONOUS),
2991     MockRead(ASYNC, ERR_IO_PENDING, 10)  // Force a pause.
2992   };
2993
2994   HttpResponseInfo response;
2995   HttpResponseInfo response2;
2996   OrderedSocketData data(reads, arraysize(reads),
2997                          writes, arraysize(writes));
2998   RunServerPushTest(&data, &response, &response2, kPushedData);
2999
3000   // Verify the SYN_REPLY.
3001   EXPECT_TRUE(response.headers.get() != NULL);
3002   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
3003
3004   // Verify the pushed stream.
3005   EXPECT_TRUE(response2.headers.get() != NULL);
3006   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
3007 }
3008
3009 TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID0) {
3010   if (spdy_util_.spdy_version() == SPDY4) {
3011     // PUSH_PROMISE with stream id 0 is connection-level error.
3012     // TODO(baranovich): Test session going away.
3013     return;
3014   }
3015
3016   scoped_ptr<SpdyFrame> stream1_syn(
3017       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
3018   scoped_ptr<SpdyFrame> stream1_body(
3019       spdy_util_.ConstructSpdyBodyFrame(1, true));
3020   scoped_ptr<SpdyFrame> stream2_rst(
3021       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
3022   MockWrite writes[] = {
3023     CreateMockWrite(*stream1_syn, 1),
3024     CreateMockWrite(*stream2_rst, 4),
3025   };
3026
3027   scoped_ptr<SpdyFrame>
3028       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
3029   scoped_ptr<SpdyFrame>
3030       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
3031                                     0,
3032                                     2,
3033                                     0,
3034                                     "http://www.google.com/foo.dat"));
3035   MockRead reads[] = {
3036     CreateMockRead(*stream1_reply, 2),
3037     CreateMockRead(*stream2_syn, 3),
3038     CreateMockRead(*stream1_body, 4),
3039     MockRead(ASYNC, ERR_IO_PENDING, 5)  // Force a pause
3040   };
3041
3042   OrderedSocketData data(reads, arraysize(reads),
3043                          writes, arraysize(writes));
3044   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
3045                                      BoundNetLog(), GetParam(), NULL);
3046
3047   helper.RunPreTestSetup();
3048   helper.AddData(&data);
3049
3050   HttpNetworkTransaction* trans = helper.trans();
3051
3052   // Start the transaction with basic parameters.
3053   TestCompletionCallback callback;
3054   int rv = trans->Start(
3055       &CreateGetRequest(), callback.callback(), BoundNetLog());
3056   EXPECT_EQ(ERR_IO_PENDING, rv);
3057   rv = callback.WaitForResult();
3058   EXPECT_EQ(OK, rv);
3059
3060   // Verify that we consumed all test data.
3061   EXPECT_TRUE(data.at_read_eof()) << "Read count: "
3062                                    << data.read_count()
3063                                    << " Read index: "
3064                                    << data.read_index();
3065   EXPECT_TRUE(data.at_write_eof()) << "Write count: "
3066                                     << data.write_count()
3067                                     << " Write index: "
3068                                     << data.write_index();
3069
3070   // Verify the SYN_REPLY.
3071   HttpResponseInfo response = *trans->GetResponseInfo();
3072   EXPECT_TRUE(response.headers.get() != NULL);
3073   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
3074 }
3075
3076 TEST_P(SpdyNetworkTransactionTest, ServerPushInvalidAssociatedStreamID9) {
3077   scoped_ptr<SpdyFrame> stream1_syn(
3078       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
3079   scoped_ptr<SpdyFrame> stream1_body(
3080       spdy_util_.ConstructSpdyBodyFrame(1, true));
3081   scoped_ptr<SpdyFrame> stream2_rst(
3082       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_INVALID_STREAM));
3083   MockWrite writes[] = {
3084     CreateMockWrite(*stream1_syn, 1),
3085     CreateMockWrite(*stream2_rst, 4),
3086   };
3087
3088   scoped_ptr<SpdyFrame>
3089       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
3090   scoped_ptr<SpdyFrame>
3091       stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
3092                                     0,
3093                                     2,
3094                                     9,
3095                                     "http://www.google.com/foo.dat"));
3096   MockRead reads[] = {
3097     CreateMockRead(*stream1_reply, 2),
3098     CreateMockRead(*stream2_syn, 3),
3099     CreateMockRead(*stream1_body, 4),
3100     MockRead(ASYNC, ERR_IO_PENDING, 5),  // Force a pause
3101   };
3102
3103   OrderedSocketData data(reads, arraysize(reads),
3104                          writes, arraysize(writes));
3105   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
3106                                      BoundNetLog(), GetParam(), NULL);
3107
3108   helper.RunPreTestSetup();
3109   helper.AddData(&data);
3110
3111   HttpNetworkTransaction* trans = helper.trans();
3112
3113   // Start the transaction with basic parameters.
3114   TestCompletionCallback callback;
3115   int rv = trans->Start(
3116       &CreateGetRequest(), callback.callback(), BoundNetLog());
3117   EXPECT_EQ(ERR_IO_PENDING, rv);
3118   rv = callback.WaitForResult();
3119   EXPECT_EQ(OK, rv);
3120
3121   // Verify that we consumed all test data.
3122   EXPECT_TRUE(data.at_read_eof()) << "Read count: "
3123                                    << data.read_count()
3124                                    << " Read index: "
3125                                    << data.read_index();
3126   EXPECT_TRUE(data.at_write_eof()) << "Write count: "
3127                                     << data.write_count()
3128                                     << " Write index: "
3129                                     << data.write_index();
3130
3131   // Verify the SYN_REPLY.
3132   HttpResponseInfo response = *trans->GetResponseInfo();
3133   EXPECT_TRUE(response.headers.get() != NULL);
3134   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
3135 }
3136
3137 TEST_P(SpdyNetworkTransactionTest, ServerPushNoURL) {
3138   scoped_ptr<SpdyFrame> stream1_syn(
3139       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
3140   scoped_ptr<SpdyFrame> stream1_body(
3141       spdy_util_.ConstructSpdyBodyFrame(1, true));
3142   scoped_ptr<SpdyFrame> stream2_rst(
3143       spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_PROTOCOL_ERROR));
3144   MockWrite writes[] = {
3145     CreateMockWrite(*stream1_syn, 1),
3146     CreateMockWrite(*stream2_rst, 4),
3147   };
3148
3149   scoped_ptr<SpdyFrame>
3150       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
3151   scoped_ptr<SpdyHeaderBlock> incomplete_headers(new SpdyHeaderBlock());
3152   (*incomplete_headers)["hello"] = "bye";
3153   (*incomplete_headers)[spdy_util_.GetStatusKey()] = "200 OK";
3154   (*incomplete_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
3155   scoped_ptr<SpdyFrame> stream2_syn(spdy_util_.ConstructInitialSpdyPushFrame(
3156       incomplete_headers.Pass(), 2, 1));
3157   MockRead reads[] = {
3158     CreateMockRead(*stream1_reply, 2),
3159     CreateMockRead(*stream2_syn, 3),
3160     CreateMockRead(*stream1_body, 4),
3161     MockRead(ASYNC, ERR_IO_PENDING, 5)  // Force a pause
3162   };
3163
3164   OrderedSocketData data(reads, arraysize(reads),
3165                          writes, arraysize(writes));
3166   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
3167                                      BoundNetLog(), GetParam(), NULL);
3168
3169   helper.RunPreTestSetup();
3170   helper.AddData(&data);
3171
3172   HttpNetworkTransaction* trans = helper.trans();
3173
3174   // Start the transaction with basic parameters.
3175   TestCompletionCallback callback;
3176   int rv = trans->Start(
3177       &CreateGetRequest(), callback.callback(), BoundNetLog());
3178   EXPECT_EQ(ERR_IO_PENDING, rv);
3179   rv = callback.WaitForResult();
3180   EXPECT_EQ(OK, rv);
3181   // Verify that we consumed all test data.
3182   EXPECT_TRUE(data.at_read_eof()) << "Read count: "
3183                                    << data.read_count()
3184                                    << " Read index: "
3185                                    << data.read_index();
3186   EXPECT_TRUE(data.at_write_eof()) << "Write count: "
3187                                     << data.write_count()
3188                                     << " Write index: "
3189                                     << data.write_index();
3190
3191   // Verify the SYN_REPLY.
3192   HttpResponseInfo response = *trans->GetResponseInfo();
3193   EXPECT_TRUE(response.headers.get() != NULL);
3194   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
3195 }
3196
3197 // Verify that various SynReply headers parse correctly through the
3198 // HTTP layer.
3199 TEST_P(SpdyNetworkTransactionTest, SynReplyHeaders) {
3200   struct SynReplyHeadersTests {
3201     int num_headers;
3202     const char* extra_headers[5];
3203     SpdyHeaderBlock expected_headers;
3204   } test_cases[] = {
3205     // This uses a multi-valued cookie header.
3206     { 2,
3207       { "cookie", "val1",
3208         "cookie", "val2",  // will get appended separated by NULL
3209         NULL
3210       },
3211     },
3212     // This is the minimalist set of headers.
3213     { 0,
3214       { NULL },
3215     },
3216     // Headers with a comma separated list.
3217     { 1,
3218       { "cookie", "val1,val2",
3219         NULL
3220       },
3221     }
3222   };
3223
3224   test_cases[0].expected_headers["cookie"] = "val1";
3225   test_cases[0].expected_headers["cookie"] += '\0';
3226   test_cases[0].expected_headers["cookie"] += "val2";
3227   test_cases[0].expected_headers["hello"] = "bye";
3228   test_cases[0].expected_headers["status"] = "200";
3229
3230   test_cases[1].expected_headers["hello"] = "bye";
3231   test_cases[1].expected_headers["status"] = "200";
3232
3233   test_cases[2].expected_headers["cookie"] = "val1,val2";
3234   test_cases[2].expected_headers["hello"] = "bye";
3235   test_cases[2].expected_headers["status"] = "200";
3236
3237   if (spdy_util_.spdy_version() < SPDY4) {
3238     // SPDY4/HTTP2 eliminates use of the :version header.
3239     test_cases[0].expected_headers["version"] = "HTTP/1.1";
3240     test_cases[1].expected_headers["version"] = "HTTP/1.1";
3241     test_cases[2].expected_headers["version"] = "HTTP/1.1";
3242   }
3243
3244   for (size_t i = 0; i < arraysize(test_cases); ++i) {
3245     scoped_ptr<SpdyFrame> req(
3246         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
3247     MockWrite writes[] = { CreateMockWrite(*req) };
3248
3249     scoped_ptr<SpdyFrame> resp(
3250         spdy_util_.ConstructSpdyGetSynReply(test_cases[i].extra_headers,
3251                                  test_cases[i].num_headers,
3252                                  1));
3253     scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
3254     MockRead reads[] = {
3255       CreateMockRead(*resp),
3256       CreateMockRead(*body),
3257       MockRead(ASYNC, 0, 0)  // EOF
3258     };
3259
3260     DelayedSocketData data(1, reads, arraysize(reads),
3261                            writes, arraysize(writes));
3262     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
3263                                        BoundNetLog(), GetParam(), NULL);
3264     helper.RunToCompletion(&data);
3265     TransactionHelperResult out = helper.output();
3266
3267     EXPECT_EQ(OK, out.rv);
3268     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
3269     EXPECT_EQ("hello!", out.response_data);
3270
3271     scoped_refptr<HttpResponseHeaders> headers = out.response_info.headers;
3272     EXPECT_TRUE(headers.get() != NULL);
3273     void* iter = NULL;
3274     std::string name, value;
3275     SpdyHeaderBlock header_block;
3276     while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
3277       if (header_block[name].empty()) {
3278         header_block[name] = value;
3279       } else {
3280         header_block[name] += '\0';
3281         header_block[name] += value;
3282       }
3283     }
3284     EXPECT_EQ(test_cases[i].expected_headers, header_block);
3285   }
3286 }
3287
3288 // Verify that various SynReply headers parse vary fields correctly
3289 // through the HTTP layer, and the response matches the request.
3290 TEST_P(SpdyNetworkTransactionTest, SynReplyHeadersVary) {
3291   // Modify the following data to change/add test cases:
3292   struct SynReplyTests {
3293     bool vary_matches;
3294     int num_headers[2];
3295     const char* extra_headers[2][16];
3296   } test_cases[] = {
3297     // Test the case of a multi-valued cookie.  When the value is delimited
3298     // with NUL characters, it needs to be unfolded into multiple headers.
3299     {
3300       true,
3301       { 1, 4 },
3302       { { "cookie",   "val1,val2",
3303           NULL
3304         },
3305         { "vary",     "cookie",
3306           spdy_util_.GetStatusKey(), "200",
3307           spdy_util_.GetPathKey(),      "/index.php",
3308           spdy_util_.GetVersionKey(), "HTTP/1.1",
3309           NULL
3310         }
3311       }
3312     }, {    // Multiple vary fields.
3313       true,
3314       { 2, 5 },
3315       { { "friend",   "barney",
3316           "enemy",    "snaggletooth",
3317           NULL
3318         },
3319         { "vary",     "friend",
3320           "vary",     "enemy",
3321           spdy_util_.GetStatusKey(), "200",
3322           spdy_util_.GetPathKey(),      "/index.php",
3323           spdy_util_.GetVersionKey(), "HTTP/1.1",
3324           NULL
3325         }
3326       }
3327     }, {    // Test a '*' vary field.
3328       false,
3329       { 1, 4 },
3330       { { "cookie",   "val1,val2",
3331           NULL
3332         },
3333         { "vary",     "*",
3334           spdy_util_.GetStatusKey(), "200",
3335           spdy_util_.GetPathKey(),      "/index.php",
3336           spdy_util_.GetVersionKey(), "HTTP/1.1",
3337           NULL
3338         }
3339       }
3340     }, {    // Multiple comma-separated vary fields.
3341       true,
3342       { 2, 4 },
3343       { { "friend",   "barney",
3344           "enemy",    "snaggletooth",
3345           NULL
3346         },
3347         { "vary",     "friend,enemy",
3348           spdy_util_.GetStatusKey(), "200",
3349           spdy_util_.GetPathKey(),      "/index.php",
3350           spdy_util_.GetVersionKey(), "HTTP/1.1",
3351           NULL
3352         }
3353       }
3354     }
3355   };
3356
3357   for (size_t i = 0; i < arraysize(test_cases); ++i) {
3358     // Construct the request.
3359     scoped_ptr<SpdyFrame> frame_req(
3360         spdy_util_.ConstructSpdyGet(test_cases[i].extra_headers[0],
3361                                     test_cases[i].num_headers[0],
3362                                     false, 1, LOWEST, true));
3363
3364     MockWrite writes[] = {
3365       CreateMockWrite(*frame_req),
3366     };
3367
3368     // Construct the reply.
3369     SpdyHeaderBlock reply_headers;
3370     AppendToHeaderBlock(test_cases[i].extra_headers[1],
3371                         test_cases[i].num_headers[1],
3372                         &reply_headers);
3373     scoped_ptr<SpdyFrame> frame_reply(
3374         spdy_util_.ConstructSpdyReply(1, reply_headers));
3375
3376     scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
3377     MockRead reads[] = {
3378       CreateMockRead(*frame_reply),
3379       CreateMockRead(*body),
3380       MockRead(ASYNC, 0, 0)  // EOF
3381     };
3382
3383     // Attach the headers to the request.
3384     int header_count = test_cases[i].num_headers[0];
3385
3386     HttpRequestInfo request = CreateGetRequest();
3387     for (int ct = 0; ct < header_count; ct++) {
3388       const char* header_key = test_cases[i].extra_headers[0][ct * 2];
3389       const char* header_value = test_cases[i].extra_headers[0][ct * 2 + 1];
3390       request.extra_headers.SetHeader(header_key, header_value);
3391     }
3392
3393     DelayedSocketData data(1, reads, arraysize(reads),
3394                            writes, arraysize(writes));
3395     NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
3396                                        BoundNetLog(), GetParam(), NULL);
3397     helper.RunToCompletion(&data);
3398     TransactionHelperResult out = helper.output();
3399
3400     EXPECT_EQ(OK, out.rv) << i;
3401     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line) << i;
3402     EXPECT_EQ("hello!", out.response_data) << i;
3403
3404     // Test the response information.
3405     EXPECT_TRUE(out.response_info.response_time >
3406                 out.response_info.request_time) << i;
3407     base::TimeDelta test_delay = out.response_info.response_time -
3408                                  out.response_info.request_time;
3409     base::TimeDelta min_expected_delay;
3410     min_expected_delay.FromMilliseconds(10);
3411     EXPECT_GT(test_delay.InMillisecondsF(),
3412               min_expected_delay.InMillisecondsF()) << i;
3413     EXPECT_EQ(out.response_info.vary_data.is_valid(),
3414               test_cases[i].vary_matches) << i;
3415
3416     // Check the headers.
3417     scoped_refptr<HttpResponseHeaders> headers = out.response_info.headers;
3418     ASSERT_TRUE(headers.get() != NULL) << i;
3419     void* iter = NULL;
3420     std::string name, value, lines;
3421     while (headers->EnumerateHeaderLines(&iter, &name, &value)) {
3422       lines.append(name);
3423       lines.append(": ");
3424       lines.append(value);
3425       lines.append("\n");
3426     }
3427
3428     // Construct the expected header reply string.
3429     std::string expected_reply =
3430         spdy_util_.ConstructSpdyReplyString(reply_headers);
3431     EXPECT_EQ(expected_reply, lines) << i;
3432   }
3433 }
3434
3435 // Verify that we don't crash on invalid SynReply responses.
3436 TEST_P(SpdyNetworkTransactionTest, InvalidSynReply) {
3437   struct InvalidSynReplyTests {
3438     int num_headers;
3439     const char* headers[10];
3440   } test_cases[] = {
3441     // SYN_REPLY missing status header
3442     { 4,
3443       { "cookie", "val1",
3444         "cookie", "val2",
3445         spdy_util_.GetPathKey(), "/index.php",
3446         spdy_util_.GetVersionKey(), "HTTP/1.1",
3447         NULL
3448       },
3449     },
3450     // SYN_REPLY missing version header
3451     { 2,
3452       { "status", "200",
3453         spdy_util_.GetPathKey(), "/index.php",
3454         NULL
3455       },
3456     },
3457     // SYN_REPLY with no headers
3458     { 0, { NULL }, },
3459   };
3460
3461   for (size_t i = 0; i < arraysize(test_cases); ++i) {
3462     scoped_ptr<SpdyFrame> req(
3463         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
3464     scoped_ptr<SpdyFrame> rst(
3465       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
3466     MockWrite writes[] = {
3467       CreateMockWrite(*req),
3468       CreateMockWrite(*rst),
3469     };
3470
3471     // Construct the reply.
3472     SpdyHeaderBlock reply_headers;
3473     AppendToHeaderBlock(
3474         test_cases[i].headers, test_cases[i].num_headers, &reply_headers);
3475     scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyReply(1, reply_headers));
3476     MockRead reads[] = {
3477       CreateMockRead(*resp),
3478       MockRead(ASYNC, 0, 0)  // EOF
3479     };
3480
3481     DelayedSocketData data(1, reads, arraysize(reads),
3482                            writes, arraysize(writes));
3483     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
3484                                        BoundNetLog(), GetParam(), NULL);
3485     helper.RunToCompletion(&data);
3486     TransactionHelperResult out = helper.output();
3487     EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
3488   }
3489 }
3490
3491 // Verify that we don't crash on some corrupt frames.
3492 // TODO(jgraettinger): SPDY4 and up treats a header decompression failure as a
3493 // connection error. I'd like to backport this behavior to SPDY3 as well.
3494 TEST_P(SpdyNetworkTransactionTest, CorruptFrameSessionError) {
3495   if (spdy_util_.spdy_version() >= SPDY4) {
3496     return;
3497   }
3498   // This is the length field that's too short.
3499   scoped_ptr<SpdyFrame> syn_reply_wrong_length(
3500       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
3501   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
3502   size_t right_size =
3503       (spdy_util_.spdy_version() < SPDY4) ?
3504       syn_reply_wrong_length->size() - framer.GetControlFrameHeaderSize() :
3505       syn_reply_wrong_length->size();
3506   size_t wrong_size = right_size - 4;
3507   test::SetFrameLength(syn_reply_wrong_length.get(),
3508                        wrong_size,
3509                        spdy_util_.spdy_version());
3510
3511   struct SynReplyTests {
3512     const SpdyFrame* syn_reply;
3513   } test_cases[] = {
3514     { syn_reply_wrong_length.get(), },
3515   };
3516
3517   for (size_t i = 0; i < arraysize(test_cases); ++i) {
3518     scoped_ptr<SpdyFrame> req(
3519         spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
3520     scoped_ptr<SpdyFrame> rst(
3521         spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
3522     MockWrite writes[] = {
3523       CreateMockWrite(*req),
3524       CreateMockWrite(*rst),
3525     };
3526
3527     scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
3528     MockRead reads[] = {
3529       MockRead(ASYNC, test_cases[i].syn_reply->data(), wrong_size),
3530       CreateMockRead(*body),
3531       MockRead(ASYNC, 0, 0)  // EOF
3532     };
3533
3534     DelayedSocketData data(1, reads, arraysize(reads),
3535                            writes, arraysize(writes));
3536     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
3537                                        BoundNetLog(), GetParam(), NULL);
3538     helper.RunToCompletion(&data);
3539     TransactionHelperResult out = helper.output();
3540     EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
3541   }
3542 }
3543
3544 // SPDY4 treats a header decompression failure as a connection-level error.
3545 TEST_P(SpdyNetworkTransactionTest, CorruptFrameSessionErrorSpdy4) {
3546   if (spdy_util_.spdy_version() < SPDY4) {
3547     return;
3548   }
3549   // This is the length field that's too short.
3550   scoped_ptr<SpdyFrame> syn_reply_wrong_length(
3551       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
3552   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
3553   size_t right_size =
3554       syn_reply_wrong_length->size() - framer.GetControlFrameHeaderSize();
3555   size_t wrong_size = right_size - 4;
3556   test::SetFrameLength(syn_reply_wrong_length.get(),
3557                        wrong_size,
3558                        spdy_util_.spdy_version());
3559
3560   scoped_ptr<SpdyFrame> req(
3561       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
3562   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
3563       0, GOAWAY_COMPRESSION_ERROR, "Framer error: 5 (DECOMPRESS_FAILURE)."));
3564   MockWrite writes[] = {CreateMockWrite(*req), CreateMockWrite(*goaway)};
3565
3566   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
3567   MockRead reads[] = {
3568     MockRead(ASYNC, syn_reply_wrong_length->data(),
3569              syn_reply_wrong_length->size() - 4),
3570   };
3571
3572   DelayedSocketData data(1, reads, arraysize(reads),
3573                          writes, arraysize(writes));
3574   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
3575                                      BoundNetLog(), GetParam(), NULL);
3576   helper.RunToCompletion(&data);
3577   TransactionHelperResult out = helper.output();
3578   EXPECT_EQ(ERR_SPDY_COMPRESSION_ERROR, out.rv);
3579 }
3580
3581 TEST_P(SpdyNetworkTransactionTest, GoAwayOnDecompressionFailure) {
3582   if (GetParam().protocol < kProtoSPDY4MinimumVersion) {
3583     // Decompression failures are a stream error in SPDY3 and above.
3584     return;
3585   }
3586   scoped_ptr<SpdyFrame> req(
3587       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
3588   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
3589       0, GOAWAY_COMPRESSION_ERROR, "Framer error: 5 (DECOMPRESS_FAILURE)."));
3590   MockWrite writes[] = {CreateMockWrite(*req), CreateMockWrite(*goaway)};
3591
3592   // Read HEADERS with corrupted payload.
3593   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
3594   memset(resp->data() + 12, 0xff, resp->size() - 12);
3595   MockRead reads[] = {CreateMockRead(*resp)};
3596
3597   DelayedSocketData data(1, reads, arraysize(reads), writes, arraysize(writes));
3598   NormalSpdyTransactionHelper helper(
3599       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
3600   helper.RunToCompletion(&data);
3601   TransactionHelperResult out = helper.output();
3602   EXPECT_EQ(ERR_SPDY_COMPRESSION_ERROR, out.rv);
3603 }
3604
3605 TEST_P(SpdyNetworkTransactionTest, GoAwayOnFrameSizeError) {
3606   scoped_ptr<SpdyFrame> req(
3607       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
3608   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
3609       0, GOAWAY_PROTOCOL_ERROR, "Framer error: 1 (INVALID_CONTROL_FRAME)."));
3610   MockWrite writes[] = {CreateMockWrite(*req), CreateMockWrite(*goaway)};
3611
3612   // Read WINDOW_UPDATE with incorrectly-sized payload.
3613   // TODO(jgraettinger): SpdyFramer signals this as an INVALID_CONTROL_FRAME,
3614   // which is mapped to a protocol error, and not a frame size error.
3615   scoped_ptr<SpdyFrame> bad_window_update(
3616       spdy_util_.ConstructSpdyWindowUpdate(1, 1));
3617   test::SetFrameLength(bad_window_update.get(),
3618                        bad_window_update->size() - 1,
3619                        spdy_util_.spdy_version());
3620   MockRead reads[] = {CreateMockRead(*bad_window_update)};
3621
3622   DelayedSocketData data(1, reads, arraysize(reads), writes, arraysize(writes));
3623   NormalSpdyTransactionHelper helper(
3624       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
3625   helper.RunToCompletion(&data);
3626   TransactionHelperResult out = helper.output();
3627   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
3628 }
3629
3630 // Test that we shutdown correctly on write errors.
3631 TEST_P(SpdyNetworkTransactionTest, WriteError) {
3632   scoped_ptr<SpdyFrame> req(
3633       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
3634   MockWrite writes[] = {
3635       // We'll write 10 bytes successfully
3636       MockWrite(ASYNC, req->data(), 10, 0),
3637       // Followed by ERROR!
3638       MockWrite(ASYNC, ERR_FAILED, 1),
3639       // Session drains and attempts to write a GOAWAY: Another ERROR!
3640       MockWrite(ASYNC, ERR_FAILED, 2),
3641   };
3642
3643   MockRead reads[] = {
3644       MockRead(ASYNC, 0, 3)  // EOF
3645   };
3646
3647   DeterministicSocketData data(reads, arraysize(reads),
3648                                writes, arraysize(writes));
3649
3650   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
3651                                      BoundNetLog(), GetParam(), NULL);
3652   helper.SetDeterministic();
3653   helper.RunPreTestSetup();
3654   helper.AddDeterministicData(&data);
3655   EXPECT_TRUE(helper.StartDefaultTest());
3656   data.RunFor(2);
3657   helper.FinishDefaultTest();
3658   EXPECT_TRUE(data.at_write_eof());
3659   EXPECT_TRUE(!data.at_read_eof());
3660   TransactionHelperResult out = helper.output();
3661   EXPECT_EQ(ERR_FAILED, out.rv);
3662 }
3663
3664 // Test that partial writes work.
3665 TEST_P(SpdyNetworkTransactionTest, PartialWrite) {
3666   // Chop the SYN_STREAM frame into 5 chunks.
3667   scoped_ptr<SpdyFrame> req(
3668       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
3669   const int kChunks = 5;
3670   scoped_ptr<MockWrite[]> writes(ChopWriteFrame(*req.get(), kChunks));
3671
3672   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
3673   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
3674   MockRead reads[] = {
3675     CreateMockRead(*resp),
3676     CreateMockRead(*body),
3677     MockRead(ASYNC, 0, 0)  // EOF
3678   };
3679
3680   DelayedSocketData data(kChunks, reads, arraysize(reads),
3681                          writes.get(), kChunks);
3682   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
3683                                      BoundNetLog(), GetParam(), NULL);
3684   helper.RunToCompletion(&data);
3685   TransactionHelperResult out = helper.output();
3686   EXPECT_EQ(OK, out.rv);
3687   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
3688   EXPECT_EQ("hello!", out.response_data);
3689 }
3690
3691 // In this test, we enable compression, but get a uncompressed SynReply from
3692 // the server.  Verify that teardown is all clean.
3693 TEST_P(SpdyNetworkTransactionTest, DecompressFailureOnSynReply) {
3694   if (spdy_util_.spdy_version() >= SPDY4) {
3695     // HPACK doesn't use deflate compression.
3696     return;
3697   }
3698   scoped_ptr<SpdyFrame> compressed(
3699       spdy_util_.ConstructSpdyGet(NULL, 0, true, 1, LOWEST, true));
3700   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
3701       0, GOAWAY_COMPRESSION_ERROR, "Framer error: 5 (DECOMPRESS_FAILURE)."));
3702   MockWrite writes[] = {CreateMockWrite(*compressed), CreateMockWrite(*goaway)};
3703
3704   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
3705   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
3706   MockRead reads[] = {
3707     CreateMockRead(*resp),
3708   };
3709
3710   DelayedSocketData data(1, reads, arraysize(reads),
3711                          writes, arraysize(writes));
3712   SpdySessionDependencies* session_deps =
3713       CreateSpdySessionDependencies(GetParam());
3714   session_deps->enable_compression = true;
3715   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
3716                                      BoundNetLog(), GetParam(), session_deps);
3717   helper.RunToCompletion(&data);
3718   TransactionHelperResult out = helper.output();
3719   EXPECT_EQ(ERR_SPDY_COMPRESSION_ERROR, out.rv);
3720   data.Reset();
3721 }
3722
3723 // Test that the NetLog contains good data for a simple GET request.
3724 TEST_P(SpdyNetworkTransactionTest, NetLog) {
3725   static const char* const kExtraHeaders[] = {
3726     "user-agent",   "Chrome",
3727   };
3728   scoped_ptr<SpdyFrame> req(
3729       spdy_util_.ConstructSpdyGet(kExtraHeaders, 1, false, 1, LOWEST, true));
3730   MockWrite writes[] = { CreateMockWrite(*req) };
3731
3732   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
3733   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
3734   MockRead reads[] = {
3735     CreateMockRead(*resp),
3736     CreateMockRead(*body),
3737     MockRead(ASYNC, 0, 0)  // EOF
3738   };
3739
3740   CapturingBoundNetLog log;
3741
3742   DelayedSocketData data(1, reads, arraysize(reads),
3743                          writes, arraysize(writes));
3744   NormalSpdyTransactionHelper helper(CreateGetRequestWithUserAgent(),
3745                                      DEFAULT_PRIORITY,
3746                                      log.bound(), GetParam(), NULL);
3747   helper.RunToCompletion(&data);
3748   TransactionHelperResult out = helper.output();
3749   EXPECT_EQ(OK, out.rv);
3750   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
3751   EXPECT_EQ("hello!", out.response_data);
3752
3753   // Check that the NetLog was filled reasonably.
3754   // This test is intentionally non-specific about the exact ordering of the
3755   // log; instead we just check to make sure that certain events exist, and that
3756   // they are in the right order.
3757   net::CapturingNetLog::CapturedEntryList entries;
3758   log.GetEntries(&entries);
3759
3760   EXPECT_LT(0u, entries.size());
3761   int pos = 0;
3762   pos = net::ExpectLogContainsSomewhere(entries, 0,
3763       net::NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST,
3764       net::NetLog::PHASE_BEGIN);
3765   pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
3766       net::NetLog::TYPE_HTTP_TRANSACTION_SEND_REQUEST,
3767       net::NetLog::PHASE_END);
3768   pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
3769       net::NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS,
3770       net::NetLog::PHASE_BEGIN);
3771   pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
3772       net::NetLog::TYPE_HTTP_TRANSACTION_READ_HEADERS,
3773       net::NetLog::PHASE_END);
3774   pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
3775       net::NetLog::TYPE_HTTP_TRANSACTION_READ_BODY,
3776       net::NetLog::PHASE_BEGIN);
3777   pos = net::ExpectLogContainsSomewhere(entries, pos + 1,
3778       net::NetLog::TYPE_HTTP_TRANSACTION_READ_BODY,
3779       net::NetLog::PHASE_END);
3780
3781   // Check that we logged all the headers correctly
3782   pos = net::ExpectLogContainsSomewhere(
3783       entries, 0,
3784       net::NetLog::TYPE_SPDY_SESSION_SYN_STREAM,
3785       net::NetLog::PHASE_NONE);
3786
3787   base::ListValue* header_list;
3788   ASSERT_TRUE(entries[pos].params.get());
3789   ASSERT_TRUE(entries[pos].params->GetList("headers", &header_list));
3790
3791   std::vector<std::string> expected;
3792   expected.push_back(std::string(spdy_util_.GetHostKey()) + ": www.google.com");
3793   expected.push_back(std::string(spdy_util_.GetPathKey()) + ": /");
3794   expected.push_back(std::string(spdy_util_.GetSchemeKey()) + ": http");
3795   expected.push_back(std::string(spdy_util_.GetMethodKey()) + ": GET");
3796   expected.push_back("user-agent: Chrome");
3797   if (spdy_util_.spdy_version() < SPDY4) {
3798     // SPDY4/HTTP2 eliminates use of the :version header.
3799     expected.push_back(std::string(spdy_util_.GetVersionKey()) + ": HTTP/1.1");
3800   }
3801   EXPECT_EQ(expected.size(), header_list->GetSize());
3802   for (std::vector<std::string>::const_iterator it = expected.begin();
3803        it != expected.end();
3804        ++it) {
3805     base::StringValue header(*it);
3806     EXPECT_NE(header_list->end(), header_list->Find(header)) <<
3807         "Header not found: " << *it;
3808   }
3809 }
3810
3811 // Since we buffer the IO from the stream to the renderer, this test verifies
3812 // that when we read out the maximum amount of data (e.g. we received 50 bytes
3813 // on the network, but issued a Read for only 5 of those bytes) that the data
3814 // flow still works correctly.
3815 TEST_P(SpdyNetworkTransactionTest, BufferFull) {
3816   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
3817
3818   scoped_ptr<SpdyFrame> req(
3819       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
3820   MockWrite writes[] = { CreateMockWrite(*req) };
3821
3822   // 2 data frames in a single read.
3823   scoped_ptr<SpdyFrame> data_frame_1(
3824       framer.CreateDataFrame(1, "goodby", 6, DATA_FLAG_NONE));
3825   scoped_ptr<SpdyFrame> data_frame_2(
3826       framer.CreateDataFrame(1, "e worl", 6, DATA_FLAG_NONE));
3827   const SpdyFrame* data_frames[2] = {
3828     data_frame_1.get(),
3829     data_frame_2.get(),
3830   };
3831   char combined_data_frames[100];
3832   int combined_data_frames_len =
3833       CombineFrames(data_frames, arraysize(data_frames),
3834                     combined_data_frames, arraysize(combined_data_frames));
3835   scoped_ptr<SpdyFrame> last_frame(
3836       framer.CreateDataFrame(1, "d", 1, DATA_FLAG_FIN));
3837
3838   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
3839   MockRead reads[] = {
3840     CreateMockRead(*resp),
3841     MockRead(ASYNC, ERR_IO_PENDING),  // Force a pause
3842     MockRead(ASYNC, combined_data_frames, combined_data_frames_len),
3843     MockRead(ASYNC, ERR_IO_PENDING),  // Force a pause
3844     CreateMockRead(*last_frame),
3845     MockRead(ASYNC, 0, 0)  // EOF
3846   };
3847
3848   DelayedSocketData data(1, reads, arraysize(reads),
3849                          writes, arraysize(writes));
3850
3851   TestCompletionCallback callback;
3852
3853   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
3854                                      BoundNetLog(), GetParam(), NULL);
3855   helper.RunPreTestSetup();
3856   helper.AddData(&data);
3857   HttpNetworkTransaction* trans = helper.trans();
3858   int rv = trans->Start(
3859       &CreateGetRequest(), callback.callback(), BoundNetLog());
3860   EXPECT_EQ(ERR_IO_PENDING, rv);
3861
3862   TransactionHelperResult out = helper.output();
3863   out.rv = callback.WaitForResult();
3864   EXPECT_EQ(out.rv, OK);
3865
3866   const HttpResponseInfo* response = trans->GetResponseInfo();
3867   EXPECT_TRUE(response->headers.get() != NULL);
3868   EXPECT_TRUE(response->was_fetched_via_spdy);
3869   out.status_line = response->headers->GetStatusLine();
3870   out.response_info = *response;  // Make a copy so we can verify.
3871
3872   // Read Data
3873   TestCompletionCallback read_callback;
3874
3875   std::string content;
3876   do {
3877     // Read small chunks at a time.
3878     const int kSmallReadSize = 3;
3879     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
3880     rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
3881     if (rv == net::ERR_IO_PENDING) {
3882       data.CompleteRead();
3883       rv = read_callback.WaitForResult();
3884     }
3885     if (rv > 0) {
3886       content.append(buf->data(), rv);
3887     } else if (rv < 0) {
3888       NOTREACHED();
3889     }
3890   } while (rv > 0);
3891
3892   out.response_data.swap(content);
3893
3894   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
3895   // MockClientSocketFactory) are still alive.
3896   base::RunLoop().RunUntilIdle();
3897
3898   // Verify that we consumed all test data.
3899   helper.VerifyDataConsumed();
3900
3901   EXPECT_EQ(OK, out.rv);
3902   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
3903   EXPECT_EQ("goodbye world", out.response_data);
3904 }
3905
3906 // Verify that basic buffering works; when multiple data frames arrive
3907 // at the same time, ensure that we don't notify a read completion for
3908 // each data frame individually.
3909 TEST_P(SpdyNetworkTransactionTest, Buffering) {
3910   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
3911
3912   scoped_ptr<SpdyFrame> req(
3913       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
3914   MockWrite writes[] = { CreateMockWrite(*req) };
3915
3916   // 4 data frames in a single read.
3917   scoped_ptr<SpdyFrame> data_frame(
3918       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
3919   scoped_ptr<SpdyFrame> data_frame_fin(
3920       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_FIN));
3921   const SpdyFrame* data_frames[4] = {
3922     data_frame.get(),
3923     data_frame.get(),
3924     data_frame.get(),
3925     data_frame_fin.get()
3926   };
3927   char combined_data_frames[100];
3928   int combined_data_frames_len =
3929       CombineFrames(data_frames, arraysize(data_frames),
3930                     combined_data_frames, arraysize(combined_data_frames));
3931
3932   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
3933   MockRead reads[] = {
3934     CreateMockRead(*resp),
3935     MockRead(ASYNC, ERR_IO_PENDING),  // Force a pause
3936     MockRead(ASYNC, combined_data_frames, combined_data_frames_len),
3937     MockRead(ASYNC, 0, 0)  // EOF
3938   };
3939
3940   DelayedSocketData data(1, reads, arraysize(reads),
3941                          writes, arraysize(writes));
3942
3943   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
3944                                      BoundNetLog(), GetParam(), NULL);
3945   helper.RunPreTestSetup();
3946   helper.AddData(&data);
3947   HttpNetworkTransaction* trans = helper.trans();
3948
3949   TestCompletionCallback callback;
3950   int rv = trans->Start(
3951       &CreateGetRequest(), callback.callback(), BoundNetLog());
3952   EXPECT_EQ(ERR_IO_PENDING, rv);
3953
3954   TransactionHelperResult out = helper.output();
3955   out.rv = callback.WaitForResult();
3956   EXPECT_EQ(out.rv, OK);
3957
3958   const HttpResponseInfo* response = trans->GetResponseInfo();
3959   EXPECT_TRUE(response->headers.get() != NULL);
3960   EXPECT_TRUE(response->was_fetched_via_spdy);
3961   out.status_line = response->headers->GetStatusLine();
3962   out.response_info = *response;  // Make a copy so we can verify.
3963
3964   // Read Data
3965   TestCompletionCallback read_callback;
3966
3967   std::string content;
3968   int reads_completed = 0;
3969   do {
3970     // Read small chunks at a time.
3971     const int kSmallReadSize = 14;
3972     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
3973     rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
3974     if (rv == net::ERR_IO_PENDING) {
3975       data.CompleteRead();
3976       rv = read_callback.WaitForResult();
3977     }
3978     if (rv > 0) {
3979       EXPECT_EQ(kSmallReadSize, rv);
3980       content.append(buf->data(), rv);
3981     } else if (rv < 0) {
3982       FAIL() << "Unexpected read error: " << rv;
3983     }
3984     reads_completed++;
3985   } while (rv > 0);
3986
3987   EXPECT_EQ(3, reads_completed);  // Reads are: 14 bytes, 14 bytes, 0 bytes.
3988
3989   out.response_data.swap(content);
3990
3991   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
3992   // MockClientSocketFactory) are still alive.
3993   base::RunLoop().RunUntilIdle();
3994
3995   // Verify that we consumed all test data.
3996   helper.VerifyDataConsumed();
3997
3998   EXPECT_EQ(OK, out.rv);
3999   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
4000   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
4001 }
4002
4003 // Verify the case where we buffer data but read it after it has been buffered.
4004 TEST_P(SpdyNetworkTransactionTest, BufferedAll) {
4005   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
4006
4007   scoped_ptr<SpdyFrame> req(
4008       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
4009   MockWrite writes[] = { CreateMockWrite(*req) };
4010
4011   // 5 data frames in a single read.
4012   scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
4013   scoped_ptr<SpdyFrame> data_frame(
4014       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
4015   scoped_ptr<SpdyFrame> data_frame_fin(
4016       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_FIN));
4017   const SpdyFrame* frames[5] = {reply.get(), data_frame.get(), data_frame.get(),
4018                                 data_frame.get(), data_frame_fin.get()};
4019   char combined_frames[200];
4020   int combined_frames_len =
4021       CombineFrames(frames, arraysize(frames),
4022                     combined_frames, arraysize(combined_frames));
4023
4024   MockRead reads[] = {
4025     MockRead(ASYNC, combined_frames, combined_frames_len),
4026     MockRead(ASYNC, 0, 0)  // EOF
4027   };
4028
4029   DelayedSocketData data(1, reads, arraysize(reads),
4030                          writes, arraysize(writes));
4031
4032   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
4033                                      BoundNetLog(), GetParam(), NULL);
4034   helper.RunPreTestSetup();
4035   helper.AddData(&data);
4036   HttpNetworkTransaction* trans = helper.trans();
4037
4038   TestCompletionCallback callback;
4039   int rv = trans->Start(
4040       &CreateGetRequest(), callback.callback(), BoundNetLog());
4041   EXPECT_EQ(ERR_IO_PENDING, rv);
4042
4043   TransactionHelperResult out = helper.output();
4044   out.rv = callback.WaitForResult();
4045   EXPECT_EQ(out.rv, OK);
4046
4047   const HttpResponseInfo* response = trans->GetResponseInfo();
4048   EXPECT_TRUE(response->headers.get() != NULL);
4049   EXPECT_TRUE(response->was_fetched_via_spdy);
4050   out.status_line = response->headers->GetStatusLine();
4051   out.response_info = *response;  // Make a copy so we can verify.
4052
4053   // Read Data
4054   TestCompletionCallback read_callback;
4055
4056   std::string content;
4057   int reads_completed = 0;
4058   do {
4059     // Read small chunks at a time.
4060     const int kSmallReadSize = 14;
4061     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
4062     rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
4063     if (rv > 0) {
4064       EXPECT_EQ(kSmallReadSize, rv);
4065       content.append(buf->data(), rv);
4066     } else if (rv < 0) {
4067       FAIL() << "Unexpected read error: " << rv;
4068     }
4069     reads_completed++;
4070   } while (rv > 0);
4071
4072   EXPECT_EQ(3, reads_completed);
4073
4074   out.response_data.swap(content);
4075
4076   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
4077   // MockClientSocketFactory) are still alive.
4078   base::RunLoop().RunUntilIdle();
4079
4080   // Verify that we consumed all test data.
4081   helper.VerifyDataConsumed();
4082
4083   EXPECT_EQ(OK, out.rv);
4084   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
4085   EXPECT_EQ("messagemessagemessagemessage", out.response_data);
4086 }
4087
4088 // Verify the case where we buffer data and close the connection.
4089 TEST_P(SpdyNetworkTransactionTest, BufferedClosed) {
4090   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
4091
4092   scoped_ptr<SpdyFrame> req(
4093       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
4094   MockWrite writes[] = { CreateMockWrite(*req) };
4095
4096   // All data frames in a single read.
4097   // NOTE: We don't FIN the stream.
4098   scoped_ptr<SpdyFrame> data_frame(
4099       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
4100   const SpdyFrame* data_frames[4] = {
4101     data_frame.get(),
4102     data_frame.get(),
4103     data_frame.get(),
4104     data_frame.get()
4105   };
4106   char combined_data_frames[100];
4107   int combined_data_frames_len =
4108       CombineFrames(data_frames, arraysize(data_frames),
4109                     combined_data_frames, arraysize(combined_data_frames));
4110   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
4111   MockRead reads[] = {
4112     CreateMockRead(*resp),
4113     MockRead(ASYNC, ERR_IO_PENDING),  // Force a wait
4114     MockRead(ASYNC, combined_data_frames, combined_data_frames_len),
4115     MockRead(ASYNC, 0, 0)  // EOF
4116   };
4117
4118   DelayedSocketData data(1, reads, arraysize(reads),
4119                          writes, arraysize(writes));
4120
4121   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
4122                                      BoundNetLog(), GetParam(), NULL);
4123   helper.RunPreTestSetup();
4124   helper.AddData(&data);
4125   HttpNetworkTransaction* trans = helper.trans();
4126
4127   TestCompletionCallback callback;
4128
4129   int rv = trans->Start(
4130       &CreateGetRequest(), callback.callback(), BoundNetLog());
4131   EXPECT_EQ(ERR_IO_PENDING, rv);
4132
4133   TransactionHelperResult out = helper.output();
4134   out.rv = callback.WaitForResult();
4135   EXPECT_EQ(out.rv, OK);
4136
4137   const HttpResponseInfo* response = trans->GetResponseInfo();
4138   EXPECT_TRUE(response->headers.get() != NULL);
4139   EXPECT_TRUE(response->was_fetched_via_spdy);
4140   out.status_line = response->headers->GetStatusLine();
4141   out.response_info = *response;  // Make a copy so we can verify.
4142
4143   // Read Data
4144   TestCompletionCallback read_callback;
4145
4146   std::string content;
4147   int reads_completed = 0;
4148   do {
4149     // Read small chunks at a time.
4150     const int kSmallReadSize = 14;
4151     scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kSmallReadSize));
4152     rv = trans->Read(buf.get(), kSmallReadSize, read_callback.callback());
4153     if (rv == net::ERR_IO_PENDING) {
4154       data.CompleteRead();
4155       rv = read_callback.WaitForResult();
4156     }
4157     if (rv > 0) {
4158       content.append(buf->data(), rv);
4159     } else if (rv < 0) {
4160       // This test intentionally closes the connection, and will get an error.
4161       EXPECT_EQ(ERR_CONNECTION_CLOSED, rv);
4162       break;
4163     }
4164     reads_completed++;
4165   } while (rv > 0);
4166
4167   EXPECT_EQ(0, reads_completed);
4168
4169   out.response_data.swap(content);
4170
4171   // Flush the MessageLoop while the SpdySessionDependencies (in particular, the
4172   // MockClientSocketFactory) are still alive.
4173   base::RunLoop().RunUntilIdle();
4174
4175   // Verify that we consumed all test data.
4176   helper.VerifyDataConsumed();
4177 }
4178
4179 // Verify the case where we buffer data and cancel the transaction.
4180 TEST_P(SpdyNetworkTransactionTest, BufferedCancelled) {
4181   BufferedSpdyFramer framer(spdy_util_.spdy_version(), false);
4182
4183   scoped_ptr<SpdyFrame> req(
4184       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
4185   scoped_ptr<SpdyFrame> rst(
4186       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_CANCEL));
4187   MockWrite writes[] = {CreateMockWrite(*req), CreateMockWrite(*rst)};
4188
4189   // NOTE: We don't FIN the stream.
4190   scoped_ptr<SpdyFrame> data_frame(
4191       framer.CreateDataFrame(1, "message", 7, DATA_FLAG_NONE));
4192
4193   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
4194   MockRead reads[] = {
4195     CreateMockRead(*resp),
4196     MockRead(ASYNC, ERR_IO_PENDING),  // Force a wait
4197     CreateMockRead(*data_frame),
4198     MockRead(ASYNC, 0, 0)  // EOF
4199   };
4200
4201   DelayedSocketData data(1, reads, arraysize(reads),
4202                          writes, arraysize(writes));
4203
4204   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
4205                                      BoundNetLog(), GetParam(), NULL);
4206   helper.RunPreTestSetup();
4207   helper.AddData(&data);
4208   HttpNetworkTransaction* trans = helper.trans();
4209   TestCompletionCallback callback;
4210
4211   int rv = trans->Start(
4212       &CreateGetRequest(), callback.callback(), BoundNetLog());
4213   EXPECT_EQ(ERR_IO_PENDING, rv);
4214
4215   TransactionHelperResult out = helper.output();
4216   out.rv = callback.WaitForResult();
4217   EXPECT_EQ(out.rv, OK);
4218
4219   const HttpResponseInfo* response = trans->GetResponseInfo();
4220   EXPECT_TRUE(response->headers.get() != NULL);
4221   EXPECT_TRUE(response->was_fetched_via_spdy);
4222   out.status_line = response->headers->GetStatusLine();
4223   out.response_info = *response;  // Make a copy so we can verify.
4224
4225   // Read Data
4226   TestCompletionCallback read_callback;
4227
4228   const int kReadSize = 256;
4229   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kReadSize));
4230   rv = trans->Read(buf.get(), kReadSize, read_callback.callback());
4231   ASSERT_EQ(net::ERR_IO_PENDING, rv) << "Unexpected read: " << rv;
4232
4233   // Complete the read now, which causes buffering to start.
4234   data.CompleteRead();
4235   // Destroy the transaction, causing the stream to get cancelled
4236   // and orphaning the buffered IO task.
4237   helper.ResetTrans();
4238
4239   // Flush the MessageLoop; this will cause the buffered IO task
4240   // to run for the final time.
4241   base::RunLoop().RunUntilIdle();
4242
4243   // Verify that we consumed all test data.
4244   helper.VerifyDataConsumed();
4245 }
4246
4247 // Test that if the server requests persistence of settings, that we save
4248 // the settings in the HttpServerProperties.
4249 TEST_P(SpdyNetworkTransactionTest, SettingsSaved) {
4250   if (spdy_util_.spdy_version() >= SPDY4) {
4251     // SPDY4 doesn't support settings persistence.
4252     return;
4253   }
4254   static const SpdyHeaderInfo kSynReplyInfo = {
4255     SYN_REPLY,                              // Syn Reply
4256     1,                                      // Stream ID
4257     0,                                      // Associated Stream ID
4258     ConvertRequestPriorityToSpdyPriority(
4259         LOWEST, spdy_util_.spdy_version()),
4260     kSpdyCredentialSlotUnused,
4261     CONTROL_FLAG_NONE,                      // Control Flags
4262     false,                                  // Compressed
4263     RST_STREAM_INVALID,                     // Status
4264     NULL,                                   // Data
4265     0,                                      // Data Length
4266     DATA_FLAG_NONE                          // Data Flags
4267   };
4268
4269   BoundNetLog net_log;
4270   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
4271                                      net_log, GetParam(), NULL);
4272   helper.RunPreTestSetup();
4273
4274   // Verify that no settings exist initially.
4275   HostPortPair host_port_pair("www.google.com", helper.port());
4276   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
4277   EXPECT_TRUE(spdy_session_pool->http_server_properties()->GetSpdySettings(
4278       host_port_pair).empty());
4279
4280   // Construct the request.
4281   scoped_ptr<SpdyFrame> req(
4282       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
4283   MockWrite writes[] = { CreateMockWrite(*req) };
4284
4285   // Construct the reply.
4286   scoped_ptr<SpdyHeaderBlock> reply_headers(new SpdyHeaderBlock());
4287   (*reply_headers)[spdy_util_.GetStatusKey()] = "200";
4288   (*reply_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
4289   scoped_ptr<SpdyFrame> reply(
4290     spdy_util_.ConstructSpdyFrame(kSynReplyInfo, reply_headers.Pass()));
4291
4292   const SpdySettingsIds kSampleId1 = SETTINGS_UPLOAD_BANDWIDTH;
4293   unsigned int kSampleValue1 = 0x0a0a0a0a;
4294   const SpdySettingsIds kSampleId2 = SETTINGS_DOWNLOAD_BANDWIDTH;
4295   unsigned int kSampleValue2 = 0x0b0b0b0b;
4296   const SpdySettingsIds kSampleId3 = SETTINGS_ROUND_TRIP_TIME;
4297   unsigned int kSampleValue3 = 0x0c0c0c0c;
4298   scoped_ptr<SpdyFrame> settings_frame;
4299   {
4300     // Construct the SETTINGS frame.
4301     SettingsMap settings;
4302     // First add a persisted setting.
4303     settings[kSampleId1] =
4304         SettingsFlagsAndValue(SETTINGS_FLAG_PLEASE_PERSIST, kSampleValue1);
4305     // Next add a non-persisted setting.
4306     settings[kSampleId2] =
4307         SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kSampleValue2);
4308     // Next add another persisted setting.
4309     settings[kSampleId3] =
4310         SettingsFlagsAndValue(SETTINGS_FLAG_PLEASE_PERSIST, kSampleValue3);
4311     settings_frame.reset(spdy_util_.ConstructSpdySettings(settings));
4312   }
4313
4314   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
4315   MockRead reads[] = {
4316     CreateMockRead(*reply),
4317     CreateMockRead(*body),
4318     CreateMockRead(*settings_frame),
4319     MockRead(ASYNC, 0, 0)  // EOF
4320   };
4321
4322   DelayedSocketData data(1, reads, arraysize(reads),
4323                          writes, arraysize(writes));
4324   helper.AddData(&data);
4325   helper.RunDefaultTest();
4326   helper.VerifyDataConsumed();
4327   TransactionHelperResult out = helper.output();
4328   EXPECT_EQ(OK, out.rv);
4329   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
4330   EXPECT_EQ("hello!", out.response_data);
4331
4332   {
4333     // Verify we had two persisted settings.
4334     const SettingsMap& settings_map =
4335         spdy_session_pool->http_server_properties()->GetSpdySettings(
4336             host_port_pair);
4337     ASSERT_EQ(2u, settings_map.size());
4338
4339     // Verify the first persisted setting.
4340     SettingsMap::const_iterator it1 = settings_map.find(kSampleId1);
4341     EXPECT_TRUE(it1 != settings_map.end());
4342     SettingsFlagsAndValue flags_and_value1 = it1->second;
4343     EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value1.first);
4344     EXPECT_EQ(kSampleValue1, flags_and_value1.second);
4345
4346     // Verify the second persisted setting.
4347     SettingsMap::const_iterator it3 = settings_map.find(kSampleId3);
4348     EXPECT_TRUE(it3 != settings_map.end());
4349     SettingsFlagsAndValue flags_and_value3 = it3->second;
4350     EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value3.first);
4351     EXPECT_EQ(kSampleValue3, flags_and_value3.second);
4352   }
4353 }
4354
4355 // Test that when there are settings saved that they are sent back to the
4356 // server upon session establishment.
4357 TEST_P(SpdyNetworkTransactionTest, SettingsPlayback) {
4358   if (spdy_util_.spdy_version() >= SPDY4) {
4359     // SPDY4 doesn't support settings persistence.
4360     return;
4361   }
4362   static const SpdyHeaderInfo kSynReplyInfo = {
4363     SYN_REPLY,                              // Syn Reply
4364     1,                                      // Stream ID
4365     0,                                      // Associated Stream ID
4366     ConvertRequestPriorityToSpdyPriority(
4367         LOWEST, spdy_util_.spdy_version()),
4368     kSpdyCredentialSlotUnused,
4369     CONTROL_FLAG_NONE,                      // Control Flags
4370     false,                                  // Compressed
4371     RST_STREAM_INVALID,                     // Status
4372     NULL,                                   // Data
4373     0,                                      // Data Length
4374     DATA_FLAG_NONE                          // Data Flags
4375   };
4376
4377   BoundNetLog net_log;
4378   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
4379                                      net_log, GetParam(), NULL);
4380   helper.RunPreTestSetup();
4381
4382   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
4383
4384   SpdySessionPoolPeer pool_peer(spdy_session_pool);
4385   pool_peer.SetEnableSendingInitialData(true);
4386
4387   // Verify that no settings exist initially.
4388   HostPortPair host_port_pair("www.google.com", helper.port());
4389   EXPECT_TRUE(spdy_session_pool->http_server_properties()->GetSpdySettings(
4390       host_port_pair).empty());
4391
4392   const SpdySettingsIds kSampleId1 = SETTINGS_MAX_CONCURRENT_STREAMS;
4393   unsigned int kSampleValue1 = 0x0a0a0a0a;
4394   const SpdySettingsIds kSampleId2 = SETTINGS_INITIAL_WINDOW_SIZE;
4395   unsigned int kSampleValue2 = 0x0c0c0c0c;
4396
4397   // First add a persisted setting.
4398   spdy_session_pool->http_server_properties()->SetSpdySetting(
4399       host_port_pair,
4400       kSampleId1,
4401       SETTINGS_FLAG_PLEASE_PERSIST,
4402       kSampleValue1);
4403
4404   // Next add another persisted setting.
4405   spdy_session_pool->http_server_properties()->SetSpdySetting(
4406       host_port_pair,
4407       kSampleId2,
4408       SETTINGS_FLAG_PLEASE_PERSIST,
4409       kSampleValue2);
4410
4411   EXPECT_EQ(2u, spdy_session_pool->http_server_properties()->GetSpdySettings(
4412       host_port_pair).size());
4413
4414   // Construct the initial SETTINGS frame.
4415   SettingsMap initial_settings;
4416   initial_settings[SETTINGS_MAX_CONCURRENT_STREAMS] =
4417       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, kMaxConcurrentPushedStreams);
4418   scoped_ptr<SpdyFrame> initial_settings_frame(
4419       spdy_util_.ConstructSpdySettings(initial_settings));
4420
4421   // Construct the initial window update.
4422   scoped_ptr<SpdyFrame> initial_window_update(
4423       spdy_util_.ConstructSpdyWindowUpdate(
4424           kSessionFlowControlStreamId,
4425           kDefaultInitialRecvWindowSize -
4426               SpdySession::GetInitialWindowSize(GetParam().protocol)));
4427
4428   // Construct the persisted SETTINGS frame.
4429   const SettingsMap& settings =
4430       spdy_session_pool->http_server_properties()->GetSpdySettings(
4431           host_port_pair);
4432   scoped_ptr<SpdyFrame> settings_frame(
4433       spdy_util_.ConstructSpdySettings(settings));
4434
4435   // Construct the request.
4436   scoped_ptr<SpdyFrame> req(
4437       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
4438
4439   std::vector<MockWrite> writes;
4440   if ((GetParam().protocol >= kProtoSPDY4MinimumVersion) &&
4441       (GetParam().protocol <= kProtoSPDY4MaximumVersion)) {
4442     writes.push_back(
4443         MockWrite(ASYNC,
4444                   kHttp2ConnectionHeaderPrefix,
4445                   kHttp2ConnectionHeaderPrefixSize));
4446   }
4447   writes.push_back(CreateMockWrite(*initial_settings_frame));
4448   if (GetParam().protocol >= kProtoSPDY31) {
4449     writes.push_back(CreateMockWrite(*initial_window_update));
4450   }
4451   writes.push_back(CreateMockWrite(*settings_frame));
4452   writes.push_back(CreateMockWrite(*req));
4453
4454   // Construct the reply.
4455   scoped_ptr<SpdyHeaderBlock> reply_headers(new SpdyHeaderBlock());
4456   (*reply_headers)[spdy_util_.GetStatusKey()] = "200";
4457   (*reply_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
4458   scoped_ptr<SpdyFrame> reply(
4459     spdy_util_.ConstructSpdyFrame(kSynReplyInfo, reply_headers.Pass()));
4460
4461   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
4462   MockRead reads[] = {
4463     CreateMockRead(*reply),
4464     CreateMockRead(*body),
4465     MockRead(ASYNC, 0, 0)  // EOF
4466   };
4467
4468   DelayedSocketData data(2, reads, arraysize(reads),
4469                          vector_as_array(&writes), writes.size());
4470   helper.AddData(&data);
4471   helper.RunDefaultTest();
4472   helper.VerifyDataConsumed();
4473   TransactionHelperResult out = helper.output();
4474   EXPECT_EQ(OK, out.rv);
4475   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
4476   EXPECT_EQ("hello!", out.response_data);
4477
4478   {
4479     // Verify we had two persisted settings.
4480     const SettingsMap& settings_map =
4481         spdy_session_pool->http_server_properties()->GetSpdySettings(
4482             host_port_pair);
4483     ASSERT_EQ(2u, settings_map.size());
4484
4485     // Verify the first persisted setting.
4486     SettingsMap::const_iterator it1 = settings_map.find(kSampleId1);
4487     EXPECT_TRUE(it1 != settings_map.end());
4488     SettingsFlagsAndValue flags_and_value1 = it1->second;
4489     EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value1.first);
4490     EXPECT_EQ(kSampleValue1, flags_and_value1.second);
4491
4492     // Verify the second persisted setting.
4493     SettingsMap::const_iterator it2 = settings_map.find(kSampleId2);
4494     EXPECT_TRUE(it2 != settings_map.end());
4495     SettingsFlagsAndValue flags_and_value2 = it2->second;
4496     EXPECT_EQ(SETTINGS_FLAG_PERSISTED, flags_and_value2.first);
4497     EXPECT_EQ(kSampleValue2, flags_and_value2.second);
4498   }
4499 }
4500
4501 TEST_P(SpdyNetworkTransactionTest, GoAwayWithActiveStream) {
4502   scoped_ptr<SpdyFrame> req(
4503       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
4504   MockWrite writes[] = { CreateMockWrite(*req) };
4505
4506   scoped_ptr<SpdyFrame> go_away(spdy_util_.ConstructSpdyGoAway());
4507   MockRead reads[] = {
4508     CreateMockRead(*go_away),
4509   };
4510
4511   DelayedSocketData data(1, reads, arraysize(reads),
4512                          writes, arraysize(writes));
4513   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
4514                                      BoundNetLog(), GetParam(), NULL);
4515   helper.AddData(&data);
4516   helper.RunToCompletion(&data);
4517   TransactionHelperResult out = helper.output();
4518   EXPECT_EQ(ERR_ABORTED, out.rv);
4519 }
4520
4521 TEST_P(SpdyNetworkTransactionTest, CloseWithActiveStream) {
4522   scoped_ptr<SpdyFrame> req(
4523       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
4524   MockWrite writes[] = { CreateMockWrite(*req) };
4525
4526   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
4527   MockRead reads[] = {
4528     CreateMockRead(*resp),
4529     MockRead(SYNCHRONOUS, 0, 0)  // EOF
4530   };
4531
4532   DelayedSocketData data(1, reads, arraysize(reads),
4533                          writes, arraysize(writes));
4534   BoundNetLog log;
4535   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
4536                                      log, GetParam(), NULL);
4537   helper.RunPreTestSetup();
4538   helper.AddData(&data);
4539   HttpNetworkTransaction* trans = helper.trans();
4540
4541   TestCompletionCallback callback;
4542   TransactionHelperResult out;
4543   out.rv = trans->Start(&CreateGetRequest(), callback.callback(), log);
4544
4545   EXPECT_EQ(out.rv, ERR_IO_PENDING);
4546   out.rv = callback.WaitForResult();
4547   EXPECT_EQ(out.rv, OK);
4548
4549   const HttpResponseInfo* response = trans->GetResponseInfo();
4550   EXPECT_TRUE(response->headers.get() != NULL);
4551   EXPECT_TRUE(response->was_fetched_via_spdy);
4552   out.rv = ReadTransaction(trans, &out.response_data);
4553   EXPECT_EQ(ERR_CONNECTION_CLOSED, out.rv);
4554
4555   // Verify that we consumed all test data.
4556   helper.VerifyDataConsumed();
4557 }
4558
4559 // HTTP_1_1_REQUIRED results in ERR_HTTP_1_1_REQUIRED.
4560 TEST_P(SpdyNetworkTransactionTest, HTTP11RequiredError) {
4561   // HTTP_1_1_REQUIRED is only supported by SPDY4.
4562   if (spdy_util_.spdy_version() < SPDY4)
4563     return;
4564
4565   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
4566                                      BoundNetLog(), GetParam(), nullptr);
4567
4568   scoped_ptr<SpdyFrame> go_away(spdy_util_.ConstructSpdyGoAway(
4569       0, GOAWAY_HTTP_1_1_REQUIRED, "Try again using HTTP/1.1 please."));
4570   MockRead reads[] = {
4571       CreateMockRead(*go_away),
4572   };
4573   DelayedSocketData data(0, reads, arraysize(reads), nullptr, 0);
4574
4575   helper.RunToCompletion(&data);
4576   TransactionHelperResult out = helper.output();
4577   EXPECT_EQ(ERR_HTTP_1_1_REQUIRED, out.rv);
4578 }
4579
4580 // Retry with HTTP/1.1 when receiving HTTP_1_1_REQUIRED.  Note that no actual
4581 // protocol negotiation happens, instead this test forces protocols for both
4582 // sockets.
4583 TEST_P(SpdyNetworkTransactionTest, HTTP11RequiredRetry) {
4584   // HTTP_1_1_REQUIRED is only supported by SPDY4.
4585   if (spdy_util_.spdy_version() < SPDY4)
4586     return;
4587   // HTTP_1_1_REQUIRED implementation relies on the assumption that HTTP/2 is
4588   // only spoken over SSL.
4589   if (GetParam().ssl_type != SPDYSSL)
4590     return;
4591
4592   HttpRequestInfo request;
4593   request.method = "GET";
4594   request.url = GURL("https://www.google.com/");
4595   scoped_ptr<SpdySessionDependencies> session_deps(
4596       CreateSpdySessionDependencies(GetParam()));
4597   // Do not force SPDY so that second socket can negotiate HTTP/1.1.
4598   session_deps->force_spdy_over_ssl = false;
4599   session_deps->force_spdy_always = false;
4600   session_deps->next_protos = SpdyNextProtos();
4601   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
4602                                      GetParam(), session_deps.release());
4603
4604   // First socket: HTTP/2 request rejected with HTTP_1_1_REQUIRED.
4605   const char* url = "https://www.google.com/";
4606   scoped_ptr<SpdyHeaderBlock> headers(spdy_util_.ConstructGetHeaderBlock(url));
4607   scoped_ptr<SpdyFrame> req(
4608       spdy_util_.ConstructSpdySyn(1, *headers, LOWEST, false, true));
4609   MockWrite writes0[] = {CreateMockWrite(*req)};
4610   scoped_ptr<SpdyFrame> go_away(spdy_util_.ConstructSpdyGoAway(
4611       0, GOAWAY_HTTP_1_1_REQUIRED, "Try again using HTTP/1.1 please."));
4612   MockRead reads0[] = {CreateMockRead(*go_away)};
4613   DelayedSocketData data0(1, reads0, arraysize(reads0), writes0,
4614                           arraysize(writes0));
4615
4616   scoped_ptr<SSLSocketDataProvider> ssl_provider0(
4617       new SSLSocketDataProvider(ASYNC, OK));
4618   // Expect HTTP/2 protocols too in SSLConfig.
4619   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoHTTP11);
4620   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoSPDY31);
4621   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoSPDY4_14);
4622   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoSPDY4_15);
4623   // Force SPDY.
4624   ssl_provider0->SetNextProto(GetParam().protocol);
4625   helper.AddDataWithSSLSocketDataProvider(&data0, ssl_provider0.Pass());
4626
4627   // Second socket: falling back to HTTP/1.1.
4628   MockWrite writes1[] = {MockWrite(
4629       "GET / HTTP/1.1\r\n"
4630       "Host: www.google.com\r\n"
4631       "Connection: keep-alive\r\n\r\n")};
4632   MockRead reads1[] = {MockRead(
4633       "HTTP/1.1 200 OK\r\n"
4634       "Content-Length: 5\r\n\r\n"
4635       "hello")};
4636   DelayedSocketData data1(1, reads1, arraysize(reads1), writes1,
4637                           arraysize(writes1));
4638
4639   scoped_ptr<SSLSocketDataProvider> ssl_provider1(
4640       new SSLSocketDataProvider(ASYNC, OK));
4641   // Expect only HTTP/1.1 protocol in SSLConfig.
4642   ssl_provider1->next_protos_expected_in_ssl_config.push_back(kProtoHTTP11);
4643   // Force HTTP/1.1.
4644   ssl_provider1->SetNextProto(kProtoHTTP11);
4645   helper.AddDataWithSSLSocketDataProvider(&data1, ssl_provider1.Pass());
4646
4647   base::WeakPtr<HttpServerProperties> http_server_properties =
4648       helper.session()->spdy_session_pool()->http_server_properties();
4649   const HostPortPair host_port_pair = HostPortPair::FromURL(GURL(url));
4650   EXPECT_FALSE(http_server_properties->RequiresHTTP11(host_port_pair));
4651
4652   helper.RunPreTestSetup();
4653   helper.StartDefaultTest();
4654   helper.FinishDefaultTestWithoutVerification();
4655   helper.VerifyDataConsumed();
4656   EXPECT_TRUE(http_server_properties->RequiresHTTP11(host_port_pair));
4657
4658   const HttpResponseInfo* response = helper.trans()->GetResponseInfo();
4659   ASSERT_TRUE(response != nullptr);
4660   ASSERT_TRUE(response->headers.get() != nullptr);
4661   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
4662   EXPECT_FALSE(response->was_fetched_via_spdy);
4663   EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1, response->connection_info);
4664   EXPECT_TRUE(response->was_npn_negotiated);
4665   EXPECT_TRUE(request.url.SchemeIs("https"));
4666   EXPECT_EQ("127.0.0.1", response->socket_address.host());
4667   EXPECT_EQ(443, response->socket_address.port());
4668   std::string response_data;
4669   ASSERT_EQ(OK, ReadTransaction(helper.trans(), &response_data));
4670   EXPECT_EQ("hello", response_data);
4671 }
4672
4673 // Retry with HTTP/1.1 to the proxy when receiving HTTP_1_1_REQUIRED from the
4674 // proxy.  Note that no actual protocol negotiation happens, instead this test
4675 // forces protocols for both sockets.
4676 TEST_P(SpdyNetworkTransactionTest, HTTP11RequiredProxyRetry) {
4677   // HTTP_1_1_REQUIRED is only supported by SPDY4.
4678   if (spdy_util_.spdy_version() < SPDY4)
4679     return;
4680   // HTTP_1_1_REQUIRED implementation relies on the assumption that HTTP/2 is
4681   // only spoken over SSL.
4682   if (GetParam().ssl_type != SPDYSSL)
4683     return;
4684
4685   HttpRequestInfo request;
4686   request.method = "GET";
4687   request.url = GURL("https://www.google.com/");
4688   scoped_ptr<SpdySessionDependencies> session_deps(
4689       CreateSpdySessionDependencies(
4690           GetParam(),
4691           ProxyService::CreateFixedFromPacResult("HTTPS myproxy:70")));
4692   // Do not force SPDY so that second socket can negotiate HTTP/1.1.
4693   session_deps->force_spdy_over_ssl = false;
4694   session_deps->force_spdy_always = false;
4695   session_deps->next_protos = SpdyNextProtos();
4696   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY, BoundNetLog(),
4697                                      GetParam(), session_deps.release());
4698
4699   // First socket: HTTP/2 CONNECT rejected with HTTP_1_1_REQUIRED.
4700   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyConnect(
4701       nullptr, 0, 1, LOWEST, HostPortPair("www.google.com", 443)));
4702   MockWrite writes0[] = {CreateMockWrite(*req)};
4703   scoped_ptr<SpdyFrame> go_away(spdy_util_.ConstructSpdyGoAway(
4704       0, GOAWAY_HTTP_1_1_REQUIRED, "Try again using HTTP/1.1 please."));
4705   MockRead reads0[] = {CreateMockRead(*go_away)};
4706   DelayedSocketData data0(1, reads0, arraysize(reads0), writes0,
4707                           arraysize(writes0));
4708
4709   scoped_ptr<SSLSocketDataProvider> ssl_provider0(
4710       new SSLSocketDataProvider(ASYNC, OK));
4711   // Expect HTTP/2 protocols too in SSLConfig.
4712   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoHTTP11);
4713   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoSPDY31);
4714   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoSPDY4_14);
4715   ssl_provider0->next_protos_expected_in_ssl_config.push_back(kProtoSPDY4_15);
4716   // Force SPDY.
4717   ssl_provider0->SetNextProto(GetParam().protocol);
4718   helper.AddDataWithSSLSocketDataProvider(&data0, ssl_provider0.Pass());
4719
4720   // Second socket: retry using HTTP/1.1.
4721   MockWrite writes1[] = {
4722       MockWrite(ASYNC, 1,
4723                 "CONNECT www.google.com:443 HTTP/1.1\r\n"
4724                 "Host: www.google.com\r\n"
4725                 "Proxy-Connection: keep-alive\r\n\r\n"),
4726       MockWrite(ASYNC, 3,
4727                 "GET / HTTP/1.1\r\n"
4728                 "Host: www.google.com\r\n"
4729                 "Connection: keep-alive\r\n\r\n"),
4730   };
4731
4732   MockRead reads1[] = {
4733       MockRead(ASYNC, 2, "HTTP/1.1 200 OK\r\n\r\n"),
4734       MockRead(ASYNC, 4,
4735                "HTTP/1.1 200 OK\r\n"
4736                "Content-Length: 5\r\n\r\n"
4737                "hello"),
4738   };
4739   DelayedSocketData data1(1, reads1, arraysize(reads1), writes1,
4740                           arraysize(writes1));
4741
4742   scoped_ptr<SSLSocketDataProvider> ssl_provider1(
4743       new SSLSocketDataProvider(ASYNC, OK));
4744   // Expect only HTTP/1.1 protocol in SSLConfig.
4745   ssl_provider1->next_protos_expected_in_ssl_config.push_back(kProtoHTTP11);
4746   // Force HTTP/1.1.
4747   ssl_provider1->SetNextProto(kProtoHTTP11);
4748   helper.AddDataWithSSLSocketDataProvider(&data1, ssl_provider1.Pass());
4749
4750   // A third socket is needed for the tunnelled connection.
4751   scoped_ptr<SSLSocketDataProvider> ssl_provider2(
4752       new SSLSocketDataProvider(ASYNC, OK));
4753   helper.session_deps()->socket_factory->AddSSLSocketDataProvider(
4754       ssl_provider2.get());
4755
4756   base::WeakPtr<HttpServerProperties> http_server_properties =
4757       helper.session()->spdy_session_pool()->http_server_properties();
4758   const HostPortPair proxy_host_port_pair = HostPortPair("myproxy", 70);
4759   EXPECT_FALSE(http_server_properties->RequiresHTTP11(proxy_host_port_pair));
4760
4761   helper.RunPreTestSetup();
4762   helper.StartDefaultTest();
4763   helper.FinishDefaultTestWithoutVerification();
4764   helper.VerifyDataConsumed();
4765   EXPECT_TRUE(http_server_properties->RequiresHTTP11(proxy_host_port_pair));
4766
4767   const HttpResponseInfo* response = helper.trans()->GetResponseInfo();
4768   ASSERT_TRUE(response != nullptr);
4769   ASSERT_TRUE(response->headers.get() != nullptr);
4770   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
4771   EXPECT_FALSE(response->was_fetched_via_spdy);
4772   EXPECT_EQ(HttpResponseInfo::CONNECTION_INFO_HTTP1, response->connection_info);
4773   EXPECT_FALSE(response->was_npn_negotiated);
4774   EXPECT_TRUE(request.url.SchemeIs("https"));
4775   EXPECT_EQ("127.0.0.1", response->socket_address.host());
4776   EXPECT_EQ(70, response->socket_address.port());
4777   std::string response_data;
4778   ASSERT_EQ(OK, ReadTransaction(helper.trans(), &response_data));
4779   EXPECT_EQ("hello", response_data);
4780 }
4781
4782 // Test to make sure we can correctly connect through a proxy.
4783 TEST_P(SpdyNetworkTransactionTest, ProxyConnect) {
4784   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
4785                                      BoundNetLog(), GetParam(), NULL);
4786   helper.session_deps().reset(CreateSpdySessionDependencies(
4787       GetParam(),
4788       ProxyService::CreateFixedFromPacResult("PROXY myproxy:70")));
4789   helper.SetSession(make_scoped_refptr(
4790       SpdySessionDependencies::SpdyCreateSession(helper.session_deps().get())));
4791   helper.RunPreTestSetup();
4792   HttpNetworkTransaction* trans = helper.trans();
4793
4794   const char kConnect443[] = {"CONNECT www.google.com:443 HTTP/1.1\r\n"
4795                            "Host: www.google.com\r\n"
4796                            "Proxy-Connection: keep-alive\r\n\r\n"};
4797   const char kConnect80[] = {"CONNECT www.google.com:80 HTTP/1.1\r\n"
4798                            "Host: www.google.com\r\n"
4799                            "Proxy-Connection: keep-alive\r\n\r\n"};
4800   const char kHTTP200[] = {"HTTP/1.1 200 OK\r\n\r\n"};
4801   scoped_ptr<SpdyFrame> req(
4802       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
4803   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
4804   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
4805
4806   MockWrite writes_SPDYNPN[] = {
4807     MockWrite(SYNCHRONOUS, kConnect443, arraysize(kConnect443) - 1, 0),
4808     CreateMockWrite(*req, 2),
4809   };
4810   MockRead reads_SPDYNPN[] = {
4811     MockRead(SYNCHRONOUS, kHTTP200, arraysize(kHTTP200) - 1, 1),
4812     CreateMockRead(*resp, 3),
4813     CreateMockRead(*body.get(), 4),
4814     MockRead(ASYNC, 0, 0, 5),
4815   };
4816
4817   MockWrite writes_SPDYSSL[] = {
4818     MockWrite(SYNCHRONOUS, kConnect80, arraysize(kConnect80) - 1, 0),
4819     CreateMockWrite(*req, 2),
4820   };
4821   MockRead reads_SPDYSSL[] = {
4822     MockRead(SYNCHRONOUS, kHTTP200, arraysize(kHTTP200) - 1, 1),
4823     CreateMockRead(*resp, 3),
4824     CreateMockRead(*body.get(), 4),
4825     MockRead(ASYNC, 0, 0, 5),
4826   };
4827
4828   MockWrite writes_SPDYNOSSL[] = {
4829     CreateMockWrite(*req, 0),
4830   };
4831
4832   MockRead reads_SPDYNOSSL[] = {
4833     CreateMockRead(*resp, 1),
4834     CreateMockRead(*body.get(), 2),
4835     MockRead(ASYNC, 0, 0, 3),
4836   };
4837
4838   scoped_ptr<OrderedSocketData> data;
4839   switch (GetParam().ssl_type) {
4840     case SPDYNOSSL:
4841       data.reset(new OrderedSocketData(reads_SPDYNOSSL,
4842                                        arraysize(reads_SPDYNOSSL),
4843                                        writes_SPDYNOSSL,
4844                                        arraysize(writes_SPDYNOSSL)));
4845       break;
4846     case SPDYSSL:
4847       data.reset(new OrderedSocketData(reads_SPDYSSL,
4848                                        arraysize(reads_SPDYSSL),
4849                                        writes_SPDYSSL,
4850                                        arraysize(writes_SPDYSSL)));
4851       break;
4852     case SPDYNPN:
4853       data.reset(new OrderedSocketData(reads_SPDYNPN,
4854                                        arraysize(reads_SPDYNPN),
4855                                        writes_SPDYNPN,
4856                                        arraysize(writes_SPDYNPN)));
4857       break;
4858     default:
4859       NOTREACHED();
4860   }
4861
4862   helper.AddData(data.get());
4863   TestCompletionCallback callback;
4864
4865   int rv = trans->Start(
4866       &CreateGetRequest(), callback.callback(), BoundNetLog());
4867   EXPECT_EQ(ERR_IO_PENDING, rv);
4868
4869   rv = callback.WaitForResult();
4870   EXPECT_EQ(0, rv);
4871
4872   // Verify the SYN_REPLY.
4873   HttpResponseInfo response = *trans->GetResponseInfo();
4874   EXPECT_TRUE(response.headers.get() != NULL);
4875   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
4876
4877   std::string response_data;
4878   ASSERT_EQ(OK, ReadTransaction(trans, &response_data));
4879   EXPECT_EQ("hello!", response_data);
4880   helper.VerifyDataConsumed();
4881 }
4882
4883 // Test to make sure we can correctly connect through a proxy to www.google.com,
4884 // if there already exists a direct spdy connection to www.google.com. See
4885 // http://crbug.com/49874
4886 TEST_P(SpdyNetworkTransactionTest, DirectConnectProxyReconnect) {
4887   // When setting up the first transaction, we store the SpdySessionPool so that
4888   // we can use the same pool in the second transaction.
4889   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
4890                                      BoundNetLog(), GetParam(), NULL);
4891
4892   // Use a proxy service which returns a proxy fallback list from DIRECT to
4893   // myproxy:70. For this test there will be no fallback, so it is equivalent
4894   // to simply DIRECT. The reason for appending the second proxy is to verify
4895   // that the session pool key used does is just "DIRECT".
4896   helper.session_deps().reset(CreateSpdySessionDependencies(
4897       GetParam(),
4898       ProxyService::CreateFixedFromPacResult("DIRECT; PROXY myproxy:70")));
4899   helper.SetSession(make_scoped_refptr(
4900       SpdySessionDependencies::SpdyCreateSession(helper.session_deps().get())));
4901
4902   SpdySessionPool* spdy_session_pool = helper.session()->spdy_session_pool();
4903   helper.RunPreTestSetup();
4904
4905   // Construct and send a simple GET request.
4906   scoped_ptr<SpdyFrame> req(
4907       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
4908   MockWrite writes[] = {
4909     CreateMockWrite(*req, 1),
4910   };
4911
4912   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
4913   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
4914   MockRead reads[] = {
4915     CreateMockRead(*resp, 2),
4916     CreateMockRead(*body, 3),
4917     MockRead(ASYNC, ERR_IO_PENDING, 4),  // Force a pause
4918     MockRead(ASYNC, 0, 5)  // EOF
4919   };
4920   OrderedSocketData data(reads, arraysize(reads),
4921                          writes, arraysize(writes));
4922   helper.AddData(&data);
4923   HttpNetworkTransaction* trans = helper.trans();
4924
4925   TestCompletionCallback callback;
4926   TransactionHelperResult out;
4927   out.rv = trans->Start(
4928       &CreateGetRequest(), callback.callback(), BoundNetLog());
4929
4930   EXPECT_EQ(out.rv, ERR_IO_PENDING);
4931   out.rv = callback.WaitForResult();
4932   EXPECT_EQ(out.rv, OK);
4933
4934   const HttpResponseInfo* response = trans->GetResponseInfo();
4935   EXPECT_TRUE(response->headers.get() != NULL);
4936   EXPECT_TRUE(response->was_fetched_via_spdy);
4937   out.rv = ReadTransaction(trans, &out.response_data);
4938   EXPECT_EQ(OK, out.rv);
4939   out.status_line = response->headers->GetStatusLine();
4940   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
4941   EXPECT_EQ("hello!", out.response_data);
4942
4943   // Check that the SpdySession is still in the SpdySessionPool.
4944   HostPortPair host_port_pair("www.google.com", helper.port());
4945   SpdySessionKey session_pool_key_direct(
4946       host_port_pair, ProxyServer::Direct(), PRIVACY_MODE_DISABLED);
4947   EXPECT_TRUE(HasSpdySession(spdy_session_pool, session_pool_key_direct));
4948   SpdySessionKey session_pool_key_proxy(
4949       host_port_pair,
4950       ProxyServer::FromURI("www.foo.com", ProxyServer::SCHEME_HTTP),
4951       PRIVACY_MODE_DISABLED);
4952   EXPECT_FALSE(HasSpdySession(spdy_session_pool, session_pool_key_proxy));
4953
4954   // Set up data for the proxy connection.
4955   const char kConnect443[] = {"CONNECT www.google.com:443 HTTP/1.1\r\n"
4956                            "Host: www.google.com\r\n"
4957                            "Proxy-Connection: keep-alive\r\n\r\n"};
4958   const char kConnect80[] = {"CONNECT www.google.com:80 HTTP/1.1\r\n"
4959                            "Host: www.google.com\r\n"
4960                            "Proxy-Connection: keep-alive\r\n\r\n"};
4961   const char kHTTP200[] = {"HTTP/1.1 200 OK\r\n\r\n"};
4962   scoped_ptr<SpdyFrame> req2(spdy_util_.ConstructSpdyGet(
4963       "http://www.google.com/foo.dat", false, 1, LOWEST));
4964   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
4965   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(1, true));
4966
4967   MockWrite writes_SPDYNPN[] = {
4968     MockWrite(SYNCHRONOUS, kConnect443, arraysize(kConnect443) - 1, 0),
4969     CreateMockWrite(*req2, 2),
4970   };
4971   MockRead reads_SPDYNPN[] = {
4972     MockRead(SYNCHRONOUS, kHTTP200, arraysize(kHTTP200) - 1, 1),
4973     CreateMockRead(*resp2, 3),
4974     CreateMockRead(*body2, 4),
4975     MockRead(ASYNC, 0, 5)  // EOF
4976   };
4977
4978   MockWrite writes_SPDYNOSSL[] = {
4979     CreateMockWrite(*req2, 0),
4980   };
4981   MockRead reads_SPDYNOSSL[] = {
4982     CreateMockRead(*resp2, 1),
4983     CreateMockRead(*body2, 2),
4984     MockRead(ASYNC, 0, 3)  // EOF
4985   };
4986
4987   MockWrite writes_SPDYSSL[] = {
4988     MockWrite(SYNCHRONOUS, kConnect80, arraysize(kConnect80) - 1, 0),
4989     CreateMockWrite(*req2, 2),
4990   };
4991   MockRead reads_SPDYSSL[] = {
4992     MockRead(SYNCHRONOUS, kHTTP200, arraysize(kHTTP200) - 1, 1),
4993     CreateMockRead(*resp2, 3),
4994     CreateMockRead(*body2, 4),
4995     MockRead(ASYNC, 0, 0, 5),
4996   };
4997
4998   scoped_ptr<OrderedSocketData> data_proxy;
4999   switch (GetParam().ssl_type) {
5000     case SPDYNPN:
5001       data_proxy.reset(new OrderedSocketData(reads_SPDYNPN,
5002                                              arraysize(reads_SPDYNPN),
5003                                              writes_SPDYNPN,
5004                                              arraysize(writes_SPDYNPN)));
5005       break;
5006     case SPDYNOSSL:
5007       data_proxy.reset(new OrderedSocketData(reads_SPDYNOSSL,
5008                                              arraysize(reads_SPDYNOSSL),
5009                                              writes_SPDYNOSSL,
5010                                              arraysize(writes_SPDYNOSSL)));
5011       break;
5012     case SPDYSSL:
5013       data_proxy.reset(new OrderedSocketData(reads_SPDYSSL,
5014                                              arraysize(reads_SPDYSSL),
5015                                              writes_SPDYSSL,
5016                                              arraysize(writes_SPDYSSL)));
5017       break;
5018     default:
5019       NOTREACHED();
5020   }
5021
5022   // Create another request to www.google.com, but this time through a proxy.
5023   HttpRequestInfo request_proxy;
5024   request_proxy.method = "GET";
5025   request_proxy.url = GURL("http://www.google.com/foo.dat");
5026   request_proxy.load_flags = 0;
5027   scoped_ptr<SpdySessionDependencies> ssd_proxy(
5028       CreateSpdySessionDependencies(GetParam()));
5029   // Ensure that this transaction uses the same SpdySessionPool.
5030   scoped_refptr<HttpNetworkSession> session_proxy(
5031       SpdySessionDependencies::SpdyCreateSession(ssd_proxy.get()));
5032   NormalSpdyTransactionHelper helper_proxy(request_proxy, DEFAULT_PRIORITY,
5033                                            BoundNetLog(), GetParam(), NULL);
5034   HttpNetworkSessionPeer session_peer(session_proxy);
5035   scoped_ptr<net::ProxyService> proxy_service(
5036           ProxyService::CreateFixedFromPacResult("PROXY myproxy:70"));
5037   session_peer.SetProxyService(proxy_service.get());
5038   helper_proxy.session_deps().swap(ssd_proxy);
5039   helper_proxy.SetSession(session_proxy);
5040   helper_proxy.RunPreTestSetup();
5041   helper_proxy.AddData(data_proxy.get());
5042
5043   HttpNetworkTransaction* trans_proxy = helper_proxy.trans();
5044   TestCompletionCallback callback_proxy;
5045   int rv = trans_proxy->Start(
5046       &request_proxy, callback_proxy.callback(), BoundNetLog());
5047   EXPECT_EQ(ERR_IO_PENDING, rv);
5048   rv = callback_proxy.WaitForResult();
5049   EXPECT_EQ(0, rv);
5050
5051   HttpResponseInfo response_proxy = *trans_proxy->GetResponseInfo();
5052   EXPECT_TRUE(response_proxy.headers.get() != NULL);
5053   EXPECT_EQ("HTTP/1.1 200 OK", response_proxy.headers->GetStatusLine());
5054
5055   std::string response_data;
5056   ASSERT_EQ(OK, ReadTransaction(trans_proxy, &response_data));
5057   EXPECT_EQ("hello!", response_data);
5058
5059   data.CompleteRead();
5060   helper_proxy.VerifyDataConsumed();
5061 }
5062
5063 // When we get a TCP-level RST, we need to retry a HttpNetworkTransaction
5064 // on a new connection, if the connection was previously known to be good.
5065 // This can happen when a server reboots without saying goodbye, or when
5066 // we're behind a NAT that masked the RST.
5067 TEST_P(SpdyNetworkTransactionTest, VerifyRetryOnConnectionReset) {
5068   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
5069   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
5070   MockRead reads[] = {
5071     CreateMockRead(*resp),
5072     CreateMockRead(*body),
5073     MockRead(ASYNC, ERR_IO_PENDING),
5074     MockRead(ASYNC, ERR_CONNECTION_RESET),
5075   };
5076
5077   MockRead reads2[] = {
5078     CreateMockRead(*resp),
5079     CreateMockRead(*body),
5080     MockRead(ASYNC, 0, 0)  // EOF
5081   };
5082
5083   // This test has a couple of variants.
5084   enum {
5085     // Induce the RST while waiting for our transaction to send.
5086     VARIANT_RST_DURING_SEND_COMPLETION,
5087     // Induce the RST while waiting for our transaction to read.
5088     // In this case, the send completed - everything copied into the SNDBUF.
5089     VARIANT_RST_DURING_READ_COMPLETION
5090   };
5091
5092   for (int variant = VARIANT_RST_DURING_SEND_COMPLETION;
5093        variant <= VARIANT_RST_DURING_READ_COMPLETION;
5094        ++variant) {
5095     DelayedSocketData data1(1, reads, arraysize(reads), NULL, 0);
5096
5097     DelayedSocketData data2(1, reads2, arraysize(reads2), NULL, 0);
5098
5099     NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
5100                                        BoundNetLog(), GetParam(), NULL);
5101     helper.AddData(&data1);
5102     helper.AddData(&data2);
5103     helper.RunPreTestSetup();
5104
5105     for (int i = 0; i < 2; ++i) {
5106       scoped_ptr<HttpNetworkTransaction> trans(
5107           new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
5108
5109       TestCompletionCallback callback;
5110       int rv = trans->Start(
5111           &helper.request(), callback.callback(), BoundNetLog());
5112       EXPECT_EQ(ERR_IO_PENDING, rv);
5113       // On the second transaction, we trigger the RST.
5114       if (i == 1) {
5115         if (variant == VARIANT_RST_DURING_READ_COMPLETION) {
5116           // Writes to the socket complete asynchronously on SPDY by running
5117           // through the message loop.  Complete the write here.
5118           base::RunLoop().RunUntilIdle();
5119         }
5120
5121         // Now schedule the ERR_CONNECTION_RESET.
5122         EXPECT_EQ(3u, data1.read_index());
5123         data1.CompleteRead();
5124         EXPECT_EQ(4u, data1.read_index());
5125       }
5126       rv = callback.WaitForResult();
5127       EXPECT_EQ(OK, rv);
5128
5129       const HttpResponseInfo* response = trans->GetResponseInfo();
5130       ASSERT_TRUE(response != NULL);
5131       EXPECT_TRUE(response->headers.get() != NULL);
5132       EXPECT_TRUE(response->was_fetched_via_spdy);
5133       std::string response_data;
5134       rv = ReadTransaction(trans.get(), &response_data);
5135       EXPECT_EQ(OK, rv);
5136       EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
5137       EXPECT_EQ("hello!", response_data);
5138     }
5139
5140     helper.VerifyDataConsumed();
5141   }
5142 }
5143
5144 // Test that turning SPDY on and off works properly.
5145 TEST_P(SpdyNetworkTransactionTest, SpdyOnOffToggle) {
5146   HttpStreamFactory::set_spdy_enabled(true);
5147   scoped_ptr<SpdyFrame> req(
5148       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
5149   MockWrite spdy_writes[] = { CreateMockWrite(*req) };
5150
5151   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
5152   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
5153   MockRead spdy_reads[] = {
5154     CreateMockRead(*resp),
5155     CreateMockRead(*body),
5156     MockRead(ASYNC, 0, 0)  // EOF
5157   };
5158
5159   DelayedSocketData data(1, spdy_reads, arraysize(spdy_reads),
5160                          spdy_writes, arraysize(spdy_writes));
5161   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
5162                                      BoundNetLog(), GetParam(), NULL);
5163   helper.RunToCompletion(&data);
5164   TransactionHelperResult out = helper.output();
5165   EXPECT_EQ(OK, out.rv);
5166   EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
5167   EXPECT_EQ("hello!", out.response_data);
5168
5169   net::HttpStreamFactory::set_spdy_enabled(false);
5170   MockRead http_reads[] = {
5171     MockRead("HTTP/1.1 200 OK\r\n\r\n"),
5172     MockRead("hello from http"),
5173     MockRead(SYNCHRONOUS, OK),
5174   };
5175   DelayedSocketData data2(1, http_reads, arraysize(http_reads), NULL, 0);
5176   NormalSpdyTransactionHelper helper2(CreateGetRequest(), DEFAULT_PRIORITY,
5177                                      BoundNetLog(), GetParam(), NULL);
5178   helper2.SetSpdyDisabled();
5179   helper2.RunToCompletion(&data2);
5180   TransactionHelperResult out2 = helper2.output();
5181   EXPECT_EQ(OK, out2.rv);
5182   EXPECT_EQ("HTTP/1.1 200 OK", out2.status_line);
5183   EXPECT_EQ("hello from http", out2.response_data);
5184
5185   net::HttpStreamFactory::set_spdy_enabled(true);
5186 }
5187
5188 // Tests that Basic authentication works over SPDY
5189 TEST_P(SpdyNetworkTransactionTest, SpdyBasicAuth) {
5190   net::HttpStreamFactory::set_spdy_enabled(true);
5191
5192   // The first request will be a bare GET, the second request will be a
5193   // GET with an Authorization header.
5194   scoped_ptr<SpdyFrame> req_get(
5195       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
5196   const char* const kExtraAuthorizationHeaders[] = {
5197     "authorization", "Basic Zm9vOmJhcg=="
5198   };
5199   scoped_ptr<SpdyFrame> req_get_authorization(
5200       spdy_util_.ConstructSpdyGet(kExtraAuthorizationHeaders,
5201                                   arraysize(kExtraAuthorizationHeaders) / 2,
5202                                   false, 3, LOWEST, true));
5203   MockWrite spdy_writes[] = {
5204     CreateMockWrite(*req_get, 1),
5205     CreateMockWrite(*req_get_authorization, 4),
5206   };
5207
5208   // The first response is a 401 authentication challenge, and the second
5209   // response will be a 200 response since the second request includes a valid
5210   // Authorization header.
5211   const char* const kExtraAuthenticationHeaders[] = {
5212     "www-authenticate",
5213     "Basic realm=\"MyRealm\""
5214   };
5215   scoped_ptr<SpdyFrame> resp_authentication(
5216       spdy_util_.ConstructSpdySynReplyError(
5217           "401 Authentication Required",
5218           kExtraAuthenticationHeaders,
5219           arraysize(kExtraAuthenticationHeaders) / 2,
5220           1));
5221   scoped_ptr<SpdyFrame> body_authentication(
5222       spdy_util_.ConstructSpdyBodyFrame(1, true));
5223   scoped_ptr<SpdyFrame> resp_data(
5224       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
5225   scoped_ptr<SpdyFrame> body_data(spdy_util_.ConstructSpdyBodyFrame(3, true));
5226   MockRead spdy_reads[] = {
5227     CreateMockRead(*resp_authentication, 2),
5228     CreateMockRead(*body_authentication, 3),
5229     CreateMockRead(*resp_data, 5),
5230     CreateMockRead(*body_data, 6),
5231     MockRead(ASYNC, 0, 7),
5232   };
5233
5234   OrderedSocketData data(spdy_reads, arraysize(spdy_reads),
5235                          spdy_writes, arraysize(spdy_writes));
5236   HttpRequestInfo request(CreateGetRequest());
5237   BoundNetLog net_log;
5238   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
5239                                      net_log, GetParam(), NULL);
5240
5241   helper.RunPreTestSetup();
5242   helper.AddData(&data);
5243   HttpNetworkTransaction* trans = helper.trans();
5244   TestCompletionCallback callback;
5245   const int rv_start = trans->Start(&request, callback.callback(), net_log);
5246   EXPECT_EQ(ERR_IO_PENDING, rv_start);
5247   const int rv_start_complete = callback.WaitForResult();
5248   EXPECT_EQ(OK, rv_start_complete);
5249
5250   // Make sure the response has an auth challenge.
5251   const HttpResponseInfo* const response_start = trans->GetResponseInfo();
5252   ASSERT_TRUE(response_start != NULL);
5253   ASSERT_TRUE(response_start->headers.get() != NULL);
5254   EXPECT_EQ(401, response_start->headers->response_code());
5255   EXPECT_TRUE(response_start->was_fetched_via_spdy);
5256   AuthChallengeInfo* auth_challenge = response_start->auth_challenge.get();
5257   ASSERT_TRUE(auth_challenge != NULL);
5258   EXPECT_FALSE(auth_challenge->is_proxy);
5259   EXPECT_EQ("basic", auth_challenge->scheme);
5260   EXPECT_EQ("MyRealm", auth_challenge->realm);
5261
5262   // Restart with a username/password.
5263   AuthCredentials credentials(base::ASCIIToUTF16("foo"),
5264                               base::ASCIIToUTF16("bar"));
5265   TestCompletionCallback callback_restart;
5266   const int rv_restart = trans->RestartWithAuth(
5267       credentials, callback_restart.callback());
5268   EXPECT_EQ(ERR_IO_PENDING, rv_restart);
5269   const int rv_restart_complete = callback_restart.WaitForResult();
5270   EXPECT_EQ(OK, rv_restart_complete);
5271   // TODO(cbentzel): This is actually the same response object as before, but
5272   // data has changed.
5273   const HttpResponseInfo* const response_restart = trans->GetResponseInfo();
5274   ASSERT_TRUE(response_restart != NULL);
5275   ASSERT_TRUE(response_restart->headers.get() != NULL);
5276   EXPECT_EQ(200, response_restart->headers->response_code());
5277   EXPECT_TRUE(response_restart->auth_challenge.get() == NULL);
5278 }
5279
5280 TEST_P(SpdyNetworkTransactionTest, ServerPushWithHeaders) {
5281   scoped_ptr<SpdyFrame> stream1_syn(
5282       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
5283   scoped_ptr<SpdyFrame> stream1_body(
5284       spdy_util_.ConstructSpdyBodyFrame(1, true));
5285   MockWrite writes[] = {
5286     CreateMockWrite(*stream1_syn, 1),
5287   };
5288
5289   scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
5290   spdy_util_.AddUrlToHeaderBlock(
5291       "http://www.google.com/foo.dat", initial_headers.get());
5292   scoped_ptr<SpdyFrame> stream2_syn(
5293       spdy_util_.ConstructInitialSpdyPushFrame(initial_headers.Pass(), 2, 1));
5294
5295   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
5296   (*late_headers)["hello"] = "bye";
5297   (*late_headers)[spdy_util_.GetStatusKey()] = "200";
5298   (*late_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
5299   scoped_ptr<SpdyFrame> stream2_headers(
5300       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
5301                                            false,
5302                                            2,
5303                                            LOWEST,
5304                                            HEADERS,
5305                                            CONTROL_FLAG_NONE,
5306                                            0));
5307
5308   scoped_ptr<SpdyFrame>
5309       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
5310   const char kPushedData[] = "pushed";
5311   scoped_ptr<SpdyFrame> stream2_body(
5312       spdy_util_.ConstructSpdyBodyFrame(
5313           2, kPushedData, strlen(kPushedData), true));
5314   MockRead reads[] = {
5315     CreateMockRead(*stream1_reply, 2),
5316     CreateMockRead(*stream2_syn, 3),
5317     CreateMockRead(*stream2_headers, 4),
5318     CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
5319     CreateMockRead(*stream2_body, 5),
5320     MockRead(ASYNC, ERR_IO_PENDING, 7),  // Force a pause
5321   };
5322
5323   HttpResponseInfo response;
5324   HttpResponseInfo response2;
5325   std::string expected_push_result("pushed");
5326   OrderedSocketData data(reads, arraysize(reads),
5327                          writes, arraysize(writes));
5328   RunServerPushTest(&data,
5329                     &response,
5330                     &response2,
5331                     expected_push_result);
5332
5333   // Verify the SYN_REPLY.
5334   EXPECT_TRUE(response.headers.get() != NULL);
5335   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
5336
5337   // Verify the pushed stream.
5338   EXPECT_TRUE(response2.headers.get() != NULL);
5339   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
5340 }
5341
5342 TEST_P(SpdyNetworkTransactionTest, ServerPushClaimBeforeHeaders) {
5343   // We push a stream and attempt to claim it before the headers come down.
5344   scoped_ptr<SpdyFrame> stream1_syn(
5345       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
5346   scoped_ptr<SpdyFrame> stream1_body(
5347       spdy_util_.ConstructSpdyBodyFrame(1, true));
5348   MockWrite writes[] = {
5349     CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
5350   };
5351
5352   scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
5353   spdy_util_.AddUrlToHeaderBlock(
5354       "http://www.google.com/foo.dat", initial_headers.get());
5355   scoped_ptr<SpdyFrame> stream2_syn(
5356       spdy_util_.ConstructInitialSpdyPushFrame(initial_headers.Pass(), 2, 1));
5357
5358   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
5359   (*late_headers)["hello"] = "bye";
5360   (*late_headers)[spdy_util_.GetStatusKey()] = "200";
5361   (*late_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
5362   scoped_ptr<SpdyFrame> stream2_headers(
5363       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
5364                                            false,
5365                                            2,
5366                                            LOWEST,
5367                                            HEADERS,
5368                                            CONTROL_FLAG_NONE,
5369                                            0));
5370
5371   scoped_ptr<SpdyFrame>
5372       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
5373   const char kPushedData[] = "pushed";
5374   scoped_ptr<SpdyFrame> stream2_body(
5375       spdy_util_.ConstructSpdyBodyFrame(
5376           2, kPushedData, strlen(kPushedData), true));
5377   MockRead reads[] = {
5378     CreateMockRead(*stream1_reply, 1),
5379     CreateMockRead(*stream2_syn, 2),
5380     CreateMockRead(*stream1_body, 3),
5381     CreateMockRead(*stream2_headers, 4),
5382     CreateMockRead(*stream2_body, 5),
5383     MockRead(ASYNC, 0, 6),  // EOF
5384   };
5385
5386   HttpResponseInfo response;
5387   HttpResponseInfo response2;
5388   std::string expected_push_result("pushed");
5389   DeterministicSocketData data(reads, arraysize(reads),
5390                                writes, arraysize(writes));
5391
5392   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
5393                                      BoundNetLog(), GetParam(), NULL);
5394   helper.SetDeterministic();
5395   helper.AddDeterministicData(&data);
5396   helper.RunPreTestSetup();
5397
5398   HttpNetworkTransaction* trans = helper.trans();
5399
5400   // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM,
5401   // and the body of the primary stream, but before we've received the HEADERS
5402   // for the pushed stream.
5403   data.SetStop(3);
5404
5405   // Start the transaction.
5406   TestCompletionCallback callback;
5407   int rv = trans->Start(
5408       &CreateGetRequest(), callback.callback(), BoundNetLog());
5409   EXPECT_EQ(ERR_IO_PENDING, rv);
5410   data.Run();
5411   rv = callback.WaitForResult();
5412   EXPECT_EQ(0, rv);
5413
5414   // Request the pushed path.  At this point, we've received the push, but the
5415   // headers are not yet complete.
5416   scoped_ptr<HttpNetworkTransaction> trans2(
5417       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
5418   rv = trans2->Start(
5419       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
5420   EXPECT_EQ(ERR_IO_PENDING, rv);
5421   data.RunFor(3);
5422   base::RunLoop().RunUntilIdle();
5423
5424   // Read the server push body.
5425   std::string result2;
5426   ReadResult(trans2.get(), &data, &result2);
5427   // Read the response body.
5428   std::string result;
5429   ReadResult(trans, &data, &result);
5430
5431   // Verify that the received push data is same as the expected push data.
5432   EXPECT_EQ(result2.compare(expected_push_result), 0)
5433       << "Received data: "
5434       << result2
5435       << "||||| Expected data: "
5436       << expected_push_result;
5437
5438   // Verify the SYN_REPLY.
5439   // Copy the response info, because trans goes away.
5440   response = *trans->GetResponseInfo();
5441   response2 = *trans2->GetResponseInfo();
5442
5443   VerifyStreamsClosed(helper);
5444
5445   // Verify the SYN_REPLY.
5446   EXPECT_TRUE(response.headers.get() != NULL);
5447   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
5448
5449   // Verify the pushed stream.
5450   EXPECT_TRUE(response2.headers.get() != NULL);
5451   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
5452
5453   // Read the final EOF (which will close the session)
5454   data.RunFor(1);
5455
5456   // Verify that we consumed all test data.
5457   EXPECT_TRUE(data.at_read_eof());
5458   EXPECT_TRUE(data.at_write_eof());
5459 }
5460
5461 // TODO(baranovich): HTTP 2 does not allow multiple HEADERS frames
5462 TEST_P(SpdyNetworkTransactionTest, ServerPushWithTwoHeaderFrames) {
5463   // We push a stream and attempt to claim it before the headers come down.
5464   scoped_ptr<SpdyFrame> stream1_syn(
5465       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
5466   scoped_ptr<SpdyFrame> stream1_body(
5467       spdy_util_.ConstructSpdyBodyFrame(1, true));
5468   MockWrite writes[] = {
5469     CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
5470   };
5471
5472   scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
5473   if (spdy_util_.spdy_version() < SPDY4) {
5474     // In SPDY4 PUSH_PROMISE headers won't show up in the response headers.
5475     (*initial_headers)["alpha"] = "beta";
5476   }
5477   spdy_util_.AddUrlToHeaderBlock(
5478       "http://www.google.com/foo.dat", initial_headers.get());
5479   scoped_ptr<SpdyFrame> stream2_syn(
5480       spdy_util_.ConstructInitialSpdyPushFrame(initial_headers.Pass(), 2, 1));
5481
5482   scoped_ptr<SpdyHeaderBlock> middle_headers(new SpdyHeaderBlock());
5483   (*middle_headers)["hello"] = "bye";
5484   scoped_ptr<SpdyFrame> stream2_headers1(
5485       spdy_util_.ConstructSpdyControlFrame(middle_headers.Pass(),
5486                                            false,
5487                                            2,
5488                                            LOWEST,
5489                                            HEADERS,
5490                                            CONTROL_FLAG_NONE,
5491                                            0));
5492
5493   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
5494   (*late_headers)[spdy_util_.GetStatusKey()] = "200";
5495   if (spdy_util_.spdy_version() < SPDY4) {
5496     // SPDY4/HTTP2 eliminates use of the :version header.
5497     (*late_headers)[spdy_util_.GetVersionKey()] = "HTTP/1.1";
5498   }
5499   scoped_ptr<SpdyFrame> stream2_headers2(
5500       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
5501                                            false,
5502                                            2,
5503                                            LOWEST,
5504                                            HEADERS,
5505                                            CONTROL_FLAG_NONE,
5506                                            0));
5507
5508   scoped_ptr<SpdyFrame>
5509       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
5510   const char kPushedData[] = "pushed";
5511   scoped_ptr<SpdyFrame> stream2_body(
5512       spdy_util_.ConstructSpdyBodyFrame(
5513           2, kPushedData, strlen(kPushedData), true));
5514   MockRead reads[] = {
5515     CreateMockRead(*stream1_reply, 1),
5516     CreateMockRead(*stream2_syn, 2),
5517     CreateMockRead(*stream1_body, 3),
5518     CreateMockRead(*stream2_headers1, 4),
5519     CreateMockRead(*stream2_headers2, 5),
5520     CreateMockRead(*stream2_body, 6),
5521     MockRead(ASYNC, 0, 7),  // EOF
5522   };
5523
5524   HttpResponseInfo response;
5525   HttpResponseInfo response2;
5526   std::string expected_push_result("pushed");
5527   DeterministicSocketData data(reads, arraysize(reads),
5528                                writes, arraysize(writes));
5529
5530   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
5531                                      BoundNetLog(), GetParam(), NULL);
5532   helper.SetDeterministic();
5533   helper.AddDeterministicData(&data);
5534   helper.RunPreTestSetup();
5535
5536   HttpNetworkTransaction* trans = helper.trans();
5537
5538   // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM,
5539   // the first HEADERS frame, and the body of the primary stream, but before
5540   // we've received the final HEADERS for the pushed stream.
5541   data.SetStop(4);
5542
5543   // Start the transaction.
5544   TestCompletionCallback callback;
5545   int rv = trans->Start(
5546       &CreateGetRequest(), callback.callback(), BoundNetLog());
5547   EXPECT_EQ(ERR_IO_PENDING, rv);
5548   data.Run();
5549   rv = callback.WaitForResult();
5550   EXPECT_EQ(0, rv);
5551
5552   // Request the pushed path.  At this point, we've received the push, but the
5553   // headers are not yet complete.
5554   scoped_ptr<HttpNetworkTransaction> trans2(
5555       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
5556   rv = trans2->Start(
5557       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
5558   EXPECT_EQ(ERR_IO_PENDING, rv);
5559   data.RunFor(3);
5560   base::RunLoop().RunUntilIdle();
5561
5562   // Read the server push body.
5563   std::string result2;
5564   ReadResult(trans2.get(), &data, &result2);
5565   // Read the response body.
5566   std::string result;
5567   ReadResult(trans, &data, &result);
5568
5569   // Verify that the received push data is same as the expected push data.
5570   EXPECT_EQ(expected_push_result, result2);
5571
5572   // Verify the SYN_REPLY.
5573   // Copy the response info, because trans goes away.
5574   response = *trans->GetResponseInfo();
5575   response2 = *trans2->GetResponseInfo();
5576
5577   VerifyStreamsClosed(helper);
5578
5579   // Verify the SYN_REPLY.
5580   EXPECT_TRUE(response.headers.get() != NULL);
5581   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
5582
5583   // Verify the pushed stream.
5584   EXPECT_TRUE(response2.headers.get() != NULL);
5585   EXPECT_EQ("HTTP/1.1 200 OK", response2.headers->GetStatusLine());
5586
5587   // Verify we got all the headers from all header blocks.
5588   if (spdy_util_.spdy_version() < SPDY4)
5589     EXPECT_TRUE(response2.headers->HasHeaderValue("alpha", "beta"));
5590   EXPECT_TRUE(response2.headers->HasHeaderValue("hello", "bye"));
5591   EXPECT_TRUE(response2.headers->HasHeaderValue("status", "200"));
5592
5593   // Read the final EOF (which will close the session)
5594   data.RunFor(1);
5595
5596   // Verify that we consumed all test data.
5597   EXPECT_TRUE(data.at_read_eof());
5598   EXPECT_TRUE(data.at_write_eof());
5599 }
5600
5601 TEST_P(SpdyNetworkTransactionTest, ServerPushWithNoStatusHeaderFrames) {
5602   // We push a stream and attempt to claim it before the headers come down.
5603   scoped_ptr<SpdyFrame> stream1_syn(
5604       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
5605   scoped_ptr<SpdyFrame> stream1_body(
5606       spdy_util_.ConstructSpdyBodyFrame(1, true));
5607   MockWrite writes[] = {
5608     CreateMockWrite(*stream1_syn, 0, SYNCHRONOUS),
5609   };
5610
5611   scoped_ptr<SpdyHeaderBlock> initial_headers(new SpdyHeaderBlock());
5612   spdy_util_.AddUrlToHeaderBlock(
5613       "http://www.google.com/foo.dat", initial_headers.get());
5614   scoped_ptr<SpdyFrame> stream2_syn(
5615       spdy_util_.ConstructInitialSpdyPushFrame(initial_headers.Pass(), 2, 1));
5616
5617   scoped_ptr<SpdyHeaderBlock> middle_headers(new SpdyHeaderBlock());
5618   (*middle_headers)["hello"] = "bye";
5619   scoped_ptr<SpdyFrame> stream2_headers1(
5620       spdy_util_.ConstructSpdyControlFrame(middle_headers.Pass(),
5621                                            false,
5622                                            2,
5623                                            LOWEST,
5624                                            HEADERS,
5625                                            CONTROL_FLAG_NONE,
5626                                            0));
5627
5628   scoped_ptr<SpdyFrame>
5629       stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
5630   const char kPushedData[] = "pushed";
5631   scoped_ptr<SpdyFrame> stream2_body(
5632       spdy_util_.ConstructSpdyBodyFrame(
5633           2, kPushedData, strlen(kPushedData), true));
5634   MockRead reads[] = {
5635     CreateMockRead(*stream1_reply, 1),
5636     CreateMockRead(*stream2_syn, 2),
5637     CreateMockRead(*stream1_body, 3),
5638     CreateMockRead(*stream2_headers1, 4),
5639     CreateMockRead(*stream2_body, 5),
5640     MockRead(ASYNC, 0, 6),  // EOF
5641   };
5642
5643   DeterministicSocketData data(reads, arraysize(reads),
5644                                writes, arraysize(writes));
5645
5646   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
5647                                      BoundNetLog(), GetParam(), NULL);
5648   helper.SetDeterministic();
5649   helper.AddDeterministicData(&data);
5650   helper.RunPreTestSetup();
5651
5652   HttpNetworkTransaction* trans = helper.trans();
5653
5654   // Run until we've received the primary SYN_STREAM, the pushed SYN_STREAM,
5655   // the first HEADERS frame, and the body of the primary stream, but before
5656   // we've received the final HEADERS for the pushed stream.
5657   data.SetStop(4);
5658
5659   // Start the transaction.
5660   TestCompletionCallback callback;
5661   int rv = trans->Start(
5662       &CreateGetRequest(), callback.callback(), BoundNetLog());
5663   EXPECT_EQ(ERR_IO_PENDING, rv);
5664   data.Run();
5665   rv = callback.WaitForResult();
5666   EXPECT_EQ(0, rv);
5667
5668   // Request the pushed path.  At this point, we've received the push, but the
5669   // headers are not yet complete.
5670   scoped_ptr<HttpNetworkTransaction> trans2(
5671       new HttpNetworkTransaction(DEFAULT_PRIORITY, helper.session().get()));
5672   rv = trans2->Start(
5673       &CreateGetPushRequest(), callback.callback(), BoundNetLog());
5674   EXPECT_EQ(ERR_IO_PENDING, rv);
5675   data.RunFor(2);
5676   base::RunLoop().RunUntilIdle();
5677
5678   // Read the server push body.
5679   std::string result2;
5680   ReadResult(trans2.get(), &data, &result2);
5681   // Read the response body.
5682   std::string result;
5683   ReadResult(trans, &data, &result);
5684   EXPECT_EQ("hello!", result);
5685
5686   // Verify that we haven't received any push data.
5687   EXPECT_EQ("", result2);
5688
5689   // Verify the SYN_REPLY.
5690   // Copy the response info, because trans goes away.
5691   HttpResponseInfo response = *trans->GetResponseInfo();
5692   ASSERT_TRUE(trans2->GetResponseInfo() == NULL);
5693
5694   VerifyStreamsClosed(helper);
5695
5696   // Verify the SYN_REPLY.
5697   EXPECT_TRUE(response.headers.get() != NULL);
5698   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
5699
5700   // Read the final EOF (which will close the session).
5701   data.RunFor(1);
5702
5703   // Verify that we consumed all test data.
5704   EXPECT_TRUE(data.at_read_eof());
5705   EXPECT_TRUE(data.at_write_eof());
5706 }
5707
5708 TEST_P(SpdyNetworkTransactionTest, SynReplyWithHeaders) {
5709   scoped_ptr<SpdyFrame> req(
5710       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
5711   scoped_ptr<SpdyFrame> rst(
5712       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
5713   MockWrite writes[] = {
5714       CreateMockWrite(*req), CreateMockWrite(*rst),
5715   };
5716
5717   scoped_ptr<SpdyFrame> stream1_reply(
5718       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
5719
5720   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
5721   (*late_headers)["hello"] = "bye";
5722   scoped_ptr<SpdyFrame> stream1_headers(
5723       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
5724                                            false,
5725                                            1,
5726                                            LOWEST,
5727                                            HEADERS,
5728                                            CONTROL_FLAG_NONE,
5729                                            0));
5730   scoped_ptr<SpdyFrame> stream1_body(
5731       spdy_util_.ConstructSpdyBodyFrame(1, true));
5732   MockRead reads[] = {
5733     CreateMockRead(*stream1_reply),
5734     CreateMockRead(*stream1_headers),
5735     CreateMockRead(*stream1_body),
5736     MockRead(ASYNC, 0, 0)  // EOF
5737   };
5738
5739   DelayedSocketData data(1, reads, arraysize(reads),
5740                          writes, arraysize(writes));
5741   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
5742                                      BoundNetLog(), GetParam(), NULL);
5743   helper.RunToCompletion(&data);
5744   TransactionHelperResult out = helper.output();
5745   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
5746 }
5747
5748 TEST_P(SpdyNetworkTransactionTest, SynReplyWithLateHeaders) {
5749   scoped_ptr<SpdyFrame> req(
5750       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
5751   scoped_ptr<SpdyFrame> rst(
5752       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_PROTOCOL_ERROR));
5753   MockWrite writes[] = {
5754     CreateMockWrite(*req),
5755     CreateMockWrite(*rst),
5756   };
5757
5758   scoped_ptr<SpdyFrame> stream1_reply(
5759       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
5760
5761   scoped_ptr<SpdyHeaderBlock> late_headers(new SpdyHeaderBlock());
5762   (*late_headers)["hello"] = "bye";
5763   scoped_ptr<SpdyFrame> stream1_headers(
5764       spdy_util_.ConstructSpdyControlFrame(late_headers.Pass(),
5765                                            false,
5766                                            1,
5767                                            LOWEST,
5768                                            HEADERS,
5769                                            CONTROL_FLAG_NONE,
5770                                            0));
5771   scoped_ptr<SpdyFrame> stream1_body(
5772       spdy_util_.ConstructSpdyBodyFrame(1, false));
5773   scoped_ptr<SpdyFrame> stream1_body2(
5774       spdy_util_.ConstructSpdyBodyFrame(1, true));
5775   MockRead reads[] = {
5776     CreateMockRead(*stream1_reply),
5777     CreateMockRead(*stream1_body),
5778     CreateMockRead(*stream1_headers),
5779     CreateMockRead(*stream1_body2),
5780     MockRead(ASYNC, 0, 0)  // EOF
5781   };
5782
5783   DelayedSocketData data(1, reads, arraysize(reads),
5784                          writes, arraysize(writes));
5785   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
5786                                      BoundNetLog(), GetParam(), NULL);
5787   helper.RunToCompletion(&data);
5788   TransactionHelperResult out = helper.output();
5789   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
5790 }
5791
5792 TEST_P(SpdyNetworkTransactionTest, ServerPushCrossOriginCorrectness) {
5793   // In this test we want to verify that we can't accidentally push content
5794   // which can't be pushed by this content server.
5795   // This test assumes that:
5796   //   - if we're requesting http://www.foo.com/barbaz
5797   //   - the browser has made a connection to "www.foo.com".
5798
5799   // A list of the URL to fetch, followed by the URL being pushed.
5800   static const char* const kTestCases[] = {
5801     "http://www.google.com/foo.html",
5802     "http://www.google.com:81/foo.js",     // Bad port
5803
5804     "http://www.google.com/foo.html",
5805     "https://www.google.com/foo.js",       // Bad protocol
5806
5807     "http://www.google.com/foo.html",
5808     "ftp://www.google.com/foo.js",         // Invalid Protocol
5809
5810     "http://www.google.com/foo.html",
5811     "http://blat.www.google.com/foo.js",   // Cross subdomain
5812
5813     "http://www.google.com/foo.html",
5814     "http://www.foo.com/foo.js",           // Cross domain
5815   };
5816
5817   for (size_t index = 0; index < arraysize(kTestCases); index += 2) {
5818     const char* url_to_fetch = kTestCases[index];
5819     const char* url_to_push = kTestCases[index + 1];
5820
5821     scoped_ptr<SpdyFrame> stream1_syn(
5822         spdy_util_.ConstructSpdyGet(url_to_fetch, false, 1, LOWEST));
5823     scoped_ptr<SpdyFrame> stream1_body(
5824         spdy_util_.ConstructSpdyBodyFrame(1, true));
5825     scoped_ptr<SpdyFrame> push_rst(
5826         spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_REFUSED_STREAM));
5827     MockWrite writes[] = {
5828       CreateMockWrite(*stream1_syn, 1),
5829       CreateMockWrite(*push_rst, 4),
5830     };
5831
5832     scoped_ptr<SpdyFrame>
5833         stream1_reply(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
5834     scoped_ptr<SpdyFrame>
5835         stream2_syn(spdy_util_.ConstructSpdyPush(NULL,
5836                                                  0,
5837                                                  2,
5838                                                  1,
5839                                                  url_to_push));
5840     const char kPushedData[] = "pushed";
5841     scoped_ptr<SpdyFrame> stream2_body(
5842         spdy_util_.ConstructSpdyBodyFrame(
5843             2, kPushedData, strlen(kPushedData), true));
5844     scoped_ptr<SpdyFrame> rst(
5845         spdy_util_.ConstructSpdyRstStream(2, RST_STREAM_CANCEL));
5846
5847     MockRead reads[] = {
5848       CreateMockRead(*stream1_reply, 2),
5849       CreateMockRead(*stream2_syn, 3),
5850       CreateMockRead(*stream1_body, 5, SYNCHRONOUS),
5851       CreateMockRead(*stream2_body, 6),
5852       MockRead(ASYNC, ERR_IO_PENDING, 7),  // Force a pause
5853     };
5854
5855     HttpResponseInfo response;
5856     OrderedSocketData data(reads, arraysize(reads),
5857                            writes, arraysize(writes));
5858
5859     HttpRequestInfo request;
5860     request.method = "GET";
5861     request.url = GURL(url_to_fetch);
5862     request.load_flags = 0;
5863
5864     // Enable cross-origin push. Since we are not using a proxy, this should
5865     // not actually enable cross-origin SPDY push.
5866     scoped_ptr<SpdySessionDependencies> session_deps(
5867         CreateSpdySessionDependencies(GetParam()));
5868     session_deps->trusted_spdy_proxy = "123.45.67.89:8080";
5869     NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
5870                                        BoundNetLog(), GetParam(),
5871                                        session_deps.release());
5872     helper.RunPreTestSetup();
5873     helper.AddData(&data);
5874
5875     HttpNetworkTransaction* trans = helper.trans();
5876
5877     // Start the transaction with basic parameters.
5878     TestCompletionCallback callback;
5879
5880     int rv = trans->Start(&request, callback.callback(), BoundNetLog());
5881     EXPECT_EQ(ERR_IO_PENDING, rv);
5882     rv = callback.WaitForResult();
5883
5884     // Read the response body.
5885     std::string result;
5886     ReadResult(trans, &data, &result);
5887
5888     // Verify that we consumed all test data.
5889     EXPECT_TRUE(data.at_read_eof());
5890     EXPECT_TRUE(data.at_write_eof());
5891
5892     // Verify the SYN_REPLY.
5893     // Copy the response info, because trans goes away.
5894     response = *trans->GetResponseInfo();
5895
5896     VerifyStreamsClosed(helper);
5897
5898     // Verify the SYN_REPLY.
5899     EXPECT_TRUE(response.headers.get() != NULL);
5900     EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
5901   }
5902 }
5903
5904 TEST_P(SpdyNetworkTransactionTest, RetryAfterRefused) {
5905   // Construct the request.
5906   scoped_ptr<SpdyFrame> req(
5907       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
5908   scoped_ptr<SpdyFrame> req2(
5909       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, LOWEST, true));
5910   MockWrite writes[] = {
5911     CreateMockWrite(*req, 1),
5912     CreateMockWrite(*req2, 3),
5913   };
5914
5915   scoped_ptr<SpdyFrame> refused(
5916       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_REFUSED_STREAM));
5917   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
5918   scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(3, true));
5919   MockRead reads[] = {
5920     CreateMockRead(*refused, 2),
5921     CreateMockRead(*resp, 4),
5922     CreateMockRead(*body, 5),
5923     MockRead(ASYNC, 0, 6)  // EOF
5924   };
5925
5926   OrderedSocketData data(reads, arraysize(reads),
5927                          writes, arraysize(writes));
5928   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
5929                                      BoundNetLog(), GetParam(), NULL);
5930
5931   helper.RunPreTestSetup();
5932   helper.AddData(&data);
5933
5934   HttpNetworkTransaction* trans = helper.trans();
5935
5936   // Start the transaction with basic parameters.
5937   TestCompletionCallback callback;
5938   int rv = trans->Start(
5939       &CreateGetRequest(), callback.callback(), BoundNetLog());
5940   EXPECT_EQ(ERR_IO_PENDING, rv);
5941   rv = callback.WaitForResult();
5942   EXPECT_EQ(OK, rv);
5943
5944   // Verify that we consumed all test data.
5945   EXPECT_TRUE(data.at_read_eof()) << "Read count: "
5946                                    << data.read_count()
5947                                    << " Read index: "
5948                                    << data.read_index();
5949   EXPECT_TRUE(data.at_write_eof()) << "Write count: "
5950                                     << data.write_count()
5951                                     << " Write index: "
5952                                     << data.write_index();
5953
5954   // Verify the SYN_REPLY.
5955   HttpResponseInfo response = *trans->GetResponseInfo();
5956   EXPECT_TRUE(response.headers.get() != NULL);
5957   EXPECT_EQ("HTTP/1.1 200 OK", response.headers->GetStatusLine());
5958 }
5959
5960 TEST_P(SpdyNetworkTransactionTest, OutOfOrderSynStream) {
5961   // This first request will start to establish the SpdySession.
5962   // Then we will start the second (MEDIUM priority) and then third
5963   // (HIGHEST priority) request in such a way that the third will actually
5964   // start before the second, causing the second to be numbered differently
5965   // than the order they were created.
5966   scoped_ptr<SpdyFrame> req1(
5967       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
5968   scoped_ptr<SpdyFrame> req2(
5969       spdy_util_.ConstructSpdyGet(NULL, 0, false, 3, HIGHEST, true));
5970   scoped_ptr<SpdyFrame> req3(
5971       spdy_util_.ConstructSpdyGet(NULL, 0, false, 5, MEDIUM, true));
5972   MockWrite writes[] = {
5973     CreateMockWrite(*req1, 0),
5974     CreateMockWrite(*req2, 3),
5975     CreateMockWrite(*req3, 4),
5976   };
5977
5978   scoped_ptr<SpdyFrame> resp1(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
5979   scoped_ptr<SpdyFrame> body1(spdy_util_.ConstructSpdyBodyFrame(1, true));
5980   scoped_ptr<SpdyFrame> resp2(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 3));
5981   scoped_ptr<SpdyFrame> body2(spdy_util_.ConstructSpdyBodyFrame(3, true));
5982   scoped_ptr<SpdyFrame> resp3(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 5));
5983   scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(5, true));
5984   MockRead reads[] = {
5985     CreateMockRead(*resp1, 1),
5986     CreateMockRead(*body1, 2),
5987     CreateMockRead(*resp2, 5),
5988     CreateMockRead(*body2, 6),
5989     CreateMockRead(*resp3, 7),
5990     CreateMockRead(*body3, 8),
5991     MockRead(ASYNC, 0, 9)  // EOF
5992   };
5993
5994   DeterministicSocketData data(reads, arraysize(reads),
5995                                writes, arraysize(writes));
5996   NormalSpdyTransactionHelper helper(CreateGetRequest(), LOWEST,
5997                                      BoundNetLog(), GetParam(), NULL);
5998   helper.SetDeterministic();
5999   helper.RunPreTestSetup();
6000   helper.AddDeterministicData(&data);
6001
6002   // Start the first transaction to set up the SpdySession
6003   HttpNetworkTransaction* trans = helper.trans();
6004   TestCompletionCallback callback;
6005   HttpRequestInfo info1 = CreateGetRequest();
6006   int rv = trans->Start(&info1, callback.callback(), BoundNetLog());
6007   EXPECT_EQ(ERR_IO_PENDING, rv);
6008
6009   // Run the message loop, but do not allow the write to complete.
6010   // This leaves the SpdySession with a write pending, which prevents
6011   // SpdySession from attempting subsequent writes until this write completes.
6012   base::RunLoop().RunUntilIdle();
6013
6014   // Now, start both new transactions
6015   HttpRequestInfo info2 = CreateGetRequest();
6016   TestCompletionCallback callback2;
6017   scoped_ptr<HttpNetworkTransaction> trans2(
6018       new HttpNetworkTransaction(MEDIUM, helper.session().get()));
6019   rv = trans2->Start(&info2, callback2.callback(), BoundNetLog());
6020   EXPECT_EQ(ERR_IO_PENDING, rv);
6021   base::RunLoop().RunUntilIdle();
6022
6023   HttpRequestInfo info3 = CreateGetRequest();
6024   TestCompletionCallback callback3;
6025   scoped_ptr<HttpNetworkTransaction> trans3(
6026       new HttpNetworkTransaction(HIGHEST, helper.session().get()));
6027   rv = trans3->Start(&info3, callback3.callback(), BoundNetLog());
6028   EXPECT_EQ(ERR_IO_PENDING, rv);
6029   base::RunLoop().RunUntilIdle();
6030
6031   // We now have two SYN_STREAM frames queued up which will be
6032   // dequeued only once the first write completes, which we
6033   // now allow to happen.
6034   data.RunFor(2);
6035   EXPECT_EQ(OK, callback.WaitForResult());
6036
6037   // And now we can allow everything else to run to completion.
6038   data.SetStop(10);
6039   data.Run();
6040   EXPECT_EQ(OK, callback2.WaitForResult());
6041   EXPECT_EQ(OK, callback3.WaitForResult());
6042
6043   helper.VerifyDataConsumed();
6044 }
6045
6046 // The tests below are only for SPDY/3 and above.
6047
6048 // Test that sent data frames and received WINDOW_UPDATE frames change
6049 // the send_window_size_ correctly.
6050
6051 // WINDOW_UPDATE is different than most other frames in that it can arrive
6052 // while the client is still sending the request body.  In order to enforce
6053 // this scenario, we feed a couple of dummy frames and give a delay of 0 to
6054 // socket data provider, so that initial read that is done as soon as the
6055 // stream is created, succeeds and schedules another read.  This way reads
6056 // and writes are interleaved; after doing a full frame write, SpdyStream
6057 // will break out of DoLoop and will read and process a WINDOW_UPDATE.
6058 // Once our WINDOW_UPDATE is read, we cannot send SYN_REPLY right away
6059 // since request has not been completely written, therefore we feed
6060 // enough number of WINDOW_UPDATEs to finish the first read and cause a
6061 // write, leading to a complete write of request body; after that we send
6062 // a reply with a body, to cause a graceful shutdown.
6063
6064 // TODO(agayev): develop a socket data provider where both, reads and
6065 // writes are ordered so that writing tests like these are easy and rewrite
6066 // all these tests using it.  Right now we are working around the
6067 // limitations as described above and it's not deterministic, tests may
6068 // fail under specific circumstances.
6069 TEST_P(SpdyNetworkTransactionTest, WindowUpdateReceived) {
6070   static int kFrameCount = 2;
6071   scoped_ptr<std::string> content(
6072       new std::string(kMaxSpdyFrameChunkSize, 'a'));
6073   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
6074       kRequestUrl, 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, NULL, 0));
6075   scoped_ptr<SpdyFrame> body(
6076       spdy_util_.ConstructSpdyBodyFrame(
6077           1, content->c_str(), content->size(), false));
6078   scoped_ptr<SpdyFrame> body_end(
6079       spdy_util_.ConstructSpdyBodyFrame(
6080           1, content->c_str(), content->size(), true));
6081
6082   MockWrite writes[] = {
6083     CreateMockWrite(*req, 0),
6084     CreateMockWrite(*body, 1),
6085     CreateMockWrite(*body_end, 2),
6086   };
6087
6088   static const int32 kDeltaWindowSize = 0xff;
6089   static const int kDeltaCount = 4;
6090   scoped_ptr<SpdyFrame> window_update(
6091       spdy_util_.ConstructSpdyWindowUpdate(1, kDeltaWindowSize));
6092   scoped_ptr<SpdyFrame> window_update_dummy(
6093       spdy_util_.ConstructSpdyWindowUpdate(2, kDeltaWindowSize));
6094   scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
6095   MockRead reads[] = {
6096     CreateMockRead(*window_update_dummy, 3),
6097     CreateMockRead(*window_update_dummy, 4),
6098     CreateMockRead(*window_update_dummy, 5),
6099     CreateMockRead(*window_update, 6),     // Four updates, therefore window
6100     CreateMockRead(*window_update, 7),     // size should increase by
6101     CreateMockRead(*window_update, 8),     // kDeltaWindowSize * 4
6102     CreateMockRead(*window_update, 9),
6103     CreateMockRead(*resp, 10),
6104     CreateMockRead(*body_end, 11),
6105     MockRead(ASYNC, 0, 0, 12)  // EOF
6106   };
6107
6108   DeterministicSocketData data(reads, arraysize(reads),
6109                                writes, arraysize(writes));
6110
6111   ScopedVector<UploadElementReader> element_readers;
6112   for (int i = 0; i < kFrameCount; ++i) {
6113     element_readers.push_back(
6114         new UploadBytesElementReader(content->c_str(), content->size()));
6115   }
6116   ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
6117
6118   // Setup the request
6119   HttpRequestInfo request;
6120   request.method = "POST";
6121   request.url = GURL(kDefaultURL);
6122   request.upload_data_stream = &upload_data_stream;
6123
6124   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
6125                                      BoundNetLog(), GetParam(), NULL);
6126   helper.SetDeterministic();
6127   helper.AddDeterministicData(&data);
6128   helper.RunPreTestSetup();
6129
6130   HttpNetworkTransaction* trans = helper.trans();
6131
6132   TestCompletionCallback callback;
6133   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
6134
6135   EXPECT_EQ(ERR_IO_PENDING, rv);
6136
6137   data.RunFor(11);
6138
6139   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
6140   ASSERT_TRUE(stream != NULL);
6141   ASSERT_TRUE(stream->stream() != NULL);
6142   EXPECT_EQ(
6143       static_cast<int>(SpdySession::GetInitialWindowSize(GetParam().protocol)) +
6144           kDeltaWindowSize * kDeltaCount - kMaxSpdyFrameChunkSize * kFrameCount,
6145       stream->stream()->send_window_size());
6146
6147   data.RunFor(1);
6148
6149   rv = callback.WaitForResult();
6150   EXPECT_EQ(OK, rv);
6151
6152   helper.VerifyDataConsumed();
6153 }
6154
6155 // Test that received data frames and sent WINDOW_UPDATE frames change
6156 // the recv_window_size_ correctly.
6157 TEST_P(SpdyNetworkTransactionTest, WindowUpdateSent) {
6158   const int32 initial_window_size =
6159       SpdySession::GetInitialWindowSize(GetParam().protocol);
6160   // Amount of body required to trigger a sent window update.
6161   const size_t kTargetSize = initial_window_size / 2 + 1;
6162
6163   scoped_ptr<SpdyFrame> req(
6164       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
6165   scoped_ptr<SpdyFrame> session_window_update(
6166       spdy_util_.ConstructSpdyWindowUpdate(0, kTargetSize));
6167   scoped_ptr<SpdyFrame> window_update(
6168       spdy_util_.ConstructSpdyWindowUpdate(1, kTargetSize));
6169
6170   std::vector<MockWrite> writes;
6171   writes.push_back(CreateMockWrite(*req));
6172   if (GetParam().protocol >= kProtoSPDY31)
6173     writes.push_back(CreateMockWrite(*session_window_update));
6174   writes.push_back(CreateMockWrite(*window_update));
6175
6176   std::vector<MockRead> reads;
6177   scoped_ptr<SpdyFrame> resp(
6178       spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
6179   reads.push_back(CreateMockRead(*resp));
6180
6181   ScopedVector<SpdyFrame> body_frames;
6182   const std::string body_data(4096, 'x');
6183   for (size_t remaining = kTargetSize; remaining != 0;) {
6184     size_t frame_size = std::min(remaining, body_data.size());
6185     body_frames.push_back(spdy_util_.ConstructSpdyBodyFrame(
6186         1, body_data.data(), frame_size, false));
6187     reads.push_back(CreateMockRead(*body_frames.back()));
6188     remaining -= frame_size;
6189   }
6190   reads.push_back(MockRead(ASYNC, ERR_IO_PENDING, 0));  // Yield.
6191
6192   DelayedSocketData data(1, vector_as_array(&reads), reads.size(),
6193                          vector_as_array(&writes), writes.size());
6194
6195   NormalSpdyTransactionHelper helper(CreateGetRequest(), DEFAULT_PRIORITY,
6196                                      BoundNetLog(), GetParam(), NULL);
6197   helper.AddData(&data);
6198   helper.RunPreTestSetup();
6199   HttpNetworkTransaction* trans = helper.trans();
6200
6201   TestCompletionCallback callback;
6202   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
6203
6204   EXPECT_EQ(ERR_IO_PENDING, rv);
6205   rv = callback.WaitForResult();
6206   EXPECT_EQ(OK, rv);
6207
6208   SpdyHttpStream* stream =
6209       static_cast<SpdyHttpStream*>(trans->stream_.get());
6210   ASSERT_TRUE(stream != NULL);
6211   ASSERT_TRUE(stream->stream() != NULL);
6212
6213   // All data has been read, but not consumed. The window reflects this.
6214   EXPECT_EQ(static_cast<int>(initial_window_size - kTargetSize),
6215             stream->stream()->recv_window_size());
6216
6217   const HttpResponseInfo* response = trans->GetResponseInfo();
6218   ASSERT_TRUE(response != NULL);
6219   ASSERT_TRUE(response->headers.get() != NULL);
6220   EXPECT_EQ("HTTP/1.1 200 OK", response->headers->GetStatusLine());
6221   EXPECT_TRUE(response->was_fetched_via_spdy);
6222
6223   // Issue a read which will cause a WINDOW_UPDATE to be sent and window
6224   // size increased to default.
6225   scoped_refptr<net::IOBuffer> buf(new net::IOBuffer(kTargetSize));
6226   EXPECT_EQ(static_cast<int>(kTargetSize),
6227             trans->Read(buf.get(), kTargetSize, CompletionCallback()));
6228   EXPECT_EQ(static_cast<int>(initial_window_size),
6229             stream->stream()->recv_window_size());
6230   EXPECT_THAT(base::StringPiece(buf->data(), kTargetSize), Each(Eq('x')));
6231
6232   // Allow scheduled WINDOW_UPDATE frames to write.
6233   base::RunLoop().RunUntilIdle();
6234   helper.VerifyDataConsumed();
6235 }
6236
6237 // Test that WINDOW_UPDATE frame causing overflow is handled correctly.
6238 TEST_P(SpdyNetworkTransactionTest, WindowUpdateOverflow) {
6239   // Number of full frames we hope to write (but will not, used to
6240   // set content-length header correctly)
6241   static int kFrameCount = 3;
6242
6243   scoped_ptr<std::string> content(
6244       new std::string(kMaxSpdyFrameChunkSize, 'a'));
6245   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
6246       kRequestUrl, 1, kMaxSpdyFrameChunkSize * kFrameCount, LOWEST, NULL, 0));
6247   scoped_ptr<SpdyFrame> body(
6248       spdy_util_.ConstructSpdyBodyFrame(
6249           1, content->c_str(), content->size(), false));
6250   scoped_ptr<SpdyFrame> rst(
6251       spdy_util_.ConstructSpdyRstStream(1, RST_STREAM_FLOW_CONTROL_ERROR));
6252
6253   // We're not going to write a data frame with FIN, we'll receive a bad
6254   // WINDOW_UPDATE while sending a request and will send a RST_STREAM frame.
6255   MockWrite writes[] = {
6256     CreateMockWrite(*req, 0),
6257     CreateMockWrite(*body, 2),
6258     CreateMockWrite(*rst, 3),
6259   };
6260
6261   static const int32 kDeltaWindowSize = 0x7fffffff;  // cause an overflow
6262   scoped_ptr<SpdyFrame> window_update(
6263       spdy_util_.ConstructSpdyWindowUpdate(1, kDeltaWindowSize));
6264   MockRead reads[] = {
6265     CreateMockRead(*window_update, 1),
6266     MockRead(ASYNC, 0, 4)  // EOF
6267   };
6268
6269   DeterministicSocketData data(reads, arraysize(reads),
6270                                writes, arraysize(writes));
6271
6272   ScopedVector<UploadElementReader> element_readers;
6273   for (int i = 0; i < kFrameCount; ++i) {
6274     element_readers.push_back(
6275         new UploadBytesElementReader(content->c_str(), content->size()));
6276   }
6277   ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
6278
6279   // Setup the request
6280   HttpRequestInfo request;
6281   request.method = "POST";
6282   request.url = GURL("http://www.google.com/");
6283   request.upload_data_stream = &upload_data_stream;
6284
6285   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
6286                                      BoundNetLog(), GetParam(), NULL);
6287   helper.SetDeterministic();
6288   helper.RunPreTestSetup();
6289   helper.AddDeterministicData(&data);
6290   HttpNetworkTransaction* trans = helper.trans();
6291
6292   TestCompletionCallback callback;
6293   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
6294   ASSERT_EQ(ERR_IO_PENDING, rv);
6295
6296   data.RunFor(5);
6297   ASSERT_TRUE(callback.have_result());
6298   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, callback.WaitForResult());
6299   helper.VerifyDataConsumed();
6300 }
6301
6302 // Test that after hitting a send window size of 0, the write process
6303 // stalls and upon receiving WINDOW_UPDATE frame write resumes.
6304
6305 // This test constructs a POST request followed by enough data frames
6306 // containing 'a' that would make the window size 0, followed by another
6307 // data frame containing default content (which is "hello!") and this frame
6308 // also contains a FIN flag.  DelayedSocketData is used to enforce all
6309 // writes go through before a read could happen.  However, the last frame
6310 // ("hello!")  is not supposed to go through since by the time its turn
6311 // arrives, window size is 0.  At this point MessageLoop::Run() called via
6312 // callback would block.  Therefore we call MessageLoop::RunUntilIdle()
6313 // which returns after performing all possible writes.  We use DCHECKS to
6314 // ensure that last data frame is still there and stream has stalled.
6315 // After that, next read is artifically enforced, which causes a
6316 // WINDOW_UPDATE to be read and I/O process resumes.
6317 TEST_P(SpdyNetworkTransactionTest, FlowControlStallResume) {
6318   const int32 initial_window_size =
6319       SpdySession::GetInitialWindowSize(GetParam().protocol);
6320   // Number of frames we need to send to zero out the window size: data
6321   // frames plus SYN_STREAM plus the last data frame; also we need another
6322   // data frame that we will send once the WINDOW_UPDATE is received,
6323   // therefore +3.
6324   size_t num_writes = initial_window_size / kMaxSpdyFrameChunkSize + 3;
6325
6326   // Calculate last frame's size; 0 size data frame is legal.
6327   size_t last_frame_size = initial_window_size % kMaxSpdyFrameChunkSize;
6328
6329   // Construct content for a data frame of maximum size.
6330   std::string content(kMaxSpdyFrameChunkSize, 'a');
6331
6332   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
6333       kRequestUrl, 1, initial_window_size + kUploadDataSize, LOWEST, NULL, 0));
6334
6335   // Full frames.
6336   scoped_ptr<SpdyFrame> body1(
6337       spdy_util_.ConstructSpdyBodyFrame(
6338           1, content.c_str(), content.size(), false));
6339
6340   // Last frame to zero out the window size.
6341   scoped_ptr<SpdyFrame> body2(
6342       spdy_util_.ConstructSpdyBodyFrame(
6343           1, content.c_str(), last_frame_size, false));
6344
6345   // Data frame to be sent once WINDOW_UPDATE frame is received.
6346   scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(1, true));
6347
6348   // Fill in mock writes.
6349   scoped_ptr<MockWrite[]> writes(new MockWrite[num_writes]);
6350   size_t i = 0;
6351   writes[i] = CreateMockWrite(*req);
6352   for (i = 1; i < num_writes - 2; i++)
6353     writes[i] = CreateMockWrite(*body1);
6354   writes[i++] = CreateMockWrite(*body2);
6355   writes[i] = CreateMockWrite(*body3);
6356
6357   // Construct read frame, give enough space to upload the rest of the
6358   // data.
6359   scoped_ptr<SpdyFrame> session_window_update(
6360       spdy_util_.ConstructSpdyWindowUpdate(0, kUploadDataSize));
6361   scoped_ptr<SpdyFrame> window_update(
6362       spdy_util_.ConstructSpdyWindowUpdate(1, kUploadDataSize));
6363   scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
6364   MockRead reads[] = {
6365     CreateMockRead(*session_window_update),
6366     CreateMockRead(*session_window_update),
6367     CreateMockRead(*window_update),
6368     CreateMockRead(*window_update),
6369     CreateMockRead(*reply),
6370     CreateMockRead(*body2),
6371     CreateMockRead(*body3),
6372     MockRead(ASYNC, 0, 0)  // EOF
6373   };
6374
6375   // Skip the session window updates unless we're using SPDY/3.1 and
6376   // above.
6377   size_t read_offset = (GetParam().protocol >= kProtoSPDY31) ? 0 : 2;
6378   size_t num_reads = arraysize(reads) - read_offset;
6379
6380   // Force all writes to happen before any read, last write will not
6381   // actually queue a frame, due to window size being 0.
6382   DelayedSocketData data(num_writes, reads + read_offset, num_reads,
6383                          writes.get(), num_writes);
6384
6385   ScopedVector<UploadElementReader> element_readers;
6386   std::string upload_data_string(initial_window_size, 'a');
6387   upload_data_string.append(kUploadData, kUploadDataSize);
6388   element_readers.push_back(new UploadBytesElementReader(
6389       upload_data_string.c_str(), upload_data_string.size()));
6390   ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
6391
6392   HttpRequestInfo request;
6393   request.method = "POST";
6394   request.url = GURL("http://www.google.com/");
6395   request.upload_data_stream = &upload_data_stream;
6396   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
6397                                      BoundNetLog(), GetParam(), NULL);
6398   helper.AddData(&data);
6399   helper.RunPreTestSetup();
6400
6401   HttpNetworkTransaction* trans = helper.trans();
6402
6403   TestCompletionCallback callback;
6404   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
6405   EXPECT_EQ(ERR_IO_PENDING, rv);
6406
6407   base::RunLoop().RunUntilIdle();  // Write as much as we can.
6408
6409   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
6410   ASSERT_TRUE(stream != NULL);
6411   ASSERT_TRUE(stream->stream() != NULL);
6412   EXPECT_EQ(0, stream->stream()->send_window_size());
6413   // All the body data should have been read.
6414   // TODO(satorux): This is because of the weirdness in reading the request
6415   // body in OnSendBodyComplete(). See crbug.com/113107.
6416   EXPECT_TRUE(upload_data_stream.IsEOF());
6417   // But the body is not yet fully sent (kUploadData is not yet sent)
6418   // since we're send-stalled.
6419   EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control());
6420
6421   data.ForceNextRead();   // Read in WINDOW_UPDATE frame.
6422   rv = callback.WaitForResult();
6423   helper.VerifyDataConsumed();
6424 }
6425
6426 // Test we correctly handle the case where the SETTINGS frame results in
6427 // unstalling the send window.
6428 TEST_P(SpdyNetworkTransactionTest, FlowControlStallResumeAfterSettings) {
6429   const int32 initial_window_size =
6430       SpdySession::GetInitialWindowSize(GetParam().protocol);
6431
6432   // Number of frames we need to send to zero out the window size: data
6433   // frames plus SYN_STREAM plus the last data frame; also we need another
6434   // data frame that we will send once the SETTING is received, therefore +3.
6435   size_t num_writes = initial_window_size / kMaxSpdyFrameChunkSize + 3;
6436
6437   // Calculate last frame's size; 0 size data frame is legal.
6438   size_t last_frame_size = initial_window_size % kMaxSpdyFrameChunkSize;
6439
6440   // Construct content for a data frame of maximum size.
6441   std::string content(kMaxSpdyFrameChunkSize, 'a');
6442
6443   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
6444       kRequestUrl, 1, initial_window_size + kUploadDataSize, LOWEST, NULL, 0));
6445
6446   // Full frames.
6447   scoped_ptr<SpdyFrame> body1(
6448       spdy_util_.ConstructSpdyBodyFrame(
6449           1, content.c_str(), content.size(), false));
6450
6451   // Last frame to zero out the window size.
6452   scoped_ptr<SpdyFrame> body2(
6453       spdy_util_.ConstructSpdyBodyFrame(
6454           1, content.c_str(), last_frame_size, false));
6455
6456   // Data frame to be sent once SETTINGS frame is received.
6457   scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(1, true));
6458
6459   // Fill in mock reads/writes.
6460   std::vector<MockRead> reads;
6461   std::vector<MockWrite> writes;
6462   size_t i = 0;
6463   writes.push_back(CreateMockWrite(*req, i++));
6464   while (i < num_writes - 2)
6465     writes.push_back(CreateMockWrite(*body1, i++));
6466   writes.push_back(CreateMockWrite(*body2, i++));
6467
6468   // Construct read frame for SETTINGS that gives enough space to upload the
6469   // rest of the data.
6470   SettingsMap settings;
6471   settings[SETTINGS_INITIAL_WINDOW_SIZE] =
6472       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, initial_window_size * 2);
6473   scoped_ptr<SpdyFrame> settings_frame_large(
6474       spdy_util_.ConstructSpdySettings(settings));
6475
6476   reads.push_back(CreateMockRead(*settings_frame_large, i++));
6477
6478   scoped_ptr<SpdyFrame> session_window_update(
6479       spdy_util_.ConstructSpdyWindowUpdate(0, kUploadDataSize));
6480   if (GetParam().protocol >= kProtoSPDY31)
6481     reads.push_back(CreateMockRead(*session_window_update, i++));
6482
6483   scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
6484   writes.push_back(CreateMockWrite(*settings_ack, i++));
6485
6486   writes.push_back(CreateMockWrite(*body3, i++));
6487
6488   scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
6489   reads.push_back(CreateMockRead(*reply, i++));
6490   reads.push_back(CreateMockRead(*body2, i++));
6491   reads.push_back(CreateMockRead(*body3, i++));
6492   reads.push_back(MockRead(ASYNC, 0, i++));  // EOF
6493
6494   // Force all writes to happen before any read, last write will not
6495   // actually queue a frame, due to window size being 0.
6496   DeterministicSocketData data(vector_as_array(&reads), reads.size(),
6497                                vector_as_array(&writes), writes.size());
6498
6499   ScopedVector<UploadElementReader> element_readers;
6500   std::string upload_data_string(initial_window_size, 'a');
6501   upload_data_string.append(kUploadData, kUploadDataSize);
6502   element_readers.push_back(new UploadBytesElementReader(
6503       upload_data_string.c_str(), upload_data_string.size()));
6504   ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
6505
6506   HttpRequestInfo request;
6507   request.method = "POST";
6508   request.url = GURL("http://www.google.com/");
6509   request.upload_data_stream = &upload_data_stream;
6510   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
6511                                      BoundNetLog(), GetParam(), NULL);
6512   helper.SetDeterministic();
6513   helper.RunPreTestSetup();
6514   helper.AddDeterministicData(&data);
6515
6516   HttpNetworkTransaction* trans = helper.trans();
6517
6518   TestCompletionCallback callback;
6519   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
6520   EXPECT_EQ(ERR_IO_PENDING, rv);
6521
6522   data.RunFor(num_writes - 1);   // Write as much as we can.
6523
6524   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
6525   ASSERT_TRUE(stream != NULL);
6526   ASSERT_TRUE(stream->stream() != NULL);
6527   EXPECT_EQ(0, stream->stream()->send_window_size());
6528
6529   // All the body data should have been read.
6530   // TODO(satorux): This is because of the weirdness in reading the request
6531   // body in OnSendBodyComplete(). See crbug.com/113107.
6532   EXPECT_TRUE(upload_data_stream.IsEOF());
6533   // But the body is not yet fully sent (kUploadData is not yet sent)
6534   // since we're send-stalled.
6535   EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control());
6536
6537   data.RunFor(7);   // Read in SETTINGS frame to unstall.
6538   rv = callback.WaitForResult();
6539   helper.VerifyDataConsumed();
6540   // If stream is NULL, that means it was unstalled and closed.
6541   EXPECT_TRUE(stream->stream() == NULL);
6542 }
6543
6544 // Test we correctly handle the case where the SETTINGS frame results in a
6545 // negative send window size.
6546 TEST_P(SpdyNetworkTransactionTest, FlowControlNegativeSendWindowSize) {
6547   const int32 initial_window_size =
6548       SpdySession::GetInitialWindowSize(GetParam().protocol);
6549   // Number of frames we need to send to zero out the window size: data
6550   // frames plus SYN_STREAM plus the last data frame; also we need another
6551   // data frame that we will send once the SETTING is received, therefore +3.
6552   size_t num_writes = initial_window_size / kMaxSpdyFrameChunkSize + 3;
6553
6554   // Calculate last frame's size; 0 size data frame is legal.
6555   size_t last_frame_size = initial_window_size % kMaxSpdyFrameChunkSize;
6556
6557   // Construct content for a data frame of maximum size.
6558   std::string content(kMaxSpdyFrameChunkSize, 'a');
6559
6560   scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyPost(
6561       kRequestUrl, 1, initial_window_size + kUploadDataSize, LOWEST, NULL, 0));
6562
6563   // Full frames.
6564   scoped_ptr<SpdyFrame> body1(
6565       spdy_util_.ConstructSpdyBodyFrame(
6566           1, content.c_str(), content.size(), false));
6567
6568   // Last frame to zero out the window size.
6569   scoped_ptr<SpdyFrame> body2(
6570       spdy_util_.ConstructSpdyBodyFrame(
6571           1, content.c_str(), last_frame_size, false));
6572
6573   // Data frame to be sent once SETTINGS frame is received.
6574   scoped_ptr<SpdyFrame> body3(spdy_util_.ConstructSpdyBodyFrame(1, true));
6575
6576   // Fill in mock reads/writes.
6577   std::vector<MockRead> reads;
6578   std::vector<MockWrite> writes;
6579   size_t i = 0;
6580   writes.push_back(CreateMockWrite(*req, i++));
6581   while (i < num_writes - 2)
6582     writes.push_back(CreateMockWrite(*body1, i++));
6583   writes.push_back(CreateMockWrite(*body2, i++));
6584
6585   // Construct read frame for SETTINGS that makes the send_window_size
6586   // negative.
6587   SettingsMap new_settings;
6588   new_settings[SETTINGS_INITIAL_WINDOW_SIZE] =
6589       SettingsFlagsAndValue(SETTINGS_FLAG_NONE, initial_window_size / 2);
6590   scoped_ptr<SpdyFrame> settings_frame_small(
6591       spdy_util_.ConstructSpdySettings(new_settings));
6592   // Construct read frames for WINDOW_UPDATE that makes the send_window_size
6593   // positive.
6594   scoped_ptr<SpdyFrame> session_window_update_init_size(
6595       spdy_util_.ConstructSpdyWindowUpdate(0, initial_window_size));
6596   scoped_ptr<SpdyFrame> window_update_init_size(
6597       spdy_util_.ConstructSpdyWindowUpdate(1, initial_window_size));
6598
6599   reads.push_back(CreateMockRead(*settings_frame_small, i++));
6600   reads.push_back(CreateMockRead(*session_window_update_init_size, i++));
6601   reads.push_back(CreateMockRead(*window_update_init_size, i++));
6602
6603   scoped_ptr<SpdyFrame> settings_ack(spdy_util_.ConstructSpdySettingsAck());
6604   writes.push_back(CreateMockWrite(*settings_ack, i++));
6605
6606   writes.push_back(CreateMockWrite(*body3, i++));
6607
6608   scoped_ptr<SpdyFrame> reply(spdy_util_.ConstructSpdyPostSynReply(NULL, 0));
6609   reads.push_back(CreateMockRead(*reply, i++));
6610   reads.push_back(CreateMockRead(*body2, i++));
6611   reads.push_back(CreateMockRead(*body3, i++));
6612   reads.push_back(MockRead(ASYNC, 0, i++));  // EOF
6613
6614   // Force all writes to happen before any read, last write will not
6615   // actually queue a frame, due to window size being 0.
6616   DeterministicSocketData data(vector_as_array(&reads), reads.size(),
6617                                vector_as_array(&writes), writes.size());
6618
6619   ScopedVector<UploadElementReader> element_readers;
6620   std::string upload_data_string(initial_window_size, 'a');
6621   upload_data_string.append(kUploadData, kUploadDataSize);
6622   element_readers.push_back(new UploadBytesElementReader(
6623       upload_data_string.c_str(), upload_data_string.size()));
6624   ElementsUploadDataStream upload_data_stream(element_readers.Pass(), 0);
6625
6626   HttpRequestInfo request;
6627   request.method = "POST";
6628   request.url = GURL("http://www.google.com/");
6629   request.upload_data_stream = &upload_data_stream;
6630   NormalSpdyTransactionHelper helper(request, DEFAULT_PRIORITY,
6631                                      BoundNetLog(), GetParam(), NULL);
6632   helper.SetDeterministic();
6633   helper.RunPreTestSetup();
6634   helper.AddDeterministicData(&data);
6635
6636   HttpNetworkTransaction* trans = helper.trans();
6637
6638   TestCompletionCallback callback;
6639   int rv = trans->Start(&helper.request(), callback.callback(), BoundNetLog());
6640   EXPECT_EQ(ERR_IO_PENDING, rv);
6641
6642   data.RunFor(num_writes - 1);   // Write as much as we can.
6643
6644   SpdyHttpStream* stream = static_cast<SpdyHttpStream*>(trans->stream_.get());
6645   ASSERT_TRUE(stream != NULL);
6646   ASSERT_TRUE(stream->stream() != NULL);
6647   EXPECT_EQ(0, stream->stream()->send_window_size());
6648
6649   // All the body data should have been read.
6650   // TODO(satorux): This is because of the weirdness in reading the request
6651   // body in OnSendBodyComplete(). See crbug.com/113107.
6652   EXPECT_TRUE(upload_data_stream.IsEOF());
6653   // But the body is not yet fully sent (kUploadData is not yet sent)
6654   // since we're send-stalled.
6655   EXPECT_TRUE(stream->stream()->send_stalled_by_flow_control());
6656
6657   // Read in WINDOW_UPDATE or SETTINGS frame.
6658   data.RunFor((GetParam().protocol >= kProtoSPDY31) ? 9 : 8);
6659   rv = callback.WaitForResult();
6660   helper.VerifyDataConsumed();
6661 }
6662
6663 TEST_P(SpdyNetworkTransactionTest, GoAwayOnOddPushStreamId) {
6664   if (spdy_util_.spdy_version() < SPDY3)
6665     return;
6666
6667   scoped_ptr<SpdyHeaderBlock> push_headers(new SpdyHeaderBlock);
6668   spdy_util_.AddUrlToHeaderBlock("http://www.google.com/a.dat",
6669                                  push_headers.get());
6670   scoped_ptr<SpdyFrame> push(
6671       spdy_util_.ConstructInitialSpdyPushFrame(push_headers.Pass(), 3, 1));
6672   MockRead reads[] = {CreateMockRead(*push, 1)};
6673
6674   scoped_ptr<SpdyFrame> req(
6675       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
6676   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
6677       0, GOAWAY_PROTOCOL_ERROR, "Odd push stream id."));
6678   MockWrite writes[] = {
6679       CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 2),
6680   };
6681
6682   DelayedSocketData data(1, reads, arraysize(reads), writes, arraysize(writes));
6683   NormalSpdyTransactionHelper helper(
6684       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
6685   helper.RunToCompletion(&data);
6686   TransactionHelperResult out = helper.output();
6687   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
6688 }
6689
6690 TEST_P(SpdyNetworkTransactionTest,
6691        GoAwayOnPushStreamIdLesserOrEqualThanLastAccepted) {
6692   if (spdy_util_.spdy_version() < SPDY3)
6693     return;
6694
6695   scoped_ptr<SpdyFrame> push_a(spdy_util_.ConstructSpdyPush(
6696       NULL, 0, 4, 1, "http://www.google.com/a.dat"));
6697   scoped_ptr<SpdyHeaderBlock> push_b_headers(new SpdyHeaderBlock);
6698   spdy_util_.AddUrlToHeaderBlock("http://www.google.com/b.dat",
6699                                  push_b_headers.get());
6700   scoped_ptr<SpdyFrame> push_b(
6701       spdy_util_.ConstructInitialSpdyPushFrame(push_b_headers.Pass(), 2, 1));
6702   MockRead reads[] = {
6703       CreateMockRead(*push_a, 1), CreateMockRead(*push_b, 2),
6704   };
6705
6706   scoped_ptr<SpdyFrame> req(
6707       spdy_util_.ConstructSpdyGet(NULL, 0, false, 1, LOWEST, true));
6708   scoped_ptr<SpdyFrame> goaway(spdy_util_.ConstructSpdyGoAway(
6709       4,
6710       GOAWAY_PROTOCOL_ERROR,
6711       "New push stream id must be greater than the last accepted."));
6712   MockWrite writes[] = {
6713       CreateMockWrite(*req, 0), CreateMockWrite(*goaway, 3),
6714   };
6715
6716   DelayedSocketData data(1, reads, arraysize(reads), writes, arraysize(writes));
6717   NormalSpdyTransactionHelper helper(
6718       CreateGetRequest(), DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
6719   helper.RunToCompletion(&data);
6720   TransactionHelperResult out = helper.output();
6721   EXPECT_EQ(ERR_SPDY_PROTOCOL_ERROR, out.rv);
6722 }
6723
6724 class SpdyNetworkTransactionNoTLSUsageCheckTest
6725     : public SpdyNetworkTransactionTest {
6726  protected:
6727   void RunNoTLSUsageCheckTest(scoped_ptr<SSLSocketDataProvider> ssl_provider) {
6728     // Construct the request.
6729     scoped_ptr<SpdyFrame> req(spdy_util_.ConstructSpdyGet(
6730         "https://www.google.com/", false, 1, LOWEST));
6731     MockWrite writes[] = {CreateMockWrite(*req)};
6732
6733     scoped_ptr<SpdyFrame> resp(spdy_util_.ConstructSpdyGetSynReply(NULL, 0, 1));
6734     scoped_ptr<SpdyFrame> body(spdy_util_.ConstructSpdyBodyFrame(1, true));
6735     MockRead reads[] = {
6736         CreateMockRead(*resp), CreateMockRead(*body),
6737         MockRead(ASYNC, 0, 0)  // EOF
6738     };
6739
6740     DelayedSocketData data(
6741         1, reads, arraysize(reads), writes, arraysize(writes));
6742     HttpRequestInfo request;
6743     request.method = "GET";
6744     request.url = GURL("https://www.google.com/");
6745     NormalSpdyTransactionHelper helper(
6746         request, DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
6747     helper.RunToCompletionWithSSLData(&data, ssl_provider.Pass());
6748     TransactionHelperResult out = helper.output();
6749     EXPECT_EQ(OK, out.rv);
6750     EXPECT_EQ("HTTP/1.1 200 OK", out.status_line);
6751     EXPECT_EQ("hello!", out.response_data);
6752   }
6753 };
6754
6755 //-----------------------------------------------------------------------------
6756 // All tests are run with three different connection types: SPDY after NPN
6757 // negotiation, SPDY without SSL, and SPDY with SSL.
6758 //
6759 // TODO(akalin): Use ::testing::Combine() when we are able to use
6760 // <tr1/tuple>.
6761 INSTANTIATE_TEST_CASE_P(
6762     Spdy,
6763     SpdyNetworkTransactionNoTLSUsageCheckTest,
6764     ::testing::Values(SpdyNetworkTransactionTestParams(kProtoSPDY31, SPDYNPN)));
6765
6766 TEST_P(SpdyNetworkTransactionNoTLSUsageCheckTest, TLSVersionTooOld) {
6767   scoped_ptr<SSLSocketDataProvider> ssl_provider(
6768       new SSLSocketDataProvider(ASYNC, OK));
6769   SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_SSL3,
6770                                 &ssl_provider->connection_status);
6771
6772   RunNoTLSUsageCheckTest(ssl_provider.Pass());
6773 }
6774
6775 TEST_P(SpdyNetworkTransactionNoTLSUsageCheckTest, TLSCipherSuiteSucky) {
6776   scoped_ptr<SSLSocketDataProvider> ssl_provider(
6777       new SSLSocketDataProvider(ASYNC, OK));
6778   // Set to TLS_RSA_WITH_NULL_MD5
6779   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
6780
6781   RunNoTLSUsageCheckTest(ssl_provider.Pass());
6782 }
6783
6784 class SpdyNetworkTransactionTLSUsageCheckTest
6785     : public SpdyNetworkTransactionTest {
6786  protected:
6787   void RunTLSUsageCheckTest(scoped_ptr<SSLSocketDataProvider> ssl_provider) {
6788     scoped_ptr<SpdyFrame> goaway(
6789         spdy_util_.ConstructSpdyGoAway(0, GOAWAY_INADEQUATE_SECURITY, ""));
6790     MockWrite writes[] = {CreateMockWrite(*goaway)};
6791
6792     DelayedSocketData data(1, NULL, 0, writes, arraysize(writes));
6793     HttpRequestInfo request;
6794     request.method = "GET";
6795     request.url = GURL("https://www.google.com/");
6796     NormalSpdyTransactionHelper helper(
6797         request, DEFAULT_PRIORITY, BoundNetLog(), GetParam(), NULL);
6798     helper.RunToCompletionWithSSLData(&data, ssl_provider.Pass());
6799     TransactionHelperResult out = helper.output();
6800     EXPECT_EQ(ERR_SPDY_INADEQUATE_TRANSPORT_SECURITY, out.rv);
6801   }
6802 };
6803
6804 INSTANTIATE_TEST_CASE_P(
6805     Spdy,
6806     SpdyNetworkTransactionTLSUsageCheckTest,
6807     ::testing::Values(
6808         SpdyNetworkTransactionTestParams(kProtoSPDY4_14, SPDYNPN),
6809         SpdyNetworkTransactionTestParams(kProtoSPDY4_15, SPDYNPN)));
6810
6811 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSVersionTooOld) {
6812   scoped_ptr<SSLSocketDataProvider> ssl_provider(
6813       new SSLSocketDataProvider(ASYNC, OK));
6814   SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_SSL3,
6815                                 &ssl_provider->connection_status);
6816
6817   RunTLSUsageCheckTest(ssl_provider.Pass());
6818 }
6819
6820 TEST_P(SpdyNetworkTransactionTLSUsageCheckTest, TLSCipherSuiteSucky) {
6821   scoped_ptr<SSLSocketDataProvider> ssl_provider(
6822       new SSLSocketDataProvider(ASYNC, OK));
6823   // Set to TLS_RSA_WITH_NULL_MD5
6824   SSLConnectionStatusSetCipherSuite(0x1, &ssl_provider->connection_status);
6825
6826   RunTLSUsageCheckTest(ssl_provider.Pass());
6827 }
6828
6829 }  // namespace net