Home | History | Annotate | Download | only in quic 
      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 <stddef.h>
      6 #include <string>
      7 #include <sys/epoll.h>
      8 #include <vector>
      9 
     10 #include "base/basictypes.h"
     11 #include "base/memory/scoped_ptr.h"
     12 #include "base/memory/singleton.h"
     13 #include "base/strings/string_number_conversions.h"
     14 #include "base/synchronization/waitable_event.h"
     15 #include "base/time/time.h"
     16 #include "net/base/ip_endpoint.h"
     17 #include "net/quic/congestion_control/tcp_cubic_sender.h"
     18 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
     19 #include "net/quic/crypto/null_encrypter.h"
     20 #include "net/quic/quic_flags.h"
     21 #include "net/quic/quic_framer.h"
     22 #include "net/quic/quic_packet_creator.h"
     23 #include "net/quic/quic_protocol.h"
     24 #include "net/quic/quic_server_id.h"
     25 #include "net/quic/quic_utils.h"
     26 #include "net/quic/test_tools/quic_connection_peer.h"
     27 #include "net/quic/test_tools/quic_flow_controller_peer.h"
     28 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
     29 #include "net/quic/test_tools/quic_session_peer.h"
     30 #include "net/quic/test_tools/quic_test_utils.h"
     31 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
     32 #include "net/test/gtest_util.h"
     33 #include "net/tools/epoll_server/epoll_server.h"
     34 #include "net/tools/quic/quic_epoll_connection_helper.h"
     35 #include "net/tools/quic/quic_in_memory_cache.h"
     36 #include "net/tools/quic/quic_packet_writer_wrapper.h"
     37 #include "net/tools/quic/quic_server.h"
     38 #include "net/tools/quic/quic_socket_utils.h"
     39 #include "net/tools/quic/quic_spdy_client_stream.h"
     40 #include "net/tools/quic/test_tools/http_message.h"
     41 #include "net/tools/quic/test_tools/packet_dropping_test_writer.h"
     42 #include "net/tools/quic/test_tools/quic_client_peer.h"
     43 #include "net/tools/quic/test_tools/quic_dispatcher_peer.h"
     44 #include "net/tools/quic/test_tools/quic_in_memory_cache_peer.h"
     45 #include "net/tools/quic/test_tools/quic_server_peer.h"
     46 #include "net/tools/quic/test_tools/quic_test_client.h"
     47 #include "net/tools/quic/test_tools/server_thread.h"
     48 #include "testing/gtest/include/gtest/gtest.h"
     49 
     50 using base::StringPiece;
     51 using base::WaitableEvent;
     52 using net::EpollServer;
     53 using net::test::GenerateBody;
     54 using net::test::QuicConnectionPeer;
     55 using net::test::QuicFlowControllerPeer;
     56 using net::test::QuicSentPacketManagerPeer;
     57 using net::test::QuicSessionPeer;
     58 using net::test::ReliableQuicStreamPeer;
     59 using net::test::ValueRestore;
     60 using net::test::kClientDataStreamId1;
     61 using net::tools::test::PacketDroppingTestWriter;
     62 using net::tools::test::QuicDispatcherPeer;
     63 using net::tools::test::QuicServerPeer;
     64 using std::ostream;
     65 using std::string;
     66 using std::vector;
     67 
     68 namespace net {
     69 namespace tools {
     70 namespace test {
     71 namespace {
     72 
     73 const char* kFooResponseBody = "Artichoke hearts make me happy.";
     74 const char* kBarResponseBody = "Palm hearts are pretty delicious, also.";
     75 
     76 // Run all tests with the cross products of all versions.
     77 struct TestParams {
     78   TestParams(const QuicVersionVector& client_supported_versions,
     79              const QuicVersionVector& server_supported_versions,
     80              QuicVersion negotiated_version,
     81              bool use_pacing,
     82              bool use_fec,
     83              QuicTag congestion_control_tag)
     84       : client_supported_versions(client_supported_versions),
     85         server_supported_versions(server_supported_versions),
     86         negotiated_version(negotiated_version),
     87         use_pacing(use_pacing),
     88         use_fec(use_fec),
     89         congestion_control_tag(congestion_control_tag) {
     90   }
     91 
     92   friend ostream& operator<<(ostream& os, const TestParams& p) {
     93     os << "{ server_supported_versions: "
     94        << QuicVersionVectorToString(p.server_supported_versions);
     95     os << " client_supported_versions: "
     96        << QuicVersionVectorToString(p.client_supported_versions);
     97     os << " negotiated_version: " << QuicVersionToString(p.negotiated_version);
     98     os << " use_pacing: " << p.use_pacing;
     99     os << " use_fec: " << p.use_fec;
    100     os << " congestion_control_tag: "
    101        << QuicUtils::TagToString(p.congestion_control_tag) << " }";
    102     return os;
    103   }
    104 
    105   QuicVersionVector client_supported_versions;
    106   QuicVersionVector server_supported_versions;
    107   QuicVersion negotiated_version;
    108   bool use_pacing;
    109   bool use_fec;
    110   QuicTag congestion_control_tag;
    111 };
    112 
    113 // Constructs various test permutations.
    114 vector<TestParams> GetTestParams() {
    115   vector<TestParams> params;
    116   QuicVersionVector all_supported_versions = QuicSupportedVersions();
    117   // TODO(rtenneti): Add kTBBR after BBR code is checked in.
    118   // QuicTag congestion_control_tags[] = {kRENO, kTBBR, kQBIC};
    119   QuicTag congestion_control_tags[] = {kRENO, kQBIC};
    120   for (size_t congestion_control_index = 0;
    121        congestion_control_index < arraysize(congestion_control_tags);
    122        congestion_control_index++) {
    123     QuicTag congestion_control_tag =
    124         congestion_control_tags[congestion_control_index];
    125     for (int use_fec = 0; use_fec < 2; ++use_fec) {
    126       for (int use_pacing = 0; use_pacing < 2; ++use_pacing) {
    127         // Add an entry for server and client supporting all versions.
    128         params.push_back(TestParams(all_supported_versions,
    129                                     all_supported_versions,
    130                                     all_supported_versions[0],
    131                                     use_pacing != 0,
    132                                     use_fec != 0,
    133                                     congestion_control_tag));
    134 
    135         // Test client supporting all versions and server supporting 1 version.
    136         // Simulate an old server and exercise version downgrade in the client.
    137         // Protocol negotiation should occur. Skip the i = 0 case because it is
    138         // essentially the same as the default case.
    139         for (size_t i = 1; i < all_supported_versions.size(); ++i) {
    140           QuicVersionVector server_supported_versions;
    141           server_supported_versions.push_back(all_supported_versions[i]);
    142           if (all_supported_versions[i] >= QUIC_VERSION_18) {
    143             // Until flow control is globally rolled out and we remove
    144             // QUIC_VERSION_16, the server MUST support at least one QUIC
    145             // version that does not use flow control.
    146             server_supported_versions.push_back(QUIC_VERSION_16);
    147           }
    148           params.push_back(TestParams(all_supported_versions,
    149                                       server_supported_versions,
    150                                       server_supported_versions[0],
    151                                       use_pacing != 0,
    152                                       use_fec != 0,
    153                                       congestion_control_tag));
    154         }
    155       }
    156     }
    157   }
    158   return params;
    159 }
    160 
    161 class ServerDelegate : public PacketDroppingTestWriter::Delegate {
    162  public:
    163   ServerDelegate(TestWriterFactory* writer_factory,
    164                  QuicDispatcher* dispatcher)
    165       : writer_factory_(writer_factory),
    166         dispatcher_(dispatcher) {}
    167   virtual ~ServerDelegate() {}
    168   virtual void OnPacketSent(WriteResult result) OVERRIDE {
    169     writer_factory_->OnPacketSent(result);
    170   }
    171   virtual void OnCanWrite() OVERRIDE { dispatcher_->OnCanWrite(); }
    172  private:
    173   TestWriterFactory* writer_factory_;
    174   QuicDispatcher* dispatcher_;
    175 };
    176 
    177 class ClientDelegate : public PacketDroppingTestWriter::Delegate {
    178  public:
    179   explicit ClientDelegate(QuicClient* client) : client_(client) {}
    180   virtual ~ClientDelegate() {}
    181   virtual void OnPacketSent(WriteResult result) OVERRIDE {}
    182   virtual void OnCanWrite() OVERRIDE {
    183     EpollEvent event(EPOLLOUT, false);
    184     client_->OnEvent(client_->fd(), &event);
    185   }
    186  private:
    187   QuicClient* client_;
    188 };
    189 
    190 class EndToEndTest : public ::testing::TestWithParam<TestParams> {
    191  protected:
    192   EndToEndTest()
    193       : server_hostname_("example.com"),
    194         server_started_(false),
    195         strike_register_no_startup_period_(false) {
    196     net::IPAddressNumber ip;
    197     CHECK(net::ParseIPLiteralToNumber("127.0.0.1", &ip));
    198     server_address_ = IPEndPoint(ip, 0);
    199 
    200     client_supported_versions_ = GetParam().client_supported_versions;
    201     server_supported_versions_ = GetParam().server_supported_versions;
    202     negotiated_version_ = GetParam().negotiated_version;
    203     FLAGS_enable_quic_fec = GetParam().use_fec;
    204 
    205     VLOG(1) << "Using Configuration: " << GetParam();
    206 
    207     client_config_.SetDefaults();
    208     server_config_.SetDefaults();
    209 
    210     // Use different flow control windows for client/server.
    211     client_config_.SetInitialFlowControlWindowToSend(
    212         2 * kInitialSessionFlowControlWindowForTest);
    213     client_config_.SetInitialStreamFlowControlWindowToSend(
    214         2 * kInitialStreamFlowControlWindowForTest);
    215     client_config_.SetInitialSessionFlowControlWindowToSend(
    216         2 * kInitialSessionFlowControlWindowForTest);
    217     server_config_.SetInitialFlowControlWindowToSend(
    218         3 * kInitialSessionFlowControlWindowForTest);
    219     server_config_.SetInitialStreamFlowControlWindowToSend(
    220         3 * kInitialStreamFlowControlWindowForTest);
    221     server_config_.SetInitialSessionFlowControlWindowToSend(
    222         3 * kInitialSessionFlowControlWindowForTest);
    223 
    224     QuicInMemoryCachePeer::ResetForTests();
    225     AddToCache("GET", "https://www.google.com/foo",
    226                "HTTP/1.1", "200", "OK", kFooResponseBody);
    227     AddToCache("GET", "https://www.google.com/bar",
    228                "HTTP/1.1", "200", "OK", kBarResponseBody);
    229   }
    230 
    231   virtual ~EndToEndTest() {
    232     // TODO(rtenneti): port RecycleUnusedPort if needed.
    233     // RecycleUnusedPort(server_address_.port());
    234     QuicInMemoryCachePeer::ResetForTests();
    235   }
    236 
    237   QuicTestClient* CreateQuicClient(QuicPacketWriterWrapper* writer) {
    238     QuicTestClient* client = new QuicTestClient(
    239         server_address_,
    240         server_hostname_,
    241         false,  // not secure
    242         client_config_,
    243         client_supported_versions_);
    244     client->UseWriter(writer);
    245     client->Connect();
    246     return client;
    247   }
    248 
    249   void set_client_initial_flow_control_receive_window(uint32 window) {
    250     CHECK(client_.get() == NULL);
    251     DVLOG(1) << "Setting client initial flow control window: " << window;
    252     client_config_.SetInitialFlowControlWindowToSend(window);
    253   }
    254 
    255   void set_client_initial_stream_flow_control_receive_window(uint32 window) {
    256     CHECK(client_.get() == NULL);
    257     DVLOG(1) << "Setting client initial stream flow control window: " << window;
    258     client_config_.SetInitialStreamFlowControlWindowToSend(window);
    259   }
    260 
    261   void set_client_initial_session_flow_control_receive_window(uint32 window) {
    262     CHECK(client_.get() == NULL);
    263     DVLOG(1) << "Setting client initial session flow control window: "
    264              << window;
    265     client_config_.SetInitialSessionFlowControlWindowToSend(window);
    266   }
    267 
    268   void set_server_initial_flow_control_receive_window(uint32 window) {
    269     CHECK(server_thread_.get() == NULL);
    270     DVLOG(1) << "Setting server initial flow control window: " << window;
    271     server_config_.SetInitialFlowControlWindowToSend(window);
    272   }
    273 
    274   void set_server_initial_stream_flow_control_receive_window(uint32 window) {
    275     CHECK(server_thread_.get() == NULL);
    276     DVLOG(1) << "Setting server initial stream flow control window: "
    277              << window;
    278     server_config_.SetInitialStreamFlowControlWindowToSend(window);
    279   }
    280 
    281   void set_server_initial_session_flow_control_receive_window(uint32 window) {
    282     CHECK(server_thread_.get() == NULL);
    283     DVLOG(1) << "Setting server initial session flow control window: "
    284              << window;
    285     server_config_.SetInitialSessionFlowControlWindowToSend(window);
    286   }
    287 
    288   const QuicSentPacketManager *
    289   GetSentPacketManagerFromFirstServerSession() const {
    290     QuicDispatcher* dispatcher =
    291         QuicServerPeer::GetDispatcher(server_thread_->server());
    292     QuicSession* session = dispatcher->session_map().begin()->second;
    293     return &session->connection()->sent_packet_manager();
    294   }
    295 
    296   bool Initialize() {
    297     QuicTagVector copt;
    298 
    299     if (GetParam().use_pacing) {
    300       copt.push_back(kPACE);
    301     }
    302     server_config_.SetConnectionOptionsToSend(copt);
    303 
    304     // TODO(nimia): Consider setting the congestion control algorithm for the
    305     // client as well according to the test parameter.
    306     copt.push_back(GetParam().congestion_control_tag);
    307 
    308     if (GetParam().use_fec) {
    309       // Set FEC config in client's connection options and in client session.
    310       copt.push_back(kFHDR);
    311     }
    312 
    313     client_config_.SetConnectionOptionsToSend(copt);
    314 
    315     // Start the server first, because CreateQuicClient() attempts
    316     // to connect to the server.
    317     StartServer();
    318     client_.reset(CreateQuicClient(client_writer_));
    319     if (GetParam().use_fec) {
    320       // Set FecPolicy to always protect data on all streams.
    321       client_->SetFecPolicy(FEC_PROTECT_ALWAYS);
    322     }
    323     static EpollEvent event(EPOLLOUT, false);
    324     client_writer_->Initialize(
    325         reinterpret_cast<QuicEpollConnectionHelper*>(
    326             QuicConnectionPeer::GetHelper(
    327                 client_->client()->session()->connection())),
    328         new ClientDelegate(client_->client()));
    329     return client_->client()->connected();
    330   }
    331 
    332   virtual void SetUp() OVERRIDE {
    333     // The ownership of these gets transferred to the QuicPacketWriterWrapper
    334     // and TestWriterFactory when Initialize() is executed.
    335     client_writer_ = new PacketDroppingTestWriter();
    336     server_writer_ = new PacketDroppingTestWriter();
    337   }
    338 
    339   virtual void TearDown() OVERRIDE {
    340     StopServer();
    341   }
    342 
    343   void StartServer() {
    344     server_thread_.reset(
    345         new ServerThread(
    346             new QuicServer(server_config_, server_supported_versions_),
    347             server_address_,
    348             strike_register_no_startup_period_));
    349     server_thread_->Initialize();
    350     server_address_ = IPEndPoint(server_address_.address(),
    351                                  server_thread_->GetPort());
    352     QuicDispatcher* dispatcher =
    353         QuicServerPeer::GetDispatcher(server_thread_->server());
    354     TestWriterFactory* packet_writer_factory = new TestWriterFactory();
    355     QuicDispatcherPeer::SetPacketWriterFactory(dispatcher,
    356                                                packet_writer_factory);
    357     QuicDispatcherPeer::UseWriter(dispatcher, server_writer_);
    358     server_writer_->Initialize(
    359         QuicDispatcherPeer::GetHelper(dispatcher),
    360         new ServerDelegate(packet_writer_factory, dispatcher));
    361     server_thread_->Start();
    362     server_started_ = true;
    363   }
    364 
    365   void StopServer() {
    366     if (!server_started_)
    367       return;
    368     if (server_thread_.get()) {
    369       server_thread_->Quit();
    370       server_thread_->Join();
    371     }
    372   }
    373 
    374   void AddToCache(StringPiece method,
    375                   StringPiece path,
    376                   StringPiece version,
    377                   StringPiece response_code,
    378                   StringPiece response_detail,
    379                   StringPiece body) {
    380     QuicInMemoryCache::GetInstance()->AddSimpleResponse(
    381         method, path, version, response_code, response_detail, body);
    382   }
    383 
    384   void SetPacketLossPercentage(int32 loss) {
    385     // TODO(rtenneti): enable when we can do random packet loss tests in
    386     // chrome's tree.
    387     if (loss != 0 && loss != 100)
    388       return;
    389     client_writer_->set_fake_packet_loss_percentage(loss);
    390     server_writer_->set_fake_packet_loss_percentage(loss);
    391   }
    392 
    393   void SetPacketSendDelay(QuicTime::Delta delay) {
    394     // TODO(rtenneti): enable when we can do random packet send delay tests in
    395     // chrome's tree.
    396     // client_writer_->set_fake_packet_delay(delay);
    397     // server_writer_->set_fake_packet_delay(delay);
    398   }
    399 
    400   void SetReorderPercentage(int32 reorder) {
    401     // TODO(rtenneti): enable when we can do random packet reorder tests in
    402     // chrome's tree.
    403     // client_writer_->set_fake_reorder_percentage(reorder);
    404     // server_writer_->set_fake_reorder_percentage(reorder);
    405   }
    406 
    407   // Verifies that the client and server connections were both free of packets
    408   // being discarded, based on connection stats.
    409   // Calls server_thread_ Pause() and Resume(), which may only be called once
    410   // per test.
    411   void VerifyCleanConnection(bool had_packet_loss) {
    412     QuicConnectionStats client_stats =
    413         client_->client()->session()->connection()->GetStats();
    414     if (!had_packet_loss) {
    415       EXPECT_EQ(0u, client_stats.packets_lost);
    416     }
    417     EXPECT_EQ(0u, client_stats.packets_discarded);
    418     EXPECT_EQ(0u, client_stats.packets_dropped);
    419     EXPECT_EQ(client_stats.packets_received, client_stats.packets_processed);
    420 
    421     server_thread_->Pause();
    422     QuicDispatcher* dispatcher =
    423         QuicServerPeer::GetDispatcher(server_thread_->server());
    424     ASSERT_EQ(1u, dispatcher->session_map().size());
    425     QuicSession* session = dispatcher->session_map().begin()->second;
    426     QuicConnectionStats server_stats = session->connection()->GetStats();
    427     if (!had_packet_loss) {
    428       EXPECT_EQ(0u, server_stats.packets_lost);
    429     }
    430     EXPECT_EQ(0u, server_stats.packets_discarded);
    431     // TODO(ianswett): Restore the check for packets_dropped equals 0.
    432     // The expect for packets received is equal to packets processed fails
    433     // due to version negotiation packets.
    434     server_thread_->Resume();
    435   }
    436 
    437   IPEndPoint server_address_;
    438   string server_hostname_;
    439   scoped_ptr<ServerThread> server_thread_;
    440   scoped_ptr<QuicTestClient> client_;
    441   PacketDroppingTestWriter* client_writer_;
    442   PacketDroppingTestWriter* server_writer_;
    443   bool server_started_;
    444   QuicConfig client_config_;
    445   QuicConfig server_config_;
    446   QuicVersionVector client_supported_versions_;
    447   QuicVersionVector server_supported_versions_;
    448   QuicVersion negotiated_version_;
    449   bool strike_register_no_startup_period_;
    450 };
    451 
    452 // Run all end to end tests with all supported versions.
    453 INSTANTIATE_TEST_CASE_P(EndToEndTests,
    454                         EndToEndTest,
    455                         ::testing::ValuesIn(GetTestParams()));
    456 
    457 TEST_P(EndToEndTest, SimpleRequestResponse) {
    458   ASSERT_TRUE(Initialize());
    459 
    460   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
    461   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
    462 }
    463 
    464 // TODO(rch): figure out how to detect missing v6 supprt (like on the linux
    465 // try bots) and selectively disable this test.
    466 TEST_P(EndToEndTest, DISABLED_SimpleRequestResponsev6) {
    467   IPAddressNumber ip;
    468   CHECK(net::ParseIPLiteralToNumber("::1", &ip));
    469   server_address_ = IPEndPoint(ip, server_address_.port());
    470   ASSERT_TRUE(Initialize());
    471 
    472   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
    473   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
    474 }
    475 
    476 TEST_P(EndToEndTest, SeparateFinPacket) {
    477   ASSERT_TRUE(Initialize());
    478 
    479   HTTPMessage request(HttpConstants::HTTP_1_1,
    480                       HttpConstants::POST, "/foo");
    481   request.set_has_complete_message(false);
    482 
    483   client_->SendMessage(request);
    484 
    485   client_->SendData(string(), true);
    486 
    487   client_->WaitForResponse();
    488   EXPECT_EQ(kFooResponseBody, client_->response_body());
    489   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
    490 
    491   request.AddBody("foo", true);
    492 
    493   client_->SendMessage(request);
    494   client_->SendData(string(), true);
    495   client_->WaitForResponse();
    496   EXPECT_EQ(kFooResponseBody, client_->response_body());
    497   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
    498 }
    499 
    500 TEST_P(EndToEndTest, MultipleRequestResponse) {
    501   ASSERT_TRUE(Initialize());
    502 
    503   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
    504   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
    505   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
    506   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
    507 }
    508 
    509 TEST_P(EndToEndTest, MultipleClients) {
    510   ASSERT_TRUE(Initialize());
    511   scoped_ptr<QuicTestClient> client2(CreateQuicClient(NULL));
    512 
    513   HTTPMessage request(HttpConstants::HTTP_1_1,
    514                       HttpConstants::POST, "/foo");
    515   request.AddHeader("content-length", "3");
    516   request.set_has_complete_message(false);
    517 
    518   client_->SendMessage(request);
    519   client2->SendMessage(request);
    520 
    521   client_->SendData("bar", true);
    522   client_->WaitForResponse();
    523   EXPECT_EQ(kFooResponseBody, client_->response_body());
    524   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
    525 
    526   client2->SendData("eep", true);
    527   client2->WaitForResponse();
    528   EXPECT_EQ(kFooResponseBody, client2->response_body());
    529   EXPECT_EQ(200u, client2->response_headers()->parsed_response_code());
    530 }
    531 
    532 TEST_P(EndToEndTest, RequestOverMultiplePackets) {
    533   // Send a large enough request to guarantee fragmentation.
    534   string huge_request =
    535       "https://www.google.com/some/path?query=" + string(kMaxPacketSize, '.');
    536   AddToCache("GET", huge_request, "HTTP/1.1", "200", "OK", kBarResponseBody);
    537 
    538   ASSERT_TRUE(Initialize());
    539 
    540   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest(huge_request));
    541   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
    542 }
    543 
    544 TEST_P(EndToEndTest, MultiplePacketsRandomOrder) {
    545   // Send a large enough request to guarantee fragmentation.
    546   string huge_request =
    547       "https://www.google.com/some/path?query=" + string(kMaxPacketSize, '.');
    548   AddToCache("GET", huge_request, "HTTP/1.1", "200", "OK", kBarResponseBody);
    549 
    550   ASSERT_TRUE(Initialize());
    551   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
    552   SetReorderPercentage(50);
    553 
    554   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest(huge_request));
    555   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
    556 }
    557 
    558 TEST_P(EndToEndTest, PostMissingBytes) {
    559   ASSERT_TRUE(Initialize());
    560 
    561   // Add a content length header with no body.
    562   HTTPMessage request(HttpConstants::HTTP_1_1,
    563                       HttpConstants::POST, "/foo");
    564   request.AddHeader("content-length", "3");
    565   request.set_skip_message_validation(true);
    566 
    567   // This should be detected as stream fin without complete request,
    568   // triggering an error response.
    569   client_->SendCustomSynchronousRequest(request);
    570   EXPECT_EQ("bad", client_->response_body());
    571   EXPECT_EQ(500u, client_->response_headers()->parsed_response_code());
    572 }
    573 
    574 // TODO(rtenneti): DISABLED_LargePostNoPacketLoss seems to be flaky.
    575 // http://crbug.com/297040.
    576 TEST_P(EndToEndTest, DISABLED_LargePostNoPacketLoss) {
    577   ASSERT_TRUE(Initialize());
    578 
    579   client_->client()->WaitForCryptoHandshakeConfirmed();
    580 
    581   // 1 MB body.
    582   string body;
    583   GenerateBody(&body, 1024 * 1024);
    584 
    585   HTTPMessage request(HttpConstants::HTTP_1_1,
    586                       HttpConstants::POST, "/foo");
    587   request.AddBody(body, true);
    588 
    589   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
    590   VerifyCleanConnection(false);
    591 }
    592 
    593 TEST_P(EndToEndTest, LargePostNoPacketLoss1sRTT) {
    594   ASSERT_TRUE(Initialize());
    595   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(1000));
    596 
    597   client_->client()->WaitForCryptoHandshakeConfirmed();
    598 
    599   // 100 KB body.
    600   string body;
    601   GenerateBody(&body, 100 * 1024);
    602 
    603   HTTPMessage request(HttpConstants::HTTP_1_1,
    604                       HttpConstants::POST, "/foo");
    605   request.AddBody(body, true);
    606 
    607   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
    608   VerifyCleanConnection(false);
    609 }
    610 
    611 TEST_P(EndToEndTest, LargePostWithPacketLoss) {
    612   // Connect with lower fake packet loss than we'd like to test.  Until
    613   // b/10126687 is fixed, losing handshake packets is pretty brutal.
    614   SetPacketLossPercentage(5);
    615   ASSERT_TRUE(Initialize());
    616 
    617   // Wait for the server SHLO before upping the packet loss.
    618   client_->client()->WaitForCryptoHandshakeConfirmed();
    619   SetPacketLossPercentage(30);
    620 
    621   // 10 KB body.
    622   string body;
    623   GenerateBody(&body, 1024 * 10);
    624 
    625   HTTPMessage request(HttpConstants::HTTP_1_1,
    626                       HttpConstants::POST, "/foo");
    627   request.AddBody(body, true);
    628 
    629   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
    630   VerifyCleanConnection(true);
    631 }
    632 
    633 TEST_P(EndToEndTest, LargePostWithPacketLossAndBlockedSocket) {
    634   // Connect with lower fake packet loss than we'd like to test.  Until
    635   // b/10126687 is fixed, losing handshake packets is pretty brutal.
    636   SetPacketLossPercentage(5);
    637   ASSERT_TRUE(Initialize());
    638 
    639   // Wait for the server SHLO before upping the packet loss.
    640   client_->client()->WaitForCryptoHandshakeConfirmed();
    641   SetPacketLossPercentage(10);
    642   client_writer_->set_fake_blocked_socket_percentage(10);
    643 
    644   // 10 KB body.
    645   string body;
    646   GenerateBody(&body, 1024 * 10);
    647 
    648   HTTPMessage request(HttpConstants::HTTP_1_1,
    649                       HttpConstants::POST, "/foo");
    650   request.AddBody(body, true);
    651 
    652   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
    653 }
    654 
    655 TEST_P(EndToEndTest, LargePostNoPacketLossWithDelayAndReordering) {
    656   ASSERT_TRUE(Initialize());
    657 
    658   client_->client()->WaitForCryptoHandshakeConfirmed();
    659   // Both of these must be called when the writer is not actively used.
    660   SetPacketSendDelay(QuicTime::Delta::FromMilliseconds(2));
    661   SetReorderPercentage(30);
    662 
    663   // 1 MB body.
    664   string body;
    665   GenerateBody(&body, 1024 * 1024);
    666 
    667   HTTPMessage request(HttpConstants::HTTP_1_1,
    668                       HttpConstants::POST, "/foo");
    669   request.AddBody(body, true);
    670 
    671   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
    672 }
    673 
    674 TEST_P(EndToEndTest, LargePostZeroRTTFailure) {
    675   // Have the server accept 0-RTT without waiting a startup period.
    676   strike_register_no_startup_period_ = true;
    677 
    678   // Send a request and then disconnect. This prepares the client to attempt
    679   // a 0-RTT handshake for the next request.
    680   ASSERT_TRUE(Initialize());
    681 
    682   string body;
    683   GenerateBody(&body, 20480);
    684 
    685   HTTPMessage request(HttpConstants::HTTP_1_1,
    686                       HttpConstants::POST, "/foo");
    687   request.AddBody(body, true);
    688 
    689   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
    690   EXPECT_EQ(2, client_->client()->session()->GetNumSentClientHellos());
    691 
    692   client_->Disconnect();
    693 
    694   // The 0-RTT handshake should succeed.
    695   client_->Connect();
    696   if (client_supported_versions_[0] >= QUIC_VERSION_18 &&
    697       negotiated_version_ <= QUIC_VERSION_16) {
    698     // If the version negotiation has resulted in a downgrade, then the client
    699     // must wait for the handshake to complete before sending any data.
    700     // Otherwise it may have queued frames which will trigger a
    701     // DFATAL when they are serialized after the downgrade.
    702     client_->client()->WaitForCryptoHandshakeConfirmed();
    703   }
    704   client_->WaitForResponseForMs(-1);
    705   ASSERT_TRUE(client_->client()->connected());
    706   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
    707   EXPECT_EQ(1, client_->client()->session()->GetNumSentClientHellos());
    708 
    709   client_->Disconnect();
    710 
    711   // Restart the server so that the 0-RTT handshake will take 1 RTT.
    712   StopServer();
    713   server_writer_ = new PacketDroppingTestWriter();
    714   StartServer();
    715 
    716   client_->Connect();
    717   if (client_supported_versions_[0] >= QUIC_VERSION_18 &&
    718       negotiated_version_ <= QUIC_VERSION_16) {
    719     // If the version negotiation has resulted in a downgrade, then the client
    720     // must wait for the handshake to complete before sending any data.
    721     // Otherwise it may have queued frames which will trigger a
    722     // DFATAL when they are serialized after the downgrade.
    723     client_->client()->WaitForCryptoHandshakeConfirmed();
    724   }
    725   ASSERT_TRUE(client_->client()->connected());
    726   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
    727   EXPECT_EQ(2, client_->client()->session()->GetNumSentClientHellos());
    728   VerifyCleanConnection(false);
    729 }
    730 
    731 TEST_P(EndToEndTest, CorrectlyConfiguredFec) {
    732   ASSERT_TRUE(Initialize());
    733   client_->client()->WaitForCryptoHandshakeConfirmed();
    734   server_thread_->WaitForCryptoHandshakeConfirmed();
    735 
    736   FecPolicy expected_policy =
    737       GetParam().use_fec ? FEC_PROTECT_ALWAYS : FEC_PROTECT_OPTIONAL;
    738 
    739   // Verify that server's FEC configuration is correct.
    740   server_thread_->Pause();
    741   QuicDispatcher* dispatcher =
    742       QuicServerPeer::GetDispatcher(server_thread_->server());
    743   ASSERT_EQ(1u, dispatcher->session_map().size());
    744   QuicSession* session = dispatcher->session_map().begin()->second;
    745   EXPECT_EQ(expected_policy,
    746             QuicSessionPeer::GetHeadersStream(session)->fec_policy());
    747   server_thread_->Resume();
    748 
    749   // Verify that client's FEC configuration is correct.
    750   EXPECT_EQ(expected_policy,
    751             QuicSessionPeer::GetHeadersStream(
    752                 client_->client()->session())->fec_policy());
    753   EXPECT_EQ(expected_policy,
    754             client_->GetOrCreateStream()->fec_policy());
    755 }
    756 
    757 // TODO(shess): This is flaky on ChromiumOS bots.
    758 // http://crbug.com/374871
    759 TEST_P(EndToEndTest, DISABLED_LargePostSmallBandwidthLargeBuffer) {
    760   ASSERT_TRUE(Initialize());
    761   SetPacketSendDelay(QuicTime::Delta::FromMicroseconds(1));
    762   // 256KB per second with a 256KB buffer from server to client.  Wireless
    763   // clients commonly have larger buffers, but our max CWND is 200.
    764   server_writer_->set_max_bandwidth_and_buffer_size(
    765       QuicBandwidth::FromBytesPerSecond(256 * 1024), 256 * 1024);
    766 
    767   client_->client()->WaitForCryptoHandshakeConfirmed();
    768 
    769   // 1 MB body.
    770   string body;
    771   GenerateBody(&body, 1024 * 1024);
    772 
    773   HTTPMessage request(HttpConstants::HTTP_1_1,
    774                       HttpConstants::POST, "/foo");
    775   request.AddBody(body, true);
    776 
    777   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
    778   // This connection will not drop packets, because the buffer size is larger
    779   // than the default receive window.
    780   VerifyCleanConnection(false);
    781 }
    782 
    783 TEST_P(EndToEndTest, DoNotSetResumeWriteAlarmIfConnectionFlowControlBlocked) {
    784   // Regression test for b/14677858.
    785   // Test that the resume write alarm is not set in QuicConnection::OnCanWrite
    786   // if currently connection level flow control blocked. If set, this results in
    787   // an infinite loop in the EpollServer, as the alarm fires and is immediately
    788   // rescheduled.
    789   ASSERT_TRUE(Initialize());
    790   if (negotiated_version_ < QUIC_VERSION_19) {
    791     return;
    792   }
    793   client_->client()->WaitForCryptoHandshakeConfirmed();
    794 
    795   // Ensure both stream and connection level are flow control blocked by setting
    796   // the send window offset to 0.
    797   const uint64 kFlowControlWindow =
    798       server_config_.GetInitialFlowControlWindowToSend();
    799   QuicSpdyClientStream* stream = client_->GetOrCreateStream();
    800   QuicSession* session = client_->client()->session();
    801   QuicFlowControllerPeer::SetSendWindowOffset(stream->flow_controller(), 0);
    802   QuicFlowControllerPeer::SetSendWindowOffset(session->flow_controller(), 0);
    803   EXPECT_TRUE(stream->flow_controller()->IsBlocked());
    804   EXPECT_TRUE(session->flow_controller()->IsBlocked());
    805 
    806   // Make sure that the stream has data pending so that it will be marked as
    807   // write blocked when it receives a stream level WINDOW_UPDATE.
    808   stream->SendBody("hello", false);
    809 
    810   // The stream now attempts to write, fails because it is still connection
    811   // level flow control blocked, and is added to the write blocked list.
    812   QuicWindowUpdateFrame window_update(stream->id(), 2 * kFlowControlWindow);
    813   stream->OnWindowUpdateFrame(window_update);
    814 
    815   // Prior to fixing b/14677858 this call would result in an infinite loop in
    816   // Chromium. As a proxy for detecting this, we now check whether the
    817   // resume_writes_alarm is set after OnCanWrite. It should not be, as the
    818   // connection is still flow control blocked.
    819   session->connection()->OnCanWrite();
    820 
    821   QuicAlarm* resume_writes_alarm =
    822       QuicConnectionPeer::GetResumeWritesAlarm(session->connection());
    823   EXPECT_FALSE(resume_writes_alarm->IsSet());
    824 }
    825 
    826 TEST_P(EndToEndTest, InvalidStream) {
    827   ASSERT_TRUE(Initialize());
    828   client_->client()->WaitForCryptoHandshakeConfirmed();
    829 
    830   string body;
    831   GenerateBody(&body, kMaxPacketSize);
    832 
    833   HTTPMessage request(HttpConstants::HTTP_1_1,
    834                       HttpConstants::POST, "/foo");
    835   request.AddBody(body, true);
    836   // Force the client to write with a stream ID belonging to a nonexistent
    837   // server-side stream.
    838   QuicSessionPeer::SetNextStreamId(client_->client()->session(), 2);
    839 
    840   client_->SendCustomSynchronousRequest(request);
    841   // EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
    842   EXPECT_EQ(QUIC_PACKET_FOR_NONEXISTENT_STREAM, client_->connection_error());
    843 }
    844 
    845 // TODO(rch): this test seems to cause net_unittests timeouts :|
    846 TEST_P(EndToEndTest, DISABLED_MultipleTermination) {
    847   ASSERT_TRUE(Initialize());
    848 
    849   HTTPMessage request(HttpConstants::HTTP_1_1,
    850                       HttpConstants::POST, "/foo");
    851   request.AddHeader("content-length", "3");
    852   request.set_has_complete_message(false);
    853 
    854   // Set the offset so we won't frame.  Otherwise when we pick up termination
    855   // before HTTP framing is complete, we send an error and close the stream,
    856   // and the second write is picked up as writing on a closed stream.
    857   QuicSpdyClientStream* stream = client_->GetOrCreateStream();
    858   ASSERT_TRUE(stream != NULL);
    859   ReliableQuicStreamPeer::SetStreamBytesWritten(3, stream);
    860 
    861   client_->SendData("bar", true);
    862   client_->WaitForWriteToFlush();
    863 
    864   // By default the stream protects itself from writes after terminte is set.
    865   // Override this to test the server handling buggy clients.
    866   ReliableQuicStreamPeer::SetWriteSideClosed(
    867       false, client_->GetOrCreateStream());
    868 
    869   EXPECT_DFATAL(client_->SendData("eep", true), "Fin already buffered");
    870 }
    871 
    872 TEST_P(EndToEndTest, Timeout) {
    873   client_config_.set_idle_connection_state_lifetime(
    874       QuicTime::Delta::FromMicroseconds(500),
    875       QuicTime::Delta::FromMicroseconds(500));
    876   // Note: we do NOT ASSERT_TRUE: we may time out during initial handshake:
    877   // that's enough to validate timeout in this case.
    878   Initialize();
    879   while (client_->client()->connected()) {
    880     client_->client()->WaitForEvents();
    881   }
    882 }
    883 
    884 TEST_P(EndToEndTest, NegotiateMaxOpenStreams) {
    885   // Negotiate 1 max open stream.
    886   client_config_.set_max_streams_per_connection(1, 1);
    887   ASSERT_TRUE(Initialize());
    888   client_->client()->WaitForCryptoHandshakeConfirmed();
    889 
    890   // Make the client misbehave after negotiation.
    891   QuicSessionPeer::SetMaxOpenStreams(client_->client()->session(), 10);
    892 
    893   HTTPMessage request(HttpConstants::HTTP_1_1,
    894                       HttpConstants::POST, "/foo");
    895   request.AddHeader("content-length", "3");
    896   request.set_has_complete_message(false);
    897 
    898   // Open two simultaneous streams.
    899   client_->SendMessage(request);
    900   client_->SendMessage(request);
    901   client_->WaitForResponse();
    902 
    903   EXPECT_FALSE(client_->connected());
    904   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
    905   EXPECT_EQ(QUIC_TOO_MANY_OPEN_STREAMS, client_->connection_error());
    906 }
    907 
    908 TEST_P(EndToEndTest, NegotiateCongestionControl) {
    909   ASSERT_TRUE(Initialize());
    910   client_->client()->WaitForCryptoHandshakeConfirmed();
    911 
    912   CongestionControlType expected_congestion_control_type;
    913   switch (GetParam().congestion_control_tag) {
    914     case kRENO:
    915       expected_congestion_control_type = kReno;
    916       break;
    917     case kTBBR:
    918       expected_congestion_control_type = kBBR;
    919       break;
    920     case kQBIC:
    921       expected_congestion_control_type = kCubic;
    922       break;
    923     default:
    924       DLOG(FATAL) << "Unexpected congestion control tag";
    925   }
    926 
    927   EXPECT_EQ(expected_congestion_control_type,
    928             QuicSentPacketManagerPeer::GetCongestionControlAlgorithm(
    929                 *GetSentPacketManagerFromFirstServerSession())
    930             ->GetCongestionControlType());
    931 }
    932 
    933 TEST_P(EndToEndTest, LimitMaxOpenStreams) {
    934   // Server limits the number of max streams to 2.
    935   server_config_.set_max_streams_per_connection(2, 2);
    936   // Client tries to negotiate for 10.
    937   client_config_.set_max_streams_per_connection(10, 5);
    938 
    939   ASSERT_TRUE(Initialize());
    940   client_->client()->WaitForCryptoHandshakeConfirmed();
    941   QuicConfig* client_negotiated_config = client_->client()->session()->config();
    942   EXPECT_EQ(2u, client_negotiated_config->max_streams_per_connection());
    943 }
    944 
    945 TEST_P(EndToEndTest, LimitCongestionWindowAndRTT) {
    946   // Client tries to request twice the server's max initial window, and the
    947   // server limits it to the max.
    948   client_config_.SetInitialCongestionWindowToSend(2 * kMaxInitialWindow);
    949   client_config_.SetInitialRoundTripTimeUsToSend(1000);
    950 
    951   ASSERT_TRUE(Initialize());
    952   client_->client()->WaitForCryptoHandshakeConfirmed();
    953   server_thread_->WaitForCryptoHandshakeConfirmed();
    954 
    955   // Pause the server so we can access the server's internals without races.
    956   server_thread_->Pause();
    957   QuicDispatcher* dispatcher =
    958       QuicServerPeer::GetDispatcher(server_thread_->server());
    959   ASSERT_EQ(1u, dispatcher->session_map().size());
    960   const QuicSentPacketManager& client_sent_packet_manager =
    961       client_->client()->session()->connection()->sent_packet_manager();
    962   const QuicSentPacketManager& server_sent_packet_manager =
    963       *GetSentPacketManagerFromFirstServerSession();
    964 
    965   // The client shouldn't set it's initial window based on the negotiated value.
    966   EXPECT_EQ(kDefaultInitialWindow * kDefaultTCPMSS,
    967             client_sent_packet_manager.GetCongestionWindow());
    968   EXPECT_EQ(kMaxInitialWindow * kDefaultTCPMSS,
    969             server_sent_packet_manager.GetCongestionWindow());
    970 
    971   EXPECT_EQ(GetParam().use_pacing, server_sent_packet_manager.using_pacing());
    972   EXPECT_EQ(GetParam().use_pacing, client_sent_packet_manager.using_pacing());
    973 
    974   // The client *should* set the intitial RTT.
    975   EXPECT_EQ(1000u, client_sent_packet_manager.GetRttStats()->initial_rtt_us());
    976   EXPECT_EQ(1000u, server_sent_packet_manager.GetRttStats()->initial_rtt_us());
    977 
    978   // Now use the negotiated limits with packet loss.
    979   SetPacketLossPercentage(30);
    980 
    981   // 10 KB body.
    982   string body;
    983   GenerateBody(&body, 1024 * 10);
    984 
    985   HTTPMessage request(HttpConstants::HTTP_1_1,
    986                       HttpConstants::POST, "/foo");
    987   request.AddBody(body, true);
    988 
    989   server_thread_->Resume();
    990 
    991   EXPECT_EQ(kFooResponseBody, client_->SendCustomSynchronousRequest(request));
    992 }
    993 
    994 TEST_P(EndToEndTest, MaxInitialRTT) {
    995   // Client tries to suggest twice the server's max initial rtt and the server
    996   // uses the max.
    997   client_config_.SetInitialRoundTripTimeUsToSend(
    998       2 * kMaxInitialRoundTripTimeUs);
    999 
   1000   ASSERT_TRUE(Initialize());
   1001   client_->client()->WaitForCryptoHandshakeConfirmed();
   1002   server_thread_->WaitForCryptoHandshakeConfirmed();
   1003 
   1004   // Pause the server so we can access the server's internals without races.
   1005   server_thread_->Pause();
   1006   QuicDispatcher* dispatcher =
   1007       QuicServerPeer::GetDispatcher(server_thread_->server());
   1008   ASSERT_EQ(1u, dispatcher->session_map().size());
   1009   QuicSession* session = dispatcher->session_map().begin()->second;
   1010   const QuicSentPacketManager& client_sent_packet_manager =
   1011       client_->client()->session()->connection()->sent_packet_manager();
   1012   const QuicSentPacketManager& server_sent_packet_manager =
   1013       session->connection()->sent_packet_manager();
   1014 
   1015   // Now that acks have been exchanged, the RTT estimate has decreased on the
   1016   // server and is not infinite on the client.
   1017   EXPECT_FALSE(
   1018       client_sent_packet_manager.GetRttStats()->SmoothedRtt().IsInfinite());
   1019   EXPECT_EQ(static_cast<int64>(kMaxInitialRoundTripTimeUs),
   1020             server_sent_packet_manager.GetRttStats()->initial_rtt_us());
   1021   EXPECT_GE(
   1022       static_cast<int64>(kMaxInitialRoundTripTimeUs),
   1023       server_sent_packet_manager.GetRttStats()->SmoothedRtt().ToMicroseconds());
   1024   server_thread_->Resume();
   1025 }
   1026 
   1027 TEST_P(EndToEndTest, MinInitialRTT) {
   1028   // Client tries to suggest 0 and the server uses the default.
   1029   client_config_.SetInitialRoundTripTimeUsToSend(0);
   1030 
   1031   ASSERT_TRUE(Initialize());
   1032   client_->client()->WaitForCryptoHandshakeConfirmed();
   1033   server_thread_->WaitForCryptoHandshakeConfirmed();
   1034 
   1035   // Pause the server so we can access the server's internals without races.
   1036   server_thread_->Pause();
   1037   QuicDispatcher* dispatcher =
   1038       QuicServerPeer::GetDispatcher(server_thread_->server());
   1039   ASSERT_EQ(1u, dispatcher->session_map().size());
   1040   QuicSession* session = dispatcher->session_map().begin()->second;
   1041   const QuicSentPacketManager& client_sent_packet_manager =
   1042       client_->client()->session()->connection()->sent_packet_manager();
   1043   const QuicSentPacketManager& server_sent_packet_manager =
   1044       session->connection()->sent_packet_manager();
   1045 
   1046   // Now that acks have been exchanged, the RTT estimate has decreased on the
   1047   // server and is not infinite on the client.
   1048   EXPECT_FALSE(
   1049       client_sent_packet_manager.GetRttStats()->SmoothedRtt().IsInfinite());
   1050   // Expect the default rtt of 100ms.
   1051   EXPECT_EQ(static_cast<int64>(100 * base::Time::kMicrosecondsPerMillisecond),
   1052             server_sent_packet_manager.GetRttStats()->initial_rtt_us());
   1053   // Ensure the bandwidth is valid.
   1054   client_sent_packet_manager.BandwidthEstimate();
   1055   server_sent_packet_manager.BandwidthEstimate();
   1056   server_thread_->Resume();
   1057 }
   1058 
   1059 TEST_P(EndToEndTest, ResetConnection) {
   1060   ASSERT_TRUE(Initialize());
   1061   client_->client()->WaitForCryptoHandshakeConfirmed();
   1062 
   1063   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   1064   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   1065   client_->ResetConnection();
   1066   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
   1067   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   1068 }
   1069 
   1070 TEST_P(EndToEndTest, MaxStreamsUberTest) {
   1071   SetPacketLossPercentage(1);
   1072   ASSERT_TRUE(Initialize());
   1073   string large_body;
   1074   GenerateBody(&large_body, 10240);
   1075   int max_streams = 100;
   1076 
   1077   AddToCache("GET", "/large_response", "HTTP/1.1", "200", "OK", large_body);;
   1078 
   1079   client_->client()->WaitForCryptoHandshakeConfirmed();
   1080   SetPacketLossPercentage(10);
   1081 
   1082   for (int i = 0; i < max_streams; ++i) {
   1083     EXPECT_LT(0, client_->SendRequest("/large_response"));
   1084   }
   1085 
   1086   // WaitForEvents waits 50ms and returns true if there are outstanding
   1087   // requests.
   1088   while (client_->client()->WaitForEvents() == true) {
   1089   }
   1090 }
   1091 
   1092 TEST_P(EndToEndTest, StreamCancelErrorTest) {
   1093   ASSERT_TRUE(Initialize());
   1094   string small_body;
   1095   GenerateBody(&small_body, 256);
   1096 
   1097   AddToCache("GET", "/small_response", "HTTP/1.1", "200", "OK", small_body);
   1098 
   1099   client_->client()->WaitForCryptoHandshakeConfirmed();
   1100 
   1101   QuicSession* session = client_->client()->session();
   1102   // Lose the request.
   1103   SetPacketLossPercentage(100);
   1104   EXPECT_LT(0, client_->SendRequest("/small_response"));
   1105   client_->client()->WaitForEvents();
   1106   // Transmit the cancel, and ensure the connection is torn down properly.
   1107   SetPacketLossPercentage(0);
   1108   QuicStreamId stream_id = kClientDataStreamId1;
   1109   session->SendRstStream(stream_id, QUIC_STREAM_CANCELLED, 0);
   1110 
   1111   // WaitForEvents waits 50ms and returns true if there are outstanding
   1112   // requests.
   1113   while (client_->client()->WaitForEvents() == true) {
   1114   }
   1115   // It should be completely fine to RST a stream before any data has been
   1116   // received for that stream.
   1117   EXPECT_EQ(QUIC_NO_ERROR, client_->connection_error());
   1118 }
   1119 
   1120 class WrongAddressWriter : public QuicPacketWriterWrapper {
   1121  public:
   1122   WrongAddressWriter() {
   1123     IPAddressNumber ip;
   1124     CHECK(net::ParseIPLiteralToNumber("127.0.0.2", &ip));
   1125     self_address_ = IPEndPoint(ip, 0);
   1126   }
   1127 
   1128   virtual WriteResult WritePacket(
   1129       const char* buffer,
   1130       size_t buf_len,
   1131       const IPAddressNumber& real_self_address,
   1132       const IPEndPoint& peer_address) OVERRIDE {
   1133     // Use wrong address!
   1134     return QuicPacketWriterWrapper::WritePacket(
   1135         buffer, buf_len, self_address_.address(), peer_address);
   1136   }
   1137 
   1138   virtual bool IsWriteBlockedDataBuffered() const OVERRIDE {
   1139     return false;
   1140   }
   1141 
   1142   IPEndPoint self_address_;
   1143 };
   1144 
   1145 TEST_P(EndToEndTest, ConnectionMigrationClientIPChanged) {
   1146   // Tests that the client's IP can not change during an established QUIC
   1147   // connection. If it changes, the connection is closed by the server as we do
   1148   // not yet support IP migration.
   1149   ASSERT_TRUE(Initialize());
   1150 
   1151   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   1152   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   1153 
   1154   WrongAddressWriter* writer = new WrongAddressWriter();
   1155 
   1156   writer->set_writer(new QuicDefaultPacketWriter(client_->client()->fd()));
   1157   QuicConnectionPeer::SetWriter(client_->client()->session()->connection(),
   1158                                 writer,
   1159                                 /* owns_writer= */ true);
   1160 
   1161   client_->SendSynchronousRequest("/bar");
   1162 
   1163   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   1164   EXPECT_EQ(QUIC_ERROR_MIGRATING_ADDRESS, client_->connection_error());
   1165 }
   1166 
   1167 TEST_P(EndToEndTest, ConnectionMigrationClientPortChanged) {
   1168   // Tests that the client's port can change during an established QUIC
   1169   // connection, and that doing so does not result in the connection being
   1170   // closed by the server.
   1171   ASSERT_TRUE(Initialize());
   1172 
   1173   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   1174   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   1175 
   1176   // Store the client address which was used to send the first request.
   1177   IPEndPoint old_address = client_->client()->client_address();
   1178 
   1179   // Stop listening on the old FD.
   1180   EpollServer* eps = client_->epoll_server();
   1181   int old_fd = client_->client()->fd();
   1182   eps->UnregisterFD(old_fd);
   1183   // Create a new socket before closing the old one, which will result in a new
   1184   // ephemeral port.
   1185   QuicClientPeer::CreateUDPSocket(client_->client());
   1186   close(old_fd);
   1187 
   1188   // The packet writer needs to be updated to use the new FD.
   1189   client_->client()->CreateQuicPacketWriter();
   1190 
   1191   // Change the internal state of the client and connection to use the new port,
   1192   // this is done because in a real NAT rebinding the client wouldn't see any
   1193   // port change, and so expects no change to incoming port.
   1194   // This is kind of ugly, but needed as we are simply swapping out the client
   1195   // FD rather than any more complex NAT rebinding simulation.
   1196   int new_port = client_->client()->client_address().port();
   1197   QuicClientPeer::SetClientPort(client_->client(), new_port);
   1198   QuicConnectionPeer::SetSelfAddress(
   1199       client_->client()->session()->connection(),
   1200       IPEndPoint(
   1201           client_->client()->session()->connection()->self_address().address(),
   1202           new_port));
   1203 
   1204   // Register the new FD for epoll events.
   1205   int new_fd = client_->client()->fd();
   1206   eps->RegisterFD(new_fd, client_->client(), EPOLLIN | EPOLLOUT | EPOLLET);
   1207 
   1208   // Send a second request, using the new FD.
   1209   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
   1210   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   1211 
   1212   // Verify that the client's ephemeral port is different.
   1213   IPEndPoint new_address = client_->client()->client_address();
   1214   EXPECT_EQ(old_address.address(), new_address.address());
   1215   EXPECT_NE(old_address.port(), new_address.port());
   1216 }
   1217 
   1218 
   1219 TEST_P(EndToEndTest, DifferentFlowControlWindowsQ019) {
   1220   // TODO(rjshade): Remove this test when removing QUIC_VERSION_19.
   1221   // Client and server can set different initial flow control receive windows.
   1222   // These are sent in CHLO/SHLO. Tests that these values are exchanged properly
   1223   // in the crypto handshake.
   1224 
   1225   const uint32 kClientIFCW = 123456;
   1226   set_client_initial_flow_control_receive_window(kClientIFCW);
   1227 
   1228   const uint32 kServerIFCW = 654321;
   1229   set_server_initial_flow_control_receive_window(kServerIFCW);
   1230 
   1231   ASSERT_TRUE(Initialize());
   1232   if (negotiated_version_ > QUIC_VERSION_19) {
   1233     return;
   1234   }
   1235 
   1236   // Values are exchanged during crypto handshake, so wait for that to finish.
   1237   client_->client()->WaitForCryptoHandshakeConfirmed();
   1238   server_thread_->WaitForCryptoHandshakeConfirmed();
   1239 
   1240   // Client should have the right value for server's receive window.
   1241   EXPECT_EQ(kServerIFCW, client_->client()
   1242                              ->session()
   1243                              ->config()
   1244                              ->ReceivedInitialFlowControlWindowBytes());
   1245 
   1246   // Server should have the right value for client's receive window.
   1247   server_thread_->Pause();
   1248   QuicDispatcher* dispatcher =
   1249       QuicServerPeer::GetDispatcher(server_thread_->server());
   1250   QuicSession* session = dispatcher->session_map().begin()->second;
   1251   EXPECT_EQ(kClientIFCW,
   1252             session->config()->ReceivedInitialFlowControlWindowBytes());
   1253   server_thread_->Resume();
   1254 }
   1255 
   1256 TEST_P(EndToEndTest, DifferentFlowControlWindowsQ020) {
   1257   // TODO(rjshade): Rename to DifferentFlowControlWindows when removing
   1258   // QUIC_VERSION_19.
   1259   // Client and server can set different initial flow control receive windows.
   1260   // These are sent in CHLO/SHLO. Tests that these values are exchanged properly
   1261   // in the crypto handshake.
   1262   const uint32 kClientStreamIFCW = 123456;
   1263   const uint32 kClientSessionIFCW = 234567;
   1264   set_client_initial_stream_flow_control_receive_window(kClientStreamIFCW);
   1265   set_client_initial_session_flow_control_receive_window(kClientSessionIFCW);
   1266 
   1267   const uint32 kServerStreamIFCW = 654321;
   1268   const uint32 kServerSessionIFCW = 765432;
   1269   set_server_initial_stream_flow_control_receive_window(kServerStreamIFCW);
   1270   set_server_initial_session_flow_control_receive_window(kServerSessionIFCW);
   1271 
   1272   ASSERT_TRUE(Initialize());
   1273   if (negotiated_version_ <= QUIC_VERSION_19) {
   1274     return;
   1275   }
   1276 
   1277   // Values are exchanged during crypto handshake, so wait for that to finish.
   1278   client_->client()->WaitForCryptoHandshakeConfirmed();
   1279   server_thread_->WaitForCryptoHandshakeConfirmed();
   1280 
   1281   // Open a data stream to make sure the stream level flow control is updated.
   1282   QuicSpdyClientStream* stream = client_->GetOrCreateStream();
   1283   stream->SendBody("hello", false);
   1284 
   1285   // Client should have the right values for server's receive window.
   1286   EXPECT_EQ(kServerStreamIFCW,
   1287             client_->client()
   1288                 ->session()
   1289                 ->config()
   1290                 ->ReceivedInitialStreamFlowControlWindowBytes());
   1291   EXPECT_EQ(kServerSessionIFCW,
   1292             client_->client()
   1293                 ->session()
   1294                 ->config()
   1295                 ->ReceivedInitialSessionFlowControlWindowBytes());
   1296   EXPECT_EQ(kServerStreamIFCW, QuicFlowControllerPeer::SendWindowOffset(
   1297                                    stream->flow_controller()));
   1298   EXPECT_EQ(kServerSessionIFCW,
   1299             QuicFlowControllerPeer::SendWindowOffset(
   1300                 client_->client()->session()->flow_controller()));
   1301 
   1302   // Server should have the right values for client's receive window.
   1303   server_thread_->Pause();
   1304   QuicDispatcher* dispatcher =
   1305       QuicServerPeer::GetDispatcher(server_thread_->server());
   1306   QuicSession* session = dispatcher->session_map().begin()->second;
   1307   EXPECT_EQ(kClientStreamIFCW,
   1308             session->config()->ReceivedInitialStreamFlowControlWindowBytes());
   1309   EXPECT_EQ(kClientSessionIFCW,
   1310             session->config()->ReceivedInitialSessionFlowControlWindowBytes());
   1311   EXPECT_EQ(kClientSessionIFCW, QuicFlowControllerPeer::SendWindowOffset(
   1312                                     session->flow_controller()));
   1313   server_thread_->Resume();
   1314 }
   1315 
   1316 TEST_P(EndToEndTest, HeadersAndCryptoStreamsNoConnectionFlowControl) {
   1317   // The special headers and crypto streams should be subject to per-stream flow
   1318   // control limits, but should not be subject to connection level flow control.
   1319   const uint32 kStreamIFCW = 123456;
   1320   const uint32 kSessionIFCW = 234567;
   1321   set_client_initial_stream_flow_control_receive_window(kStreamIFCW);
   1322   set_client_initial_session_flow_control_receive_window(kSessionIFCW);
   1323   set_server_initial_stream_flow_control_receive_window(kStreamIFCW);
   1324   set_server_initial_session_flow_control_receive_window(kSessionIFCW);
   1325 
   1326   ASSERT_TRUE(Initialize());
   1327   if (negotiated_version_ < QUIC_VERSION_21) {
   1328     return;
   1329   }
   1330 
   1331   // Wait for crypto handshake to finish. This should have contributed to the
   1332   // crypto stream flow control window, but not affected the session flow
   1333   // control window.
   1334   client_->client()->WaitForCryptoHandshakeConfirmed();
   1335   server_thread_->WaitForCryptoHandshakeConfirmed();
   1336 
   1337   QuicCryptoStream* crypto_stream =
   1338       QuicSessionPeer::GetCryptoStream(client_->client()->session());
   1339   EXPECT_LT(
   1340       QuicFlowControllerPeer::SendWindowSize(crypto_stream->flow_controller()),
   1341       kStreamIFCW);
   1342   EXPECT_EQ(kSessionIFCW, QuicFlowControllerPeer::SendWindowSize(
   1343                               client_->client()->session()->flow_controller()));
   1344 
   1345   // Send a request with no body, and verify that the connection level window
   1346   // has not been affected.
   1347   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   1348 
   1349   QuicHeadersStream* headers_stream =
   1350       QuicSessionPeer::GetHeadersStream(client_->client()->session());
   1351   EXPECT_LT(
   1352       QuicFlowControllerPeer::SendWindowSize(headers_stream->flow_controller()),
   1353       kStreamIFCW);
   1354   EXPECT_EQ(kSessionIFCW, QuicFlowControllerPeer::SendWindowSize(
   1355                               client_->client()->session()->flow_controller()));
   1356 
   1357   // Server should be in a similar state: connection flow control window should
   1358   // not have any bytes marked as received.
   1359   server_thread_->Pause();
   1360   QuicDispatcher* dispatcher =
   1361       QuicServerPeer::GetDispatcher(server_thread_->server());
   1362   QuicSession* session = dispatcher->session_map().begin()->second;
   1363   QuicFlowController* server_connection_flow_controller =
   1364       session->flow_controller();
   1365   EXPECT_EQ(kSessionIFCW, QuicFlowControllerPeer::ReceiveWindowSize(
   1366       server_connection_flow_controller));
   1367   server_thread_->Resume();
   1368 }
   1369 
   1370 TEST_P(EndToEndTest, RequestWithNoBodyWillNeverSendStreamFrameWithFIN) {
   1371   // Regression test for b/16010251.
   1372   // A stream created on receipt of a simple request with no body will never get
   1373   // a stream frame with a FIN. Verify that we don't keep track of the stream in
   1374   // the locally closed streams map: it will never be removed if so.
   1375   ASSERT_TRUE(Initialize());
   1376 
   1377   // Send a simple headers only request, and receive response.
   1378   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   1379   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   1380 
   1381   // Now verify that the server is not waiting for a final FIN or RST.
   1382   server_thread_->Pause();
   1383   QuicDispatcher* dispatcher =
   1384       QuicServerPeer::GetDispatcher(server_thread_->server());
   1385   QuicSession* session = dispatcher->session_map().begin()->second;
   1386   EXPECT_EQ(0u, QuicSessionPeer::GetLocallyClosedStreamsHighestOffset(
   1387       session).size());
   1388   server_thread_->Resume();
   1389 }
   1390 
   1391 }  // namespace
   1392 }  // namespace test
   1393 }  // namespace tools
   1394 }  // namespace net
   1395