1 // Copyright 2014 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "remoting/protocol/pseudotcp_channel_factory.h" 6 7 #include "base/bind.h" 8 #include "jingle/glue/pseudotcp_adapter.h" 9 #include "net/base/net_errors.h" 10 #include "net/socket/stream_socket.h" 11 #include "remoting/base/constants.h" 12 #include "remoting/protocol/datagram_channel_factory.h" 13 14 namespace remoting { 15 namespace protocol { 16 17 namespace { 18 19 // Value is chosen to balance the extra latency against the reduced 20 // load due to ACK traffic. 21 const int kTcpAckDelayMilliseconds = 10; 22 23 // Values for the TCP send and receive buffer size. This should be tuned to 24 // accommodate high latency network but not backlog the decoding pipeline. 25 const int kTcpReceiveBufferSize = 256 * 1024; 26 const int kTcpSendBufferSize = kTcpReceiveBufferSize + 30 * 1024; 27 28 } // namespace 29 30 PseudoTcpChannelFactory::PseudoTcpChannelFactory( 31 DatagramChannelFactory* datagram_channel_factory) 32 : datagram_channel_factory_(datagram_channel_factory) { 33 } 34 35 PseudoTcpChannelFactory::~PseudoTcpChannelFactory() { 36 // CancelChannelCreation() is expected to be called before destruction. 37 DCHECK(pending_sockets_.empty()); 38 } 39 40 void PseudoTcpChannelFactory::CreateChannel( 41 const std::string& name, 42 const ChannelCreatedCallback& callback) { 43 datagram_channel_factory_->CreateChannel( 44 name, 45 base::Bind(&PseudoTcpChannelFactory::OnDatagramChannelCreated, 46 base::Unretained(this), name, callback)); 47 } 48 49 void PseudoTcpChannelFactory::CancelChannelCreation(const std::string& name) { 50 PendingSocketsMap::iterator it = pending_sockets_.find(name); 51 if (it == pending_sockets_.end()) { 52 datagram_channel_factory_->CancelChannelCreation(name); 53 } else { 54 delete it->second; 55 pending_sockets_.erase(it); 56 } 57 } 58 59 void PseudoTcpChannelFactory::OnDatagramChannelCreated( 60 const std::string& name, 61 const ChannelCreatedCallback& callback, 62 scoped_ptr<net::Socket> datagram_socket) { 63 jingle_glue::PseudoTcpAdapter* adapter = 64 new jingle_glue::PseudoTcpAdapter(datagram_socket.release()); 65 pending_sockets_[name] = adapter; 66 67 adapter->SetSendBufferSize(kTcpSendBufferSize); 68 adapter->SetReceiveBufferSize(kTcpReceiveBufferSize); 69 adapter->SetNoDelay(true); 70 adapter->SetAckDelay(kTcpAckDelayMilliseconds); 71 72 // TODO(sergeyu): This is a hack to improve latency of the video channel. 73 // Consider removing it once we have better flow control implemented. 74 if (name == kVideoChannelName) 75 adapter->SetWriteWaitsForSend(true); 76 77 int result = adapter->Connect( 78 base::Bind(&PseudoTcpChannelFactory::OnPseudoTcpConnected, 79 base::Unretained(this), name, callback)); 80 if (result != net::ERR_IO_PENDING) 81 OnPseudoTcpConnected(name, callback, result); 82 } 83 84 void PseudoTcpChannelFactory::OnPseudoTcpConnected( 85 const std::string& name, 86 const ChannelCreatedCallback& callback, 87 int result) { 88 PendingSocketsMap::iterator it = pending_sockets_.find(name); 89 DCHECK(it != pending_sockets_.end()); 90 scoped_ptr<net::StreamSocket> socket(it->second); 91 pending_sockets_.erase(it); 92 93 if (result != net::OK) 94 socket.reset(); 95 96 callback.Run(socket.Pass()); 97 } 98 99 } // namespace protocol 100 } // namespace remoting 101