Port QuicServer to Chrome network stack

net/quic/quic_server.h

Index: net/quic/quic_server.h
diff --git a/net/tools/quic/quic_server.h b/net/quic/quic_server.h
similarity index 46%
copy from net/tools/quic/quic_server.h
copy to net/quic/quic_server.h
index 119fa78ee4e01352ad0f886843adab9759d9e9aa..89177dc01d00a51b244d0b34db7d9aec23870c7b 100644
--- a/net/tools/quic/quic_server.h
+++ b/net/quic/quic_server.h
@@ -5,65 +5,49 @@
 // A toy server, which listens on a specified address for QUIC traffic and
 // handles incoming responses.
 
-#ifndef NET_TOOLS_QUIC_QUIC_SERVER_H_
-#define NET_TOOLS_QUIC_QUIC_SERVER_H_
+#ifndef NET_QUIC_QUIC_SERVER_H_
+#define NET_QUIC_QUIC_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/quic/crypto/quic_crypto_server_config.h"
+#include "net/quic/quic_clock.h"
 #include "net/quic/quic_config.h"
-#include "net/quic/quic_framer.h"
-#include "net/tools/epoll_server/epoll_server.h"
-#include "net/tools/quic/quic_dispatcher.h"
 
 namespace net {
 
-namespace tools {
 
 namespace test {
 class QuicServerPeer;
 }  // namespace test
 
+class QuicConnectionHelperInterface;
 class QuicDispatcher;
+class UDPServerSocket;
 
-class QuicServer : public EpollCallbackInterface {
+class NET_EXPORT_PRIVATE QuicServer {
  public:
-  QuicServer();
   QuicServer(const QuicConfig& config,
              const QuicVersionVector& supported_versions,
              uint32 server_initial_flow_control_receive_window);
 
   virtual ~QuicServer();
 
-  // Start listening on the specified address.
-  bool Listen(const IPEndPoint& address);
+  // Start listening on the specified address. Returns an error code.
+  int Listen(const IPEndPoint& address);
 
-  // Wait up to 50ms, and handle any events which occur.
-  void WaitForEvents();
-
-  // Server deletion is imminent.  Start cleaning up the epoll server.
+  // Server deletion is imminent. Start cleaning up.
   void Shutdown();
 
-  // From EpollCallbackInterface
-  virtual void OnRegistration(EpollServer* eps,
-                              int fd,
-                              int event_mask) OVERRIDE {}
-  virtual void OnModification(int fd, int event_mask) OVERRIDE {}
-  virtual void OnEvent(int fd, EpollEvent* event) OVERRIDE;
-  virtual void OnUnregistration(int fd, bool replaced) OVERRIDE {}
-
-  // Reads a packet from the given fd, and then passes it off to
-  // the QuicDispatcher.  Returns true if a packet is read, false
-  // otherwise.
-  // If packets_dropped is non-null, the socket is configured to track
-  // dropped packets, and some packets are read, it will be set to the number of
-  // dropped packets.
-  static bool ReadAndDispatchSinglePacket(int fd, int port,
-                                          QuicDispatcher* dispatcher,
-                                          uint32* packets_dropped);
-
-  virtual void OnShutdown(EpollServer* eps, int fd) OVERRIDE {}
+  // 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();
@@ -75,40 +59,21 @@ class QuicServer : public EpollCallbackInterface {
     crypto_config_.SetProofSource(source);
   }
 
-  bool overflow_supported() { return overflow_supported_; }
-
-  uint32 packets_dropped() { return packets_dropped_; }
-
-  int port() { return port_; }
-
  private:
-  friend class net::tools::test::QuicServerPeer;
+  friend class net::test::QuicServerPeer;
 
   // Initialize the internal state of the server.
   void Initialize();
 
   // Accepts data from the framer and demuxes clients to sessions.
   scoped_ptr<QuicDispatcher> dispatcher_;
-  // Frames incoming packets and hands them to the dispatcher.
-  EpollServer epoll_server_;
-
-  // The port the server is listening on.
-  int port_;
-
-  // Listening connection.  Also used for outbound client communication.
-  int fd_;
 
-  // If overflow_supported_ is true this will be the number of packets dropped
-  // during the lifetime of the server.  This may overflow if enough packets
-  // are dropped.
-  uint32 packets_dropped_;
+  QuicClock clock_;
 
-  // True if the kernel supports SO_RXQ_OVFL, the number of packets dropped
-  // because the socket would otherwise overflow.
-  bool overflow_supported_;
+  QuicConnectionHelperInterface* helper_;
 
-  // If true, use recvmmsg for reading.
-  bool use_recvmmsg_;
+  // Listening socket. Also used for outbound client communication.
+  scoped_ptr<UDPServerSocket> socket_;
 
   // config_ contains non-crypto parameters that are negotiated in the crypto
   // handshake.
@@ -126,10 +91,28 @@ class QuicServer : public EpollCallbackInterface {
   // connections.
   uint32 server_initial_flow_control_receive_window_;
 
+  // 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_;
+
+  // The number of iterations of the read loop that have completed synchronously
+  // and without posting a new task to the message loop.
+  int synchronous_read_count_;
+
+  // The target buffer of the current read.
+  scoped_refptr<IOBufferWithSize> read_buffer_;
+
+  // The source address of the current read.
+  IPEndPoint read_addr_;
+
+  base::WeakPtrFactory<QuicServer> weak_factory_;
+
   DISALLOW_COPY_AND_ASSIGN(QuicServer);
 };
 
-}  // namespace tools
 }  // namespace net
 
-#endif  // NET_TOOLS_QUIC_QUIC_SERVER_H_
+#endif  // NET_QUIC_QUIC_SERVER_H_