Factor out ServerThread from the QUIC EndToEndTest in order to reuse in

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 "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/synchronization/waitable_event.h"
-#include "base/threading/simple_thread.h"
 #include "net/base/ip_endpoint.h"
 #include "net/quic/crypto/aes_128_gcm_12_encrypter.h"
 #include "net/quic/crypto/null_encrypter.h"
 #include "net/quic/quic_framer.h"
 #include "net/quic/quic_packet_creator.h"
 #include "net/quic/quic_protocol.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_session_peer.h"
 #include "net/quic/test_tools/reliable_quic_stream_peer.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/quic_in_memory_cache.h"
 #include "net/tools/quic/quic_server.h"
 #include "net/tools/quic/quic_socket_utils.h"
 #include "net/tools/quic/test_tools/http_message_test_utils.h"
 #include "net/tools/quic/test_tools/quic_client_peer.h"
 #include "net/tools/quic/test_tools/quic_epoll_connection_helper_peer.h"
 #include "net/tools/quic/test_tools/quic_test_client.h"
+#include "net/tools/quic/test_tools/server_thread.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using base::WaitableEvent;
 using net::test::QuicConnectionPeer;
 using net::test::QuicSessionPeer;
 using net::test::ReliableQuicStreamPeer;
 using std::string;
 
 namespace net {
@@ skipping 10 matching lines @@
     "https://www.google.com/foo/test/a/request/string/longer/than/25/bytes";
 
 void GenerateBody(string* body, int length) {
   body->clear();
   body->reserve(length);
   for (int i = 0; i < length; ++i) {
     body->append(1, static_cast<char>(32 + i % (126 - 32)));
   }
 }
 
-
-// Simple wrapper class to run server in a thread.
-class ServerThread : public base::SimpleThread {
- public:
-  ServerThread(IPEndPoint address,
-               const QuicConfig& config,
-               bool strike_register_no_startup_period)
-      : SimpleThread("server_thread"),
-        listening_(true, false),
-        quit_(true, false),
-        server_(config),
-        address_(address),
-        port_(0) {
-    if (strike_register_no_startup_period) {
-      server_.SetStrikeRegisterNoStartupPeriod();
-    }
-  }
-  virtual ~ServerThread() {
-  }
-
-  virtual void Run() OVERRIDE {
-    server_.Listen(address_);
-
-    port_lock_.Acquire();
-    port_ = server_.port();
-    port_lock_.Release();
-
-    listening_.Signal();
-    while (!quit_.IsSignaled()) {
-      server_.WaitForEvents();
-    }
-    server_.Shutdown();
-  }
-
-  int GetPort() {
-    port_lock_.Acquire();
-    int rc = port_;
-    port_lock_.Release();
-    return rc;
-  }
-
-  WaitableEvent* listening() { return &listening_; }
-  WaitableEvent* quit() { return &quit_; }
-
- private:
-  WaitableEvent listening_;
-  WaitableEvent quit_;
-  base::Lock port_lock_;
-  QuicServer server_;
-  IPEndPoint address_;
-  int port_;
-
-  DISALLOW_COPY_AND_ASSIGN(ServerThread);
-};
-
 class EndToEndTest : public ::testing::TestWithParam<QuicVersion> {
  public:
   static void SetUpTestCase() {
     QuicInMemoryCache::GetInstance()->ResetForTests();
   }
 
  protected:
   EndToEndTest()
       : server_hostname_("example.com"),
         server_started_(false),
@@ skipping 48 matching lines @@
 
   void StopServer() {
     if (!server_started_)
       return;
     if (server_thread_.get()) {
       server_thread_->quit()->Signal();
       server_thread_->Join();
     }
   }
 
-  void AddToCache(const StringPiece& method,
-                  const StringPiece& path,
-                  const StringPiece& version,
-                  const StringPiece& response_code,
-                  const StringPiece& response_detail,
-                  const StringPiece& body) {
-    BalsaHeaders request_headers, response_headers;
-    request_headers.SetRequestFirstlineFromStringPieces(method,
-                                                        path,
-                                                        version);
-    response_headers.SetRequestFirstlineFromStringPieces(version,
-                                                         response_code,
-                                                         response_detail);
-    response_headers.AppendHeader("content-length",
-                                  base::IntToString(body.length()));
-
-    // Check if response already exists and matches.
-    QuicInMemoryCache* cache = QuicInMemoryCache::GetInstance();
-    const QuicInMemoryCache::Response* cached_response =
-        cache->GetResponse(request_headers);
-    if (cached_response != NULL) {
-      string cached_response_headers_str, response_headers_str;
-      cached_response->headers().DumpToString(&cached_response_headers_str);
-      response_headers.DumpToString(&response_headers_str);
-      CHECK_EQ(cached_response_headers_str, response_headers_str);
-      CHECK_EQ(cached_response->body(), body);
-      return;
-    }
-    cache->AddResponse(request_headers, response_headers, body);
+  void AddToCache(StringPiece method,
+                  StringPiece path,
+                  StringPiece version,
+                  StringPiece response_code,
+                  StringPiece response_detail,
+                  StringPiece body) {
+    QuicInMemoryCache::GetInstance()->AddOrVerifyResponse(
+        method, path, version, response_code, response_detail, body);
   }
 
   IPEndPoint server_address_;
   string server_hostname_;
   scoped_ptr<ServerThread> server_thread_;
   scoped_ptr<QuicTestClient> client_;
   bool server_started_;
   QuicConfig client_config_;
   QuicConfig server_config_;
   QuicVersion version_;
@@ skipping 512 matching lines @@
   QuicEpollConnectionHelperPeer::SetWriter(helper, NULL);
 
   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