Adds MediaStreamSource, MediaStreamAudioSource and MediaStreamVideoCaptureDeviceSource

content/renderer/media/media_stream_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 <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_audio_processor_options.h"
-#include "content/renderer/media/media_stream_source_extra_data.h"
+#include "content/renderer/media/media_stream_audio_source.h"
 #include "content/renderer/media/media_stream_track_extra_data.h"
+#include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/peer_connection_identity_service.h"
 #include "content/renderer/media/rtc_media_constraints.h"
 #include "content/renderer/media/rtc_peer_connection_handler.h"
 #include "content/renderer/media/rtc_video_capturer.h"
 #include "content/renderer/media/rtc_video_decoder_factory.h"
 #include "content/renderer/media/rtc_video_encoder_factory.h"
 #include "content/renderer/media/webaudio_capturer_source.h"
 #include "content/renderer/media/webrtc_audio_device_impl.h"
 #include "content/renderer/media/webrtc_local_audio_track.h"
@@ skipping 85 matching lines @@
  private:
   scoped_refptr<P2PSocketDispatcher> socket_dispatcher_;
   // |network_manager_| and |socket_factory_| are a weak references, owned by
   // MediaStreamDependencyFactory.
   talk_base::NetworkManager* network_manager_;
   talk_base::PacketSocketFactory* socket_factory_;
   // Raw ptr to the WebFrame that created the P2PPortAllocatorFactory.
   blink::WebFrame* web_frame_;
 };
 
-// SourceStateObserver is a help class used for observing the startup state
-// transition of webrtc media sources such as a camera or microphone.
-// An instance of the object deletes itself after use.
-// Usage:
-// 1. Create an instance of the object with the blink::WebMediaStream
-//    the observed sources belongs to a callback.
-// 2. Add the sources to the observer using AddSource.
-// 3. Call StartObserving()
-// 4. The callback will be triggered when all sources have transitioned from
-//    webrtc::MediaSourceInterface::kInitializing.
-class SourceStateObserver : public webrtc::ObserverInterface,
-                            public base::NonThreadSafe {
- public:
-  SourceStateObserver(
-      blink::WebMediaStream* web_stream,
-      const MediaStreamDependencyFactory::MediaSourcesCreatedCallback& callback)
-     : web_stream_(web_stream),
-       ready_callback_(callback),
-       live_(true) {
-  }
-
-  void AddSource(webrtc::MediaSourceInterface* source) {
-    DCHECK(CalledOnValidThread());
-    switch (source->state()) {
-      case webrtc::MediaSourceInterface::kInitializing:
-        sources_.push_back(source);
-        source->RegisterObserver(this);
-        break;
-      case webrtc::MediaSourceInterface::kLive:
-        // The source is already live so we don't need to wait for it.
-        break;
-      case webrtc::MediaSourceInterface::kEnded:
-        // The source have already failed.
-        live_ = false;
-        break;
-      default:
-        NOTREACHED();
-    }
-  }
-
-  void StartObservering() {
-    DCHECK(CalledOnValidThread());
-    CheckIfSourcesAreLive();
-  }
-
-  virtual void OnChanged() OVERRIDE {
-    DCHECK(CalledOnValidThread());
-    CheckIfSourcesAreLive();
-  }
-
- private:
-  void CheckIfSourcesAreLive() {
-    ObservedSources::iterator it = sources_.begin();
-    while (it != sources_.end()) {
-      if ((*it)->state() != webrtc::MediaSourceInterface::kInitializing) {
-        live_ &=  (*it)->state() == webrtc::MediaSourceInterface::kLive;
-        (*it)->UnregisterObserver(this);
-        it = sources_.erase(it);
-      } else {
-        ++it;
-      }
-    }
-    if (sources_.empty()) {
-      ready_callback_.Run(web_stream_, live_);
-      delete this;
-    }
-  }
-
-  blink::WebMediaStream* web_stream_;
-  MediaStreamDependencyFactory::MediaSourcesCreatedCallback ready_callback_;
-  bool live_;
-  typedef std::vector<scoped_refptr<webrtc::MediaSourceInterface> >
-      ObservedSources;
-  ObservedSources sources_;
-};
-
 MediaStreamDependencyFactory::MediaStreamDependencyFactory(
     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"),
       aec_dump_file_(base::kInvalidPlatformFileValue) {
 }
 
 MediaStreamDependencyFactory::~MediaStreamDependencyFactory() {
   CleanupPeerConnectionFactory();
   if (aec_dump_file_ != base::kInvalidPlatformFileValue)
     base::ClosePlatformFile(aec_dump_file_);
 }
 
 blink::WebRTCPeerConnectionHandler*
 MediaStreamDependencyFactory::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);
 
-  if (!EnsurePeerConnectionFactory())
-    return NULL;
-
   return new RTCPeerConnectionHandler(client, this);
 }
 
-void MediaStreamDependencyFactory::CreateNativeMediaSources(
+bool MediaStreamDependencyFactory::InitializeMediaStreamAudioSource(
     int render_view_id,
     const blink::WebMediaConstraints& audio_constraints,
-    const blink::WebMediaConstraints& video_constraints,
-    blink::WebMediaStream* web_stream,
-    const MediaSourcesCreatedCallback& sources_created) {
-  DVLOG(1) << "MediaStreamDependencyFactory::CreateNativeMediaSources()";
-  if (!EnsurePeerConnectionFactory()) {
-    sources_created.Run(web_stream, false);
-    return;
-  }
-
-  // |source_observer| clean up itself when it has completed
-  // source_observer->StartObservering.
-  SourceStateObserver* source_observer =
-      new SourceStateObserver(web_stream, sources_created);
-
-  // Create local video sources.
-  RTCMediaConstraints native_video_constraints(video_constraints);
-  blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
-  web_stream->videoTracks(video_tracks);
-  for (size_t i = 0; i < video_tracks.size(); ++i) {
-    const blink::WebMediaStreamSource& source = video_tracks[i].source();
-    MediaStreamSourceExtraData* source_data =
-        static_cast<MediaStreamSourceExtraData*>(source.extraData());
-
-    // Check if the source has already been created. This happens when the same
-    // source is used in multiple MediaStreams as a result of calling
-    // getUserMedia.
-    if (source_data->video_source())
-      continue;
-
-    const bool is_screencast =
-        source_data->device_info().device.type == MEDIA_TAB_VIDEO_CAPTURE ||
-        source_data->device_info().device.type == MEDIA_DESKTOP_VIDEO_CAPTURE;
-    source_data->SetVideoSource(
-        CreateLocalVideoSource(source_data->device_info().session_id,
-                               is_screencast,
-                               &native_video_constraints).get());
-    source_observer->AddSource(source_data->video_source());
-  }
+    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);
   ApplyFixedAudioConstraints(&native_audio_constraints);
-  blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
-  web_stream->audioTracks(audio_tracks);
-  for (size_t i = 0; i < audio_tracks.size(); ++i) {
-    const blink::WebMediaStreamSource& source = audio_tracks[i].source();
-    MediaStreamSourceExtraData* source_data =
-        static_cast<MediaStreamSourceExtraData*>(source.extraData());
 
-    // Check if the source has already been created. This happens when the same
-    // source is used in multiple MediaStreams as a result of calling
-    // getUserMedia.
-    if (source_data->local_audio_source())
-      continue;
+  StreamDeviceInfo device_info = source_data->device_info();
+  RTCMediaConstraints constraints = native_audio_constraints;
 
-    // TODO(xians): Create a new capturer for difference microphones when we
-    // support multiple microphones. See issue crbug/262117 .
-    StreamDeviceInfo device_info = source_data->device_info();
-    RTCMediaConstraints constraints = native_audio_constraints;
-
-    // If any platform effects are available, check them against the
-    // constraints. Disable effects to match false constraints, but if a
-    // constraint is true, set the constraint to false to later disable the
-    // software effect.
-    int effects = device_info.device.input.effects;
-    if (effects != media::AudioParameters::NO_EFFECTS) {
-      for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kConstraintEffectMap); ++i) {
-        bool value;
-        if (!webrtc::FindConstraint(&constraints,
-                kConstraintEffectMap[i].constraint, &value, NULL) || !value) {
-          // If the constraint is false, or does not exist, disable the platform
-          // effect.
-          effects &= ~kConstraintEffectMap[i].effect;
-          DVLOG(1) << "Disabling constraint: "
-                   << kConstraintEffectMap[i].constraint;
-        } else if (effects & kConstraintEffectMap[i].effect) {
-          // If the constraint is true, leave the platform effect enabled, and
-          // set the constraint to false to later disable the software effect.
-          constraints.AddMandatory(kConstraintEffectMap[i].constraint,
-              webrtc::MediaConstraintsInterface::kValueFalse, true);
-          DVLOG(1) << "Disabling platform effect: "
-                   << kConstraintEffectMap[i].constraint;
-        }
+  // If any platform effects are available, check them against the
+  // constraints. Disable effects to match false constraints, but if a
+  // constraint is true, set the constraint to false to later disable the
+  // software effect.
+  int effects = device_info.device.input.effects;
+  if (effects != media::AudioParameters::NO_EFFECTS) {
+    for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kConstraintEffectMap); ++i) {
+      bool value;
+      if (!webrtc::FindConstraint(&constraints,
+                                  kConstraintEffectMap[i].constraint, &value,
+                                  NULL) || !value) {
+        // If the constraint is false, or does not exist, disable the platform
+        // effect.
+        effects &= ~kConstraintEffectMap[i].effect;
+        DVLOG(1) << "Disabling constraint: "
+            << kConstraintEffectMap[i].constraint;
+      } else if (effects & kConstraintEffectMap[i].effect) {
+        // If the constraint is true, leave the platform effect enabled, and
+        // set the constraint to false to later disable the software effect.
+        constraints.AddMandatory(kConstraintEffectMap[i].constraint,
+                                 webrtc::MediaConstraintsInterface::kValueFalse,
+                                 true);
+        DVLOG(1) << "Disabling platform effect: "
+            << kConstraintEffectMap[i].constraint;
       }
-      device_info.device.input.effects = effects;
     }
-
-    scoped_refptr<WebRtcAudioCapturer> capturer(
-        CreateAudioCapturer(render_view_id, device_info, audio_constraints));
-    if (!capturer.get()) {
-      DLOG(WARNING) << "Failed to create the capturer for device "
-                    << device_info.device.id;
-      sources_created.Run(web_stream, false);
-      // TODO(xians): Don't we need to check if source_observer is observing
-      // something? If not, then it looks like we have a leak here.
-      // OTOH, if it _is_ observing something, then the callback might
-      // be called multiple times which is likely also a bug.
-      return;
-    }
-    source_data->SetAudioCapturer(capturer);
-
-    // Creates a LocalAudioSource object which holds audio options.
-    // TODO(xians): The option should apply to the track instead of the source.
-    source_data->SetLocalAudioSource(
-        CreateLocalAudioSource(&constraints).get());
-    source_observer->AddSource(source_data->local_audio_source());
+    device_info.device.input.effects = effects;
   }
 
-  source_observer->StartObservering();
+  scoped_refptr<WebRtcAudioCapturer> capturer(
+      CreateAudioCapturer(render_view_id, device_info, audio_constraints));
+  if (!capturer.get()) {
+    DLOG(WARNING) << "Failed to create the capturer for device "
+        << device_info.device.id;
+    // TODO(xians): Don't we need to check if source_observer is observing
+    // something? If not, then it looks like we have a leak here.
+    // OTOH, if it _is_ observing something, then the callback might
+    // be called multiple times which is likely also a bug.
+    return false;
+  }
+  source_data->SetAudioCapturer(capturer);
+
+  // Creates a LocalAudioSource object which holds audio options.
+  // TODO(xians): The option should apply to the track instead of the source.
+  // TODO(perkj): Move audio constraints parsing to Chrome.
+  // Currently there are a few constraints that are parsed by libjingle and
+  // the state is set to ended if parsing fails.
+  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;
+}
+
+cricket::VideoCapturer* MediaStreamDependencyFactory::CreateVideoCapturer(
+    const StreamDeviceInfo& info) {
+  bool is_screeencast =
+      info.device.type == MEDIA_TAB_VIDEO_CAPTURE ||
+      info.device.type == MEDIA_DESKTOP_VIDEO_CAPTURE;
+  return new RtcVideoCapturer(info.session_id, is_screeencast);
 }
 
 void MediaStreamDependencyFactory::CreateNativeLocalMediaStream(
     blink::WebMediaStream* web_stream) {
   DVLOG(1) << "MediaStreamDependencyFactory::CreateNativeLocalMediaStream()";
-  if (!EnsurePeerConnectionFactory()) {
-    DVLOG(1) << "EnsurePeerConnectionFactory() failed!";
-    return;
-  }
 
   std::string label = base::UTF16ToUTF8(web_stream->id());
   scoped_refptr<webrtc::MediaStreamInterface> native_stream =
       CreateLocalMediaStream(label);
   MediaStreamExtraData* extra_data =
       new MediaStreamExtraData(native_stream.get(), true);
   web_stream->setExtraData(extra_data);
 
   // Add audio tracks.
   blink::WebVector<blink::WebMediaStreamTrack> audio_tracks;
@@ skipping 18 matching lines @@
   MediaStreamExtraData* extra_data =
      static_cast<MediaStreamExtraData*>(web_stream->extraData());
   extra_data->SetLocalStreamStopCallback(stream_stop);
 }
 
 scoped_refptr<webrtc::AudioTrackInterface>
 MediaStreamDependencyFactory::CreateNativeAudioMediaStreamTrack(
     const blink::WebMediaStreamTrack& track) {
   blink::WebMediaStreamSource source = track.source();
   DCHECK_EQ(source.type(), blink::WebMediaStreamSource::TypeAudio);
-  MediaStreamSourceExtraData* source_data =
-      static_cast<MediaStreamSourceExtraData*>(source.extraData());
+  MediaStreamAudioSource* source_data =
+      static_cast<MediaStreamAudioSource*>(source.extraData());
 
   // In the future the constraints will belong to the track itself, but
   // right now they're on the source, so we fetch them from there.
   RTCMediaConstraints track_constraints(source.constraints());
 
   // Apply default audio constraints that enable echo cancellation,
   // automatic gain control, noise suppression and high-pass filter.
   ApplyFixedAudioConstraints(&track_constraints);
 
   scoped_refptr<WebAudioCapturerSource> webaudio_source;
   if (!source_data) {
     if (source.requiresAudioConsumer()) {
       // We're adding a WebAudio MediaStream.
       // Create a specific capturer for each WebAudio consumer.
       webaudio_source = CreateWebAudioSource(&source, track_constraints);
       source_data =
-          static_cast<MediaStreamSourceExtraData*>(source.extraData());
+          static_cast<MediaStreamAudioSource*>(source.extraData());
     } else {
       // TODO(perkj): Implement support for sources from
       // remote MediaStreams.
       NOTIMPLEMENTED();
       return NULL;
     }
   }
 
   scoped_refptr<webrtc::AudioTrackInterface> audio_track(
       CreateLocalAudioTrack(track.id().utf8(),
                             source_data->GetAudioCapturer(),
                             webaudio_source.get(),
                             source_data->local_audio_source()));
   AddNativeTrackToBlinkTrack(audio_track.get(), track, true);
 
   audio_track->set_enabled(track.isEnabled());
 
   // Pass the pointer of the source provider to the blink audio track.
   blink::WebMediaStreamTrack writable_track = track;
   writable_track.setSourceProvider(static_cast<WebRtcLocalAudioTrack*>(
       audio_track.get())->audio_source_provider());
 
   return audio_track;
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
 MediaStreamDependencyFactory::CreateNativeVideoMediaStreamTrack(
     const blink::WebMediaStreamTrack& track) {
+  DCHECK(track.extraData() == NULL);
   blink::WebMediaStreamSource source = track.source();
   DCHECK_EQ(source.type(), blink::WebMediaStreamSource::TypeVideo);
-  MediaStreamSourceExtraData* source_data =
-      static_cast<MediaStreamSourceExtraData*>(source.extraData());
+
+  MediaStreamVideoSource* source_data =
+      static_cast<MediaStreamVideoSource*>(source.extraData());
 
   if (!source_data) {
     // TODO(perkj): Implement support for sources from
     // remote MediaStreams.
     NOTIMPLEMENTED();
     return NULL;
   }
 
-  std::string track_id = base::UTF16ToUTF8(track.id());
-  scoped_refptr<webrtc::VideoTrackInterface> video_track(
-      CreateLocalVideoTrack(track_id, source_data->video_source()));
-  AddNativeTrackToBlinkTrack(video_track.get(), track, true);
+  // Create native track from the source.
+  scoped_refptr<webrtc::VideoTrackInterface> webrtc_track =
+      CreateLocalVideoTrack(track.id().utf8(), source_data->GetAdapter());
 
-  video_track->set_enabled(track.isEnabled());
+  bool local_track = true;
+  AddNativeTrackToBlinkTrack(webrtc_track, track, local_track);
 
-  return video_track;
+  webrtc_track->set_enabled(track.isEnabled());
+
+  return webrtc_track;
 }
 
 void MediaStreamDependencyFactory::CreateNativeMediaStreamTrack(
     const blink::WebMediaStreamTrack& track) {
   DCHECK(!track.isNull() && !track.extraData());
   DCHECK(!track.source().isNull());
 
   switch (track.source().type()) {
     case blink::WebMediaStreamSource::TypeAudio:
       CreateNativeAudioMediaStreamTrack(track);
@@ skipping 91 matching lines @@
           native_stream->FindVideoTrack(track_id));
   }
   return false;
 }
 
 scoped_refptr<webrtc::VideoSourceInterface>
     MediaStreamDependencyFactory::CreateVideoSource(
         cricket::VideoCapturer* capturer,
         const webrtc::MediaConstraintsInterface* constraints) {
   scoped_refptr<webrtc::VideoSourceInterface> source =
-      pc_factory_->CreateVideoSource(capturer, constraints).get();
+      GetPcFactory()->CreateVideoSource(capturer, constraints).get();
   return source;
 }
 
-bool MediaStreamDependencyFactory::CreatePeerConnectionFactory() {
+const scoped_refptr<webrtc::PeerConnectionFactoryInterface>&
+MediaStreamDependencyFactory::GetPcFactory() {
+  if (!pc_factory_)
+    CreatePeerConnectionFactory();
+  CHECK(pc_factory_);
+  return pc_factory_;
+}
+
+void MediaStreamDependencyFactory::CreatePeerConnectionFactory() {
   DCHECK(!pc_factory_.get());
   DCHECK(!audio_device_.get());
+  DCHECK(!signaling_thread_);
+  DCHECK(!worker_thread_);
+  DCHECK(!network_manager_);
+  DCHECK(!socket_factory_);
+  DCHECK(!chrome_worker_thread_.IsRunning());
+
   DVLOG(1) << "MediaStreamDependencyFactory::CreatePeerConnectionFactory()";
 
+  jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
+  jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
+  signaling_thread_ = jingle_glue::JingleThreadWrapper::current();
+  CHECK(signaling_thread_);
+
+  chrome_worker_thread_.Start();
+
+  base::WaitableEvent start_worker_event(true, false);
+  chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+      &MediaStreamDependencyFactory::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,
+      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()) {
+    LOG(ERROR) << "Failed on InitializeSSL.";
+    NOTREACHED();
+    return;
+  }
+#else
+  // TODO(ronghuawu): Replace this call with InitializeSSL.
+  net::EnsureNSSSSLInit();
+#endif
+
   scoped_ptr<cricket::WebRtcVideoDecoderFactory> decoder_factory;
   scoped_ptr<cricket::WebRtcVideoEncoderFactory> encoder_factory;
 
   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
   scoped_refptr<RendererGpuVideoAcceleratorFactories> gpu_factories =
       RenderThreadImpl::current()->GetGpuFactories();
   if (!cmd_line->HasSwitch(switches::kDisableWebRtcHWDecoding)) {
     if (gpu_factories)
       decoder_factory.reset(new RTCVideoDecoderFactory(gpu_factories));
   }
@@ skipping 12 matching lines @@
 
   scoped_refptr<WebRtcAudioDeviceImpl> audio_device(
       new WebRtcAudioDeviceImpl());
 
   scoped_refptr<webrtc::PeerConnectionFactoryInterface> factory(
       webrtc::CreatePeerConnectionFactory(worker_thread_,
                                           signaling_thread_,
                                           audio_device.get(),
                                           encoder_factory.release(),
                                           decoder_factory.release()));
-  if (!factory.get()) {
-    return false;
-  }
+  CHECK(factory);
 
   audio_device_ = audio_device;
   pc_factory_ = factory;
   webrtc::PeerConnectionFactoryInterface::Options factory_options;
   factory_options.disable_sctp_data_channels =
       cmd_line->HasSwitch(switches::kDisableSCTPDataChannels);
   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_ != base::kInvalidPlatformFileValue) {
     StartAecDump(aec_dump_file_);
     aec_dump_file_ = base::kInvalidPlatformFileValue;
   }
-
-  return true;
 }
 
 bool MediaStreamDependencyFactory::PeerConnectionFactoryCreated() {
   return pc_factory_.get() != NULL;
 }
 
 scoped_refptr<webrtc::PeerConnectionInterface>
 MediaStreamDependencyFactory::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 pc_factory_->CreatePeerConnection(ice_servers,
-                                           constraints,
-                                           pa_factory.get(),
-                                           identity_service,
-                                           observer).get();
+  return GetPcFactory()->CreatePeerConnection(ice_servers,
+                                            constraints,
+                                            pa_factory.get(),
+                                            identity_service,
+                                            observer).get();
 }
 
 scoped_refptr<webrtc::MediaStreamInterface>
 MediaStreamDependencyFactory::CreateLocalMediaStream(
     const std::string& label) {
-  return pc_factory_->CreateLocalMediaStream(label).get();
+  return GetPcFactory()->CreateLocalMediaStream(label).get();
 }
 
 scoped_refptr<webrtc::AudioSourceInterface>
 MediaStreamDependencyFactory::CreateLocalAudioSource(
     const webrtc::MediaConstraintsInterface* constraints) {
   scoped_refptr<webrtc::AudioSourceInterface> source =
-      pc_factory_->CreateAudioSource(constraints).get();
+      GetPcFactory()->CreateAudioSource(constraints).get();
   return source;
 }
 
-scoped_refptr<webrtc::VideoSourceInterface>
-MediaStreamDependencyFactory::CreateLocalVideoSource(
-    int video_session_id,
-    bool is_screencast,
-    const webrtc::MediaConstraintsInterface* constraints) {
-  RtcVideoCapturer* capturer = new RtcVideoCapturer(
-      video_session_id, is_screencast);
-
-  // The video source takes ownership of |capturer|.
-  scoped_refptr<webrtc::VideoSourceInterface> source =
-      CreateVideoSource(capturer, constraints);
-  return source;
-}
-
 scoped_refptr<WebAudioCapturerSource>
 MediaStreamDependencyFactory::CreateWebAudioSource(
     blink::WebMediaStreamSource* source,
     const RTCMediaConstraints& constraints) {
   DVLOG(1) << "MediaStreamDependencyFactory::CreateWebAudioSource()";
   DCHECK(GetWebRtcAudioDevice());
 
   scoped_refptr<WebAudioCapturerSource>
       webaudio_capturer_source(new WebAudioCapturerSource());
-  MediaStreamSourceExtraData* source_data = new MediaStreamSourceExtraData();
+  MediaStreamAudioSource* source_data = new MediaStreamAudioSource();
 
   // Create a LocalAudioSource object which holds audio options.
   // SetLocalAudioSource() affects core audio parts in third_party/Libjingle.
   source_data->SetLocalAudioSource(CreateLocalAudioSource(&constraints).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(
     const std::string& id,
     webrtc::VideoSourceInterface* source) {
-  return pc_factory_->CreateVideoTrack(id, source).get();
+  return GetPcFactory()->CreateVideoTrack(id, source).get();
 }
 
 scoped_refptr<webrtc::VideoTrackInterface>
 MediaStreamDependencyFactory::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 =
       CreateVideoSource(capturer, NULL);
 
   // Create native track from the source.
-  return pc_factory_->CreateVideoTrack(id, source.get()).get();
+  return GetPcFactory()->CreateVideoTrack(id, source.get()).get();
 }
 
 scoped_refptr<webrtc::AudioTrackInterface>
 MediaStreamDependencyFactory::CreateLocalAudioTrack(
     const std::string& id,
     const scoped_refptr<WebRtcAudioCapturer>& capturer,
     WebAudioCapturerSource* webaudio_source,
     webrtc::AudioSourceInterface* source) {
   // TODO(xians): Merge |source| to the capturer(). We can't do this today
   // because only one capturer() is supported while one |source| is created
@@ skipping 45 matching lines @@
   network_manager_ = new IpcNetworkManager(p2p_socket_dispatcher_.get());
   event->Signal();
 }
 
 void MediaStreamDependencyFactory::DeleteIpcNetworkManager() {
   DCHECK_EQ(base::MessageLoop::current(), chrome_worker_thread_.message_loop());
   delete network_manager_;
   network_manager_ = NULL;
 }
 
-bool MediaStreamDependencyFactory::EnsurePeerConnectionFactory() {
-  DCHECK(CalledOnValidThread());
-  if (PeerConnectionFactoryCreated())
-    return true;
-
-  if (!signaling_thread_) {
-    jingle_glue::JingleThreadWrapper::EnsureForCurrentMessageLoop();
-    jingle_glue::JingleThreadWrapper::current()->set_send_allowed(true);
-    signaling_thread_ = jingle_glue::JingleThreadWrapper::current();
-    CHECK(signaling_thread_);
-  }
-
-  if (!worker_thread_) {
-    if (!chrome_worker_thread_.IsRunning()) {
-      if (!chrome_worker_thread_.Start()) {
-        LOG(ERROR) << "Could not start worker thread";
-        signaling_thread_ = NULL;
-        return false;
-      }
-    }
-    base::WaitableEvent event(true, false);
-    chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
-        &MediaStreamDependencyFactory::InitializeWorkerThread,
-        base::Unretained(this),
-        &worker_thread_,
-        &event));
-    event.Wait();
-    DCHECK(worker_thread_);
-  }
-
-  if (!network_manager_) {
-    base::WaitableEvent event(true, false);
-    chrome_worker_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
-        &MediaStreamDependencyFactory::CreateIpcNetworkManagerOnWorkerThread,
-        base::Unretained(this),
-        &event));
-    event.Wait();
-  }
-
-  if (!socket_factory_) {
-    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()) {
-    LOG(ERROR) << "Failed on InitializeSSL.";
-    return false;
-  }
-#else
-  // TODO(ronghuawu): Replace this call with InitializeSSL.
-  net::EnsureNSSSSLInit();
-#endif
-
-  if (!CreatePeerConnectionFactory()) {
-    LOG(ERROR) << "Could not create PeerConnection factory";
-    return false;
-  }
-  return true;
-}
-
 void MediaStreamDependencyFactory::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,
           base::Unretained(this)));
       // Stopping the thread will wait until all tasks have been
@@ skipping 85 matching lines @@
 void MediaStreamDependencyFactory::OnDisableAecDump() {
   if (aec_dump_file_ != base::kInvalidPlatformFileValue)
     base::ClosePlatformFile(aec_dump_file_);
   aec_dump_file_ = base::kInvalidPlatformFileValue;
 }
 
 void MediaStreamDependencyFactory::StartAecDump(
     const base::PlatformFile& aec_dump_file) {
  // |pc_factory_| always takes ownership of |aec_dump_file|. If StartAecDump()
  // fails, |aec_dump_file| will be closed.
- if (!pc_factory_->StartAecDump(aec_dump_file))
+ if (!GetPcFactory()->StartAecDump(aec_dump_file))
    VLOG(1) << "Could not start AEC dump.";
 }
 
 }  // namespace content