OLD | NEW |
---|---|
1 // Copyright 2014 The Chromium Authors. All rights reserved. | 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 | 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 "content/renderer/media/webrtc/peer_connection_dependency_factory.h" | 5 #include "content/renderer/media/webrtc/peer_connection_dependency_factory.h" |
6 | 6 |
7 #include <vector> | 7 #include <vector> |
8 | 8 |
9 #include "base/command_line.h" | 9 #include "base/command_line.h" |
10 #include "base/location.h" | 10 #include "base/location.h" |
(...skipping 104 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
115 } | 115 } |
116 } | 116 } |
117 } | 117 } |
118 | 118 |
119 class P2PPortAllocatorFactory : public webrtc::PortAllocatorFactoryInterface { | 119 class P2PPortAllocatorFactory : public webrtc::PortAllocatorFactoryInterface { |
120 public: | 120 public: |
121 P2PPortAllocatorFactory(P2PSocketDispatcher* socket_dispatcher, | 121 P2PPortAllocatorFactory(P2PSocketDispatcher* socket_dispatcher, |
122 rtc::NetworkManager* network_manager, | 122 rtc::NetworkManager* network_manager, |
123 rtc::PacketSocketFactory* socket_factory, | 123 rtc::PacketSocketFactory* socket_factory, |
124 const GURL& origin, | 124 const GURL& origin, |
125 bool enable_multiple_routes) | 125 const P2PPortAllocator::Config& config) |
126 : socket_dispatcher_(socket_dispatcher), | 126 : socket_dispatcher_(socket_dispatcher), |
127 network_manager_(network_manager), | 127 network_manager_(network_manager), |
128 socket_factory_(socket_factory), | 128 socket_factory_(socket_factory), |
129 origin_(origin), | 129 origin_(origin), |
130 enable_multiple_routes_(enable_multiple_routes) {} | 130 config_(config) {} |
131 | 131 |
132 cricket::PortAllocator* CreatePortAllocator( | 132 cricket::PortAllocator* CreatePortAllocator( |
133 const std::vector<StunConfiguration>& stun_servers, | 133 const std::vector<StunConfiguration>& stun_servers, |
134 const std::vector<TurnConfiguration>& turn_configurations) override { | 134 const std::vector<TurnConfiguration>& turn_configurations) override { |
135 P2PPortAllocator::Config config; | 135 P2PPortAllocator::Config config = config_; |
136 for (size_t i = 0; i < stun_servers.size(); ++i) { | 136 for (size_t i = 0; i < stun_servers.size(); ++i) { |
137 config.stun_servers.insert(rtc::SocketAddress( | 137 config.stun_servers.insert(rtc::SocketAddress( |
138 stun_servers[i].server.hostname(), | 138 stun_servers[i].server.hostname(), |
139 stun_servers[i].server.port())); | 139 stun_servers[i].server.port())); |
140 } | 140 } |
141 for (size_t i = 0; i < turn_configurations.size(); ++i) { | 141 for (size_t i = 0; i < turn_configurations.size(); ++i) { |
142 P2PPortAllocator::Config::RelayServerConfig relay_config; | 142 P2PPortAllocator::Config::RelayServerConfig relay_config; |
143 relay_config.server_address = turn_configurations[i].server.hostname(); | 143 relay_config.server_address = turn_configurations[i].server.hostname(); |
144 relay_config.port = turn_configurations[i].server.port(); | 144 relay_config.port = turn_configurations[i].server.port(); |
145 relay_config.username = turn_configurations[i].username; | 145 relay_config.username = turn_configurations[i].username; |
146 relay_config.password = turn_configurations[i].password; | 146 relay_config.password = turn_configurations[i].password; |
147 relay_config.transport_type = turn_configurations[i].transport_type; | 147 relay_config.transport_type = turn_configurations[i].transport_type; |
148 relay_config.secure = turn_configurations[i].secure; | 148 relay_config.secure = turn_configurations[i].secure; |
149 config.relays.push_back(relay_config); | 149 config.relays.push_back(relay_config); |
150 } | 150 } |
151 config.enable_multiple_routes = enable_multiple_routes_; | |
152 | 151 |
153 return new P2PPortAllocator( | 152 return new P2PPortAllocator( |
154 socket_dispatcher_.get(), network_manager_, | 153 socket_dispatcher_.get(), network_manager_, |
155 socket_factory_, config, origin_); | 154 socket_factory_, config, origin_); |
156 } | 155 } |
157 | 156 |
158 protected: | 157 protected: |
159 ~P2PPortAllocatorFactory() override {} | 158 ~P2PPortAllocatorFactory() override {} |
160 | 159 |
161 private: | 160 private: |
162 scoped_refptr<P2PSocketDispatcher> socket_dispatcher_; | 161 scoped_refptr<P2PSocketDispatcher> socket_dispatcher_; |
163 // |network_manager_| and |socket_factory_| are a weak references, owned by | 162 // |network_manager_| and |socket_factory_| are a weak references, owned by |
164 // PeerConnectionDependencyFactory. | 163 // PeerConnectionDependencyFactory. |
165 rtc::NetworkManager* network_manager_; | 164 rtc::NetworkManager* network_manager_; |
166 rtc::PacketSocketFactory* socket_factory_; | 165 rtc::PacketSocketFactory* socket_factory_; |
167 // The origin URL of the WebFrame that created the | 166 // The origin URL of the WebFrame that created the |
168 // P2PPortAllocatorFactory. | 167 // P2PPortAllocatorFactory. |
169 GURL origin_; | 168 GURL origin_; |
170 // When false, only 'any' address (all 0s) will be bound for address | 169 |
171 // discovery. | 170 // Keep track options which impact PortAllocator, like whether to allow |
pthatcher2
2015/08/26 21:09:59
Keep track options => keep track of options
| |
172 bool enable_multiple_routes_; | 171 // multiple routes or non-proxied udp transport. The STUN and Relay |
172 // information is ignored from |config_|. | |
pthatcher2
2015/08/26 21:09:59
Actually, the code doesn't ignore it, it only adds
| |
173 P2PPortAllocator::Config config_; | |
173 }; | 174 }; |
174 | 175 |
175 PeerConnectionDependencyFactory::PeerConnectionDependencyFactory( | 176 PeerConnectionDependencyFactory::PeerConnectionDependencyFactory( |
176 P2PSocketDispatcher* p2p_socket_dispatcher) | 177 P2PSocketDispatcher* p2p_socket_dispatcher) |
177 : network_manager_(NULL), | 178 : network_manager_(NULL), |
178 p2p_socket_dispatcher_(p2p_socket_dispatcher), | 179 p2p_socket_dispatcher_(p2p_socket_dispatcher), |
179 signaling_thread_(NULL), | 180 signaling_thread_(NULL), |
180 worker_thread_(NULL), | 181 worker_thread_(NULL), |
181 chrome_signaling_thread_("Chrome_libJingle_Signaling"), | 182 chrome_signaling_thread_("Chrome_libJingle_Signaling"), |
182 chrome_worker_thread_("Chrome_libJingle_WorkerThread") { | 183 chrome_worker_thread_("Chrome_libJingle_WorkerThread") { |
(...skipping 216 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
399 PeerConnectionDependencyFactory::CreatePeerConnection( | 400 PeerConnectionDependencyFactory::CreatePeerConnection( |
400 const webrtc::PeerConnectionInterface::RTCConfiguration& config, | 401 const webrtc::PeerConnectionInterface::RTCConfiguration& config, |
401 const webrtc::MediaConstraintsInterface* constraints, | 402 const webrtc::MediaConstraintsInterface* constraints, |
402 blink::WebFrame* web_frame, | 403 blink::WebFrame* web_frame, |
403 webrtc::PeerConnectionObserver* observer) { | 404 webrtc::PeerConnectionObserver* observer) { |
404 CHECK(web_frame); | 405 CHECK(web_frame); |
405 CHECK(observer); | 406 CHECK(observer); |
406 if (!GetPcFactory().get()) | 407 if (!GetPcFactory().get()) |
407 return NULL; | 408 return NULL; |
408 | 409 |
409 // Copy the flag from Preference associated with this WebFrame. | |
410 bool enable_multiple_routes = true; | |
411 rtc::scoped_ptr<PeerConnectionIdentityStore> identity_store( | 410 rtc::scoped_ptr<PeerConnectionIdentityStore> identity_store( |
412 new PeerConnectionIdentityStore( | 411 new PeerConnectionIdentityStore( |
413 GURL(web_frame->document().url()), | 412 GURL(web_frame->document().url()), |
414 GURL(web_frame->document().firstPartyForCookies()))); | 413 GURL(web_frame->document().firstPartyForCookies()))); |
415 | 414 |
415 // Copy the flag from Preference associated with this WebFrame. | |
416 P2PPortAllocator::Config config; | |
416 if (web_frame && web_frame->view()) { | 417 if (web_frame && web_frame->view()) { |
417 RenderViewImpl* renderer_view_impl = | 418 RenderViewImpl* renderer_view_impl = |
418 RenderViewImpl::FromWebView(web_frame->view()); | 419 RenderViewImpl::FromWebView(web_frame->view()); |
419 if (renderer_view_impl) { | 420 if (renderer_view_impl) { |
420 enable_multiple_routes = renderer_view_impl->renderer_preferences() | 421 config.enable_multiple_routes = renderer_view_impl->renderer_preferences() |
421 .enable_webrtc_multiple_routes; | 422 .enable_webrtc_multiple_routes; |
423 config.enable_nonproxied_udp_transport = | |
424 renderer_view_impl->renderer_preferences() | |
425 .enable_webrtc_nonproxied_udp_transport; | |
422 } | 426 } |
423 } | 427 } |
424 | 428 |
425 scoped_refptr<P2PPortAllocatorFactory> pa_factory = | 429 scoped_refptr<P2PPortAllocatorFactory> pa_factory = |
426 new rtc::RefCountedObject<P2PPortAllocatorFactory>( | 430 new rtc::RefCountedObject<P2PPortAllocatorFactory>( |
427 p2p_socket_dispatcher_.get(), network_manager_, socket_factory_.get(), | 431 p2p_socket_dispatcher_.get(), network_manager_, socket_factory_.get(), |
428 GURL(web_frame->document().url().spec()).GetOrigin(), | 432 GURL(web_frame->document().url().spec()).GetOrigin(), config); |
429 enable_multiple_routes); | |
430 | 433 |
431 return GetPcFactory()->CreatePeerConnection(config, | 434 return GetPcFactory()->CreatePeerConnection(config, |
432 constraints, | 435 constraints, |
433 pa_factory.get(), | 436 pa_factory.get(), |
434 identity_store.Pass(), | 437 identity_store.Pass(), |
435 observer).get(); | 438 observer).get(); |
436 } | 439 } |
437 | 440 |
438 scoped_refptr<webrtc::MediaStreamInterface> | 441 scoped_refptr<webrtc::MediaStreamInterface> |
439 PeerConnectionDependencyFactory::CreateLocalMediaStream( | 442 PeerConnectionDependencyFactory::CreateLocalMediaStream( |
(...skipping 247 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
687 } | 690 } |
688 | 691 |
689 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() { | 692 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() { |
690 if (audio_device_.get()) | 693 if (audio_device_.get()) |
691 return; | 694 return; |
692 | 695 |
693 audio_device_ = new WebRtcAudioDeviceImpl(); | 696 audio_device_ = new WebRtcAudioDeviceImpl(); |
694 } | 697 } |
695 | 698 |
696 } // namespace content | 699 } // namespace content |
OLD | NEW |