Move creation of webrtc specific MediaStreamVideoTrack classes to WebRtcMediaStreamAdapter.

This cl adds a new container for each webrtc Video track called WebRtcVideoTrackAdapter owned by WebRtcMediaStreamAdapter.
Furthermore it cleans up the use of MediaStreamDepencyFactory now when its not needed.

BUG=323223

Review URL: https://codereview.chromium.org/230833003

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@265595 0039d316-1c4b-4281-b951-d872f2087c98

34 files changed, 238 insertions, 259 deletions

diff --git a/content/renderer/media/media_stream_center.cc b/content/renderer/media/media_stream_center.cc
index ca0c9d9..934790e 100644
--- a/content/renderer/media/media_stream_center.cc
+++ b/content/renderer/media/media_stream_center.cc
@@ -45,8 +45,7 @@ void CreateNativeAudioMediaStreamTrack(
 }
 
 void CreateNativeVideoMediaStreamTrack(
-    const blink::WebMediaStreamTrack& track,
-    MediaStreamDependencyFactory* factory) {
+    const blink::WebMediaStreamTrack& track) {
   DCHECK(track.extraData() == NULL);
   blink::WebMediaStreamSource source = track.source();
   DCHECK_EQ(source.type(), blink::WebMediaStreamSource::TypeVideo);
@@ -57,7 +56,7 @@ void CreateNativeVideoMediaStreamTrack(
   writable_track.setExtraData(
       new MediaStreamVideoTrack(native_source, source.constraints(),
                                 MediaStreamVideoSource::ConstraintsCallback(),
-                                track.isEnabled(), factory));
+                                track.isEnabled()));
 }
 
 void CreateNativeMediaStreamTrack(const blink::WebMediaStreamTrack& track,
@@ -70,7 +69,7 @@ void CreateNativeMediaStreamTrack(const blink::WebMediaStreamTrack& track,
       CreateNativeAudioMediaStreamTrack(track, factory);
       break;
     case blink::WebMediaStreamSource::TypeVideo:
-      CreateNativeVideoMediaStreamTrack(track, factory);
+      CreateNativeVideoMediaStreamTrack(track);
       break;
   }
 }
diff --git a/content/renderer/media/media_stream_impl.cc b/content/renderer/media/media_stream_impl.cc
index 67fc064..1f09817 100644
--- a/content/renderer/media/media_stream_impl.cc
+++ b/content/renderer/media/media_stream_impl.cc
@@ -446,8 +446,7 @@ MediaStreamVideoSource* MediaStreamImpl::CreateVideoSource(
   return new content::MediaStreamVideoCapturerSource(
       device,
       stop_callback,
-      new VideoCapturerDelegate(device),
-      dependency_factory_);
+      new VideoCapturerDelegate(device));
 }
 
 void MediaStreamImpl::CreateVideoTracks(
@@ -829,7 +828,7 @@ MediaStreamImpl::UserMediaRequestInfo::CreateAndStartVideoTrack(
       native_source, constraints, base::Bind(
           &MediaStreamImpl::UserMediaRequestInfo::OnTrackStarted,
           AsWeakPtr()),
-      true, factory);
+      true);
 }
 
 void MediaStreamImpl::UserMediaRequestInfo::CallbackOnTracksStarted(
diff --git a/content/renderer/media/media_stream_impl_unittest.cc b/content/renderer/media/media_stream_impl_unittest.cc
index f5c7ca5..bc0fbaf 100644
--- a/content/renderer/media/media_stream_impl_unittest.cc
+++ b/content/renderer/media/media_stream_impl_unittest.cc
@@ -25,7 +25,7 @@ class MockMediaStreamVideoCapturerSource : public MockMediaStreamVideoSource {
       const StreamDeviceInfo& device,
       const SourceStoppedCallback& stop_callback,
       MediaStreamDependencyFactory* factory)
-  : MockMediaStreamVideoSource(factory, false) {
+  : MockMediaStreamVideoSource(false) {
     SetDeviceInfo(device);
     SetStopCallback(stop_callback);
   }
diff --git a/content/renderer/media/media_stream_track.cc b/content/renderer/media/media_stream_track.cc
index b5b2695..529bc38 100644
--- a/content/renderer/media/media_stream_track.cc
+++ b/content/renderer/media/media_stream_track.cc
@@ -44,9 +44,4 @@ webrtc::AudioTrackInterface* MediaStreamTrack::GetAudioAdapter() {
   return static_cast<webrtc::AudioTrackInterface*>(track_.get());
 }
 
-webrtc::VideoTrackInterface* MediaStreamTrack::GetVideoAdapter() {
-  NOTREACHED();
-  return NULL;
-}
-
 }  // namespace content
diff --git a/content/renderer/media/media_stream_track.h b/content/renderer/media/media_stream_track.h
index 5dfa41b..456005d 100644
--- a/content/renderer/media/media_stream_track.h
+++ b/content/renderer/media/media_stream_track.h
@@ -13,7 +13,6 @@
 
 namespace webrtc {
 class AudioTrackInterface;
-class VideoTrackInterface;
 class MediaStreamTrackInterface;
 }  // namespace webrtc
 
@@ -40,7 +39,6 @@ class CONTENT_EXPORT MediaStreamTrack
   virtual void Stop();
 
   virtual webrtc::AudioTrackInterface* GetAudioAdapter();
-  virtual webrtc::VideoTrackInterface* GetVideoAdapter();
 
   bool is_local_track () const { return is_local_track_; }
 
diff --git a/content/renderer/media/media_stream_video_capture_source_unittest.cc b/content/renderer/media/media_stream_video_capture_source_unittest.cc
index cfb5ff0..ea203a2 100644
--- a/content/renderer/media/media_stream_video_capture_source_unittest.cc
+++ b/content/renderer/media/media_stream_video_capture_source_unittest.cc
@@ -2,11 +2,11 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "base/bind.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/renderer/media/media_stream_video_capturer_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/mock_media_constraint_factory.h"
-#include "content/renderer/media/mock_media_stream_dependency_factory.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
@@ -34,8 +34,7 @@ class MediaStreamVideoCapturerSourceTest : public testing::Test {
     source_ = new MediaStreamVideoCapturerSource(
         device_info,
         MediaStreamSource::SourceStoppedCallback(),
-        delegate_,
-        &factory_);
+        delegate_);
 
     webkit_source_.initialize(base::UTF8ToUTF16("dummy_source_id"),
                               blink::WebMediaStreamSource::TypeVideo,
@@ -46,21 +45,19 @@ class MediaStreamVideoCapturerSourceTest : public testing::Test {
   blink::WebMediaStreamTrack StartSource() {
     MockMediaConstraintFactory factory;
     bool enabled = true;
-    MediaStreamDependencyFactory* dependency_factory = NULL;
     // CreateVideoTrack will trigger OnConstraintsApplied.
     return MediaStreamVideoTrack::CreateVideoTrack(
         source_, factory.CreateWebMediaConstraints(),
         base::Bind(
             &MediaStreamVideoCapturerSourceTest::OnConstraintsApplied,
             base::Unretained(this)),
-            enabled, dependency_factory);
+            enabled);
   }
 
  protected:
   void OnConstraintsApplied(MediaStreamSource* source, bool success) {
   }
 
-  MockMediaStreamDependencyFactory factory_;
   blink::WebMediaStreamSource webkit_source_;
   MediaStreamVideoCapturerSource* source_;  // owned by webkit_source.
   scoped_refptr<MockVideoCapturerDelegate> delegate_;
diff --git a/content/renderer/media/media_stream_video_capturer_source.cc b/content/renderer/media/media_stream_video_capturer_source.cc
index 6359c45..b6bc73a 100644
--- a/content/renderer/media/media_stream_video_capturer_source.cc
+++ b/content/renderer/media/media_stream_video_capturer_source.cc
@@ -219,9 +219,8 @@ void VideoCapturerDelegate::OnDeviceSupportedFormatsEnumerated(
 MediaStreamVideoCapturerSource::MediaStreamVideoCapturerSource(
     const StreamDeviceInfo& device_info,
     const SourceStoppedCallback& stop_callback,
-    const scoped_refptr<VideoCapturerDelegate>& delegate,
-    MediaStreamDependencyFactory* factory)
-    : MediaStreamVideoSource(factory),
+    const scoped_refptr<VideoCapturerDelegate>& delegate)
+    : MediaStreamVideoSource(),
       delegate_(delegate) {
   SetDeviceInfo(device_info);
   SetStopCallback(stop_callback);
diff --git a/content/renderer/media/media_stream_video_capturer_source.h b/content/renderer/media/media_stream_video_capturer_source.h
index 6fff76c..b719887 100644
--- a/content/renderer/media/media_stream_video_capturer_source.h
+++ b/content/renderer/media/media_stream_video_capturer_source.h
@@ -110,8 +110,7 @@ class CONTENT_EXPORT MediaStreamVideoCapturerSource
   MediaStreamVideoCapturerSource(
       const StreamDeviceInfo& device_info,
       const SourceStoppedCallback& stop_callback,
-      const scoped_refptr<VideoCapturerDelegate>& delegate,
-      MediaStreamDependencyFactory* factory);
+      const scoped_refptr<VideoCapturerDelegate>& delegate);
 
   virtual ~MediaStreamVideoCapturerSource();
 
diff --git a/content/renderer/media/media_stream_video_source.cc b/content/renderer/media/media_stream_video_source.cc
index 73ee6ec..28cc3e2 100644
--- a/content/renderer/media/media_stream_video_source.cc
+++ b/content/renderer/media/media_stream_video_source.cc
@@ -300,11 +300,8 @@ bool MediaStreamVideoSource::IsConstraintSupported(const std::string& name) {
   return false;
 }
 
-MediaStreamVideoSource::MediaStreamVideoSource(
-    MediaStreamDependencyFactory* factory)
-    : state_(NEW),
-      factory_(factory),
-      capture_adapter_(NULL) {
+MediaStreamVideoSource::MediaStreamVideoSource()
+    : state_(NEW) {
 }
 
 MediaStreamVideoSource::~MediaStreamVideoSource() {
@@ -362,28 +359,6 @@ void MediaStreamVideoSource::RemoveTrack(MediaStreamVideoTrack* video_track) {
     StopSource();
 }
 
-void MediaStreamVideoSource::InitAdapter() {
-  if (adapter_)
-    return;
-  // Create the webrtc::MediaStreamVideoSourceInterface adapter.
-  // It needs the constraints so that constraints used by a PeerConnection
-  // will be available such as constraints for CPU adaptation and a tab
-  // capture.
-  bool is_screencast =
-      device_info().device.type == MEDIA_TAB_VIDEO_CAPTURE ||
-      device_info().device.type == MEDIA_DESKTOP_VIDEO_CAPTURE;
-  capture_adapter_ = factory_->CreateVideoCapturer(is_screencast);
-  adapter_ = factory_->CreateVideoSource(capture_adapter_,
-                                         current_constraints_);
-}
-
-webrtc::VideoSourceInterface* MediaStreamVideoSource::GetAdapter() {
-  if (!adapter_) {
-    InitAdapter();
-  }
-  return adapter_;
-}
-
 void MediaStreamVideoSource::DoStopSource() {
   DCHECK(CalledOnValidThread());
   DVLOG(3) << "DoStopSource()";
@@ -415,12 +390,6 @@ void MediaStreamVideoSource::DeliverVideoFrame(
     }
   }
 
-  if ((frame->format() == media::VideoFrame::I420 ||
-       frame->format() == media::VideoFrame::YV12) &&
-      capture_adapter_) {
-    capture_adapter_->OnFrameCaptured(video_frame);
-  }
-
   for (std::vector<MediaStreamVideoTrack*>::iterator it = tracks_.begin();
        it != tracks_.end(); ++it) {
     (*it)->OnVideoFrame(video_frame);
diff --git a/content/renderer/media/media_stream_video_source.h b/content/renderer/media/media_stream_video_source.h
index 3bb8b0b..5c5289d 100644
--- a/content/renderer/media/media_stream_video_source.h
+++ b/content/renderer/media/media_stream_video_source.h
@@ -8,25 +8,18 @@
 #include <vector>
 
 #include "base/compiler_specific.h"
+#include "base/threading/non_thread_safe.h"
 #include "content/common/content_export.h"
-#include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/media_stream_source.h"
 #include "media/base/video_frame.h"
-#include "media/base/video_frame_pool.h"
 #include "media/video/capture/video_capture_types.h"
 #include "third_party/WebKit/public/platform/WebMediaConstraints.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 
-namespace media {
-class VideoFrame;
-}
-
 namespace content {
 
-class MediaStreamDependencyFactory;
 class MediaStreamVideoTrack;
-class WebRtcVideoCapturerAdapter;
 
 // MediaStreamVideoSource is an interface used for sending video frames to a
 // MediaStreamVideoTrack.
@@ -47,7 +40,7 @@ class CONTENT_EXPORT MediaStreamVideoSource
     : public MediaStreamSource,
       NON_EXPORTED_BASE(public base::NonThreadSafe) {
  public:
-  explicit MediaStreamVideoSource(MediaStreamDependencyFactory* factory);
+  MediaStreamVideoSource();
   virtual ~MediaStreamVideoSource();
 
   // Returns the MediaStreamVideoSource object owned by |source|.
@@ -60,12 +53,6 @@ class CONTENT_EXPORT MediaStreamVideoSource
                 const ConstraintsCallback& callback);
   void RemoveTrack(MediaStreamVideoTrack* track);
 
-  // TODO(ronghuawu): Remove webrtc::VideoSourceInterface from the public
-  // interface of this class.
-  // This creates a VideoSourceInterface implementation if it does not already
-  // exist.
-  virtual webrtc::VideoSourceInterface* GetAdapter();
-
   // Return true if |name| is a constraint supported by MediaStreamVideoSource.
   static bool IsConstraintSupported(const std::string& name);
 
@@ -89,8 +76,6 @@ class CONTENT_EXPORT MediaStreamVideoSource
  protected:
   virtual void DoStopSource() OVERRIDE;
 
-  MediaStreamDependencyFactory* factory() { return factory_; }
-
   // Sets ready state and notifies the ready state to all registered tracks.
   virtual void SetReadyState(blink::WebMediaStreamSource::ReadyState state);
 
@@ -179,12 +164,6 @@ class CONTENT_EXPORT MediaStreamVideoSource
   // Tracks that currently are receiving video frames.
   std::vector<MediaStreamVideoTrack*> tracks_;
 
-  // TODO(perkj): The below classes use webrtc/libjingle types. The goal is to
-  // get rid of them as far as possible.
-  MediaStreamDependencyFactory* factory_;
-  scoped_refptr<webrtc::VideoSourceInterface> adapter_;
-  WebRtcVideoCapturerAdapter* capture_adapter_;
-
   DISALLOW_COPY_AND_ASSIGN(MediaStreamVideoSource);
 };
 
diff --git a/content/renderer/media/media_stream_video_source_unittest.cc b/content/renderer/media/media_stream_video_source_unittest.cc
index 0c3963c..c6e4bf8 100644
--- a/content/renderer/media/media_stream_video_source_unittest.cc
+++ b/content/renderer/media/media_stream_video_source_unittest.cc
@@ -5,12 +5,13 @@
 #include <string>
 #include <vector>
 
+#include "base/bind.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/renderer/media/media_stream_video_source.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/mock_media_constraint_factory.h"
-#include "content/renderer/media/mock_media_stream_dependency_factory.h"
+#include "content/renderer/media/mock_media_stream_video_sink.h"
 #include "content/renderer/media/mock_media_stream_video_sink.h"
 #include "content/renderer/media/mock_media_stream_video_source.h"
 #include "media/base/video_frame.h"
@@ -24,7 +25,7 @@ class MediaStreamVideoSourceTest
   MediaStreamVideoSourceTest()
       : number_of_successful_constraints_applied_(0),
         number_of_failed_constraints_applied_(0),
-        mock_source_(new MockMediaStreamVideoSource(&factory_, true)) {
+        mock_source_(new MockMediaStreamVideoSource(true)) {
     media::VideoCaptureFormats formats;
     formats.push_back(media::VideoCaptureFormat(
         gfx::Size(1280, 720), 30, media::PIXEL_FORMAT_I420));
@@ -47,13 +48,12 @@ class MediaStreamVideoSourceTest
       const std::string& id,
       const blink::WebMediaConstraints& constraints) {
     bool enabled = true;
-    MediaStreamDependencyFactory* factory = NULL;
     return MediaStreamVideoTrack::CreateVideoTrack(
         mock_source_, constraints,
         base::Bind(
             &MediaStreamVideoSourceTest::OnConstraintsApplied,
             base::Unretained(this)),
-        enabled, factory);
+        enabled);
   }
 
   blink::WebMediaStreamTrack CreateTrackAndStartSource(
@@ -69,10 +69,6 @@ class MediaStreamVideoSourceTest
     EXPECT_EQ(expected_height, format.requested_format.frame_size.height());
     EXPECT_EQ(expected_frame_rate, format.requested_format.frame_rate);
 
-    MediaStreamVideoSource* source =
-        static_cast<MediaStreamVideoSource*>(track.source().extraData());
-    EXPECT_TRUE(source->GetAdapter() != NULL);
-
     EXPECT_EQ(0, NumberOfSuccessConstraintsCallbacks());
     mock_source_->StartMockedSource();
     // Once the source has started successfully we expect that the
@@ -93,31 +89,30 @@ class MediaStreamVideoSourceTest
 
   // Test that the source crops to the requested max width and
   // height even though the camera delivers a larger frame.
-  // TODO(perkj): Frame resolution should be verified in MediaStreamVideoTrack
-  // and not in the adapter.
   void TestSourceCropFrame(int capture_width,
                            int capture_height,
                            const blink::WebMediaConstraints& constraints,
-                           int expected_height,
-                           int expected_width) {
+                           int expected_width,
+                           int expected_height) {
     // Expect the source to start capture with the supported resolution.
-    blink::WebMediaStreamTrack track = CreateTrackAndStartSource(
-        constraints, capture_width, capture_height , 30);
+    blink::WebMediaStreamTrack track =
+        CreateTrackAndStartSource(constraints, capture_width, capture_height ,
+                                  30);
 
-    ASSERT_TRUE(mock_source()->GetAdapter());
-    MockVideoSource* adapter = static_cast<MockVideoSource*>(
-        mock_source()->GetAdapter());
-    EXPECT_EQ(0, adapter->GetFrameNum());
+    MockMediaStreamVideoSink sink;
+    MediaStreamVideoSink::AddToVideoTrack(&sink, track);
+    EXPECT_EQ(0, sink.number_of_frames());
 
     scoped_refptr<media::VideoFrame> frame =
         media::VideoFrame::CreateBlackFrame(gfx::Size(capture_width,
                                                       capture_height));
     mock_source()->DeliverVideoFrame(frame);
-    EXPECT_EQ(1, adapter->GetFrameNum());
+    EXPECT_EQ(1, sink.number_of_frames());
 
     // Expect the delivered frame to be cropped.
-    EXPECT_EQ(expected_height, adapter->GetLastFrameWidth());
-    EXPECT_EQ(expected_width, adapter->GetLastFrameHeight());
+    EXPECT_EQ(expected_height, sink.frame_size().height());
+    EXPECT_EQ(expected_width, sink.frame_size().width());
+    MediaStreamVideoSink::RemoveFromVideoTrack(&sink, track);
   }
 
   void ReleaseTrackAndSourceOnAddTrackCallback(
@@ -144,7 +139,6 @@ class MediaStreamVideoSourceTest
   blink::WebMediaStreamTrack track_to_release_;
   int number_of_successful_constraints_applied_;
   int number_of_failed_constraints_applied_;
-  MockMediaStreamDependencyFactory factory_;
   blink::WebMediaStreamSource webkit_source_;
   // |mock_source_| is owned by |webkit_source_|.
   MockMediaStreamVideoSource* mock_source_;
@@ -360,32 +354,6 @@ TEST_F(MediaStreamVideoSourceTest, OptionalConstraints) {
   CreateTrackAndStartSource(factory.CreateWebMediaConstraints(), 1280, 720, 30);
 }
 
-// Test that the webrtc video adapter can be created and that it received
-// video frames if the source deliver video frames.
-TEST_F(MediaStreamVideoSourceTest, AdapterReceiveVideoFrame) {
-  MockMediaConstraintFactory factory;
-  blink::WebMediaStreamTrack track = CreateTrackAndStartSource(
-      factory.CreateWebMediaConstraints(),
-      MediaStreamVideoSource::kDefaultWidth,
-      MediaStreamVideoSource::kDefaultHeight,
-      MediaStreamVideoSource::kDefaultFrameRate);
-  ASSERT_TRUE(mock_source()->GetAdapter());
-  MockVideoSource* adapter = static_cast<MockVideoSource*>(
-      mock_source()->GetAdapter());
-  EXPECT_EQ(0, adapter->GetFrameNum());
-
-  scoped_refptr<media::VideoFrame> frame =
-      media::VideoFrame::CreateBlackFrame(
-          gfx::Size(MediaStreamVideoSource::kDefaultWidth,
-                    MediaStreamVideoSource::kDefaultHeight));
-   mock_source()->DeliverVideoFrame(frame);
-   EXPECT_EQ(1, adapter->GetFrameNum());
-   EXPECT_EQ(MediaStreamVideoSource::kDefaultWidth,
-             adapter->GetLastFrameWidth());
-   EXPECT_EQ(MediaStreamVideoSource::kDefaultHeight,
-             adapter->GetLastFrameHeight());
-}
-
 // Test that the source crops to the requested max width and
 // height even though the camera delivers a larger frame.
 TEST_F(MediaStreamVideoSourceTest, DeliverCroppedVideoFrameOptional640360) {
diff --git a/content/renderer/media/media_stream_video_track.cc b/content/renderer/media/media_stream_video_track.cc
index 3935e7b..f5cea67 100644
--- a/content/renderer/media/media_stream_video_track.cc
+++ b/content/renderer/media/media_stream_video_track.cc
@@ -4,8 +4,6 @@
 
 #include "content/renderer/media/media_stream_video_track.h"
 
-#include "content/renderer/media/media_stream_dependency_factory.h"
-
 namespace content {
 
 //static
@@ -13,15 +11,13 @@ blink::WebMediaStreamTrack MediaStreamVideoTrack::CreateVideoTrack(
     MediaStreamVideoSource* source,
     const blink::WebMediaConstraints& constraints,
     const MediaStreamVideoSource::ConstraintsCallback& callback,
-    bool enabled,
-    MediaStreamDependencyFactory* factory) {
+    bool enabled) {
   blink::WebMediaStreamTrack track;
   track.initialize(source->owner());
   track.setExtraData(new MediaStreamVideoTrack(source,
                                                constraints,
                                                callback,
-                                               enabled,
-                                               factory));
+                                               enabled));
   return track;
 }
 
@@ -35,12 +31,11 @@ MediaStreamVideoTrack::MediaStreamVideoTrack(
     MediaStreamVideoSource* source,
     const blink::WebMediaConstraints& constraints,
     const MediaStreamVideoSource::ConstraintsCallback& callback,
-    bool enabled,
-    MediaStreamDependencyFactory* factory)
+    bool enabled)
     : MediaStreamTrack(NULL, true),
       enabled_(enabled),
-      source_(source),
-      factory_(factory) {
+      constraints_(constraints),
+      source_(source) {
   source->AddTrack(this, constraints, callback);
 }
 
@@ -63,21 +58,6 @@ void MediaStreamVideoTrack::RemoveSink(MediaStreamVideoSink* sink) {
   sinks_.erase(it);
 }
 
-webrtc::VideoTrackInterface* MediaStreamVideoTrack::GetVideoAdapter() {
-  DCHECK(thread_checker_.CalledOnValidThread());
-  DCHECK_EQ(owner().source().type(), blink::WebMediaStreamSource::TypeVideo);
-  if (!track_.get()) {
-    MediaStreamVideoSource* source =
-          static_cast<MediaStreamVideoSource*>(owner().source().extraData());
-    scoped_refptr<webrtc::VideoTrackInterface> video_track(
-        factory_->CreateLocalVideoTrack(owner().id().utf8(),
-                                        source->GetAdapter()));
-    video_track->set_enabled(owner().isEnabled());
-    track_ = video_track;
-  }
-  return static_cast<webrtc::VideoTrackInterface*>(track_.get());
-}
-
 void MediaStreamVideoTrack::SetEnabled(bool enabled) {
   DCHECK(thread_checker_.CalledOnValidThread());
   enabled_ = enabled;
diff --git a/content/renderer/media/media_stream_video_track.h b/content/renderer/media/media_stream_video_track.h
index 9e5ef38..c28ebb1 100644
--- a/content/renderer/media/media_stream_video_track.h
+++ b/content/renderer/media/media_stream_video_track.h
@@ -15,14 +15,8 @@
 #include "content/renderer/media/media_stream_track.h"
 #include "content/renderer/media/media_stream_video_source.h"
 
-namespace webrtc {
-class VideoTrackInterface;
-}
-
 namespace content {
 
-class MediaStreamDependencyFactory;
-
 // MediaStreamVideoTrack is a video specific representation of a
 // blink::WebMediaStreamTrack in content. It is owned by the blink object
 // and can be retrieved from a blink object using
@@ -41,8 +35,7 @@ class CONTENT_EXPORT MediaStreamVideoTrack : public MediaStreamTrack {
       MediaStreamVideoSource* source,
       const blink::WebMediaConstraints& constraints,
       const MediaStreamVideoSource::ConstraintsCallback& callback,
-      bool enabled,
-      MediaStreamDependencyFactory* factory);
+      bool enabled);
 
   static MediaStreamVideoTrack* GetVideoTrack(
       const blink::WebMediaStreamTrack& track);
@@ -52,21 +45,21 @@ class CONTENT_EXPORT MediaStreamVideoTrack : public MediaStreamTrack {
        MediaStreamVideoSource* source,
        const blink::WebMediaConstraints& constraints,
        const MediaStreamVideoSource::ConstraintsCallback& callback,
-       bool enabled,
-       MediaStreamDependencyFactory* factory);
+       bool enabled);
   virtual ~MediaStreamVideoTrack();
   virtual void AddSink(MediaStreamVideoSink* sink);
   virtual void RemoveSink(MediaStreamVideoSink* sink);
 
-  // TODO(perkj): GetVideoAdapter is webrtc specific. Move GetVideoAdapter to
-  // where the track is added to a RTCPeerConnection. crbug/323223.
-  virtual webrtc::VideoTrackInterface* GetVideoAdapter() OVERRIDE;
   virtual void SetEnabled(bool enabled) OVERRIDE;
   virtual void Stop() OVERRIDE;
 
   void OnVideoFrame(const scoped_refptr<media::VideoFrame>& frame);
   void OnReadyStateChanged(blink::WebMediaStreamSource::ReadyState state);
 
+  const blink::WebMediaConstraints& constraints() const {
+    return constraints_;
+  }
+
  protected:
   // Used to DCHECK that we are called on the correct thread.
   base::ThreadChecker thread_checker_;
@@ -74,16 +67,13 @@ class CONTENT_EXPORT MediaStreamVideoTrack : public MediaStreamTrack {
  private:
   bool enabled_;
   std::vector<MediaStreamVideoSink*> sinks_;
+  blink::WebMediaConstraints constraints_;
 
   // Weak ref to the source this tracks is connected to.  |source_| is owned
   // by the blink::WebMediaStreamSource and is guaranteed to outlive the
   // track.
   MediaStreamVideoSource* source_;
 
-  // Weak ref to a MediaStreamDependencyFactory, owned by the RenderThread.
-  // It's valid for the lifetime of RenderThread.
-  MediaStreamDependencyFactory* factory_;
-
   DISALLOW_COPY_AND_ASSIGN(MediaStreamVideoTrack);
 };
 
diff --git a/content/renderer/media/media_stream_video_track_unittest.cc b/content/renderer/media/media_stream_video_track_unittest.cc
index c2307c6..c10fba2 100644
--- a/content/renderer/media/media_stream_video_track_unittest.cc
+++ b/content/renderer/media/media_stream_video_track_unittest.cc
@@ -4,7 +4,6 @@
 
 #include "base/strings/utf_string_conversions.h"
 #include "content/renderer/media/media_stream_video_track.h"
-#include "content/renderer/media/mock_media_stream_dependency_factory.h"
 #include "content/renderer/media/mock_media_stream_video_sink.h"
 #include "content/renderer/media/mock_media_stream_video_source.h"
 #include "media/base/video_frame.h"
@@ -15,7 +14,7 @@ namespace content {
 class MediaStreamVideoTrackTest : public ::testing::Test {
  public:
   MediaStreamVideoTrackTest()
-      : mock_source_(new MockMediaStreamVideoSource(&factory_, false)),
+      : mock_source_(new MockMediaStreamVideoSource(false)),
         source_started_(false) {
     blink_source_.initialize(base::UTF8ToUTF16("dummy_source_id"),
                               blink::WebMediaStreamSource::TypeVideo,
@@ -32,7 +31,7 @@ class MediaStreamVideoTrackTest : public ::testing::Test {
     blink::WebMediaStreamTrack track =
         MediaStreamVideoTrack::CreateVideoTrack(
             mock_source_, constraints,
-            MediaStreamSource::ConstraintsCallback(), enabled, &factory_);
+            MediaStreamSource::ConstraintsCallback(), enabled);
     if (!source_started_) {
       mock_source_->StartMockedSource();
       source_started_ = true;
@@ -46,20 +45,12 @@ class MediaStreamVideoTrackTest : public ::testing::Test {
   }
 
  private:
-  MockMediaStreamDependencyFactory factory_;
   blink::WebMediaStreamSource blink_source_;
   // |mock_source_| is owned by |webkit_source_|.
   MockMediaStreamVideoSource* mock_source_;
   bool source_started_;
 };
 
-TEST_F(MediaStreamVideoTrackTest, GetAdapter) {
-  blink::WebMediaStreamTrack track = CreateTrack();
-  MediaStreamVideoTrack* video_track =
-      MediaStreamVideoTrack::GetVideoTrack(track);
-  EXPECT_TRUE(video_track->GetVideoAdapter() != NULL);
-}
-
 TEST_F(MediaStreamVideoTrackTest, AddAndRemoveSink) {
   MockMediaStreamVideoSink sink;
   blink::WebMediaStreamTrack track = CreateTrack();
diff --git a/content/renderer/media/mock_media_stream_registry.cc b/content/renderer/media/mock_media_stream_registry.cc
index 2155cd6..53bf948 100644
--- a/content/renderer/media/mock_media_stream_registry.cc
+++ b/content/renderer/media/mock_media_stream_registry.cc
@@ -37,7 +37,7 @@ void MockMediaStreamRegistry::AddVideoTrack(const std::string& track_id) {
                           blink::WebMediaStreamSource::TypeVideo,
                           "mock video source name");
   MockMediaStreamVideoSource* native_source =
-      new MockMediaStreamVideoSource(&dependency_factory_, false);
+      new MockMediaStreamVideoSource(false);
   blink_source.setExtraData(native_source);
   blink::WebMediaStreamTrack blink_track;
   blink_track.initialize(base::UTF8ToUTF16(track_id), blink_source);
@@ -48,8 +48,7 @@ void MockMediaStreamRegistry::AddVideoTrack(const std::string& track_id) {
       new MediaStreamVideoTrack(native_source,
                                 constraints,
                                 MediaStreamVideoSource::ConstraintsCallback(),
-                                true,
-                                &dependency_factory_);
+                                true);
   blink_track.setExtraData(native_track);
   test_stream_.addTrack(blink_track);
 }
diff --git a/content/renderer/media/mock_media_stream_registry.h b/content/renderer/media/mock_media_stream_registry.h
index 1435cb5..ac0ffa1 100644
--- a/content/renderer/media/mock_media_stream_registry.h
+++ b/content/renderer/media/mock_media_stream_registry.h
@@ -7,8 +7,8 @@
 
 #include <string>
 
+#include "base/compiler_specific.h"
 #include "content/renderer/media/media_stream_registry_interface.h"
-#include "content/renderer/media/mock_media_stream_dependency_factory.h"
 
 namespace content {
 
@@ -20,10 +20,10 @@ class MockMediaStreamRegistry : public MediaStreamRegistryInterface {
   void AddVideoTrack(const std::string& track_id);
   virtual blink::WebMediaStream GetMediaStream(
       const std::string& url) OVERRIDE;
+
   const blink::WebMediaStream test_stream() const;
 
  private:
-  MockMediaStreamDependencyFactory dependency_factory_;
   blink::WebMediaStream test_stream_;
   std::string stream_url_;
 };
diff --git a/content/renderer/media/mock_media_stream_video_sink.cc b/content/renderer/media/mock_media_stream_video_sink.cc
index 16483ef..ce9222f 100644
--- a/content/renderer/media/mock_media_stream_video_sink.cc
+++ b/content/renderer/media/mock_media_stream_video_sink.cc
@@ -17,7 +17,7 @@ void MockMediaStreamVideoSink::OnVideoFrame(
     const scoped_refptr<media::VideoFrame>& frame) {
   ++number_of_frames_;
   format_ = frame->format();
-  frame_size_ = frame->visible_rect().size();
+  frame_size_ = frame->natural_size();
 }
 
 void MockMediaStreamVideoSink::OnReadyStateChanged(
diff --git a/content/renderer/media/mock_media_stream_video_sink.h b/content/renderer/media/mock_media_stream_video_sink.h
index a5ff93f..9511a0a 100644
--- a/content/renderer/media/mock_media_stream_video_sink.h
+++ b/content/renderer/media/mock_media_stream_video_sink.h
@@ -23,9 +23,10 @@ class MockMediaStreamVideoSink : public MediaStreamVideoSink {
 
   int number_of_frames() const { return number_of_frames_; }
   media::VideoFrame::Format format() const { return format_; }
+  gfx::Size frame_size() const { return frame_size_; }
+
   bool enabled() const { return enabled_; }
   blink::WebMediaStreamSource::ReadyState state() const { return state_; }
-  gfx::Size frame_size() const { return frame_size_; }
 
  private:
   int number_of_frames_;
diff --git a/content/renderer/media/mock_media_stream_video_source.cc b/content/renderer/media/mock_media_stream_video_source.cc
index f88473b..84a4479 100644
--- a/content/renderer/media/mock_media_stream_video_source.cc
+++ b/content/renderer/media/mock_media_stream_video_source.cc
@@ -7,9 +7,8 @@
 namespace content {
 
 MockMediaStreamVideoSource::MockMediaStreamVideoSource(
-    MediaStreamDependencyFactory* factory,
     bool manual_get_supported_formats)
-    : MediaStreamVideoSource(factory),
+    : MediaStreamVideoSource(),
       manual_get_supported_formats_(manual_get_supported_formats),
       max_requested_height_(0),
       max_requested_width_(0),
diff --git a/content/renderer/media/mock_media_stream_video_source.h b/content/renderer/media/mock_media_stream_video_source.h
index c1e5452..33d3f70c 100644
--- a/content/renderer/media/mock_media_stream_video_source.h
+++ b/content/renderer/media/mock_media_stream_video_source.h
@@ -12,8 +12,7 @@ namespace content {
 class MockMediaStreamVideoSource
     : public MediaStreamVideoSource {
  public:
-  MockMediaStreamVideoSource(MediaStreamDependencyFactory* factory,
-                             bool manual_get_supported_formats);
+  MockMediaStreamVideoSource(bool manual_get_supported_formats);
   virtual ~MockMediaStreamVideoSource();
 
   // Simulate that the underlying source start successfully.
diff --git a/content/renderer/media/remote_media_stream_impl.cc b/content/renderer/media/remote_media_stream_impl.cc
index 1510607b..f61830d 100644
--- a/content/renderer/media/remote_media_stream_impl.cc
+++ b/content/renderer/media/remote_media_stream_impl.cc
@@ -12,7 +12,6 @@
 #include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/media/webrtc/media_stream_remote_video_source.h"
-#include "content/renderer/render_thread_impl.h"
 #include "third_party/WebKit/public/platform/WebString.h"
 
 namespace content {
@@ -28,12 +27,6 @@ void InitializeWebkitTrack(webrtc::MediaStreamTrackInterface* track,
   webkit_source.initialize(webkit_track_id, type, webkit_track_id);
   webkit_track->initialize(webkit_track_id, webkit_source);
 
-  MediaStreamDependencyFactory* factory = NULL;
-  // RenderThreadImpl::current() may be NULL in unit tests.
-  RenderThreadImpl* render_thread = RenderThreadImpl::current();
-  if (render_thread)
-    factory = render_thread->GetMediaStreamDependencyFactory();
-
   if (type == blink::WebMediaStreamSource::TypeVideo) {
     MediaStreamRemoteVideoSource* video_source =
         new MediaStreamRemoteVideoSource(
@@ -46,7 +39,7 @@ void InitializeWebkitTrack(webrtc::MediaStreamTrackInterface* track,
     webkit_track->setExtraData(
         new MediaStreamVideoTrack(video_source, constraints,
                                   MediaStreamVideoSource::ConstraintsCallback(),
-                                  track->enabled(), factory));
+                                  track->enabled()));
   } else {
     DCHECK(type == blink::WebMediaStreamSource::TypeAudio);
     content::MediaStreamDependencyFactory::AddNativeAudioTrackToBlinkTrack(
@@ -79,7 +72,6 @@ class RemoteMediaStreamTrackAdapter {
  private:
   scoped_refptr<webrtc::MediaStreamTrackInterface> webrtc_track_;
   blink::WebMediaStreamTrack webkit_track_;
-  bool sent_ended_message_;
 
   DISALLOW_COPY_AND_ASSIGN(RemoteMediaStreamTrackAdapter);
 };
diff --git a/content/renderer/media/rtc_peer_connection_handler.cc b/content/renderer/media/rtc_peer_connection_handler.cc
index bdfe3ec..1171c28 100644
--- a/content/renderer/media/rtc_peer_connection_handler.cc
+++ b/content/renderer/media/rtc_peer_connection_handler.cc
@@ -612,16 +612,23 @@ void RTCPeerConnectionHandler::getStats(LocalRTCStatsRequest* request) {
       new talk_base::RefCountedObject<StatsResponse>(request));
   webrtc::MediaStreamTrackInterface* track = NULL;
   if (request->hasSelector()) {
-    MediaStreamTrack* native_track =
-        MediaStreamTrack::GetTrack(request->component());
-    if (native_track) {
-      blink::WebMediaStreamSource::Type type =
-          request->component().source().type();
-      if (type == blink::WebMediaStreamSource::TypeAudio)
-        track = native_track->GetAudioAdapter();
-      else {
-        DCHECK_EQ(blink::WebMediaStreamSource::TypeVideo, type);
-        track = native_track->GetVideoAdapter();
+    blink::WebMediaStreamSource::Type type =
+        request->component().source().type();
+    std::string track_id = request->component().id().utf8();
+    if (type == blink::WebMediaStreamSource::TypeAudio) {
+      track =
+          native_peer_connection_->local_streams()->FindAudioTrack(track_id);
+      if (!track) {
+        track =
+            native_peer_connection_->remote_streams()->FindAudioTrack(track_id);
+      }
+    } else {
+      DCHECK_EQ(blink::WebMediaStreamSource::TypeVideo, type);
+      track =
+          native_peer_connection_->local_streams()->FindVideoTrack(track_id);
+      if (!track) {
+        track =
+            native_peer_connection_->remote_streams()->FindVideoTrack(track_id);
       }
     }
     if (!track) {
diff --git a/content/renderer/media/rtc_peer_connection_handler_unittest.cc b/content/renderer/media/rtc_peer_connection_handler_unittest.cc
index 7bec216..1544020 100644
--- a/content/renderer/media/rtc_peer_connection_handler_unittest.cc
+++ b/content/renderer/media/rtc_peer_connection_handler_unittest.cc
@@ -232,11 +232,9 @@ class RTCPeerConnectionHandlerTest : public ::testing::Test {
                             blink::WebMediaStreamSource::TypeVideo,
                             blink::WebString::fromUTF8("video_track"));
     MockMediaStreamVideoSource* native_video_source =
-        new MockMediaStreamVideoSource(mock_dependency_factory_.get(),
-                                       false);
+        new MockMediaStreamVideoSource(false);
     video_source.setExtraData(native_video_source);
 
-
     blink::WebVector<blink::WebMediaStreamTrack> audio_tracks(
         static_cast<size_t>(1));
     audio_tracks[0].initialize(audio_source.id(), audio_source);
@@ -251,8 +249,7 @@ class RTCPeerConnectionHandlerTest : public ::testing::Test {
     constraints.initialize();
     video_tracks[0] = MediaStreamVideoTrack::CreateVideoTrack(
         native_video_source, constraints,
-        MediaStreamVideoSource::ConstraintsCallback(), true,
-        mock_dependency_factory_.get());
+        MediaStreamVideoSource::ConstraintsCallback(), true);
 
     blink::WebMediaStream local_stream;
     local_stream.initialize(base::UTF8ToUTF16(stream_label), audio_tracks,
diff --git a/content/renderer/media/webrtc/media_stream_remote_video_source.cc b/content/renderer/media/webrtc/media_stream_remote_video_source.cc
index d7c00be..39865aa 100644
--- a/content/renderer/media/webrtc/media_stream_remote_video_source.cc
+++ b/content/renderer/media/webrtc/media_stream_remote_video_source.cc
@@ -6,6 +6,7 @@
 
 #include "base/bind.h"
 #include "base/location.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "content/renderer/media/native_handle_impl.h"
 #include "media/base/video_frame.h"
 #include "media/base/video_util.h"
@@ -15,7 +16,7 @@ namespace content {
 
 MediaStreamRemoteVideoSource::MediaStreamRemoteVideoSource(
     webrtc::VideoTrackInterface* remote_track)
-    : MediaStreamVideoSource(NULL),
+    : MediaStreamVideoSource(),
       message_loop_proxy_(base::MessageLoopProxy::current()),
       remote_track_(remote_track),
       last_state_(remote_track_->state()),
@@ -53,11 +54,6 @@ void MediaStreamRemoteVideoSource::StopSourceImpl() {
   }
 }
 
-webrtc::VideoSourceInterface* MediaStreamRemoteVideoSource::GetAdapter() {
-  DCHECK(message_loop_proxy_->BelongsToCurrentThread());
-  return remote_track_->GetSource();
-}
-
 void MediaStreamRemoteVideoSource::SetSize(int width, int height) {
 }
 
diff --git a/content/renderer/media/webrtc/media_stream_remote_video_source.h b/content/renderer/media/webrtc/media_stream_remote_video_source.h
index 2d5be61..a409271 100644
--- a/content/renderer/media/webrtc/media_stream_remote_video_source.h
+++ b/content/renderer/media/webrtc/media_stream_remote_video_source.h
@@ -39,8 +39,6 @@ class CONTENT_EXPORT MediaStreamRemoteVideoSource
 
   virtual void StopSourceImpl() OVERRIDE;
 
-  virtual webrtc::VideoSourceInterface* GetAdapter() OVERRIDE;
-
   // Implements webrtc::VideoRendererInterface used for receiving video frames
   // from the PeerConnection video track. May be called on
   // a different thread.
diff --git a/content/renderer/media/webrtc/media_stream_remote_video_source_unittest.cc b/content/renderer/media/webrtc/media_stream_remote_video_source_unittest.cc
index 068320f..0b6b327 100644
--- a/content/renderer/media/webrtc/media_stream_remote_video_source_unittest.cc
+++ b/content/renderer/media/webrtc/media_stream_remote_video_source_unittest.cc
@@ -75,14 +75,13 @@ class MediaStreamRemoteVideoSourceTest
    bool enabled = true;
    blink::WebMediaConstraints constraints;
    constraints.initialize();
-   MediaStreamDependencyFactory* factory = NULL;
    return new MediaStreamVideoTrack(
        source(),
        constraints,
        base::Bind(
            &MediaStreamRemoteVideoSourceTest::OnConstraintsApplied,
            base::Unretained(this)),
-       enabled, factory);
+       enabled);
   }
 
   int NumberOfSuccessConstraintsCallbacks() const {
diff --git a/content/renderer/media/webrtc/video_destination_handler.cc b/content/renderer/media/webrtc/video_destination_handler.cc
index 2da6c09..ac16f1e 100644
--- a/content/renderer/media/webrtc/video_destination_handler.cc
+++ b/content/renderer/media/webrtc/video_destination_handler.cc
@@ -11,7 +11,6 @@
 #include "base/rand_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "content/renderer/media/media_stream.h"
-#include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/media_stream_registry_interface.h"
 #include "content/renderer/media/media_stream_video_track.h"
 #include "content/renderer/pepper/ppb_image_data_impl.h"
@@ -25,8 +24,8 @@
 
 namespace content {
 
-PpFrameWriter::PpFrameWriter(MediaStreamDependencyFactory* factory)
-    : MediaStreamVideoSource(factory), first_frame_received_(false) {
+PpFrameWriter::PpFrameWriter()
+    : MediaStreamVideoSource(), first_frame_received_(false) {
   DVLOG(3) << "PpFrameWriter ctor";
 }
 
@@ -96,8 +95,8 @@ void PpFrameWriter::PutFrame(PPB_ImageData_Impl* image_data,
   if (state() != MediaStreamVideoSource::STARTED)
     return;
 
-  const base::TimeDelta timestamp = base::TimeDelta::FromMilliseconds(
-      time_stamp_ns / talk_base::kNumNanosecsPerMillisec);
+  const base::TimeDelta timestamp = base::TimeDelta::FromMicroseconds(
+      time_stamp_ns / base::Time::kNanosecondsPerMicrosecond);
 
   // TODO(perkj): It would be more efficient to use I420 here. Using YV12 will
   // force a copy into a tightly packed I420 frame in
@@ -144,15 +143,10 @@ class PpFrameWriterProxy : public FrameWriterInterface {
 };
 
 bool VideoDestinationHandler::Open(
-    MediaStreamDependencyFactory* factory,
     MediaStreamRegistryInterface* registry,
     const std::string& url,
     FrameWriterInterface** frame_writer) {
   DVLOG(3) << "VideoDestinationHandler::Open";
-  if (!factory) {
-    factory = RenderThreadImpl::current()->GetMediaStreamDependencyFactory();
-    DCHECK(factory != NULL);
-  }
   blink::WebMediaStream stream;
   if (registry) {
     stream = registry->GetMediaStream(url);
@@ -173,7 +167,7 @@ bool VideoDestinationHandler::Open(
   // theoretically it's possible we can get an id that's duplicated with the
   // existing sources.
   base::Base64Encode(base::RandBytesAsString(64), &track_id);
-  PpFrameWriter* writer = new PpFrameWriter(factory);
+  PpFrameWriter* writer = new PpFrameWriter();
 
   // Create a new webkit video track.
   blink::WebMediaStreamSource webkit_source;
@@ -189,7 +183,7 @@ bool VideoDestinationHandler::Open(
 
   stream.addTrack(MediaStreamVideoTrack::CreateVideoTrack(
       writer, constraints, MediaStreamVideoSource::ConstraintsCallback(),
-      track_enabled, factory));
+      track_enabled));
 
   *frame_writer = new PpFrameWriterProxy(writer->AsWeakPtr());
   return true;
diff --git a/content/renderer/media/webrtc/video_destination_handler.h b/content/renderer/media/webrtc/video_destination_handler.h
index e490002..b13d26d 100644
--- a/content/renderer/media/webrtc/video_destination_handler.h
+++ b/content/renderer/media/webrtc/video_destination_handler.h
@@ -40,7 +40,7 @@ class CONTENT_EXPORT PpFrameWriter
       public FrameWriterInterface,
       NON_EXPORTED_BASE(public base::SupportsWeakPtr<PpFrameWriter>) {
  public:
-  explicit PpFrameWriter(MediaStreamDependencyFactory* factory);
+  PpFrameWriter();
   virtual ~PpFrameWriter();
 
   // FrameWriterInterface implementation.
@@ -71,14 +71,11 @@ class CONTENT_EXPORT VideoDestinationHandler {
   // Instantiates and adds a new video track to the MediaStream specified by
   // |url|. Returns a handler for delivering frames to the new video track as
   // |frame_writer|.
-  // If |factory| is NULL the MediaStreamDependencyFactory owned by
-  // RenderThreadImpl::current() will be used.
   // If |registry| is NULL the global blink::WebMediaStreamRegistry will be
   // used to look up the media stream.
   // The caller of the function takes the ownership of |frame_writer|.
   // Returns true on success and false on failure.
-  static bool Open(MediaStreamDependencyFactory* factory,
-                   MediaStreamRegistryInterface* registry,
+  static bool Open(MediaStreamRegistryInterface* registry,
                    const std::string& url,
                    FrameWriterInterface** frame_writer);
 
diff --git a/content/renderer/media/webrtc/video_destination_handler_unittest.cc b/content/renderer/media/webrtc/video_destination_handler_unittest.cc
index d99f9f2..fb3d863 100644
--- a/content/renderer/media/webrtc/video_destination_handler_unittest.cc
+++ b/content/renderer/media/webrtc/video_destination_handler_unittest.cc
@@ -7,7 +7,6 @@
 #include "base/strings/utf_string_conversions.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_video_track.h"
-#include "content/renderer/media/mock_media_stream_dependency_factory.h"
 #include "content/renderer/media/mock_media_stream_registry.h"
 #include "content/renderer/media/mock_media_stream_video_sink.h"
 #include "content/renderer/media/webrtc/video_destination_handler.h"
@@ -30,16 +29,15 @@ class VideoDestinationHandlerTest : public PpapiUnittest {
   }
 
  protected:
-  MockMediaStreamDependencyFactory factory_;
   MockMediaStreamRegistry registry_;
 };
 
 TEST_F(VideoDestinationHandlerTest, Open) {
   FrameWriterInterface* frame_writer = NULL;
   // Unknow url will return false.
-  EXPECT_FALSE(VideoDestinationHandler::Open(&factory_, &registry_,
+  EXPECT_FALSE(VideoDestinationHandler::Open(&registry_,
                                              kUnknownStreamUrl, &frame_writer));
-  EXPECT_TRUE(VideoDestinationHandler::Open(&factory_, &registry_,
+  EXPECT_TRUE(VideoDestinationHandler::Open(&registry_,
                                             kTestStreamUrl, &frame_writer));
   // The |frame_writer| is a proxy and is owned by who call Open.
   delete frame_writer;
@@ -47,7 +45,7 @@ TEST_F(VideoDestinationHandlerTest, Open) {
 
 TEST_F(VideoDestinationHandlerTest, PutFrame) {
   FrameWriterInterface* frame_writer = NULL;
-  EXPECT_TRUE(VideoDestinationHandler::Open(&factory_, &registry_,
+  EXPECT_TRUE(VideoDestinationHandler::Open(&registry_,
                                             kTestStreamUrl, &frame_writer));
   ASSERT_TRUE(frame_writer);
 
diff --git a/content/renderer/media/webrtc/webrtc_media_stream_adapter.cc b/content/renderer/media/webrtc/webrtc_media_stream_adapter.cc
index 26ca316c..9a7f8b5 100644
--- a/content/renderer/media/webrtc/webrtc_media_stream_adapter.cc
+++ b/content/renderer/media/webrtc/webrtc_media_stream_adapter.cc
@@ -8,7 +8,6 @@
 #include "content/renderer/media/media_stream_audio_source.h"
 #include "content/renderer/media/media_stream_dependency_factory.h"
 #include "content/renderer/media/media_stream_track.h"
-#include "content/renderer/media/media_stream_video_track.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamSource.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebString.h"
@@ -59,8 +58,17 @@ void WebRtcMediaStreamAdapter::TrackRemoved(
         webrtc_media_stream_->FindAudioTrack(track_id));
   } else {
     DCHECK_EQ(track.source().type(), blink::WebMediaStreamSource::TypeVideo);
-    webrtc_media_stream_->RemoveTrack(
-        webrtc_media_stream_->FindVideoTrack(track_id));
+    scoped_refptr<webrtc::VideoTrackInterface> webrtc_track =
+        webrtc_media_stream_->FindVideoTrack(track_id).get();
+    webrtc_media_stream_->RemoveTrack(webrtc_track.get());
+
+    for (ScopedVector<WebRtcVideoTrackAdapter>::iterator it =
+             video_adapters_.begin(); it != video_adapters_.end(); ++it) {
+      if ((*it)->webrtc_video_track() == webrtc_track) {
+        video_adapters_.erase(it);
+        break;
+      }
+    }
   }
 }
 
@@ -94,9 +102,10 @@ void WebRtcMediaStreamAdapter::CreateAudioTrack(
 void WebRtcMediaStreamAdapter::CreateVideoTrack(
     const blink::WebMediaStreamTrack& track) {
   DCHECK_EQ(track.source().type(), blink::WebMediaStreamSource::TypeVideo);
-  MediaStreamVideoTrack* native_track =
-      MediaStreamVideoTrack::GetVideoTrack(track);
-  webrtc_media_stream_->AddTrack(native_track->GetVideoAdapter());
+  WebRtcVideoTrackAdapter* adapter =
+      new WebRtcVideoTrackAdapter(track, factory_);
+  video_adapters_.push_back(adapter);
+  webrtc_media_stream_->AddTrack(adapter->webrtc_video_track());
 }
 
 }  // namespace content
diff --git a/content/renderer/media/webrtc/webrtc_media_stream_adapter.h b/content/renderer/media/webrtc/webrtc_media_stream_adapter.h
index 7b55cbc..9c64b44 100644
--- a/content/renderer/media/webrtc/webrtc_media_stream_adapter.h
+++ b/content/renderer/media/webrtc/webrtc_media_stream_adapter.h
@@ -7,8 +7,10 @@
 
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
+#include "base/memory/scoped_vector.h"
 #include "content/common/content_export.h"
 #include "content/renderer/media/media_stream.h"
+#include "content/renderer/media/webrtc/webrtc_video_track_adapter.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
 
@@ -55,6 +57,7 @@ class CONTENT_EXPORT WebRtcMediaStreamAdapter
   MediaStreamDependencyFactory* factory_;
 
   scoped_refptr<webrtc::MediaStreamInterface> webrtc_media_stream_;
+  ScopedVector<WebRtcVideoTrackAdapter> video_adapters_;
 
   DISALLOW_COPY_AND_ASSIGN (WebRtcMediaStreamAdapter);
 };
diff --git a/content/renderer/media/webrtc/webrtc_media_stream_adapter_unittest.cc b/content/renderer/media/webrtc/webrtc_media_stream_adapter_unittest.cc
index bff0b1d..8cbceff 100644
--- a/content/renderer/media/webrtc/webrtc_media_stream_adapter_unittest.cc
+++ b/content/renderer/media/webrtc/webrtc_media_stream_adapter_unittest.cc
@@ -53,14 +53,13 @@ class WebRtcMediaStreamAdapterTest : public ::testing::Test {
                               blink::WebMediaStreamSource::TypeVideo,
                               "video");
       MediaStreamVideoSource* native_source =
-          new MockMediaStreamVideoSource(dependency_factory_.get(), false);
+          new MockMediaStreamVideoSource(false);
       video_source.setExtraData(native_source);
       blink::WebMediaConstraints constraints;
       constraints.initialize();
       video_track_vector[0] = MediaStreamVideoTrack::CreateVideoTrack(
           native_source, constraints,
-          MediaStreamVideoSource::ConstraintsCallback(), true,
-          dependency_factory_.get());
+          MediaStreamVideoSource::ConstraintsCallback(), true);
     }
 
     blink::WebMediaStream stream_desc;
diff --git a/content/renderer/media/webrtc/webrtc_video_track_adapter.cc b/content/renderer/media/webrtc/webrtc_video_track_adapter.cc
new file mode 100644
index 0000000..023aba1
--- /dev/null
+++ b/content/renderer/media/webrtc/webrtc_video_track_adapter.cc
@@ -0,0 +1,68 @@
+// Copyright 2014 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/webrtc/webrtc_video_track_adapter.h"
+
+#include "base/strings/utf_string_conversions.h"
+#include "content/common/media/media_stream_options.h"
+#include "content/renderer/media/media_stream_video_source.h"
+#include "content/renderer/media/media_stream_video_track.h"
+
+namespace {
+
+bool ConstraintKeyExists(const blink::WebMediaConstraints& constraints,
+                         const blink::WebString& name) {
+  blink::WebString value_str;
+  return constraints.getMandatoryConstraintValue(name, value_str) ||
+      constraints.getOptionalConstraintValue(name, value_str);
+}
+
+}  // anonymouse namespace
+
+namespace content {
+
+WebRtcVideoTrackAdapter::WebRtcVideoTrackAdapter(
+    const blink::WebMediaStreamTrack& track,
+    MediaStreamDependencyFactory* factory)
+    : web_track_(track) {
+  MediaStreamVideoSink::AddToVideoTrack(this, web_track_);
+
+  const blink::WebMediaConstraints& constraints =
+      MediaStreamVideoTrack::GetVideoTrack(track)->constraints();
+
+  bool is_screencast = ConstraintKeyExists(
+      constraints, base::UTF8ToUTF16(kMediaStreamSource));
+  capture_adapter_ = factory->CreateVideoCapturer(is_screencast);
+
+  // |video_source| owns |capture_adapter|
+  video_source_ = factory->CreateVideoSource(capture_adapter_,
+                                             track.source().constraints());
+
+  video_track_ = factory->CreateLocalVideoTrack(web_track_.id().utf8(),
+                                                video_source_);
+  video_track_->set_enabled(web_track_.isEnabled());
+
+  DVLOG(3) << "WebRtcVideoTrackAdapter ctor() : is_screencast "
+           << is_screencast;
+}
+
+WebRtcVideoTrackAdapter::~WebRtcVideoTrackAdapter() {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  DVLOG(3) << "WebRtcVideoTrackAdapter dtor().";
+  MediaStreamVideoSink::RemoveFromVideoTrack(this, web_track_);
+}
+
+void WebRtcVideoTrackAdapter::OnEnabledChanged(bool enabled) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  video_track_->set_enabled(enabled);
+}
+
+void WebRtcVideoTrackAdapter::OnVideoFrame(
+    const scoped_refptr<media::VideoFrame>& frame) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  capture_adapter_->OnFrameCaptured(frame);
+}
+
+}  // namespace content
+
diff --git a/content/renderer/media/webrtc/webrtc_video_track_adapter.h b/content/renderer/media/webrtc/webrtc_video_track_adapter.h
new file mode 100644
index 0000000..b2cff0a
--- /dev/null
+++ b/content/renderer/media/webrtc/webrtc_video_track_adapter.h
@@ -0,0 +1,61 @@
+// Copyright 2014 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.
+
+#ifndef CONTENT_RENDERER_MEDIA_WEBRTC_WEBRTC_VIDEO_TRACK_ADAPTER_H_
+#define CONTENT_RENDERER_MEDIA_WEBRTC_WEBRTC_VIDEO_TRACK_ADAPTER_H_
+
+#include "base/macros.h"
+#include "base/threading/thread_checker.h"
+#include "content/public/renderer/media_stream_video_sink.h"
+#include "content/renderer/media/media_stream_dependency_factory.h"
+#include "content/renderer/media/webrtc/webrtc_video_capturer_adapter.h"
+#include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
+#include "third_party/libjingle/source/talk/app/webrtc/mediastreaminterface.h"
+#include "third_party/libjingle/source/talk/app/webrtc/videosourceinterface.h"
+
+namespace content {
+
+// WebRtcVideoTrackAdapter is an adapter between a
+// content::MediaStreamVideoTrack object and a webrtc VideoTrack that is
+// currently sent on a PeerConnection.
+// The responsibility of the class is to create and own a representation of a
+// webrtc VideoTrack that can be added and removed from a RTCPeerConnection.
+// An instance of WebRtcVideoTrackAdapter is created when a VideoTrack is
+// added to an RTCPeerConnection object.
+// Instances of this class is owned by the WebRtcMediaStreamAdapter object that
+// created it.
+class WebRtcVideoTrackAdapter : public MediaStreamVideoSink {
+ public:
+  WebRtcVideoTrackAdapter(const blink::WebMediaStreamTrack& track,
+                          MediaStreamDependencyFactory* factory);
+  virtual ~WebRtcVideoTrackAdapter();
+
+  webrtc::VideoTrackInterface* webrtc_video_track() {
+    return video_track_.get();
+  }
+
+ protected:
+  // Implements MediaStreamVideoSink
+  virtual void OnVideoFrame(
+      const scoped_refptr<media::VideoFrame>& frame) OVERRIDE;
+  virtual void OnEnabledChanged(bool enabled) OVERRIDE;
+
+ private:
+  // Used to DCHECK that we are called on the correct thread.
+  base::ThreadChecker thread_checker_;
+
+  scoped_refptr<webrtc::VideoSourceInterface> video_source_;
+  scoped_refptr<webrtc::VideoTrackInterface> video_track_;
+
+  blink::WebMediaStreamTrack web_track_;
+
+  // |capture_adapter_| is owned by |video_source_|
+  WebRtcVideoCapturerAdapter* capture_adapter_;
+
+  DISALLOW_COPY_AND_ASSIGN (WebRtcVideoTrackAdapter);
+};
+
+}  // namespace content
+
+#endif  // CONTENT_RENDERER_MEDIA_WEBRTC_WEBRTC_VIDEO_TRACK_ADAPTER_H_