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 | 142 DCHECK(event_handler); |
143 DCHECK(name_.empty()); | |
173 DCHECK(!name.empty()); | 144 DCHECK(!name.empty()); |
Wez
2014/09/10 22:19:42
DCHECK(!callback.is_null())?
Sergey Ulanov
2014/09/10 22:49:31
Done.
| |
174 DCHECK(event_handler); | |
175 | |
176 // Can be initialized only once. | |
177 DCHECK(name_.empty()); | |
178 | 145 |
179 name_ = name; | 146 name_ = name; |
180 event_handler_ = event_handler; | 147 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; | 148 callback_ = callback; |
188 | 149 |
189 if (can_start_) | 150 if (can_start_) |
190 DoStart(); | 151 DoStart(); |
191 } | 152 } |
192 | 153 |
193 void LibjingleStreamTransport::DoStart() { | 154 void LibjingleTransport::DoStart() { |
194 DCHECK(!channel_.get()); | 155 DCHECK(!channel_.get()); |
195 | 156 |
196 // Create P2PTransportChannel, attach signal handlers and connect it. | 157 // Create P2PTransportChannel, attach signal handlers and connect it. |
197 // TODO(sergeyu): Specify correct component ID for the channel. | 158 // TODO(sergeyu): Specify correct component ID for the channel. |
198 channel_.reset(new cricket::P2PTransportChannel( | 159 channel_.reset(new cricket::P2PTransportChannel( |
199 std::string(), 0, NULL, port_allocator_)); | 160 std::string(), 0, NULL, port_allocator_)); |
200 channel_->SetIceProtocolType(cricket::ICEPROTO_GOOGLE); | 161 channel_->SetIceProtocolType(cricket::ICEPROTO_GOOGLE); |
201 channel_->SetIceCredentials(ice_username_fragment_, ice_password_); | 162 channel_->SetIceCredentials(ice_username_fragment_, ice_password_); |
202 channel_->SignalRequestSignaling.connect( | 163 channel_->SignalRequestSignaling.connect( |
203 this, &LibjingleStreamTransport::OnRequestSignaling); | 164 this, &LibjingleTransport::OnRequestSignaling); |
204 channel_->SignalCandidateReady.connect( | 165 channel_->SignalCandidateReady.connect( |
205 this, &LibjingleStreamTransport::OnCandidateReady); | 166 this, &LibjingleTransport::OnCandidateReady); |
206 channel_->SignalRouteChange.connect( | 167 channel_->SignalRouteChange.connect( |
207 this, &LibjingleStreamTransport::OnRouteChange); | 168 this, &LibjingleTransport::OnRouteChange); |
208 channel_->SignalWritableState.connect( | 169 channel_->SignalWritableState.connect( |
209 this, &LibjingleStreamTransport::OnWritableState); | 170 this, &LibjingleTransport::OnWritableState); |
210 channel_->set_incoming_only( | 171 channel_->set_incoming_only( |
211 !(network_settings_.flags & NetworkSettings::NAT_TRAVERSAL_OUTGOING)); | 172 !(network_settings_.flags & NetworkSettings::NAT_TRAVERSAL_OUTGOING)); |
212 | 173 |
213 channel_->Connect(); | 174 channel_->Connect(); |
214 | 175 |
215 --connect_attempts_left_; | 176 --connect_attempts_left_; |
216 | 177 |
217 // Start reconnection timer. | 178 // Start reconnection timer. |
218 reconnect_timer_.Start( | 179 reconnect_timer_.Start( |
219 FROM_HERE, base::TimeDelta::FromSeconds(kReconnectDelaySeconds), | 180 FROM_HERE, base::TimeDelta::FromSeconds(kReconnectDelaySeconds), |
220 this, &LibjingleStreamTransport::TryReconnect); | 181 this, &LibjingleTransport::TryReconnect); |
221 | 182 |
222 // Create net::Socket adapter for the P2PTransportChannel. | 183 // Create net::Socket adapter for the P2PTransportChannel. |
223 scoped_ptr<jingle_glue::TransportChannelSocketAdapter> channel_adapter( | 184 scoped_ptr<jingle_glue::TransportChannelSocketAdapter> socket( |
224 new jingle_glue::TransportChannelSocketAdapter(channel_.get())); | 185 new jingle_glue::TransportChannelSocketAdapter(channel_.get())); |
186 socket->SetOnDestroyedCallback(base::Bind( | |
187 &LibjingleTransport::OnChannelDestroyed, base::Unretained(this))); | |
225 | 188 |
226 channel_adapter->SetOnDestroyedCallback(base::Bind( | 189 Transport::ConnectedCallback callback = callback_; |
227 &LibjingleStreamTransport::OnChannelDestroyed, base::Unretained(this))); | 190 callback_.Reset(); |
228 | 191 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 } | 192 } |
249 | 193 |
250 void LibjingleStreamTransport::AddRemoteCandidate( | 194 void LibjingleTransport::AddRemoteCandidate( |
251 const cricket::Candidate& candidate) { | 195 const cricket::Candidate& candidate) { |
252 DCHECK(CalledOnValidThread()); | 196 DCHECK(CalledOnValidThread()); |
253 | 197 |
254 // To enforce the no-relay setting, it's not enough to not produce relay | 198 // 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. | 199 // candidates. It's also necessary to discard remote relay candidates. |
256 bool relay_allowed = (network_settings_.flags & | 200 bool relay_allowed = (network_settings_.flags & |
257 NetworkSettings::NAT_TRAVERSAL_RELAY) != 0; | 201 NetworkSettings::NAT_TRAVERSAL_RELAY) != 0; |
258 if (!relay_allowed && candidate.type() == cricket::RELAY_PORT_TYPE) | 202 if (!relay_allowed && candidate.type() == cricket::RELAY_PORT_TYPE) |
259 return; | 203 return; |
260 | 204 |
261 if (channel_) { | 205 if (channel_) { |
262 channel_->OnCandidate(candidate); | 206 channel_->OnCandidate(candidate); |
263 } else { | 207 } else { |
264 pending_candidates_.push_back(candidate); | 208 pending_candidates_.push_back(candidate); |
265 } | 209 } |
266 } | 210 } |
267 | 211 |
268 const std::string& LibjingleStreamTransport::name() const { | 212 const std::string& LibjingleTransport::name() const { |
269 DCHECK(CalledOnValidThread()); | 213 DCHECK(CalledOnValidThread()); |
270 return name_; | 214 return name_; |
271 } | 215 } |
272 | 216 |
273 bool LibjingleStreamTransport::is_connected() const { | 217 bool LibjingleTransport::is_connected() const { |
274 DCHECK(CalledOnValidThread()); | 218 DCHECK(CalledOnValidThread()); |
275 return callback_.is_null(); | 219 return callback_.is_null(); |
276 } | 220 } |
277 | 221 |
278 void LibjingleStreamTransport::OnRequestSignaling( | 222 void LibjingleTransport::OnRequestSignaling( |
279 cricket::TransportChannelImpl* channel) { | 223 cricket::TransportChannelImpl* channel) { |
280 DCHECK(CalledOnValidThread()); | 224 DCHECK(CalledOnValidThread()); |
281 channel_->OnSignalingReady(); | 225 channel_->OnSignalingReady(); |
282 } | 226 } |
283 | 227 |
284 void LibjingleStreamTransport::OnCandidateReady( | 228 void LibjingleTransport::OnCandidateReady( |
285 cricket::TransportChannelImpl* channel, | 229 cricket::TransportChannelImpl* channel, |
286 const cricket::Candidate& candidate) { | 230 const cricket::Candidate& candidate) { |
287 DCHECK(CalledOnValidThread()); | 231 DCHECK(CalledOnValidThread()); |
288 event_handler_->OnTransportCandidate(this, candidate); | 232 event_handler_->OnTransportCandidate(this, candidate); |
289 } | 233 } |
290 | 234 |
291 void LibjingleStreamTransport::OnRouteChange( | 235 void LibjingleTransport::OnRouteChange( |
292 cricket::TransportChannel* channel, | 236 cricket::TransportChannel* channel, |
293 const cricket::Candidate& candidate) { | 237 const cricket::Candidate& candidate) { |
294 TransportRoute route; | 238 TransportRoute route; |
295 | 239 |
296 if (candidate.type() == "local") { | 240 if (candidate.type() == "local") { |
297 route.type = TransportRoute::DIRECT; | 241 route.type = TransportRoute::DIRECT; |
298 } else if (candidate.type() == "stun") { | 242 } else if (candidate.type() == "stun") { |
299 route.type = TransportRoute::STUN; | 243 route.type = TransportRoute::STUN; |
300 } else if (candidate.type() == "relay") { | 244 } else if (candidate.type() == "relay") { |
301 route.type = TransportRoute::RELAY; | 245 route.type = TransportRoute::RELAY; |
(...skipping 10 matching lines...) Expand all Loading... | |
312 const cricket::Candidate& local_candidate = | 256 const cricket::Candidate& local_candidate = |
313 channel_->best_connection()->local_candidate(); | 257 channel_->best_connection()->local_candidate(); |
314 if (!jingle_glue::SocketAddressToIPEndPoint( | 258 if (!jingle_glue::SocketAddressToIPEndPoint( |
315 local_candidate.address(), &route.local_address)) { | 259 local_candidate.address(), &route.local_address)) { |
316 LOG(FATAL) << "Failed to convert local IP address."; | 260 LOG(FATAL) << "Failed to convert local IP address."; |
317 } | 261 } |
318 | 262 |
319 event_handler_->OnTransportRouteChange(this, route); | 263 event_handler_->OnTransportRouteChange(this, route); |
320 } | 264 } |
321 | 265 |
322 void LibjingleStreamTransport::OnWritableState( | 266 void LibjingleTransport::OnWritableState( |
323 cricket::TransportChannel* channel) { | 267 cricket::TransportChannel* channel) { |
324 DCHECK_EQ(channel, channel_.get()); | 268 DCHECK_EQ(channel, channel_.get()); |
325 | 269 |
326 if (channel->writable()) { | 270 if (channel->writable()) { |
327 channel_was_writable_ = true; | 271 channel_was_writable_ = true; |
328 connect_attempts_left_ = kMaxReconnectAttempts; | 272 connect_attempts_left_ = kMaxReconnectAttempts; |
329 reconnect_timer_.Stop(); | 273 reconnect_timer_.Stop(); |
330 } else if (!channel->writable() && channel_was_writable_) { | 274 } else if (!channel->writable() && channel_was_writable_) { |
331 reconnect_timer_.Reset(); | 275 reconnect_timer_.Reset(); |
332 TryReconnect(); | 276 TryReconnect(); |
333 } | 277 } |
334 } | 278 } |
335 | 279 |
336 void LibjingleStreamTransport::OnTcpConnected(int result) { | 280 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()) { | 281 if (is_connected()) { |
363 // The connection socket is being deleted, so delete the transport too. | 282 // The connection socket is being deleted, so delete the transport too. |
364 delete this; | 283 delete this; |
365 } | 284 } |
366 } | 285 } |
367 | 286 |
368 void LibjingleStreamTransport::TryReconnect() { | 287 void LibjingleTransport::TryReconnect() { |
369 DCHECK(!channel_->writable()); | 288 DCHECK(!channel_->writable()); |
370 | 289 |
371 if (connect_attempts_left_ <= 0) { | 290 if (connect_attempts_left_ <= 0) { |
372 reconnect_timer_.Stop(); | 291 reconnect_timer_.Stop(); |
373 | 292 |
374 // Notify the caller that ICE connection has failed - normally that will | 293 // Notify the caller that ICE connection has failed - normally that will |
375 // terminate Jingle connection (i.e. the transport will be destroyed). | 294 // terminate Jingle connection (i.e. the transport will be destroyed). |
376 event_handler_->OnTransportFailed(this); | 295 event_handler_->OnTransportFailed(this); |
377 return; | 296 return; |
378 } | 297 } |
379 --connect_attempts_left_; | 298 --connect_attempts_left_; |
380 | 299 |
381 // Restart ICE by resetting ICE password. | 300 // Restart ICE by resetting ICE password. |
382 ice_password_ = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH); | 301 ice_password_ = rtc::CreateRandomString(cricket::ICE_PWD_LENGTH); |
383 channel_->SetIceCredentials(ice_username_fragment_, ice_password_); | 302 channel_->SetIceCredentials(ice_username_fragment_, ice_password_); |
384 } | 303 } |
385 | 304 |
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 | 305 } // namespace |
412 | 306 |
413 LibjingleTransportFactory::LibjingleTransportFactory( | 307 LibjingleTransportFactory::LibjingleTransportFactory( |
414 SignalStrategy* signal_strategy, | 308 SignalStrategy* signal_strategy, |
415 scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator, | 309 scoped_ptr<cricket::HttpPortAllocatorBase> port_allocator, |
416 const NetworkSettings& network_settings) | 310 const NetworkSettings& network_settings) |
417 : signal_strategy_(signal_strategy), | 311 : signal_strategy_(signal_strategy), |
418 port_allocator_(port_allocator.Pass()), | 312 port_allocator_(port_allocator.Pass()), |
419 network_settings_(network_settings) { | 313 network_settings_(network_settings) { |
420 } | 314 } |
421 | 315 |
422 LibjingleTransportFactory::~LibjingleTransportFactory() { | 316 LibjingleTransportFactory::~LibjingleTransportFactory() { |
423 // This method may be called in response to a libjingle signal, so | 317 // This method may be called in response to a libjingle signal, so |
424 // libjingle objects must be deleted asynchronously. | 318 // libjingle objects must be deleted asynchronously. |
425 scoped_refptr<base::SingleThreadTaskRunner> task_runner = | 319 scoped_refptr<base::SingleThreadTaskRunner> task_runner = |
426 base::ThreadTaskRunnerHandle::Get(); | 320 base::ThreadTaskRunnerHandle::Get(); |
427 task_runner->DeleteSoon(FROM_HERE, port_allocator_.release()); | 321 task_runner->DeleteSoon(FROM_HERE, port_allocator_.release()); |
428 } | 322 } |
429 | 323 |
430 void LibjingleTransportFactory::PrepareTokens() { | 324 void LibjingleTransportFactory::PrepareTokens() { |
431 EnsureFreshJingleInfo(); | 325 EnsureFreshJingleInfo(); |
432 } | 326 } |
433 | 327 |
434 scoped_ptr<StreamTransport> LibjingleTransportFactory::CreateStreamTransport() { | 328 scoped_ptr<Transport> LibjingleTransportFactory::CreateTransport() { |
435 scoped_ptr<LibjingleStreamTransport> result( | 329 scoped_ptr<LibjingleTransport> result( |
436 new LibjingleStreamTransport(port_allocator_.get(), network_settings_)); | 330 new LibjingleTransport(port_allocator_.get(), network_settings_)); |
437 | 331 |
438 EnsureFreshJingleInfo(); | 332 EnsureFreshJingleInfo(); |
439 | 333 |
440 // If there is a pending |jingle_info_request_| delay starting the new | 334 // If there is a pending |jingle_info_request_| delay starting the new |
441 // transport until the request is finished. | 335 // transport until the request is finished. |
442 if (jingle_info_request_) { | 336 if (jingle_info_request_) { |
443 on_jingle_info_callbacks_.push_back( | 337 on_jingle_info_callbacks_.push_back( |
444 base::Bind(&LibjingleStreamTransport::OnCanStart, | 338 base::Bind(&LibjingleTransport::OnCanStart, |
445 result->AsWeakPtr())); | 339 result->AsWeakPtr())); |
446 } else { | 340 } else { |
447 result->OnCanStart(); | 341 result->OnCanStart(); |
448 } | 342 } |
449 | 343 |
450 return result.PassAs<StreamTransport>(); | 344 return result.PassAs<Transport>(); |
451 } | |
452 | |
453 scoped_ptr<DatagramTransport> | |
454 LibjingleTransportFactory::CreateDatagramTransport() { | |
455 NOTIMPLEMENTED(); | |
456 return scoped_ptr<DatagramTransport>(); | |
457 } | 345 } |
458 | 346 |
459 void LibjingleTransportFactory::EnsureFreshJingleInfo() { | 347 void LibjingleTransportFactory::EnsureFreshJingleInfo() { |
460 uint32 stun_or_relay_flags = NetworkSettings::NAT_TRAVERSAL_STUN | | 348 uint32 stun_or_relay_flags = NetworkSettings::NAT_TRAVERSAL_STUN | |
461 NetworkSettings::NAT_TRAVERSAL_RELAY; | 349 NetworkSettings::NAT_TRAVERSAL_RELAY; |
462 if (!(network_settings_.flags & stun_or_relay_flags) || | 350 if (!(network_settings_.flags & stun_or_relay_flags) || |
463 jingle_info_request_) { | 351 jingle_info_request_) { |
464 return; | 352 return; |
465 } | 353 } |
466 | 354 |
(...skipping 22 matching lines...) Expand all Loading... | |
489 last_jingle_info_update_time_ = base::TimeTicks::Now(); | 377 last_jingle_info_update_time_ = base::TimeTicks::Now(); |
490 | 378 |
491 while (!on_jingle_info_callbacks_.empty()) { | 379 while (!on_jingle_info_callbacks_.empty()) { |
492 on_jingle_info_callbacks_.begin()->Run(); | 380 on_jingle_info_callbacks_.begin()->Run(); |
493 on_jingle_info_callbacks_.pop_front(); | 381 on_jingle_info_callbacks_.pop_front(); |
494 } | 382 } |
495 } | 383 } |
496 | 384 |
497 } // namespace protocol | 385 } // namespace protocol |
498 } // namespace remoting | 386 } // namespace remoting |
OLD | NEW |