Renamed MediaStreamDependencyFactory to PeerConnectionDependencyFactory.

content/renderer/media/webrtc/peer_connection_dependency_factory.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-#include "content/renderer/media/media_stream_dependency_factory.h"
+#include "content/renderer/media/webrtc/peer_connection_dependency_factory.h"
 
 #include <vector>
 
 #include "base/command_line.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/synchronization/waitable_event.h"
 #include "content/common/media/media_stream_messages.h"
 #include "content/public/common/content_switches.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_audio_processor_options.h"
@@ skipping 130 matching lines @@
         web_frame_, socket_dispatcher_.get(), network_manager_,
         socket_factory_, config);
   }
 
  protected:
   virtual ~P2PPortAllocatorFactory() {}
 
  private:
   scoped_refptr<P2PSocketDispatcher> socket_dispatcher_;
   // |network_manager_| and |socket_factory_| are a weak references, owned by
-  // MediaStreamDependencyFactory.
+  // PeerConnectionDependencyFactory.
   talk_base::NetworkManager* network_manager_;
   talk_base::PacketSocketFactory* socket_factory_;
   // Raw ptr to the WebFrame that created the P2PPortAllocatorFactory.
   blink::WebFrame* web_frame_;
 };
 
-MediaStreamDependencyFactory::MediaStreamDependencyFactory(
+PeerConnectionDependencyFactory::PeerConnectionDependencyFactory(
     P2PSocketDispatcher* p2p_socket_dispatcher)
     : network_manager_(NULL),
       p2p_socket_dispatcher_(p2p_socket_dispatcher),
       signaling_thread_(NULL),
       worker_thread_(NULL),
       chrome_worker_thread_("Chrome_libJingle_WorkerThread") {
 }
 
-MediaStreamDependencyFactory::~MediaStreamDependencyFactory() {
+PeerConnectionDependencyFactory::~PeerConnectionDependencyFactory() {
   CleanupPeerConnectionFactory();
 }
 
 blink::WebRTCPeerConnectionHandler*
-MediaStreamDependencyFactory::CreateRTCPeerConnectionHandler(
+PeerConnectionDependencyFactory::CreateRTCPeerConnectionHandler(
     blink::WebRTCPeerConnectionHandlerClient* client) {
   // Save histogram data so we can see how much PeerConnetion is used.
   // The histogram counts the number of calls to the JS API
   // webKitRTCPeerConnection.
   UpdateWebRTCMethodCount(WEBKIT_RTC_PEER_CONNECTION);
 
   return new RTCPeerConnectionHandler(client, this);
 }
 
-bool MediaStreamDependencyFactory::InitializeMediaStreamAudioSource(
+bool PeerConnectionDependencyFactory::InitializeMediaStreamAudioSource(
     int render_view_id,
     const blink::WebMediaConstraints& audio_constraints,
     MediaStreamAudioSource* source_data) {
   DVLOG(1) << "InitializeMediaStreamAudioSources()";
 
   // Do additional source initialization if the audio source is a valid
   // microphone or tab audio.
   RTCMediaConstraints native_audio_constraints(audio_constraints);
   MediaAudioConstraints::ApplyFixedAudioConstraints(&native_audio_constraints);
 
@@ skipping 25 matching lines @@
   scoped_refptr<webrtc::AudioSourceInterface> rtc_source(
       CreateLocalAudioSource(&constraints).get());
   if (rtc_source->state() != webrtc::MediaSourceInterface::kLive) {
     DLOG(WARNING) << "Failed to create rtc LocalAudioSource.";
     return false;
   }
   source_data->SetLocalAudioSource(rtc_source);
   return true;
 }
 
-WebRtcVideoCapturerAdapter* MediaStreamDependencyFactory::CreateVideoCapturer(
+WebRtcVideoCapturerAdapter*
+PeerConnectionDependencyFactory::CreateVideoCapturer(
     bool is_screeencast) {
   // We need to make sure the libjingle thread wrappers have been created
   // before we can use an instance of a WebRtcVideoCapturerAdapter. This is
   // since the base class of WebRtcVideoCapturerAdapter is a
   // cricket::VideoCapturer and it uses the libjingle thread wrappers.
   if (!GetPcFactory())
     return NULL;
   return new WebRtcVideoCapturerAdapter(is_screeencast);
 }
 
 scoped_refptr<webrtc::VideoSourceInterface>
-MediaStreamDependencyFactory::CreateVideoSource(
+PeerConnectionDependencyFactory::CreateVideoSource(
     cricket::VideoCapturer* capturer,
     const blink::WebMediaConstraints& constraints) {
   RTCMediaConstraints webrtc_constraints(constraints);
   scoped_refptr<webrtc::VideoSourceInterface> source =
       GetPcFactory()->CreateVideoSource(capturer, &webrtc_constraints).get();
   return source;
 }
 
 const scoped_refptr<webrtc::PeerConnectionFactoryInterface>&
-MediaStreamDependencyFactory::GetPcFactory() {
+PeerConnectionDependencyFactory::GetPcFactory() {
   if (!pc_factory_)
     CreatePeerConnectionFactory();
   CHECK(pc_factory_);
   return pc_factory_;
 }
 
-void MediaStreamDependencyFactory::CreatePeerConnectionFactory() {
+void PeerConnectionDependencyFactory::CreatePeerConnectionFactory() {
   DCHECK(!pc_factory_.get());
   DCHECK(!signaling_thread_);
   DCHECK(!worker_thread_);
   DCHECK(!network_manager_);
   DCHECK(!socket_factory_);
   DCHECK(!chrome_worker_thread_.IsRunning());
 
-  DVLOG(1) << "MediaStreamDependencyFactory::CreatePeerConnectionFactory()";
+  DVLOG(1) << "PeerConnectionDependencyFactory::CreatePeerConnectionFactory()";
 
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
   signaling_thread_ = jingle_glue::JingleThreadWrapper::current();
   CHECK(signaling_thread_);
 
   CHECK(chrome_worker_thread_.Start());
 
   base::WaitableEvent start_worker_event(true, false);
   chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
-      &MediaStreamDependencyFactory::InitializeWorkerThread,
+      &PeerConnectionDependencyFactory::InitializeWorkerThread,
       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(
-      &MediaStreamDependencyFactory::CreateIpcNetworkManagerOnWorkerThread,
+      &PeerConnectionDependencyFactory::CreateIpcNetworkManagerOnWorkerThread,
       base::Unretained(this),
       &create_network_manager_event));
   create_network_manager_event.Wait();
 
   socket_factory_.reset(
       new IpcPacketSocketFactory(p2p_socket_dispatcher_.get()));
 
   // Init SSL, which will be needed by PeerConnection.
 #if defined(USE_OPENSSL)
   if (!talk_base::InitializeSSL()) {
@@ skipping 42 matching lines @@
   factory_options.disable_sctp_data_channels = false;
   factory_options.disable_encryption =
       cmd_line->HasSwitch(switches::kDisableWebRtcEncryption);
   pc_factory_->SetOptions(factory_options);
 
   // |aec_dump_file| will be invalid when dump is not enabled.
   if (aec_dump_file_.IsValid())
     StartAecDump(aec_dump_file_.Pass());
 }
 
-bool MediaStreamDependencyFactory::PeerConnectionFactoryCreated() {
+bool PeerConnectionDependencyFactory::PeerConnectionFactoryCreated() {
   return pc_factory_.get() != NULL;
 }
 
 scoped_refptr<webrtc::PeerConnectionInterface>
-MediaStreamDependencyFactory::CreatePeerConnection(
+PeerConnectionDependencyFactory::CreatePeerConnection(
     const webrtc::PeerConnectionInterface::IceServers& ice_servers,
     const webrtc::MediaConstraintsInterface* constraints,
     blink::WebFrame* web_frame,
     webrtc::PeerConnectionObserver* observer) {
   CHECK(web_frame);
   CHECK(observer);
   if (!GetPcFactory())
     return NULL;
 
   scoped_refptr<P2PPortAllocatorFactory> pa_factory =
         new talk_base::RefCountedObject<P2PPortAllocatorFactory>(
             p2p_socket_dispatcher_.get(),
             network_manager_,
             socket_factory_.get(),
             web_frame);
 
   PeerConnectionIdentityService* identity_service =
       new PeerConnectionIdentityService(
           GURL(web_frame->document().url().spec()).GetOrigin());
 
   return GetPcFactory()->CreatePeerConnection(ice_servers,
                                             constraints,
                                             pa_factory.get(),
                                             identity_service,
                                             observer).get();
 }
 
 scoped_refptr<webrtc::MediaStreamInterface>
-MediaStreamDependencyFactory::CreateLocalMediaStream(
+PeerConnectionDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
   return GetPcFactory()->CreateLocalMediaStream(label).get();
 }
 
 scoped_refptr<webrtc::AudioSourceInterface>
-MediaStreamDependencyFactory::CreateLocalAudioSource(
+PeerConnectionDependencyFactory::CreateLocalAudioSource(
     const webrtc::MediaConstraintsInterface* constraints) {
   scoped_refptr<webrtc::AudioSourceInterface> source =
       GetPcFactory()->CreateAudioSource(constraints).get();
   return source;
 }
 
-void MediaStreamDependencyFactory::CreateLocalAudioTrack(
+void PeerConnectionDependencyFactory::CreateLocalAudioTrack(
     const blink::WebMediaStreamTrack& track) {
   blink::WebMediaStreamSource source = track.source();
   DCHECK_EQ(source.type(), blink::WebMediaStreamSource::TypeAudio);
   MediaStreamAudioSource* source_data =
       static_cast<MediaStreamAudioSource*>(source.extraData());
 
   scoped_refptr<WebAudioCapturerSource> webaudio_source;
   if (!source_data) {
     if (source.requiresAudioConsumer()) {
       // We're adding a WebAudio MediaStream.
@@ skipping 24 matching lines @@
                                 source_data->GetAudioCapturer(),
                                 webaudio_source));
 
   StartLocalAudioTrack(audio_track.get());
 
   // Pass the ownership of the native local audio track to the blink track.
   blink::WebMediaStreamTrack writable_track = track;
   writable_track.setExtraData(audio_track.release());
 }
 
-void MediaStreamDependencyFactory::StartLocalAudioTrack(
+void PeerConnectionDependencyFactory::StartLocalAudioTrack(
     WebRtcLocalAudioTrack* audio_track) {
   // Add the WebRtcAudioDevice as the sink to the local audio track.
   // TODO(xians): Implement a PeerConnection sink adapter and remove this
   // AddSink() call.
   audio_track->AddSink(GetWebRtcAudioDevice());
   // Start the audio track. This will hook the |audio_track| to the capturer
   // as the sink of the audio, and only start the source of the capturer if
   // it is the first audio track connecting to the capturer.
   audio_track->Start();
 }
 
 scoped_refptr<WebAudioCapturerSource>
-MediaStreamDependencyFactory::CreateWebAudioSource(
+PeerConnectionDependencyFactory::CreateWebAudioSource(
     blink::WebMediaStreamSource* source) {
-  DVLOG(1) << "MediaStreamDependencyFactory::CreateWebAudioSource()";
+  DVLOG(1) << "PeerConnectionDependencyFactory::CreateWebAudioSource()";
 
   scoped_refptr<WebAudioCapturerSource>
       webaudio_capturer_source(new WebAudioCapturerSource());
   MediaStreamAudioSource* source_data = new MediaStreamAudioSource();
 
   // Use the current default capturer for the WebAudio track so that the
   // WebAudio track can pass a valid delay value and |need_audio_processing|
   // flag to PeerConnection.
   // TODO(xians): Remove this after moving APM to Chrome.
   if (GetWebRtcAudioDevice()) {
     source_data->SetAudioCapturer(
         GetWebRtcAudioDevice()->GetDefaultCapturer());
   }
 
   // Create a LocalAudioSource object which holds audio options.
   // SetLocalAudioSource() affects core audio parts in third_party/Libjingle.
   source_data->SetLocalAudioSource(CreateLocalAudioSource(NULL).get());
   source->setExtraData(source_data);
 
   // Replace the default source with WebAudio as source instead.
   source->addAudioConsumer(webaudio_capturer_source.get());
 
   return webaudio_capturer_source;
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
-MediaStreamDependencyFactory::CreateLocalVideoTrack(
+PeerConnectionDependencyFactory::CreateLocalVideoTrack(
     const std::string& id,
     webrtc::VideoSourceInterface* source) {
   return GetPcFactory()->CreateVideoTrack(id, source).get();
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
-MediaStreamDependencyFactory::CreateLocalVideoTrack(
+PeerConnectionDependencyFactory::CreateLocalVideoTrack(
     const std::string& id, cricket::VideoCapturer* capturer) {
   if (!capturer) {
     LOG(ERROR) << "CreateLocalVideoTrack called with null VideoCapturer.";
     return NULL;
   }
 
   // Create video source from the |capturer|.
   scoped_refptr<webrtc::VideoSourceInterface> source =
       GetPcFactory()->CreateVideoSource(capturer, NULL).get();
 
   // Create native track from the source.
   return GetPcFactory()->CreateVideoTrack(id, source.get()).get();
 }
 
 webrtc::SessionDescriptionInterface*
-MediaStreamDependencyFactory::CreateSessionDescription(
+PeerConnectionDependencyFactory::CreateSessionDescription(
     const std::string& type,
     const std::string& sdp,
     webrtc::SdpParseError* error) {
   return webrtc::CreateSessionDescription(type, sdp, error);
 }
 
-webrtc::IceCandidateInterface* MediaStreamDependencyFactory::CreateIceCandidate(
+webrtc::IceCandidateInterface*
+PeerConnectionDependencyFactory::CreateIceCandidate(
     const std::string& sdp_mid,
     int sdp_mline_index,
     const std::string& sdp) {
   return webrtc::CreateIceCandidate(sdp_mid, sdp_mline_index, sdp);
 }
 
 WebRtcAudioDeviceImpl*
-MediaStreamDependencyFactory::GetWebRtcAudioDevice() {
+PeerConnectionDependencyFactory::GetWebRtcAudioDevice() {
   return audio_device_.get();
 }
 
-void MediaStreamDependencyFactory::InitializeWorkerThread(
+void PeerConnectionDependencyFactory::InitializeWorkerThread(
     talk_base::Thread** thread,
     base::WaitableEvent* event) {
   jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
   jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
   *thread = jingle_glue::JingleThreadWrapper::current();
   event->Signal();
 }
 
-void MediaStreamDependencyFactory::CreateIpcNetworkManagerOnWorkerThread(
+void PeerConnectionDependencyFactory::CreateIpcNetworkManagerOnWorkerThread(
     base::WaitableEvent* event) {
   DCHECK_EQ(base::MessageLoop::current(), chrome_worker_thread_.message_loop());
   network_manager_ = new IpcNetworkManager(p2p_socket_dispatcher_.get());
   event->Signal();
 }
 
-void MediaStreamDependencyFactory::DeleteIpcNetworkManager() {
+void PeerConnectionDependencyFactory::DeleteIpcNetworkManager() {
   DCHECK_EQ(base::MessageLoop::current(), chrome_worker_thread_.message_loop());
   delete network_manager_;
   network_manager_ = NULL;
 }
 
-void MediaStreamDependencyFactory::CleanupPeerConnectionFactory() {
+void PeerConnectionDependencyFactory::CleanupPeerConnectionFactory() {
   pc_factory_ = NULL;
   if (network_manager_) {
     // The network manager needs to free its resources on the thread they were
     // created, which is the worked thread.
     if (chrome_worker_thread_.IsRunning()) {
       chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
-          &MediaStreamDependencyFactory::DeleteIpcNetworkManager,
+          &PeerConnectionDependencyFactory::DeleteIpcNetworkManager,
           base::Unretained(this)));
       // Stopping the thread will wait until all tasks have been
       // processed before returning. We wait for the above task to finish before
       // letting the the function continue to avoid any potential race issues.
       chrome_worker_thread_.Stop();
     } else {
       NOTREACHED() << "Worker thread not running.";
     }
   }
 }
 
 scoped_refptr<WebRtcAudioCapturer>
-MediaStreamDependencyFactory::CreateAudioCapturer(
+PeerConnectionDependencyFactory::CreateAudioCapturer(
     int render_view_id,
     const StreamDeviceInfo& device_info,
     const blink::WebMediaConstraints& constraints,
     MediaStreamAudioSource* audio_source) {
   // TODO(xians): Handle the cases when gUM is called without a proper render
   // view, for example, by an extension.
   DCHECK_GE(render_view_id, 0);
 
   EnsureWebRtcAudioDeviceImpl();
   DCHECK(GetWebRtcAudioDevice());
   return WebRtcAudioCapturer::CreateCapturer(render_view_id, device_info,
                                              constraints,
                                              GetWebRtcAudioDevice(),
                                              audio_source);
 }
 
-void MediaStreamDependencyFactory::AddNativeAudioTrackToBlinkTrack(
+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>
-MediaStreamDependencyFactory::GetWebRtcWorkerThread() const {
+PeerConnectionDependencyFactory::GetWebRtcWorkerThread() const {
   DCHECK(CalledOnValidThread());
   return chrome_worker_thread_.message_loop_proxy();
 }
 
-bool MediaStreamDependencyFactory::OnControlMessageReceived(
+bool PeerConnectionDependencyFactory::OnControlMessageReceived(
     const IPC::Message& message) {
   bool handled = true;
-  IPC_BEGIN_MESSAGE_MAP(MediaStreamDependencyFactory, message)
+  IPC_BEGIN_MESSAGE_MAP(PeerConnectionDependencyFactory, message)
     IPC_MESSAGE_HANDLER(MediaStreamMsg_EnableAecDump, OnAecDumpFile)
     IPC_MESSAGE_HANDLER(MediaStreamMsg_DisableAecDump, OnDisableAecDump)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void MediaStreamDependencyFactory::OnAecDumpFile(
+void PeerConnectionDependencyFactory::OnAecDumpFile(
     IPC::PlatformFileForTransit file_handle) {
   DCHECK(!aec_dump_file_.IsValid());
   base::File file = IPC::PlatformFileForTransitToFile(file_handle);
   DCHECK(file.IsValid());
 
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAudioTrackProcessing)) {
     EnsureWebRtcAudioDeviceImpl();
     GetWebRtcAudioDevice()->EnableAecDump(file.Pass());
     return;
   }
 
   // TODO(xians): Remove the following code after kEnableAudioTrackProcessing
   // is removed.
   if (PeerConnectionFactoryCreated())
     StartAecDump(file.Pass());
   else
     aec_dump_file_ = file.Pass();
 }
 
-void MediaStreamDependencyFactory::OnDisableAecDump() {
+void PeerConnectionDependencyFactory::OnDisableAecDump() {
   if (CommandLine::ForCurrentProcess()->HasSwitch(
           switches::kEnableAudioTrackProcessing)) {
     GetWebRtcAudioDevice()->DisableAecDump();
     return;
   }
 
   // TODO(xians): Remove the following code after kEnableAudioTrackProcessing
   // is removed.
   if (aec_dump_file_.IsValid())
     aec_dump_file_.Close();
 }
 
-void MediaStreamDependencyFactory::StartAecDump(base::File aec_dump_file) {
+void PeerConnectionDependencyFactory::StartAecDump(base::File aec_dump_file) {
   // |pc_factory_| always takes ownership of |aec_dump_file|. If StartAecDump()
   // fails, |aec_dump_file| will be closed.
   if (!GetPcFactory()->StartAecDump(aec_dump_file.TakePlatformFile()))
     VLOG(1) << "Could not start AEC dump.";
 }
 
-void MediaStreamDependencyFactory::EnsureWebRtcAudioDeviceImpl() {
+void PeerConnectionDependencyFactory::EnsureWebRtcAudioDeviceImpl() {
   if (audio_device_)
     return;
 
   audio_device_ = new WebRtcAudioDeviceImpl();
 }
 
 }  // namespace content