Port QuicServer to Chrome network stack

net/quic/quic_server_packet_writer.h

Index: net/quic/quic_server_packet_writer.h
diff --git a/net/quic/quic_server_packet_writer.h b/net/quic/quic_server_packet_writer.h
index 63829935521019e5712e27410f70bbc38485ff40..1c17e42bdc91d22a9eaf43f03353163fab0ac226 100644
--- a/net/quic/quic_server_packet_writer.h
+++ b/net/quic/quic_server_packet_writer.h
@@ -11,38 +11,57 @@
 #include "net/quic/quic_connection.h"
 #include "net/quic/quic_packet_writer.h"
 #include "net/quic/quic_protocol.h"
-#include "net/udp/udp_server_socket.h"
 
 namespace net {
 
+class QuicBlockedWriterInterface;
+class UDPServerSocket;
 struct WriteResult;
 
 // Chrome specific packet writer which uses a UDPServerSocket for writing
 // data.
 class QuicServerPacketWriter : public QuicPacketWriter {
  public:
-  QuicServerPacketWriter();
-  explicit QuicServerPacketWriter(UDPServerSocket* socket);
+  typedef base::Callback<void(WriteResult)> WriteCallback;
+
+  QuicServerPacketWriter(UDPServerSocket* socket,
+                         QuicBlockedWriterInterface* blocked_writer);
   virtual ~QuicServerPacketWriter();
 
-  // QuicPacketWriter
-  virtual WriteResult WritePacket(const char* buffer,
-                                  size_t buf_len,
-                                  const net::IPAddressNumber& self_address,
-                                  const net::IPEndPoint& peer_address) OVERRIDE;
+  // Use this method to write packets rather than WritePacket:
+  // QuicServerPacketWriter requires a callback to exist for every write, which
+  // will be called once the write completes.
+  virtual WriteResult WritePacketWithCallback(
+      const char* buffer,
+      size_t buf_len,
+      const IPAddressNumber& self_address,
+      const IPEndPoint& peer_address,
+      WriteCallback callback);
+
+  void OnWriteComplete(int rv);

[wtc, 2014/06/24 01:06:48]

The Style Guide recommends that declaration order in the .h file matches the
definition order in the .cc file. So please make the two orders match as much as
possible. For example, OnWriteComplete should be declared after SetWritable.

See
http://google-styleguide.googlecode.com/svn/trunk/cppguide.xml#Declaration_Order:

Method definitions in the corresponding .cc file should be the same as the
declaration order, as much as possible. 

[dmziegler, 2014/06/24 19:01:18]

Done.

+
+  // QuicPacketWriter implementation:
   virtual bool IsWriteBlockedDataBuffered() const OVERRIDE;
   virtual bool IsWriteBlocked() const OVERRIDE;
   virtual void SetWritable() OVERRIDE;
 
-  void OnWriteComplete(int rv);
-  void SetConnection(QuicConnection* connection) {
-    connection_ = connection;
-  }
-
+ protected:
+  // Do not call WritePacket on its own -- use WritePacketWithCallback
+  virtual WriteResult WritePacket(const char* buffer,
+                                  size_t buf_len,
+                                  const IPAddressNumber& self_address,
+                                  const IPEndPoint& peer_address) OVERRIDE;
  private:
   base::WeakPtrFactory<QuicServerPacketWriter> weak_factory_;
   UDPServerSocket* socket_;
-  QuicConnection* connection_;
+
+  // To be notified after every successful asynchronous write.
+  QuicBlockedWriterInterface* blocked_writer_;
+
+  // To call once the write completes.
+  WriteCallback callback_;
+
+  // Whether a write is currently in flight.
   bool write_blocked_;
 
   DISALLOW_COPY_AND_ASSIGN(QuicServerPacketWriter);