void HarmonizeConstraintsAndEffects(RTCMediaConstraints* constraints,
int* effects) {
if (*effects != media::AudioParameters::NO_EFFECTS) {
- for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kConstraintEffectMap); ++i) {
+ for (size_t i = 0; i < arraysize(kConstraintEffectMap); ++i) {
bool value;
size_t is_mandatory = 0;
if (!webrtc::FindConstraint(constraints,
P2PPortAllocatorFactory(
P2PSocketDispatcher* socket_dispatcher,
rtc::NetworkManager* network_manager,
- rtc::PacketSocketFactory* socket_factory,
- blink::WebFrame* web_frame)
+ rtc::PacketSocketFactory* socket_factory)
: socket_dispatcher_(socket_dispatcher),
network_manager_(network_manager),
- socket_factory_(socket_factory),
- web_frame_(web_frame) {
+ socket_factory_(socket_factory) {
}
- virtual cricket::PortAllocator* CreatePortAllocator(
+ cricket::PortAllocator* CreatePortAllocator(
const std::vector<StunConfiguration>& stun_servers,
- const std::vector<TurnConfiguration>& turn_configurations) OVERRIDE {
- CHECK(web_frame_);
+ const std::vector<TurnConfiguration>& turn_configurations) override {
P2PPortAllocator::Config config;
for (size_t i = 0; i < stun_servers.size(); ++i) {
config.stun_servers.insert(rtc::SocketAddress(
stun_servers[i].server.hostname(),
stun_servers[i].server.port()));
}
- config.legacy_relay = false;
for (size_t i = 0; i < turn_configurations.size(); ++i) {
P2PPortAllocator::Config::RelayServerConfig relay_config;
relay_config.server_address = turn_configurations[i].server.hostname();
}
return new P2PPortAllocator(
- web_frame_, socket_dispatcher_.get(), network_manager_,
- socket_factory_, config);
+ socket_dispatcher_.get(), network_manager_, socket_factory_, config);
}
protected:
- virtual ~P2PPortAllocatorFactory() {}
+ ~P2PPortAllocatorFactory() override {}
private:
scoped_refptr<P2PSocketDispatcher> socket_dispatcher_;
// PeerConnectionDependencyFactory.
rtc::NetworkManager* network_manager_;
rtc::PacketSocketFactory* socket_factory_;
- // Raw ptr to the WebFrame that created the P2PPortAllocatorFactory.
- blink::WebFrame* web_frame_;
};
PeerConnectionDependencyFactory::PeerConnectionDependencyFactory(
p2p_socket_dispatcher_(p2p_socket_dispatcher),
signaling_thread_(NULL),
worker_thread_(NULL),
+ chrome_signaling_thread_("Chrome_libJingle_Signaling"),
chrome_worker_thread_("Chrome_libJingle_WorkerThread") {
}
DCHECK(!worker_thread_);
DCHECK(!network_manager_);
DCHECK(!socket_factory_);
+ DCHECK(!chrome_signaling_thread_.IsRunning());
DCHECK(!chrome_worker_thread_.IsRunning());
DVLOG(1) << "PeerConnectionDependencyFactory::CreatePeerConnectionFactory()";
+ // To allow sending to the signaling/worker threads.
jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
- signaling_thread_ = jingle_glue::JingleThreadWrapper::current();
- CHECK(signaling_thread_);
+ CHECK(chrome_signaling_thread_.Start());
CHECK(chrome_worker_thread_.Start());
base::WaitableEvent start_worker_event(true, false);
base::Unretained(this),
&worker_thread_,
&start_worker_event));
- start_worker_event.Wait();
- CHECK(worker_thread_);
base::WaitableEvent create_network_manager_event(true, false);
chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
&PeerConnectionDependencyFactory::CreateIpcNetworkManagerOnWorkerThread,
base::Unretained(this),
&create_network_manager_event));
+
+ start_worker_event.Wait();
create_network_manager_event.Wait();
- socket_factory_.reset(
- new IpcPacketSocketFactory(p2p_socket_dispatcher_.get()));
+ CHECK(worker_thread_);
// Init SSL, which will be needed by PeerConnection.
#if defined(USE_OPENSSL)
net::EnsureNSSSSLInit();
#endif
+ base::WaitableEvent start_signaling_event(true, false);
+ chrome_signaling_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+ &PeerConnectionDependencyFactory::InitializeSignalingThread,
+ base::Unretained(this),
+ RenderThreadImpl::current()->GetGpuFactories(),
+ &start_signaling_event));
+
+ // TODO(xians): Remove the following code after kDisableAudioTrackProcessing
+ // is removed.
+ if (!MediaStreamAudioProcessor::IsAudioTrackProcessingEnabled()) {
+ aec_dump_message_filter_ = AecDumpMessageFilter::Get();
+ // In unit tests not creating a message filter, |aec_dump_message_filter_|
+ // will be NULL. We can just ignore that. Other unit tests and browser tests
+ // ensure that we do get the filter when we should.
+ if (aec_dump_message_filter_.get())
+ aec_dump_message_filter_->AddDelegate(this);
+ }
+
+ start_signaling_event.Wait();
+ CHECK(signaling_thread_);
+}
+
+void PeerConnectionDependencyFactory::InitializeSignalingThread(
+ const scoped_refptr<media::GpuVideoAcceleratorFactories>& gpu_factories,
+ base::WaitableEvent* event) {
+ DCHECK(chrome_signaling_thread_.task_runner()->BelongsToCurrentThread());
+ DCHECK(worker_thread_);
+ DCHECK(p2p_socket_dispatcher_.get());
+
+ jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
+ jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
+ signaling_thread_ = jingle_glue::JingleThreadWrapper::current();
+
+ EnsureWebRtcAudioDeviceImpl();
+
+ socket_factory_.reset(
+ new IpcPacketSocketFactory(p2p_socket_dispatcher_.get()));
+
scoped_ptr<cricket::WebRtcVideoDecoderFactory> decoder_factory;
scoped_ptr<cricket::WebRtcVideoEncoderFactory> encoder_factory;
const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
- scoped_refptr<media::GpuVideoAcceleratorFactories> gpu_factories =
- RenderThreadImpl::current()->GetGpuFactories();
- if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWDecoding)) {
- if (gpu_factories.get())
+ if (gpu_factories.get()) {
+ if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWDecoding))
decoder_factory.reset(new RTCVideoDecoderFactory(gpu_factories));
- }
- if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWEncoding)) {
- if (gpu_factories.get())
+ if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWEncoding))
encoder_factory.reset(new RTCVideoEncoderFactory(gpu_factories));
}
encoder_factory.reset();
#endif
- EnsureWebRtcAudioDeviceImpl();
-
- scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
- webrtc::CreatePeerConnectionFactory(worker_thread_,
- signaling_thread_,
- audio_device_.get(),
- encoder_factory.release(),
- decoder_factory.release()));
- CHECK(factory.get());
+ pc_factory_ = webrtc::CreatePeerConnectionFactory(
+ worker_thread_, signaling_thread_, audio_device_.get(),
+ encoder_factory.release(), decoder_factory.release());
+ CHECK(pc_factory_.get());
- pc_factory_ = factory;
webrtc::PeerConnectionFactoryInterface::Options factory_options;
factory_options.disable_sctp_data_channels = false;
factory_options.disable_encryption =
cmd_line->HasSwitch(switches::kDisableWebRtcEncryption);
pc_factory_->SetOptions(factory_options);
- // TODO(xians): Remove the following code after kDisableAudioTrackProcessing
- // is removed.
- if (!MediaStreamAudioProcessor::IsAudioTrackProcessingEnabled()) {
- aec_dump_message_filter_ = AecDumpMessageFilter::Get();
- // In unit tests not creating a message filter, |aec_dump_message_filter_|
- // will be NULL. We can just ignore that. Other unit tests and browser tests
- // ensure that we do get the filter when we should.
- if (aec_dump_message_filter_.get())
- aec_dump_message_filter_->AddDelegate(this);
- }
+ event->Signal();
}
bool PeerConnectionDependencyFactory::PeerConnectionFactoryCreated() {
new rtc::RefCountedObject<P2PPortAllocatorFactory>(
p2p_socket_dispatcher_.get(),
network_manager_,
- socket_factory_.get(),
- web_frame);
+ socket_factory_.get());
PeerConnectionIdentityService* identity_service =
new PeerConnectionIdentityService(
audio_source);
}
-void PeerConnectionDependencyFactory::AddNativeAudioTrackToBlinkTrack(
- webrtc::MediaStreamTrackInterface* native_track,
- const blink::WebMediaStreamTrack& webkit_track,
- bool is_local_track) {
- DCHECK(!webkit_track.isNull() && !webkit_track.extraData());
- DCHECK_EQ(blink::WebMediaStreamSource::TypeAudio,
- webkit_track.source().type());
- blink::WebMediaStreamTrack track = webkit_track;
-
- DVLOG(1) << "AddNativeTrackToBlinkTrack() audio";
- track.setExtraData(
- new MediaStreamTrack(
- static_cast<webrtc::AudioTrackInterface*>(native_track),
- is_local_track));
-}
-
scoped_refptr<base::MessageLoopProxy>
PeerConnectionDependencyFactory::GetWebRtcWorkerThread() const {
DCHECK(CalledOnValidThread());
return chrome_worker_thread_.message_loop_proxy();
}
+scoped_refptr<base::MessageLoopProxy>
+PeerConnectionDependencyFactory::GetWebRtcSignalingThread() const {
+ DCHECK(CalledOnValidThread());
+ return chrome_signaling_thread_.message_loop_proxy();
+}
+
void PeerConnectionDependencyFactory::OnAecDumpFile(
const IPC::PlatformFileForTransit& file_handle) {
DCHECK(CalledOnValidThread());
projects / platform / framework / web / crosswalk.git / blobdiff