Add P2PDatagramSocket and P2PStreamSocket interfaces.

remoting/base/buffered_socket_writer.cc

 // Copyright 2015 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.
 
 #include "remoting/base/buffered_socket_writer.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/stl_util.h"
 #include "base/thread_task_runner_handle.h"
 #include "net/base/net_errors.h"
 
 namespace remoting {
 
 struct BufferedSocketWriterBase::PendingPacket {
   PendingPacket(scoped_refptr<net::IOBufferWithSize> data,
                 const base::Closure& done_task)
       : data(data),
         done_task(done_task) {
   }
 
   scoped_refptr<net::IOBufferWithSize> data;
   base::Closure done_task;
 };
 
 BufferedSocketWriterBase::BufferedSocketWriterBase()
-    : socket_(nullptr),
-      write_pending_(false),
+    : write_pending_(false),
       closed_(false),
       destroyed_flag_(nullptr) {
 }
 
-void BufferedSocketWriterBase::Init(net::Socket* socket,
-                                    const WriteFailedCallback& callback) {
+void BufferedSocketWriterBase::Init(
+    const WriteCallback& write_callback,
+    const WriteFailedCallback& write_failed_callback) {
   DCHECK(CalledOnValidThread());
-  DCHECK(socket);
-  socket_ = socket;
-  write_failed_callback_ = callback;
+  DCHECK(write_callback_.is_null());
+  write_callback_ = write_callback;
+  write_failed_callback_ = write_failed_callback;
 }
 
 bool BufferedSocketWriterBase::Write(
     scoped_refptr<net::IOBufferWithSize> data, const base::Closure& done_task) {
   DCHECK(CalledOnValidThread());
-  DCHECK(socket_);
   DCHECK(data.get());
 
   // Don't write after Close().
   if (closed_)
     return false;
 
   queue_.push_back(new PendingPacket(data, done_task));
 
   DoWrite();
 
   // DoWrite() may trigger OnWriteError() to be called.
   return !closed_;
 }
 
 void BufferedSocketWriterBase::DoWrite() {
   DCHECK(CalledOnValidThread());
-  DCHECK(socket_);
+  DCHECK(!write_callback_.is_null());
 
   // Don't try to write if there is another write pending.
   if (write_pending_)
     return;
 
   // Don't write after Close().
   if (closed_)
     return;
 
   while (true) {
     net::IOBuffer* current_packet;
     int current_packet_size;
     GetNextPacket(&current_packet, &current_packet_size);
 
     // Return if the queue is empty.
     if (!current_packet)
       return;
 
-    int result = socket_->Write(
-        current_packet, current_packet_size,
-        base::Bind(&BufferedSocketWriterBase::OnWritten,
-                   base::Unretained(this)));
+    int result =
+        write_callback_.Run(current_packet, current_packet_size,
+                            base::Bind(&BufferedSocketWriterBase::OnWritten,
+                                       base::Unretained(this)));
     bool write_again = false;
     HandleWriteResult(result, &write_again);
     if (!write_again)
       return;
   }
 }
 
 void BufferedSocketWriterBase::HandleWriteResult(int result,
                                                  bool* write_again) {
   *write_again = false;
@@ skipping 118 matching lines @@
 }
 
 void BufferedDatagramWriter::OnError(int result) {
   // Nothing to do here.
 }
 
 BufferedDatagramWriter::~BufferedDatagramWriter() {
 }
 
 }  // namespace remoting