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