Add P2PDatagramSocket and P2PStreamSocket interfaces.

remoting/base/buffered_socket_writer.h

 // 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.
 
 #ifndef REMOTING_BASE_BUFFERED_SOCKET_WRITER_H_
 #define REMOTING_BASE_BUFFERED_SOCKET_WRITER_H_
 
 #include <list>
 
 #include "base/callback.h"
 #include "base/synchronization/lock.h"
 #include "base/threading/non_thread_safe.h"
+#include "net/base/completion_callback.h"
 #include "net/base/io_buffer.h"
-#include "net/socket/socket.h"
-
-namespace net {
-class Socket;
-}  // namespace net
 
 namespace remoting {
 
 // BufferedSocketWriter and BufferedDatagramWriter implement write data queue
 // for stream and datagram sockets. BufferedSocketWriterBase is a base class
 // that implements base functionality common for streams and datagrams.
 // These classes are particularly useful when data comes from a thread
 // that doesn't own the socket, as Write() can be called from any thread.
 // Whenever new data is written it is just put in the queue, and then written
 // on the thread that owns the socket. GetBufferChunks() and GetBufferSize()
 // can be used to throttle writes.
-
 class BufferedSocketWriterBase : public base::NonThreadSafe {
  public:
+  typedef base::Callback<int(net::IOBuffer* buf, int buf_len,
+                             const net::CompletionCallback& callback)>
+      WriteCallback;
   typedef base::Callback<void(int)> WriteFailedCallback;
 
   BufferedSocketWriterBase();
   virtual ~BufferedSocketWriterBase();
 
   // Initializes the writer. Must be called on the thread that will be used
   // to access the socket in the future. |callback| will be called after each
-  // failed write. Caller retains ownership of |socket|.
-  // TODO(sergeyu): Change it so that it take ownership of |socket|.
-  void Init(net::Socket* socket, const WriteFailedCallback& callback);
+  // failed write.
+  void Init(const WriteCallback& write_callback,
+            const WriteFailedCallback& write_failed_callback);
 
   // Puts a new data chunk in the buffer. Returns false and doesn't enqueue
   // the data if called before Init(). Can be called on any thread.
   bool Write(scoped_refptr<net::IOBufferWithSize> buffer,
              const base::Closure& done_task);

[Wez, 2015/07/10 01:18:24]

Not necessarily for this CL, but this class seems overly complex; we could
replace it with separate Stream and Datagram implementations (the Datagram one
just queues the buffers and sends them; no need to track positions within
buffers) and have those implement P2PStreamSocket/DatagramSocket respectively -
WDYT?

[Sergey Ulanov, 2015/07/10 20:48:57]

Simplified this code now. BufferedDatagramWriter was never used (and there were
no tests). I don't think we want to implement P2PStreamSocket here because this
class deals only with writing and Write() semantics is different.

 
   // Returns true when there is data waiting to be written.
   bool has_data_pending() { return !queue_.empty(); }
 
   // Stops writing and drops current buffers. Must be called on the
   // network thread.
   void Close();
 
  protected:
   struct PendingPacket;
@@ skipping 20 matching lines @@
   virtual void OnError(int result) = 0;
 
  private:
   void DoWrite();
   void HandleWriteResult(int result, bool* write_again);
   void OnWritten(int result);
 
   // This method is called when an error is encountered.
   void HandleError(int result);
 
-  net::Socket* socket_;
+  WriteCallback write_callback_;
   WriteFailedCallback write_failed_callback_;
 
   bool write_pending_;
 
   bool closed_;
 
   bool* destroyed_flag_;
 };
 
 class BufferedSocketWriter : public BufferedSocketWriterBase {
@@ skipping 17 matching lines @@
 
  protected:
   void GetNextPacket(net::IOBuffer** buffer, int* size) override;
   base::Closure AdvanceBufferPosition(int written) override;
   void OnError(int result) override;
 };
 
 }  // namespace remoting
 
 #endif  // REMOTING_BASE_BUFFERED_SOCKET_WRITER_H_