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 <utility> | 7 #include <utility> |
8 #include <vector> | 8 #include <vector> |
9 | 9 |
10 #include "base/command_line.h" | 10 #include "base/command_line.h" |
(...skipping 117 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
128 constraints->AddOptional(kConstraintEffectMap[i].constraint, | 128 constraints->AddOptional(kConstraintEffectMap[i].constraint, |
129 webrtc::MediaConstraintsInterface::kValueFalse, true); | 129 webrtc::MediaConstraintsInterface::kValueFalse, true); |
130 } | 130 } |
131 DVLOG(1) << "Disabling constraint: " | 131 DVLOG(1) << "Disabling constraint: " |
132 << kConstraintEffectMap[i].constraint; | 132 << kConstraintEffectMap[i].constraint; |
133 } | 133 } |
134 } | 134 } |
135 } | 135 } |
136 } | 136 } |
137 | 137 |
138 class P2PPortAllocatorFactory | |
139 : public rtc::RefCountedObject<webrtc::PortAllocatorFactoryInterface> { | |
140 public: | |
141 P2PPortAllocatorFactory( | |
142 scoped_ptr<media::MediaPermission> media_permission, | |
143 const scoped_refptr<P2PSocketDispatcher>& socket_dispatcher, | |
144 rtc::NetworkManager* network_manager, | |
145 rtc::PacketSocketFactory* socket_factory, | |
146 const P2PPortAllocator::Config& config, | |
147 const GURL& origin, | |
148 const scoped_refptr<base::SingleThreadTaskRunner>& task_runner) | |
149 : media_permission_(media_permission.Pass()), | |
150 socket_dispatcher_(socket_dispatcher), | |
151 network_manager_(network_manager), | |
152 socket_factory_(socket_factory), | |
153 config_(config), | |
154 origin_(origin), | |
155 task_runner_(task_runner) {} | |
156 | |
157 cricket::PortAllocator* CreatePortAllocator( | |
158 const std::vector<StunConfiguration>& stun_servers, | |
159 const std::vector<TurnConfiguration>& turn_configurations) override { | |
160 P2PPortAllocator::Config config = config_; | |
161 for (size_t i = 0; i < stun_servers.size(); ++i) { | |
162 config.stun_servers.insert(rtc::SocketAddress( | |
163 stun_servers[i].server.hostname(), | |
164 stun_servers[i].server.port())); | |
165 } | |
166 for (size_t i = 0; i < turn_configurations.size(); ++i) { | |
167 P2PPortAllocator::Config::RelayServerConfig relay_config; | |
168 relay_config.server_address = turn_configurations[i].server.hostname(); | |
169 relay_config.port = turn_configurations[i].server.port(); | |
170 relay_config.username = turn_configurations[i].username; | |
171 relay_config.password = turn_configurations[i].password; | |
172 relay_config.transport_type = turn_configurations[i].transport_type; | |
173 relay_config.secure = turn_configurations[i].secure; | |
174 config.relays.push_back(relay_config); | |
175 } | |
176 | |
177 scoped_ptr<rtc::NetworkManager> network_manager; | |
178 if (config.enable_multiple_routes) { | |
179 media::MediaPermission* media_permission = media_permission_.get(); | |
180 FilteringNetworkManager* filtering_network_manager = | |
181 new FilteringNetworkManager(network_manager_, origin_, | |
182 media_permission_.Pass()); | |
183 if (media_permission) { | |
184 // Start permission check earlier to reduce any impact to call set up | |
185 // time. It's safe to use Unretained here since both destructor and | |
186 // Initialize can only be called on the worker thread. | |
187 task_runner_->PostTask( | |
188 FROM_HERE, base::Bind(&FilteringNetworkManager::Initialize, | |
189 base::Unretained(filtering_network_manager))); | |
190 } | |
191 network_manager.reset(filtering_network_manager); | |
192 } else { | |
193 network_manager.reset(new EmptyNetworkManager(network_manager_)); | |
194 } | |
195 | |
196 return new P2PPortAllocator(socket_dispatcher_, network_manager.Pass(), | |
197 socket_factory_, config, origin_, task_runner_); | |
198 } | |
199 | |
200 protected: | |
201 ~P2PPortAllocatorFactory() override {} | |
202 | |
203 private: | |
204 // Ownership of |media_permission_| will be passed to FilteringNetworkManager | |
205 // during CreatePortAllocator. | |
206 scoped_ptr<media::MediaPermission> media_permission_; | |
207 | |
208 scoped_refptr<P2PSocketDispatcher> socket_dispatcher_; | |
209 rtc::NetworkManager* network_manager_; | |
210 rtc::PacketSocketFactory* socket_factory_; | |
211 P2PPortAllocator::Config config_; | |
212 GURL origin_; | |
213 | |
214 // This is the worker thread where |media_permission_| and |network_manager_| | |
215 // live on. | |
216 scoped_refptr<base::SingleThreadTaskRunner> task_runner_; | |
217 }; | |
218 | |
219 PeerConnectionDependencyFactory::PeerConnectionDependencyFactory( | 138 PeerConnectionDependencyFactory::PeerConnectionDependencyFactory( |
220 P2PSocketDispatcher* p2p_socket_dispatcher) | 139 P2PSocketDispatcher* p2p_socket_dispatcher) |
221 : network_manager_(NULL), | 140 : network_manager_(NULL), |
222 p2p_socket_dispatcher_(p2p_socket_dispatcher), | 141 p2p_socket_dispatcher_(p2p_socket_dispatcher), |
223 signaling_thread_(NULL), | 142 signaling_thread_(NULL), |
224 worker_thread_(NULL), | 143 worker_thread_(NULL), |
225 chrome_signaling_thread_("Chrome_libJingle_Signaling"), | 144 chrome_signaling_thread_("Chrome_libJingle_Signaling"), |
226 chrome_worker_thread_("Chrome_libJingle_WorkerThread") { | 145 chrome_worker_thread_("Chrome_libJingle_WorkerThread") { |
227 TryScheduleStunProbeTrial(); | 146 TryScheduleStunProbeTrial(); |
228 } | 147 } |
(...skipping 304 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
533 chrome_worker_thread_.task_runner()); | 452 chrome_worker_thread_.task_runner()); |
534 } | 453 } |
535 DCHECK(media_permission); | 454 DCHECK(media_permission); |
536 } | 455 } |
537 } | 456 } |
538 } | 457 } |
539 | 458 |
540 const GURL& requesting_origin = | 459 const GURL& requesting_origin = |
541 GURL(web_frame->document().url().spec()).GetOrigin(); | 460 GURL(web_frame->document().url().spec()).GetOrigin(); |
542 | 461 |
543 scoped_refptr<P2PPortAllocatorFactory> pa_factory = | 462 scoped_ptr<rtc::NetworkManager> network_manager; |
544 new P2PPortAllocatorFactory( | 463 if (port_config.enable_multiple_routes) { |
545 media_permission.Pass(), p2p_socket_dispatcher_, network_manager_, | 464 media::MediaPermission* media_permission_ptr = media_permission.get(); |
546 socket_factory_.get(), port_config, requesting_origin, | 465 FilteringNetworkManager* filtering_network_manager = |
547 chrome_worker_thread_.task_runner()); | 466 new FilteringNetworkManager(network_manager_, requesting_origin, |
| 467 std::move(media_permission)); |
| 468 if (media_permission_ptr) { |
| 469 // Start permission check earlier to reduce any impact to call set up |
| 470 // time. It's safe to use Unretained here since both destructor and |
| 471 // Initialize can only be called on the worker thread. |
| 472 chrome_worker_thread_.task_runner()->PostTask( |
| 473 FROM_HERE, base::Bind(&FilteringNetworkManager::Initialize, |
| 474 base::Unretained(filtering_network_manager))); |
| 475 } |
| 476 network_manager.reset(filtering_network_manager); |
| 477 } else { |
| 478 network_manager.reset(new EmptyNetworkManager(network_manager_)); |
| 479 } |
| 480 rtc::scoped_ptr<P2PPortAllocator> port_allocator(new P2PPortAllocator( |
| 481 p2p_socket_dispatcher_, std::move(network_manager), socket_factory_.get(), |
| 482 port_config, requesting_origin, chrome_worker_thread_.task_runner())); |
548 | 483 |
549 return GetPcFactory() | 484 return GetPcFactory() |
550 ->CreatePeerConnection(config, constraints, pa_factory.get(), | 485 ->CreatePeerConnection(config, constraints, std::move(port_allocator), |
551 std::move(identity_store), observer) | 486 std::move(identity_store), observer) |
552 .get(); | 487 .get(); |
553 } | 488 } |
554 | 489 |
555 scoped_refptr<webrtc::MediaStreamInterface> | 490 scoped_refptr<webrtc::MediaStreamInterface> |
556 PeerConnectionDependencyFactory::CreateLocalMediaStream( | 491 PeerConnectionDependencyFactory::CreateLocalMediaStream( |
557 const std::string& label) { | 492 const std::string& label) { |
558 return GetPcFactory()->CreateLocalMediaStream(label).get(); | 493 return GetPcFactory()->CreateLocalMediaStream(label).get(); |
559 } | 494 } |
560 | 495 |
(...skipping 252 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
813 } | 748 } |
814 | 749 |
815 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() { | 750 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() { |
816 if (audio_device_.get()) | 751 if (audio_device_.get()) |
817 return; | 752 return; |
818 | 753 |
819 audio_device_ = new WebRtcAudioDeviceImpl(); | 754 audio_device_ = new WebRtcAudioDeviceImpl(); |
820 } | 755 } |
821 | 756 |
822 } // namespace content | 757 } // namespace content |
OLD | NEW |