OLD | NEW |
1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. | 1 // Copyright (c) 2012 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "remoting/protocol/libjingle_transport_factory.h" | 5 #include "remoting/protocol/libjingle_transport_factory.h" |
6 | 6 |
7 #include "base/callback.h" | 7 #include "base/callback.h" |
8 #include "base/single_thread_task_runner.h" | 8 #include "base/single_thread_task_runner.h" |
9 #include "base/thread_task_runner_handle.h" | 9 #include "base/thread_task_runner_handle.h" |
10 #include "base/timer/timer.h" | 10 #include "base/timer/timer.h" |
11 #include "jingle/glue/channel_socket_adapter.h" | 11 #include "jingle/glue/channel_socket_adapter.h" |
| 12 #include "jingle/glue/pseudotcp_adapter.h" |
12 #include "jingle/glue/utils.h" | 13 #include "jingle/glue/utils.h" |
13 #include "net/base/net_errors.h" | 14 #include "net/base/net_errors.h" |
| 15 #include "remoting/base/constants.h" |
| 16 #include "remoting/protocol/channel_authenticator.h" |
14 #include "remoting/protocol/network_settings.h" | 17 #include "remoting/protocol/network_settings.h" |
15 #include "remoting/signaling/jingle_info_request.h" | 18 #include "remoting/signaling/jingle_info_request.h" |
16 #include "third_party/libjingle/source/talk/p2p/base/constants.h" | 19 #include "third_party/libjingle/source/talk/p2p/base/constants.h" |
17 #include "third_party/libjingle/source/talk/p2p/base/p2ptransportchannel.h" | 20 #include "third_party/libjingle/source/talk/p2p/base/p2ptransportchannel.h" |
18 #include "third_party/libjingle/source/talk/p2p/base/port.h" | 21 #include "third_party/libjingle/source/talk/p2p/base/port.h" |
19 #include "third_party/libjingle/source/talk/p2p/client/basicportallocator.h" | 22 #include "third_party/libjingle/source/talk/p2p/client/basicportallocator.h" |
20 #include "third_party/libjingle/source/talk/p2p/client/httpportallocator.h" | 23 #include "third_party/libjingle/source/talk/p2p/client/httpportallocator.h" |
21 #include "third_party/webrtc/base/network.h" | 24 #include "third_party/webrtc/base/network.h" |
22 | 25 |
23 namespace remoting { | 26 namespace remoting { |
24 namespace protocol { | 27 namespace protocol { |
25 | 28 |
26 namespace { | 29 namespace { |
27 | 30 |
| 31 // Value is chosen to balance the extra latency against the reduced |
| 32 // load due to ACK traffic. |
| 33 const int kTcpAckDelayMilliseconds = 10; |
| 34 |
| 35 // Values for the TCP send and receive buffer size. This should be tuned to |
| 36 // accommodate high latency network but not backlog the decoding pipeline. |
| 37 const int kTcpReceiveBufferSize = 256 * 1024; |
| 38 const int kTcpSendBufferSize = kTcpReceiveBufferSize + 30 * 1024; |
| 39 |
28 // Try connecting ICE twice with timeout of 15 seconds for each attempt. | 40 // Try connecting ICE twice with timeout of 15 seconds for each attempt. |
29 const int kMaxReconnectAttempts = 2; | 41 const int kMaxReconnectAttempts = 2; |
30 const int kReconnectDelaySeconds = 15; | 42 const int kReconnectDelaySeconds = 15; |
31 | 43 |
32 // Get fresh STUN/Relay configuration every hour. | 44 // Get fresh STUN/Relay configuration every hour. |
33 const int kJingleInfoUpdatePeriodSeconds = 3600; | 45 const int kJingleInfoUpdatePeriodSeconds = 3600; |
34 | 46 |
35 class LibjingleTransport | 47 class LibjingleStreamTransport |
36 : public Transport, | 48 : public StreamTransport, |
37 public base::SupportsWeakPtr<LibjingleTransport>, | 49 public base::SupportsWeakPtr<LibjingleStreamTransport>, |
38 public sigslot::has_slots<> { | 50 public sigslot::has_slots<> { |
39 public: | 51 public: |
40 LibjingleTransport(cricket::PortAllocator* port_allocator, | 52 LibjingleStreamTransport(cricket::PortAllocator* port_allocator, |
41 const NetworkSettings& network_settings); | 53 const NetworkSettings& network_settings); |
42 virtual ~LibjingleTransport(); | 54 virtual ~LibjingleStreamTransport(); |
43 | 55 |
44 // Called by JingleTransportFactory when it has fresh Jingle info. | 56 // Called by JingleTransportFactory when it has fresh Jingle info. |
45 void OnCanStart(); | 57 void OnCanStart(); |
46 | 58 |
47 // Transport interface. | 59 // StreamTransport interface. |
48 virtual void Connect( | 60 virtual void Initialize( |
49 const std::string& name, | 61 const std::string& name, |
50 Transport::EventHandler* event_handler, | 62 Transport::EventHandler* event_handler, |
51 const Transport::ConnectedCallback& callback) OVERRIDE; | 63 scoped_ptr<ChannelAuthenticator> authenticator) OVERRIDE; |
| 64 virtual void Connect( |
| 65 const StreamTransport::ConnectedCallback& callback) OVERRIDE; |
52 virtual void AddRemoteCandidate(const cricket::Candidate& candidate) OVERRIDE; | 66 virtual void AddRemoteCandidate(const cricket::Candidate& candidate) OVERRIDE; |
53 virtual const std::string& name() const OVERRIDE; | 67 virtual const std::string& name() const OVERRIDE; |
54 virtual bool is_connected() const OVERRIDE; | 68 virtual bool is_connected() const OVERRIDE; |
55 | 69 |
56 private: | 70 private: |
57 void DoStart(); | 71 void DoStart(); |
58 | 72 |
59 // Signal handlers for cricket::TransportChannel. | 73 // Signal handlers for cricket::TransportChannel. |
60 void OnRequestSignaling(cricket::TransportChannelImpl* channel); | 74 void OnRequestSignaling(cricket::TransportChannelImpl* channel); |
61 void OnCandidateReady(cricket::TransportChannelImpl* channel, | 75 void OnCandidateReady(cricket::TransportChannelImpl* channel, |
62 const cricket::Candidate& candidate); | 76 const cricket::Candidate& candidate); |
63 void OnRouteChange(cricket::TransportChannel* channel, | 77 void OnRouteChange(cricket::TransportChannel* channel, |
64 const cricket::Candidate& candidate); | 78 const cricket::Candidate& candidate); |
65 void OnWritableState(cricket::TransportChannel* channel); | 79 void OnWritableState(cricket::TransportChannel* channel); |
66 | 80 |
| 81 // Callback for PseudoTcpAdapter::Connect(). |
| 82 void OnTcpConnected(int result); |
| 83 |
| 84 // Callback for Authenticator::SecureAndAuthenticate(); |
| 85 void OnAuthenticationDone(net::Error error, |
| 86 scoped_ptr<net::StreamSocket> socket); |
| 87 |
67 // Callback for jingle_glue::TransportChannelSocketAdapter to notify when the | 88 // Callback for jingle_glue::TransportChannelSocketAdapter to notify when the |
68 // socket is destroyed. | 89 // socket is destroyed. |
69 void OnChannelDestroyed(); | 90 void OnChannelDestroyed(); |
70 | 91 |
71 // Tries to connect by restarting ICE. Called by |reconnect_timer_|. | 92 // Tries to connect by restarting ICE. Called by |reconnect_timer_|. |
72 void TryReconnect(); | 93 void TryReconnect(); |
73 | 94 |
| 95 // Helper methods to call |callback_|. |
| 96 void NotifyConnected(scoped_ptr<net::StreamSocket> socket); |
| 97 void NotifyConnectFailed(); |
| 98 |
74 cricket::PortAllocator* port_allocator_; | 99 cricket::PortAllocator* port_allocator_; |
75 NetworkSettings network_settings_; | 100 NetworkSettings network_settings_; |
76 | 101 |
77 std::string name_; | 102 std::string name_; |
78 EventHandler* event_handler_; | 103 EventHandler* event_handler_; |
79 Transport::ConnectedCallback callback_; | 104 StreamTransport::ConnectedCallback callback_; |
| 105 scoped_ptr<ChannelAuthenticator> authenticator_; |
80 std::string ice_username_fragment_; | 106 std::string ice_username_fragment_; |
81 std::string ice_password_; | 107 std::string ice_password_; |
82 | 108 |
83 bool can_start_; | 109 bool can_start_; |
84 | 110 |
85 std::list<cricket::Candidate> pending_candidates_; | 111 std::list<cricket::Candidate> pending_candidates_; |
86 scoped_ptr<cricket::P2PTransportChannel> channel_; | 112 scoped_ptr<cricket::P2PTransportChannel> channel_; |
87 bool channel_was_writable_; | 113 bool channel_was_writable_; |
88 int connect_attempts_left_; | 114 int connect_attempts_left_; |
89 base::RepeatingTimer<LibjingleTransport> reconnect_timer_; | 115 base::RepeatingTimer<LibjingleStreamTransport> reconnect_timer_; |
90 | 116 |
91 DISALLOW_COPY_AND_ASSIGN(LibjingleTransport); | 117 // We own |socket_| until it is connected. |
| 118 scoped_ptr<jingle_glue::PseudoTcpAdapter> socket_; |
| 119 |
| 120 DISALLOW_COPY_AND_ASSIGN(LibjingleStreamTransport); |
92 }; | 121 }; |
93 | 122 |
94 LibjingleTransport::LibjingleTransport( | 123 LibjingleStreamTransport::LibjingleStreamTransport( |
95 cricket::PortAllocator* port_allocator, | 124 cricket::PortAllocator* port_allocator, |
96 const NetworkSettings& network_settings) | 125 const NetworkSettings& network_settings) |
97 : port_allocator_(port_allocator), | 126 : port_allocator_(port_allocator), |
98 network_settings_(network_settings), | 127 network_settings_(network_settings), |
99 event_handler_(NULL), | 128 event_handler_(NULL), |
100 ice_username_fragment_( | 129 ice_username_fragment_( |
101 rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH)), | 130 rtc::CreateRandomString(cricket::ICE_UFRAG_LENGTH)), |
102 ice_password_(rtc::CreateRandomString(cricket::ICE_PWD_LENGTH)), | 131 ice_password_(rtc::CreateRandomString(cricket::ICE_PWD_LENGTH)), |
103 can_start_(false), | 132 can_start_(false), |
104 channel_was_writable_(false), | 133 channel_was_writable_(false), |
105 connect_attempts_left_(kMaxReconnectAttempts) { | 134 connect_attempts_left_(kMaxReconnectAttempts) { |
106 DCHECK(!ice_username_fragment_.empty()); | 135 DCHECK(!ice_username_fragment_.empty()); |
107 DCHECK(!ice_password_.empty()); | 136 DCHECK(!ice_password_.empty()); |
108 } | 137 } |
109 | 138 |
110 LibjingleTransport::~LibjingleTransport() { | 139 LibjingleStreamTransport::~LibjingleStreamTransport() { |
111 DCHECK(event_handler_); | 140 DCHECK(event_handler_); |
112 | |
113 event_handler_->OnTransportDeleted(this); | 141 event_handler_->OnTransportDeleted(this); |
| 142 // Channel should be already destroyed if we were connected. |
| 143 DCHECK(!is_connected() || socket_.get() == NULL); |
114 | 144 |
115 if (channel_.get()) { | 145 if (channel_.get()) { |
116 base::ThreadTaskRunnerHandle::Get()->DeleteSoon( | 146 base::ThreadTaskRunnerHandle::Get()->DeleteSoon( |
117 FROM_HERE, channel_.release()); | 147 FROM_HERE, channel_.release()); |
118 } | 148 } |
119 } | 149 } |
120 | 150 |
121 void LibjingleTransport::OnCanStart() { | 151 void LibjingleStreamTransport::OnCanStart() { |
122 DCHECK(CalledOnValidThread()); | 152 DCHECK(CalledOnValidThread()); |
123 | 153 |
124 DCHECK(!can_start_); | 154 DCHECK(!can_start_); |
125 can_start_ = true; | 155 can_start_ = true; |
126 | 156 |
127 // If Connect() has been called then start connection. | 157 // If Connect() has been called then start connection. |
128 if (!callback_.is_null()) | 158 if (!callback_.is_null()) |
129 DoStart(); | 159 DoStart(); |
130 | 160 |
131 while (!pending_candidates_.empty()) { | 161 while (!pending_candidates_.empty()) { |
132 channel_->OnCandidate(pending_candidates_.front()); | 162 channel_->OnCandidate(pending_candidates_.front()); |
133 pending_candidates_.pop_front(); | 163 pending_candidates_.pop_front(); |
134 } | 164 } |
135 } | 165 } |
136 | 166 |
137 void LibjingleTransport::Connect( | 167 void LibjingleStreamTransport::Initialize( |
138 const std::string& name, | 168 const std::string& name, |
139 Transport::EventHandler* event_handler, | 169 Transport::EventHandler* event_handler, |
140 const Transport::ConnectedCallback& callback) { | 170 scoped_ptr<ChannelAuthenticator> authenticator) { |
141 DCHECK(CalledOnValidThread()); | 171 DCHECK(CalledOnValidThread()); |
| 172 |
142 DCHECK(!name.empty()); | 173 DCHECK(!name.empty()); |
143 DCHECK(event_handler); | 174 DCHECK(event_handler); |
144 DCHECK(!callback.is_null()); | |
145 | 175 |
| 176 // Can be initialized only once. |
146 DCHECK(name_.empty()); | 177 DCHECK(name_.empty()); |
| 178 |
147 name_ = name; | 179 name_ = name; |
148 event_handler_ = event_handler; | 180 event_handler_ = event_handler; |
| 181 authenticator_ = authenticator.Pass(); |
| 182 } |
| 183 |
| 184 void LibjingleStreamTransport::Connect( |
| 185 const StreamTransport::ConnectedCallback& callback) { |
| 186 DCHECK(CalledOnValidThread()); |
149 callback_ = callback; | 187 callback_ = callback; |
150 | 188 |
151 if (can_start_) | 189 if (can_start_) |
152 DoStart(); | 190 DoStart(); |
153 } | 191 } |
154 | 192 |
155 void LibjingleTransport::DoStart() { | 193 void LibjingleStreamTransport::DoStart() { |
156 DCHECK(!channel_.get()); | 194 DCHECK(!channel_.get()); |
157 | 195 |
158 // Create P2PTransportChannel, attach signal handlers and connect it. | 196 // Create P2PTransportChannel, attach signal handlers and connect it. |
159 // TODO(sergeyu): Specify correct component ID for the channel. | 197 // TODO(sergeyu): Specify correct component ID for the channel. |
160 channel_.reset(new cricket::P2PTransportChannel( | 198 channel_.reset(new cricket::P2PTransportChannel( |
161 std::string(), 0, NULL, port_allocator_)); | 199 std::string(), 0, NULL, port_allocator_)); |
162 channel_->SetIceProtocolType(cricket::ICEPROTO_GOOGLE); | 200 channel_->SetIceProtocolType(cricket::ICEPROTO_GOOGLE); |
163 channel_->SetIceCredentials(ice_username_fragment_, ice_password_); | 201 channel_->SetIceCredentials(ice_username_fragment_, ice_password_); |
164 channel_->SignalRequestSignaling.connect( | 202 channel_->SignalRequestSignaling.connect( |
165 this, &LibjingleTransport::OnRequestSignaling); | 203 this, &LibjingleStreamTransport::OnRequestSignaling); |
166 channel_->SignalCandidateReady.connect( | 204 channel_->SignalCandidateReady.connect( |
167 this, &LibjingleTransport::OnCandidateReady); | 205 this, &LibjingleStreamTransport::OnCandidateReady); |
168 channel_->SignalRouteChange.connect( | 206 channel_->SignalRouteChange.connect( |
169 this, &LibjingleTransport::OnRouteChange); | 207 this, &LibjingleStreamTransport::OnRouteChange); |
170 channel_->SignalWritableState.connect( | 208 channel_->SignalWritableState.connect( |
171 this, &LibjingleTransport::OnWritableState); | 209 this, &LibjingleStreamTransport::OnWritableState); |
172 channel_->set_incoming_only( | 210 channel_->set_incoming_only( |
173 !(network_settings_.flags & NetworkSettings::NAT_TRAVERSAL_OUTGOING)); | 211 !(network_settings_.flags & NetworkSettings::NAT_TRAVERSAL_OUTGOING)); |
174 | 212 |
175 channel_->Connect(); | 213 channel_->Connect(); |
176 | 214 |
177 --connect_attempts_left_; | 215 --connect_attempts_left_; |
178 | 216 |
179 // Start reconnection timer. | 217 // Start reconnection timer. |
180 reconnect_timer_.Start( | 218 reconnect_timer_.Start( |
181 FROM_HERE, base::TimeDelta::FromSeconds(kReconnectDelaySeconds), | 219 FROM_HERE, base::TimeDelta::FromSeconds(kReconnectDelaySeconds), |
182 this, &LibjingleTransport::TryReconnect); | 220 this, &LibjingleStreamTransport::TryReconnect); |
183 | 221 |
184 // Create net::Socket adapter for the P2PTransportChannel. | 222 // Create net::Socket adapter for the P2PTransportChannel. |
185 scoped_ptr<jingle_glue::TransportChannelSocketAdapter> socket( | 223 scoped_ptr<jingle_glue::TransportChannelSocketAdapter> channel_adapter( |
186 new jingle_glue::TransportChannelSocketAdapter(channel_.get())); | 224 new jingle_glue::TransportChannelSocketAdapter(channel_.get())); |
187 socket->SetOnDestroyedCallback(base::Bind( | |
188 &LibjingleTransport::OnChannelDestroyed, base::Unretained(this))); | |
189 | 225 |
190 Transport::ConnectedCallback callback = callback_; | 226 channel_adapter->SetOnDestroyedCallback(base::Bind( |
191 callback_.Reset(); | 227 &LibjingleStreamTransport::OnChannelDestroyed, base::Unretained(this))); |
192 callback.Run(socket.PassAs<net::Socket>()); | 228 |
| 229 // Configure and connect PseudoTCP adapter. |
| 230 socket_.reset( |
| 231 new jingle_glue::PseudoTcpAdapter(channel_adapter.release())); |
| 232 socket_->SetSendBufferSize(kTcpSendBufferSize); |
| 233 socket_->SetReceiveBufferSize(kTcpReceiveBufferSize); |
| 234 socket_->SetNoDelay(true); |
| 235 socket_->SetAckDelay(kTcpAckDelayMilliseconds); |
| 236 |
| 237 // TODO(sergeyu): This is a hack to improve latency of the video |
| 238 // channel. Consider removing it once we have better flow control |
| 239 // implemented. |
| 240 if (name_ == kVideoChannelName) |
| 241 socket_->SetWriteWaitsForSend(true); |
| 242 |
| 243 int result = socket_->Connect( |
| 244 base::Bind(&LibjingleStreamTransport::OnTcpConnected, |
| 245 base::Unretained(this))); |
| 246 if (result != net::ERR_IO_PENDING) |
| 247 OnTcpConnected(result); |
193 } | 248 } |
194 | 249 |
195 void LibjingleTransport::AddRemoteCandidate( | 250 void LibjingleStreamTransport::AddRemoteCandidate( |
196 const cricket::Candidate& candidate) { | 251 const cricket::Candidate& candidate) { |
197 DCHECK(CalledOnValidThread()); | 252 DCHECK(CalledOnValidThread()); |
198 | 253 |
199 // To enforce the no-relay setting, it's not enough to not produce relay | 254 // To enforce the no-relay setting, it's not enough to not produce relay |
200 // candidates. It's also necessary to discard remote relay candidates. | 255 // candidates. It's also necessary to discard remote relay candidates. |
201 bool relay_allowed = (network_settings_.flags & | 256 bool relay_allowed = (network_settings_.flags & |
202 NetworkSettings::NAT_TRAVERSAL_RELAY) != 0; | 257 NetworkSettings::NAT_TRAVERSAL_RELAY) != 0; |
203 if (!relay_allowed && candidate.type() == cricket::RELAY_PORT_TYPE) | 258 if (!relay_allowed && candidate.type() == cricket::RELAY_PORT_TYPE) |
204 return; | 259 return; |
205 | 260 |
206 if (channel_) { | 261 if (channel_) { |
207 channel_->OnCandidate(candidate); | 262 channel_->OnCandidate(candidate); |
208 } else { | 263 } else { |
209 pending_candidates_.push_back(candidate); | 264 pending_candidates_.push_back(candidate); |
210 } | 265 } |
211 } | 266 } |
212 | 267 |
213 const std::string& LibjingleTransport::name() const { | 268 const std::string& LibjingleStreamTransport::name() const { |
214 DCHECK(CalledOnValidThread()); | 269 DCHECK(CalledOnValidThread()); |
215 return name_; | 270 return name_; |
216 } | 271 } |
217 | 272 |
218 bool LibjingleTransport::is_connected() const { | 273 bool LibjingleStreamTransport::is_connected() const { |
219 DCHECK(CalledOnValidThread()); | 274 DCHECK(CalledOnValidThread()); |
220 return callback_.is_null(); | 275 return callback_.is_null(); |
221 } | 276 } |
222 | 277 |
223 void LibjingleTransport::OnRequestSignaling( | 278 void LibjingleStreamTransport::OnRequestSignaling( |
224 cricket::TransportChannelImpl* channel) { | 279 cricket::TransportChannelImpl* channel) { |
225 DCHECK(CalledOnValidThread()); | 280 DCHECK(CalledOnValidThread()); |
226 channel_->OnSignalingReady(); | 281 channel_->OnSignalingReady(); |
227 } | 282 } |
228 | 283 |
229 void LibjingleTransport::OnCandidateReady( | 284 void LibjingleStreamTransport::OnCandidateReady( |
230 cricket::TransportChannelImpl* channel, | 285 cricket::TransportChannelImpl* channel, |
231 const cricket::Candidate& candidate) { | 286 const cricket::Candidate& candidate) { |
232 DCHECK(CalledOnValidThread()); | 287 DCHECK(CalledOnValidThread()); |
233 event_handler_->OnTransportCandidate(this, candidate); | 288 event_handler_->OnTransportCandidate(this, candidate); |
234 } | 289 } |
235 | 290 |
236 void LibjingleTransport::OnRouteChange( | 291 void LibjingleStreamTransport::OnRouteChange( |
237 cricket::TransportChannel* channel, | 292 cricket::TransportChannel* channel, |
238 const cricket::Candidate& candidate) { | 293 const cricket::Candidate& candidate) { |
239 TransportRoute route; | 294 TransportRoute route; |
240 | 295 |
241 if (candidate.type() == "local") { | 296 if (candidate.type() == "local") { |
242 route.type = TransportRoute::DIRECT; | 297 route.type = TransportRoute::DIRECT; |
243 } else if (candidate.type() == "stun") { | 298 } else if (candidate.type() == "stun") { |
244 route.type = TransportRoute::STUN; | 299 route.type = TransportRoute::STUN; |
245 } else if (candidate.type() == "relay") { | 300 } else if (candidate.type() == "relay") { |
246 route.type = TransportRoute::RELAY; | 301 route.type = TransportRoute::RELAY; |
(...skipping 10 matching lines...) Expand all Loading... |
257 const cricket::Candidate& local_candidate = | 312 const cricket::Candidate& local_candidate = |
258 channel_->best_connection()->local_candidate(); | 313 channel_->best_connection()->local_candidate(); |
259 if (!jingle_glue::SocketAddressToIPEndPoint( | 314 if (!jingle_glue::SocketAddressToIPEndPoint( |
260 local_candidate.address(), &route.local_address)) { | 315 local_candidate.address(), &route.local_address)) { |
261 LOG(FATAL) << "Failed to convert local IP address."; | 316 LOG(FATAL) << "Failed to convert local IP address."; |
262 } | 317 } |
263 | 318 |
264 event_handler_->OnTransportRouteChange(this, route); | 319 event_handler_->OnTransportRouteChange(this, route); |
265 } | 320 } |
266 | 321 |
267 void LibjingleTransport::OnWritableState( | 322 void LibjingleStreamTransport::OnWritableState( |
268 cricket::TransportChannel* channel) { | 323 cricket::TransportChannel* channel) { |
269 DCHECK_EQ(channel, channel_.get()); | 324 DCHECK_EQ(channel, channel_.get()); |
270 | 325 |
271 if (channel->writable()) { | 326 if (channel->writable()) { |
272 channel_was_writable_ = true; | 327 channel_was_writable_ = true; |
273 connect_attempts_left_ = kMaxReconnectAttempts; | 328 connect_attempts_left_ = kMaxReconnectAttempts; |
274 reconnect_timer_.Stop(); | 329 reconnect_timer_.Stop(); |
275 } else if (!channel->writable() && channel_was_writable_) { | 330 } else if (!channel->writable() && channel_was_writable_) { |
276 reconnect_timer_.Reset(); | 331 reconnect_timer_.Reset(); |
277 TryReconnect(); | 332 TryReconnect(); |
278 } | 333 } |
279 } | 334 } |
280 | 335 |
281 void LibjingleTransport::OnChannelDestroyed() { | 336 void LibjingleStreamTransport::OnTcpConnected(int result) { |
| 337 DCHECK(CalledOnValidThread()); |
| 338 |
| 339 if (result != net::OK) { |
| 340 NotifyConnectFailed(); |
| 341 return; |
| 342 } |
| 343 |
| 344 authenticator_->SecureAndAuthenticate( |
| 345 socket_.PassAs<net::StreamSocket>(), |
| 346 base::Bind(&LibjingleStreamTransport::OnAuthenticationDone, |
| 347 base::Unretained(this))); |
| 348 } |
| 349 |
| 350 void LibjingleStreamTransport::OnAuthenticationDone( |
| 351 net::Error error, |
| 352 scoped_ptr<net::StreamSocket> socket) { |
| 353 if (error != net::OK) { |
| 354 NotifyConnectFailed(); |
| 355 return; |
| 356 } |
| 357 |
| 358 NotifyConnected(socket.Pass()); |
| 359 } |
| 360 |
| 361 void LibjingleStreamTransport::OnChannelDestroyed() { |
282 if (is_connected()) { | 362 if (is_connected()) { |
283 // The connection socket is being deleted, so delete the transport too. | 363 // The connection socket is being deleted, so delete the transport too. |
284 delete this; | 364 delete this; |
285 } | 365 } |
286 } | 366 } |
287 | 367 |
288 void LibjingleTransport::TryReconnect() { | 368 void LibjingleStreamTransport::TryReconnect() { |
289 DCHECK(!channel_->writable()); | 369 DCHECK(!channel_->writable()); |
290 | 370 |
291 if (connect_attempts_left_ <= 0) { | 371 if (connect_attempts_left_ <= 0) { |
292 reconnect_timer_.Stop(); | 372 reconnect_timer_.Stop(); |
293 | 373 |
294 // Notify the caller that ICE connection has failed - normally that will | 374 // Notify the caller that ICE connection has failed - normally that will |
295 // terminate Jingle connection (i.e. the transport will be destroyed). | 375 // terminate Jingle connection (i.e. the transport will be destroyed). |
296 event_handler_->OnTransportFailed(this); | 376 event_handler_->OnTransportFailed(this); |
297 return; | 377 return; |
298 } | 378 } |
299 --connect_attempts_left_; | 379 --connect_attempts_left_; |
300 | 380 |
301 // Restart ICE by resetting ICE password. | 381 // Restart ICE by resetting ICE password. |
302 ice_password_ = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH); | 382 ice_password_ = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH); |
303 channel_->SetIceCredentials(ice_username_fragment_, ice_password_); | 383 channel_->SetIceCredentials(ice_username_fragment_, ice_password_); |
304 } | 384 } |
305 | 385 |
| 386 void LibjingleStreamTransport::NotifyConnected( |
| 387 scoped_ptr<net::StreamSocket> socket) { |
| 388 DCHECK(!is_connected()); |
| 389 StreamTransport::ConnectedCallback callback = callback_; |
| 390 callback_.Reset(); |
| 391 callback.Run(socket.Pass()); |
| 392 } |
| 393 |
| 394 void LibjingleStreamTransport::NotifyConnectFailed() { |
| 395 DCHECK(!is_connected()); |
| 396 |
| 397 socket_.reset(); |
| 398 |
| 399 // This method may be called in response to a libjingle signal, so |
| 400 // libjingle objects must be deleted asynchronously. |
| 401 if (channel_.get()) { |
| 402 base::ThreadTaskRunnerHandle::Get()->DeleteSoon( |
| 403 FROM_HERE, channel_.release()); |
| 404 } |
| 405 |
| 406 authenticator_.reset(); |
| 407 |
| 408 NotifyConnected(scoped_ptr<net::StreamSocket>()); |
| 409 } |
| 410 |
306 } // namespace | 411 } // namespace |
307 | 412 |
308 LibjingleTransportFactory::LibjingleTransportFactory( | 413 LibjingleTransportFactory::LibjingleTransportFactory( |
309 SignalStrategy* signal_strategy, | 414 SignalStrategy* signal_strategy, |
310 scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator, | 415 scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator, |
311 const NetworkSettings& network_settings) | 416 const NetworkSettings& network_settings) |
312 : signal_strategy_(signal_strategy), | 417 : signal_strategy_(signal_strategy), |
313 port_allocator_(port_allocator.Pass()), | 418 port_allocator_(port_allocator.Pass()), |
314 network_settings_(network_settings) { | 419 network_settings_(network_settings) { |
315 } | 420 } |
316 | 421 |
317 LibjingleTransportFactory::~LibjingleTransportFactory() { | 422 LibjingleTransportFactory::~LibjingleTransportFactory() { |
318 // This method may be called in response to a libjingle signal, so | 423 // This method may be called in response to a libjingle signal, so |
319 // libjingle objects must be deleted asynchronously. | 424 // libjingle objects must be deleted asynchronously. |
320 scoped_refptr<base::SingleThreadTaskRunner> task_runner = | 425 scoped_refptr<base::SingleThreadTaskRunner> task_runner = |
321 base::ThreadTaskRunnerHandle::Get(); | 426 base::ThreadTaskRunnerHandle::Get(); |
322 task_runner->DeleteSoon(FROM_HERE, port_allocator_.release()); | 427 task_runner->DeleteSoon(FROM_HERE, port_allocator_.release()); |
323 } | 428 } |
324 | 429 |
325 void LibjingleTransportFactory::PrepareTokens() { | 430 void LibjingleTransportFactory::PrepareTokens() { |
326 EnsureFreshJingleInfo(); | 431 EnsureFreshJingleInfo(); |
327 } | 432 } |
328 | 433 |
329 scoped_ptr<Transport> LibjingleTransportFactory::CreateTransport() { | 434 scoped_ptr<StreamTransport> LibjingleTransportFactory::CreateStreamTransport() { |
330 scoped_ptr<LibjingleTransport> result( | 435 scoped_ptr<LibjingleStreamTransport> result( |
331 new LibjingleTransport(port_allocator_.get(), network_settings_)); | 436 new LibjingleStreamTransport(port_allocator_.get(), network_settings_)); |
332 | 437 |
333 EnsureFreshJingleInfo(); | 438 EnsureFreshJingleInfo(); |
334 | 439 |
335 // If there is a pending |jingle_info_request_| delay starting the new | 440 // If there is a pending |jingle_info_request_| delay starting the new |
336 // transport until the request is finished. | 441 // transport until the request is finished. |
337 if (jingle_info_request_) { | 442 if (jingle_info_request_) { |
338 on_jingle_info_callbacks_.push_back( | 443 on_jingle_info_callbacks_.push_back( |
339 base::Bind(&LibjingleTransport::OnCanStart, | 444 base::Bind(&LibjingleStreamTransport::OnCanStart, |
340 result->AsWeakPtr())); | 445 result->AsWeakPtr())); |
341 } else { | 446 } else { |
342 result->OnCanStart(); | 447 result->OnCanStart(); |
343 } | 448 } |
344 | 449 |
345 return result.PassAs<Transport>(); | 450 return result.PassAs<StreamTransport>(); |
| 451 } |
| 452 |
| 453 scoped_ptr<DatagramTransport> |
| 454 LibjingleTransportFactory::CreateDatagramTransport() { |
| 455 NOTIMPLEMENTED(); |
| 456 return scoped_ptr<DatagramTransport>(); |
346 } | 457 } |
347 | 458 |
348 void LibjingleTransportFactory::EnsureFreshJingleInfo() { | 459 void LibjingleTransportFactory::EnsureFreshJingleInfo() { |
349 uint32 stun_or_relay_flags = NetworkSettings::NAT_TRAVERSAL_STUN | | 460 uint32 stun_or_relay_flags = NetworkSettings::NAT_TRAVERSAL_STUN | |
350 NetworkSettings::NAT_TRAVERSAL_RELAY; | 461 NetworkSettings::NAT_TRAVERSAL_RELAY; |
351 if (!(network_settings_.flags & stun_or_relay_flags) || | 462 if (!(network_settings_.flags & stun_or_relay_flags) || |
352 jingle_info_request_) { | 463 jingle_info_request_) { |
353 return; | 464 return; |
354 } | 465 } |
355 | 466 |
(...skipping 22 matching lines...) Expand all Loading... |
378 last_jingle_info_update_time_ = base::TimeTicks::Now(); | 489 last_jingle_info_update_time_ = base::TimeTicks::Now(); |
379 | 490 |
380 while (!on_jingle_info_callbacks_.empty()) { | 491 while (!on_jingle_info_callbacks_.empty()) { |
381 on_jingle_info_callbacks_.begin()->Run(); | 492 on_jingle_info_callbacks_.begin()->Run(); |
382 on_jingle_info_callbacks_.pop_front(); | 493 on_jingle_info_callbacks_.pop_front(); |
383 } | 494 } |
384 } | 495 } |
385 | 496 |
386 } // namespace protocol | 497 } // namespace protocol |
387 } // namespace remoting | 498 } // namespace remoting |
OLD | NEW |