Implement QuicChannel and QuicChannelFactory

remoting/protocol/fake_datagram_socket.cc

 // 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.
 
 #include "remoting/protocol/fake_datagram_socket.h"
 
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
@@ skipping 51 matching lines @@
     read_buffer_size_ = buf_len;
     read_callback_ = callback;
     return net::ERR_IO_PENDING;
   }
 }
 
 int FakeDatagramSocket::Send(const scoped_refptr<net::IOBuffer>& buf,
                              int buf_len,
                              const net::CompletionCallback& callback) {
   EXPECT_TRUE(task_runner_->BelongsToCurrentThread());
+  EXPECT_FALSE(send_pending_);
+
+  if (async_send_) {
+    send_pending_ = true;
+    task_runner_->PostTask(
+        FROM_HERE,
+        base::Bind(&FakeDatagramSocket::DoAsyncSend, weak_factory_.GetWeakPtr(),
+                   buf, buf_len, callback));
+    return net::ERR_IO_PENDING;
+  } else {
+    return DoSend(buf, buf_len);
+  }
+}
+
+void FakeDatagramSocket::DoAsyncSend(const scoped_refptr<net::IOBuffer>& buf,
+                                     int buf_len,
+                                     const net::CompletionCallback& callback) {
+  EXPECT_TRUE(task_runner_->BelongsToCurrentThread());
+
+  EXPECT_TRUE(send_pending_);
+  send_pending_ = false;
+  callback.Run(DoSend(buf, buf_len));
+}
+
+int FakeDatagramSocket::DoSend(const scoped_refptr<net::IOBuffer>& buf,
+                               int buf_len) {
+  EXPECT_TRUE(task_runner_->BelongsToCurrentThread());
+
+  if (next_send_error_ != net::OK) {
+    int r = next_send_error_;
+    next_send_error_ = net::OK;
+    return r;
+  }
+
   written_packets_.push_back(std::string());
   written_packets_.back().assign(buf->data(), buf->data() + buf_len);
 
   if (peer_socket_.get()) {
     task_runner_->PostTask(
         FROM_HERE,
         base::Bind(&FakeDatagramSocket::AppendInputPacket, peer_socket_,
                    std::string(buf->data(), buf->data() + buf_len)));
   }
 
@@ skipping 70 matching lines @@
     callback.Run(owned_socket.Pass());
 }
 
 void FakeDatagramChannelFactory::CancelChannelCreation(
     const std::string& name) {
   channels_.erase(name);
 }
 
 }  // namespace protocol
 }  // namespace remoting