Landing Recent QUIC changes until Sun Sep 4 03:41:00

net/tools/quic/end_to_end_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 #include <sys/epoll.h>
 
 #include <list>
 #include <memory>
 #include <string>
@@ skipping 1350 matching lines @@
     case kTBBR:
       expected_congestion_control_type = kBBR;
       break;
     case kQBIC:
       expected_congestion_control_type = kCubic;
       break;
     default:
       DLOG(FATAL) << "Unexpected congestion control tag";
   }
 
+  server_thread_->Pause();
   EXPECT_EQ(expected_congestion_control_type,
             QuicSentPacketManagerPeer::GetSendAlgorithm(
                 *static_cast<const QuicSentPacketManager*>(
                     GetSentPacketManagerFromFirstServerSession()))
                 ->GetCongestionControlType());
+  server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, LimitMaxOpenStreams) {
   // Server limits the number of max streams to 2.
   server_config_.SetMaxStreamsPerConnection(2, 2);
   // Client tries to negotiate for 10.
   client_config_.SetMaxStreamsPerConnection(10, 5);
 
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
@@ skipping 772 matching lines @@
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
 }
 
 // A test stream that gives |response_body_| as an error response body.
 class ServerStreamWithErrorResponseBody : public QuicSimpleServerStream {
  public:
   ServerStreamWithErrorResponseBody(QuicStreamId id,
                                     QuicSpdySession* session,
                                     string response_body)
-      : QuicSimpleServerStream(id, session), response_body_(response_body) {}
+      : QuicSimpleServerStream(id, session),
+        response_body_(std::move(response_body)) {}
 
   ~ServerStreamWithErrorResponseBody() override {}
 
  protected:
   void SendErrorResponse() override {
     DVLOG(1) << "Sending error response for stream " << id();
     SpdyHeaderBlock headers;
     headers[":status"] = "500";
     headers["content-length"] = base::UintToString(response_body_.size());
     // This method must call CloseReadSide to cause the test case, StopReading
     // is not sufficient.
     ReliableQuicStreamPeer::CloseReadSide(this);
     SendHeadersAndBody(std::move(headers), response_body_);
   }
 
   string response_body_;
 };
 
 class StreamWithErrorFactory : public QuicTestServer::StreamFactory {
  public:
   explicit StreamWithErrorFactory(string response_body)
-      : response_body_(response_body) {}
+      : response_body_(std::move(response_body)) {}
 
   ~StreamWithErrorFactory() override {}
 
   QuicSimpleServerStream* CreateStream(QuicStreamId id,
                                        QuicSpdySession* session) override {
     return new ServerStreamWithErrorResponseBody(id, session, response_body_);
   }
 
  private:
   string response_body_;
@@ skipping 415 matching lines @@
   AddRequestAndResponseWithServerPush("example.com", "/push_example", kBody,
                                       push_urls, kNumResources, 0);
   client_->client()->set_response_listener(new TestResponseListener);
 
   // Send the first request: this will trigger the server to send all the push
   // resources associated with this request, and these will be cached by the
   // client.
   EXPECT_EQ(kBody, client_->SendSynchronousRequest(
                        "https://example.com/push_example"));
 
-  for (string url : push_urls) {
+  for (const string& url : push_urls) {
     // Sending subsequent requesets will not actually send anything on the wire,
     // as the responses are already in the client's cache.
     DVLOG(1) << "send request for pushed stream on url " << url;
     string expected_body = "This is server push response body for " + url;
     string response_body = client_->SendSynchronousRequest(url);
     DVLOG(1) << "response body " << response_body;
     EXPECT_EQ(expected_body, response_body);
   }
   // Expect only original request has been sent and push responses have been
   // received as normal response.
@@ skipping 283 matching lines @@
   EXPECT_EQ(kBarResponseBody, client_->response_body());
   QuicConnectionStats client_stats =
       client_->client()->session()->connection()->GetStats();
   EXPECT_EQ(0u, client_stats.packets_lost);
   EXPECT_EQ(1, client_->client()->GetNumSentClientHellos());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net