Index: remoting/protocol/pseudotcp_channel_factory.cc |
diff --git a/remoting/protocol/pseudotcp_channel_factory.cc b/remoting/protocol/pseudotcp_channel_factory.cc |
new file mode 100644 |
index 0000000000000000000000000000000000000000..689db92bde51b7fc45e81acb6fc24f26d5ef66f2 |
--- /dev/null |
+++ b/remoting/protocol/pseudotcp_channel_factory.cc |
@@ -0,0 +1,100 @@ |
+// 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/pseudotcp_channel_factory.h" |
+ |
+#include "base/bind.h" |
+#include "jingle/glue/pseudotcp_adapter.h" |
+#include "net/base/net_errors.h" |
+#include "net/socket/stream_socket.h" |
+#include "remoting/base/constants.h" |
+#include "remoting/protocol/datagram_channel_factory.h" |
+ |
+namespace remoting { |
+namespace protocol { |
+ |
+namespace { |
+ |
+// Value is chosen to balance the extra latency against the reduced |
+// load due to ACK traffic. |
+const int kTcpAckDelayMilliseconds = 10; |
+ |
+// Values for the TCP send and receive buffer size. This should be tuned to |
+// accommodate high latency network but not backlog the decoding pipeline. |
+const int kTcpReceiveBufferSize = 256 * 1024; |
+const int kTcpSendBufferSize = kTcpReceiveBufferSize + 30 * 1024; |
+ |
+} // namespace |
+ |
+PseudoTcpChannelFactory::PseudoTcpChannelFactory( |
+ DatagramChannelFactory* datagram_channel_factory) |
+ : datagram_channel_factory_(datagram_channel_factory) { |
+} |
+ |
+PseudoTcpChannelFactory::~PseudoTcpChannelFactory() { |
+ // CancelChannelCreation() is expected to be called before destruction. |
+ DCHECK(pending_sockets_.empty()); |
+} |
+ |
+void PseudoTcpChannelFactory::CreateChannel( |
+ const std::string& name, |
+ const ChannelCreatedCallback& callback) { |
+ datagram_channel_factory_->CreateChannel( |
+ name, |
+ base::Bind(&PseudoTcpChannelFactory::OnDatagramChannelCreated, |
+ base::Unretained(this), name, callback)); |
+} |
+ |
+void PseudoTcpChannelFactory::CancelChannelCreation(const std::string& name) { |
+ PendingSocketsMap::iterator it = pending_sockets_.find(name); |
+ if (it == pending_sockets_.end()) { |
+ datagram_channel_factory_->CancelChannelCreation(name); |
+ } else { |
+ delete it->second; |
+ pending_sockets_.erase(it); |
+ } |
+} |
+ |
+void PseudoTcpChannelFactory::OnDatagramChannelCreated( |
+ const std::string& name, |
+ const ChannelCreatedCallback& callback, |
+ scoped_ptr<net::Socket> datagram_socket) { |
+ jingle_glue::PseudoTcpAdapter* adapter = |
+ new jingle_glue::PseudoTcpAdapter(datagram_socket.release()); |
+ pending_sockets_[name] = adapter; |
+ |
+ adapter->SetSendBufferSize(kTcpSendBufferSize); |
+ adapter->SetReceiveBufferSize(kTcpReceiveBufferSize); |
+ adapter->SetNoDelay(true); |
+ adapter->SetAckDelay(kTcpAckDelayMilliseconds); |
+ |
+ // TODO(sergeyu): This is a hack to improve latency of the video channel. |
+ // Consider removing it once we have better flow control implemented. |
+ if (name == kVideoChannelName) |
+ adapter->SetWriteWaitsForSend(true); |
+ |
+ int result = adapter->Connect( |
+ base::Bind(&PseudoTcpChannelFactory::OnPseudoTcpConnected, |
+ base::Unretained(this), name, callback)); |
+ if (result != net::ERR_IO_PENDING) |
+ OnPseudoTcpConnected(name, callback, result); |
+} |
+ |
+void PseudoTcpChannelFactory::OnPseudoTcpConnected( |
+ const std::string& name, |
+ const ChannelCreatedCallback& callback, |
+ int result) { |
+ PendingSocketsMap::iterator it = pending_sockets_.find(name); |
+ DCHECK(it != pending_sockets_.end()); |
+ scoped_ptr<net::StreamSocket> socket(it->second); |
+ pending_sockets_.erase(it); |
+ |
+ if (result != net::OK) |
+ socket.reset(); |
+ |
+ callback.Run(socket.Pass()); |
+} |
+ |
+} // namespace protocol |
+} // namespace remoting |