Fix end_to_end_test performance regression caused by using mutexes

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 <string>
 #include <vector>
 
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
@@ skipping 200 matching lines @@
   }
 
   virtual void TearDown() {
     StopServer();
   }
 
   void StartServer() {
     server_thread_.reset(new ServerThread(server_address_, server_config_,
                                           server_supported_versions_,
                                           strike_register_no_startup_period_));
-    server_thread_->Start();
-    server_thread_->WaitForServerStartup();
+    server_thread_->Initialize();
     server_address_ = IPEndPoint(server_address_.address(),
                                  server_thread_->GetPort());
     QuicDispatcher* dispatcher =
         QuicServerPeer::GetDispatcher(server_thread_->server());
+    QuicDispatcherPeer::UseWriter(dispatcher, server_writer_);
     server_writer_->SetConnectionHelper(
         QuicDispatcherPeer::GetHelper(dispatcher));
-    // TODO(rtenneti): Enable server_thread's Pause/Resume.
-    // server_thread_->Pause();
-    QuicDispatcherPeer::UseWriter(dispatcher, server_writer_);
-    // TODO(rtenneti): Enable server_thread's Pause/Resume.
-    // server_thread_->Resume();
+    server_thread_->Start();
     server_started_ = true;
   }
 
   void StopServer() {
     if (!server_started_)
       return;
     if (server_thread_.get()) {
       server_thread_->Quit();
       server_thread_->Join();
     }
@@ skipping 477 matching lines @@
 TEST_P(EndToEndTest, InitialRTT) {
   // Client tries to negotiate twice the server's max and negotiation settles
   // on the max.
   client_config_.set_initial_round_trip_time_us(2 * kMaxInitialRoundTripTimeUs,
                                                 0);
 
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
   server_thread_->WaitForCryptoHandshakeConfirmed();
 
-  // Pause the server so we can access the server's internals without races.
-  // TODO(rtenneti): Enable server_thread's Pause/Resume.
-  // server_thread_->Pause();
+  server_thread_->Pause();
   QuicDispatcher* dispatcher =
       QuicServerPeer::GetDispatcher(server_thread_->server());
   ASSERT_EQ(1u, dispatcher->session_map().size());
   QuicSession* session = dispatcher->session_map().begin()->second;
   QuicConfig* client_negotiated_config = client_->client()->session()->config();
   QuicConfig* server_negotiated_config = session->config();
   const QuicSentPacketManager& client_sent_packet_manager =
       client_->client()->session()->connection()->sent_packet_manager();
   const QuicSentPacketManager& server_sent_packet_manager =
       session->connection()->sent_packet_manager();
 
   EXPECT_EQ(kMaxInitialRoundTripTimeUs,
             client_negotiated_config->initial_round_trip_time_us());
   EXPECT_EQ(kMaxInitialRoundTripTimeUs,
             server_negotiated_config->initial_round_trip_time_us());
   // Now that acks have been exchanged, the RTT estimate has decreased on the
   // server and is not infinite on the client.
   EXPECT_FALSE(client_sent_packet_manager.SmoothedRtt().IsInfinite());
   EXPECT_GE(static_cast<int64>(kMaxInitialRoundTripTimeUs),
             server_sent_packet_manager.SmoothedRtt().ToMicroseconds());
-  // TODO(rtenneti): Enable server_thread's Pause/Resume.
-  // server_thread_->Resume();
+  server_thread_->Resume();
 }
 
 TEST_P(EndToEndTest, ResetConnection) {
   ASSERT_TRUE(Initialize());
   client_->client()->WaitForCryptoHandshakeConfirmed();
 
   EXPECT_EQ(kFooResponseBody, client_->SendSynchronousRequest("/foo"));
   EXPECT_EQ(200u, client_->response_headers()->parsed_response_code());
   client_->ResetConnection();
   EXPECT_EQ(kBarResponseBody, client_->SendSynchronousRequest("/bar"));
@@ skipping 97 matching lines @@
   client_->SendSynchronousRequest("/bar");
 
   EXPECT_EQ(QUIC_STREAM_CONNECTION_ERROR, client_->stream_error());
   EXPECT_EQ(QUIC_ERROR_MIGRATING_ADDRESS, client_->connection_error());
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace tools
 }  // namespace net