Move remaining QUIC server files from net/quic/ to net/tools/quic/.

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_QUIC_SERVER_H_
-#define NET_QUIC_QUIC_SERVER_H_
+#ifndef NET_QUIC_TOOLS_QUIC_SIMPLE_SERVER_H_
+#define NET_QUIC_TOOLS_QUIC_SIMPLE_SERVER_H_
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
 #include "net/base/io_buffer.h"
 #include "net/base/ip_endpoint.h"
 #include "net/base/net_log.h"
 #include "net/quic/crypto/quic_crypto_server_config.h"
 #include "net/quic/quic_clock.h"
 #include "net/quic/quic_config.h"
 #include "net/quic/quic_connection_helper.h"
 
 namespace net {
 
+class UDPServerSocket;
+
+namespace tools {
+
+class QuicDispatcher;
 
 namespace test {
-class QuicServerPeer;
+class QuicSimpleServerPeer;
 }  // namespace test
 
-namespace tools {
-class QuicDispatcher;
-}  // namespace tools
+class QuicSimpleServer {
+ public:
+  QuicSimpleServer(const QuicConfig& config,
+                   const QuicVersionVector& supported_versions);
 
-class UDPServerSocket;
-
-class QuicServer {
- public:
-  QuicServer(const QuicConfig& config,
-             const QuicVersionVector& supported_versions);
-
-  virtual ~QuicServer();
+  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();
   }
 
   // SetProofSource sets the ProofSource that will be used to verify the
   // server's certificate, and takes ownership of |source|.
   void SetProofSource(ProofSource* source) {
     crypto_config_.SetProofSource(source);
   }
 
-  tools::QuicDispatcher* dispatcher() { return dispatcher_.get(); }
+  QuicDispatcher* dispatcher() { return dispatcher_.get(); }
 
  private:
-  friend class net::test::QuicServerPeer;
+  friend class test::QuicSimpleServerPeer;
 
   // Initialize the internal state of the server.
   void Initialize();
 
   // Accepts data from the framer and demuxes clients to sessions.
-  scoped_ptr<tools::QuicDispatcher> dispatcher_;
+  scoped_ptr<QuicDispatcher> dispatcher_;
 
   // Used by the helper_ to time alarms.
   QuicClock clock_;
 
   // Used to manage the message loop.
   QuicConnectionHelper helper_;
 
   // Listening socket. Also used for outbound client communication.
   scoped_ptr<UDPServerSocket> socket_;
 
@@ skipping 22 matching lines @@
 
   // The target buffer of the current read.
   scoped_refptr<IOBufferWithSize> read_buffer_;
 
   // The source address of the current read.
   IPEndPoint client_address_;
 
   // The log to use for the socket.
   NetLog net_log_;
 
-  base::WeakPtrFactory<QuicServer> weak_factory_;
+  base::WeakPtrFactory<QuicSimpleServer> weak_factory_;
 
-  DISALLOW_COPY_AND_ASSIGN(QuicServer);
+  DISALLOW_COPY_AND_ASSIGN(QuicSimpleServer);
 };
 
+}  // namespace tools
 }  // namespace net
 
-#endif  // NET_QUIC_QUIC_SERVER_H_
+#endif  // NET_QUIC_TOOLS_QUIC_SIMPLE_SERVER_H_