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 |
138 PeerConnectionDependencyFactory::PeerConnectionDependencyFactory( | 219 PeerConnectionDependencyFactory::PeerConnectionDependencyFactory( |
139 P2PSocketDispatcher* p2p_socket_dispatcher) | 220 P2PSocketDispatcher* p2p_socket_dispatcher) |
140 : network_manager_(NULL), | 221 : network_manager_(NULL), |
141 p2p_socket_dispatcher_(p2p_socket_dispatcher), | 222 p2p_socket_dispatcher_(p2p_socket_dispatcher), |
142 signaling_thread_(NULL), | 223 signaling_thread_(NULL), |
143 worker_thread_(NULL), | 224 worker_thread_(NULL), |
144 chrome_signaling_thread_("Chrome_libJingle_Signaling"), | 225 chrome_signaling_thread_("Chrome_libJingle_Signaling"), |
145 chrome_worker_thread_("Chrome_libJingle_WorkerThread") { | 226 chrome_worker_thread_("Chrome_libJingle_WorkerThread") { |
146 TryScheduleStunProbeTrial(); | 227 TryScheduleStunProbeTrial(); |
147 } | 228 } |
(...skipping 304 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
452 chrome_worker_thread_.task_runner()); | 533 chrome_worker_thread_.task_runner()); |
453 } | 534 } |
454 DCHECK(media_permission); | 535 DCHECK(media_permission); |
455 } | 536 } |
456 } | 537 } |
457 } | 538 } |
458 | 539 |
459 const GURL& requesting_origin = | 540 const GURL& requesting_origin = |
460 GURL(web_frame->document().url().spec()).GetOrigin(); | 541 GURL(web_frame->document().url().spec()).GetOrigin(); |
461 | 542 |
462 scoped_ptr<rtc::NetworkManager> network_manager; | 543 scoped_refptr<P2PPortAllocatorFactory> pa_factory = |
463 if (port_config.enable_multiple_routes) { | 544 new P2PPortAllocatorFactory( |
464 media::MediaPermission* media_permission_ptr = media_permission.get(); | 545 media_permission.Pass(), p2p_socket_dispatcher_, network_manager_, |
465 FilteringNetworkManager* filtering_network_manager = | 546 socket_factory_.get(), port_config, requesting_origin, |
466 new FilteringNetworkManager(network_manager_, requesting_origin, | 547 chrome_worker_thread_.task_runner()); |
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())); | |
483 | 548 |
484 return GetPcFactory() | 549 return GetPcFactory() |
485 ->CreatePeerConnection(config, constraints, std::move(port_allocator), | 550 ->CreatePeerConnection(config, constraints, pa_factory.get(), |
486 std::move(identity_store), observer) | 551 std::move(identity_store), observer) |
487 .get(); | 552 .get(); |
488 } | 553 } |
489 | 554 |
490 scoped_refptr<webrtc::MediaStreamInterface> | 555 scoped_refptr<webrtc::MediaStreamInterface> |
491 PeerConnectionDependencyFactory::CreateLocalMediaStream( | 556 PeerConnectionDependencyFactory::CreateLocalMediaStream( |
492 const std::string& label) { | 557 const std::string& label) { |
493 return GetPcFactory()->CreateLocalMediaStream(label).get(); | 558 return GetPcFactory()->CreateLocalMediaStream(label).get(); |
494 } | 559 } |
495 | 560 |
(...skipping 252 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
748 } | 813 } |
749 | 814 |
750 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() { | 815 void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() { |
751 if (audio_device_.get()) | 816 if (audio_device_.get()) |
752 return; | 817 return; |
753 | 818 |
754 audio_device_ = new WebRtcAudioDeviceImpl(); | 819 audio_device_ = new WebRtcAudioDeviceImpl(); |
755 } | 820 } |
756 | 821 |
757 } // namespace content | 822 } // namespace content |
OLD | NEW |