Move the chromium specific QUIC end-to-end tests from net/quic/core

net/tools/quic/quic_simple_server.h

 // Copyright 2014 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.
 //
 // A toy server, which listens on a specified address for QUIC traffic and
 // handles incoming responses.
 
 #ifndef NET_QUIC_TOOLS_QUIC_SIMPLE_SERVER_H_
 #define NET_QUIC_TOOLS_QUIC_SIMPLE_SERVER_H_
 
@@ skipping 15 matching lines @@
 
 
 class QuicDispatcher;
 
 namespace test {
 class QuicSimpleServerPeer;
 }  // namespace test
 
 class QuicSimpleServer {
  public:
-  QuicSimpleServer(std::unique_ptr<ProofSource> proof_source,
-                   const QuicConfig& config,
-                   const QuicVersionVector& supported_versions);
+  QuicSimpleServer(
+      std::unique_ptr<ProofSource> proof_source,
+      const QuicConfig& config,
+      const QuicCryptoServerConfig::ConfigOptions& crypto_config_options,
+      const QuicVersionVector& supported_versions);
 
   virtual ~QuicSimpleServer();
 
   // Start listening on the specified address. Returns an error code.
   int Listen(const IPEndPoint& address);
 
   // Server deletion is imminent. Start cleaning up.
   void Shutdown();
 
   // Start reading on the socket. On asynchronous reads, this registers
   // OnReadComplete as the callback, which will then call StartReading again.
   void StartReading();
 
   // Called on reads that complete asynchronously. Dispatches the packet and
   // continues the read loop.
   void OnReadComplete(int result);
 
   void SetStrikeRegisterNoStartupPeriod() {
     crypto_config_.set_strike_register_no_startup_period();
   }
 
   QuicDispatcher* dispatcher() { return dispatcher_.get(); }
 
+  IPEndPoint server_address() const { return server_address_; }
+
  private:
   friend class test::QuicSimpleServerPeer;
 
   // Initialize the internal state of the server.
   void Initialize();
 
   QuicVersionManager version_manager_;
 
   // Accepts data from the framer and demuxes clients to sessions.
   std::unique_ptr<QuicDispatcher> dispatcher_;
 
   // Used by the helper_ to time alarms.
   QuicClock clock_;
 
   // Used to manage the message loop. Owned by dispatcher_.
   QuicChromiumConnectionHelper* helper_;
 
   // Used to manage the message loop. Owned by dispatcher_.
   QuicChromiumAlarmFactory* alarm_factory_;
 
   // Listening socket. Also used for outbound client communication.
   std::unique_ptr<UDPServerSocket> socket_;
 
   // config_ contains non-crypto parameters that are negotiated in the crypto
   // handshake.
   QuicConfig config_;
+  // crypto_config_ contains crypto parameters that are negotiated in the crypto
+  // handshake.
+  QuicCryptoServerConfig::ConfigOptions crypto_config_options_;
   // crypto_config_ contains crypto parameters for the handshake.
   QuicCryptoServerConfig crypto_config_;
 
   // The address that the server listens on.
   IPEndPoint server_address_;
 
   // Keeps track of whether a read is currently in flight, after which
   // OnReadComplete will be called.
   bool read_pending_;
 
@@ skipping 11 matching lines @@
   NetLog net_log_;
 
   base::WeakPtrFactory<QuicSimpleServer> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicSimpleServer);
 };
 
 }  // namespace net
 
 #endif  // NET_QUIC_TOOLS_QUIC_SIMPLE_SERVER_H_