Refactor VideoSourceHandler to implement MediaStreamVideoSink.

VideoSourceHandler now receive video frames from a MediaStreamVideoTrack.

TBR jam for content_tests.gypi
TBR=jam

BUG=334243

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

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

8 files changed, 103 insertions, 176 deletions

diff --git a/content/renderer/media/media_stream_dependency_factory.cc b/content/renderer/media/media_stream_dependency_factory.cc
index 0393fa4..fef5308 100644
--- a/content/renderer/media/media_stream_dependency_factory.cc
+++ b/content/renderer/media/media_stream_dependency_factory.cc
@@ -316,41 +316,6 @@ bool MediaStreamDependencyFactory::AddNativeMediaStreamTrack(
   return false;
 }
 
-bool MediaStreamDependencyFactory::AddNativeVideoMediaTrack(
-    const std::string& track_id,
-    blink::WebMediaStream* stream,
-    cricket::VideoCapturer* capturer) {
-  if (!stream) {
-    LOG(ERROR) << "AddNativeVideoMediaTrack called with null WebMediaStream.";
-    return false;
-  }
-
-  // Create native track from the source.
-  scoped_refptr<webrtc::VideoTrackInterface> native_track =
-      CreateLocalVideoTrack(track_id, capturer);
-
-  // Add the webrtc track to the webrtc stream
-  webrtc::MediaStreamInterface* native_stream =
-      MediaStream::GetAdapter(*stream);
-  DCHECK(native_stream);
-  native_stream->AddTrack(native_track.get());
-
-  // Create a new webkit video track.
-  blink::WebMediaStreamTrack webkit_track;
-  blink::WebMediaStreamSource webkit_source;
-  blink::WebString webkit_track_id(base::UTF8ToUTF16(track_id));
-  blink::WebMediaStreamSource::Type type =
-      blink::WebMediaStreamSource::TypeVideo;
-  webkit_source.initialize(webkit_track_id, type, webkit_track_id);
-
-  webkit_track.initialize(webkit_track_id, webkit_source);
-  AddNativeTrackToBlinkTrack(native_track.get(), webkit_track, true);
-
-  // Add the track to WebMediaStream.
-  stream->addTrack(webkit_track);
-  return true;
-}
-
 bool MediaStreamDependencyFactory::RemoveNativeMediaStreamTrack(
     const blink::WebMediaStream& stream,
     const blink::WebMediaStreamTrack& track) {
diff --git a/content/renderer/media/media_stream_dependency_factory.h b/content/renderer/media/media_stream_dependency_factory.h
index 730ae2a..accac97 100644
--- a/content/renderer/media/media_stream_dependency_factory.h
+++ b/content/renderer/media/media_stream_dependency_factory.h
@@ -100,12 +100,6 @@ class CONTENT_EXPORT MediaStreamDependencyFactory
   bool AddNativeMediaStreamTrack(const blink::WebMediaStream& stream,
                                  const blink::WebMediaStreamTrack& track);
 
-  // Creates and adds libjingle representation of a MediaStreamTrack to |stream|
-  // based on the desired |track_id| and |capturer|.
-  bool AddNativeVideoMediaTrack(const std::string& track_id,
-                                blink::WebMediaStream* stream,
-                                cricket::VideoCapturer* capturer);
-
   // Removes a libjingle MediaStreamTrack from the libjingle representation of
   // |stream|.
   bool RemoveNativeMediaStreamTrack(const blink::WebMediaStream& stream,
diff --git a/content/renderer/media/mock_media_stream_registry.cc b/content/renderer/media/mock_media_stream_registry.cc
index 6144fd6..6b990bc 100644
--- a/content/renderer/media/mock_media_stream_registry.cc
+++ b/content/renderer/media/mock_media_stream_registry.cc
@@ -8,36 +8,52 @@
 
 #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_video_source.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"
 #include "third_party/WebKit/public/platform/WebVector.h"
-#include "third_party/libjingle/source/talk/media/base/videocapturer.h"
 
 namespace content {
 
-static const std::string kTestStreamLabel = "stream_label";
+static const char kTestStreamLabel[] = "stream_label";
 
-MockMediaStreamRegistry::MockMediaStreamRegistry(
-    MockMediaStreamDependencyFactory* factory)
-    : factory_(factory) {
+MockMediaStreamRegistry::MockMediaStreamRegistry() {
 }
 
 void MockMediaStreamRegistry::Init(const std::string& stream_url) {
   stream_url_ = stream_url;
-  scoped_refptr<webrtc::MediaStreamInterface> stream(
-      factory_->CreateLocalMediaStream(kTestStreamLabel));
   blink::WebVector<blink::WebMediaStreamTrack> webkit_audio_tracks;
   blink::WebVector<blink::WebMediaStreamTrack> webkit_video_tracks;
-  blink::WebString webkit_stream_label(base::UTF8ToUTF16(stream->label()));
-  test_stream_.initialize(webkit_stream_label,
-                          webkit_audio_tracks, webkit_video_tracks);
-  test_stream_.setExtraData(new MediaStream(stream.get()));
+  blink::WebString label(kTestStreamLabel);
+  test_stream_.initialize(label, webkit_audio_tracks, webkit_video_tracks);
+  test_stream_.setExtraData(new MediaStream(&dependency_factory_,
+                                            MediaStream::StreamStopCallback(),
+                                            test_stream_));
 }
 
-bool MockMediaStreamRegistry::AddVideoTrack(const std::string& track_id) {
-  cricket::VideoCapturer* capturer = NULL;
-  return factory_->AddNativeVideoMediaTrack(track_id, &test_stream_, capturer);
+void MockMediaStreamRegistry::AddVideoTrack(const std::string& track_id) {
+  blink::WebMediaStreamSource blink_source;
+  blink_source.initialize("mock video source id",
+                          blink::WebMediaStreamSource::TypeVideo,
+                          "mock video source name");
+  MockMediaStreamVideoSource* native_source =
+      new MockMediaStreamVideoSource(&dependency_factory_, false);
+  blink_source.setExtraData(native_source);
+  blink::WebMediaStreamTrack blink_track;
+  blink_track.initialize(base::UTF8ToUTF16(track_id), blink_source);
+  blink::WebMediaConstraints constraints;
+  constraints.initialize();
+
+  MediaStreamVideoTrack* native_track =
+      new MediaStreamVideoTrack(native_source,
+                                constraints,
+                                MediaStreamVideoSource::ConstraintsCallback(),
+                                true,
+                                &dependency_factory_);
+  blink_track.setExtraData(native_track);
+  test_stream_.addTrack(blink_track);
 }
 
 blink::WebMediaStream MockMediaStreamRegistry::GetMediaStream(
diff --git a/content/renderer/media/mock_media_stream_registry.h b/content/renderer/media/mock_media_stream_registry.h
index c0dba84..1435cb5 100644
--- a/content/renderer/media/mock_media_stream_registry.h
+++ b/content/renderer/media/mock_media_stream_registry.h
@@ -14,16 +14,16 @@ namespace content {
 
 class MockMediaStreamRegistry : public MediaStreamRegistryInterface {
  public:
-  explicit MockMediaStreamRegistry(MockMediaStreamDependencyFactory* factory);
+  MockMediaStreamRegistry();
 
   void Init(const std::string& stream_label);
-  bool AddVideoTrack(const std::string& track_id);
-  virtual blink::WebMediaStream GetMediaStream(const std::string& url)
-      OVERRIDE;
+  void AddVideoTrack(const std::string& track_id);
+  virtual blink::WebMediaStream GetMediaStream(
+      const std::string& url) OVERRIDE;
   const blink::WebMediaStream test_stream() const;
 
  private:
-  MockMediaStreamDependencyFactory* factory_;
+  MockMediaStreamDependencyFactory dependency_factory_;
   blink::WebMediaStream test_stream_;
   std::string stream_url_;
 };
diff --git a/content/renderer/media/video_source_handler.cc b/content/renderer/media/video_source_handler.cc
index e9756d0..9882207 100644
--- a/content/renderer/media/video_source_handler.cc
+++ b/content/renderer/media/video_source_handler.cc
@@ -7,45 +7,32 @@
 #include <string>
 
 #include "base/logging.h"
+#include "base/synchronization/lock.h"
+#include "content/public/renderer/media_stream_video_sink.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/render_thread_impl.h"
 #include "third_party/WebKit/public/platform/WebMediaStream.h"
 #include "third_party/WebKit/public/platform/WebURL.h"
 #include "third_party/WebKit/public/web/WebMediaStreamRegistry.h"
-#include "third_party/libjingle/source/talk/media/base/videoframe.h"
-#include "third_party/libjingle/source/talk/media/base/videorenderer.h"
 #include "url/gurl.h"
 
-using cricket::VideoFrame;
-using cricket::VideoRenderer;
-using webrtc::VideoSourceInterface;
-
 namespace content {
 
-// PpFrameReceiver implements cricket::VideoRenderer so that it can be attached
-// to native video track's video source to receive the captured frame.
+// PpFrameReceiver implements MediaStreamVideoSink so that it can be attached
+// to video track to receive the captured frame.
 // It can be attached to a FrameReaderInterface to output the received frame.
-class PpFrameReceiver : public cricket::VideoRenderer {
+class PpFrameReceiver : public MediaStreamVideoSink {
  public:
   PpFrameReceiver() : reader_(NULL) {}
   virtual ~PpFrameReceiver() {}
 
-  // Implements VideoRenderer.
-  virtual bool SetSize(int width, int height, int reserved) OVERRIDE {
-    return true;
-  }
-  virtual bool RenderFrame(const cricket::VideoFrame* frame) OVERRIDE {
+  // Implements MediaStreamVideoSink.
+  virtual void OnVideoFrame(
+      const scoped_refptr<media::VideoFrame>& frame) OVERRIDE {
     base::AutoLock auto_lock(lock_);
     if (reader_) {
-      // |frame| will be invalid after this function is returned. So keep a copy
-      // before return.
-      cricket::VideoFrame* copied_frame = frame->Copy();
-      copied_frame->MakeExclusive();
-      reader_->GotFrame(copied_frame);
+      reader_->GotFrame(frame);
     }
-    return true;
   }
 
   void SetReader(FrameReaderInterface* reader) {
@@ -75,15 +62,17 @@ VideoSourceHandler::~VideoSourceHandler() {
 
 bool VideoSourceHandler::Open(const std::string& url,
                               FrameReaderInterface* reader) {
-  scoped_refptr<webrtc::VideoSourceInterface> source = GetFirstVideoSource(url);
-  if (!source.get()) {
+  DCHECK(thread_checker_.CalledOnValidThread());
+  const blink::WebMediaStreamTrack& track = GetFirstVideoTrack(url);
+  if (track.isNull()) {
     return false;
   }
-  reader_to_receiver_[reader] = new SourceInfo(source, reader);
+  reader_to_receiver_[reader] = new SourceInfo(track, reader);
   return true;
 }
 
 bool VideoSourceHandler::Close(FrameReaderInterface* reader) {
+  DCHECK(thread_checker_. CalledOnValidThread());
   SourceInfoMap::iterator it = reader_to_receiver_.find(reader);
   if (it == reader_to_receiver_.end()) {
     return false;
@@ -93,9 +82,8 @@ bool VideoSourceHandler::Close(FrameReaderInterface* reader) {
   return true;
 }
 
-scoped_refptr<VideoSourceInterface> VideoSourceHandler::GetFirstVideoSource(
+blink::WebMediaStreamTrack VideoSourceHandler::GetFirstVideoTrack(
     const std::string& url) {
-  scoped_refptr<webrtc::VideoSourceInterface> source;
   blink::WebMediaStream stream;
   if (registry_) {
     stream = registry_->GetMediaStream(url);
@@ -103,24 +91,25 @@ scoped_refptr<VideoSourceInterface> VideoSourceHandler::GetFirstVideoSource(
     stream =
         blink::WebMediaStreamRegistry::lookupMediaStreamDescriptor(GURL(url));
   }
-  if (stream.isNull() || !stream.extraData()) {
+
+  if (stream.isNull()) {
     LOG(ERROR) << "GetFirstVideoSource - invalid url: " << url;
-    return source;
+    return blink::WebMediaStreamTrack();
   }
 
   // Get the first video track from the stream.
-  webrtc::MediaStreamInterface* native_stream = MediaStream::GetAdapter(stream);
-  webrtc::VideoTrackVector native_video_tracks =
-      native_stream->GetVideoTracks();
-  if (native_video_tracks.empty()) {
-    LOG(ERROR) << "GetFirstVideoSource - stream has no video track.";
-    return source;
+  blink::WebVector<blink::WebMediaStreamTrack> video_tracks;
+  stream.videoTracks(video_tracks);
+  if (video_tracks.isEmpty()) {
+    LOG(ERROR) << "GetFirstVideoSource - non video tracks available."
+               << " url: " << url;
+    return blink::WebMediaStreamTrack();
   }
-  source = native_video_tracks[0]->GetSource();
-  return source;
+
+  return video_tracks[0];
 }
 
-VideoRenderer* VideoSourceHandler::GetReceiver(
+MediaStreamVideoSink* VideoSourceHandler::GetReceiver(
     FrameReaderInterface* reader) {
   SourceInfoMap::iterator it = reader_to_receiver_.find(reader);
   if (it == reader_to_receiver_.end()) {
@@ -130,16 +119,16 @@ VideoRenderer* VideoSourceHandler::GetReceiver(
 }
 
 VideoSourceHandler::SourceInfo::SourceInfo(
-    scoped_refptr<webrtc::VideoSourceInterface> source,
+    const blink::WebMediaStreamTrack& blink_track,
     FrameReaderInterface* reader)
     : receiver_(new PpFrameReceiver()),
-      source_(source) {
-  source_->AddSink(receiver_.get());
+      track_(blink_track) {
+  MediaStreamVideoSink::AddToVideoTrack(receiver_.get(), track_);
   receiver_->SetReader(reader);
 }
 
 VideoSourceHandler::SourceInfo::~SourceInfo() {
-  source_->RemoveSink(receiver_.get());
+  MediaStreamVideoSink::RemoveFromVideoTrack(receiver_.get(), track_);
   receiver_->SetReader(NULL);
 }
 
diff --git a/content/renderer/media/video_source_handler.h b/content/renderer/media/video_source_handler.h
index 712e940..7337d80 100644
--- a/content/renderer/media/video_source_handler.h
+++ b/content/renderer/media/video_source_handler.h
@@ -11,17 +11,15 @@
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/threading/thread_checker.h"
 #include "content/common/content_export.h"
-#include "third_party/libjingle/source/talk/app/webrtc/videosourceinterface.h"
-
-namespace cricket {
-class VideoFrame;
-}
+#include "media/base/video_frame.h"
+#include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 
 namespace content {
 
-class MediaStreamDependencyFactory;
 class MediaStreamRegistryInterface;
+class MediaStreamVideoSink;
 class PpFrameReceiver;
 
 // Interface used by the effects pepper plugin to get captured frame
@@ -29,15 +27,13 @@ class PpFrameReceiver;
 class CONTENT_EXPORT FrameReaderInterface {
  public:
   // Got a new captured frame.
-  // The ownership of the |frame| is transfered to the caller. So the caller
-  // must delete |frame| when done with it.
-  virtual bool GotFrame(cricket::VideoFrame* frame) = 0;
+  virtual bool GotFrame(const scoped_refptr<media::VideoFrame>& frame) = 0;
 
  protected:
   virtual ~FrameReaderInterface() {}
 };
 
-// VideoSourceHandler is a glue class between the webrtc MediaStream and
+// VideoSourceHandler is a glue class between MediaStreamVideoTrack and
 // the effects pepper plugin host.
 class CONTENT_EXPORT VideoSourceHandler {
  public:
@@ -54,28 +50,29 @@ class CONTENT_EXPORT VideoSourceHandler {
   // Returns true on success and false on failure.
   bool Close(FrameReaderInterface* reader);
 
-  // Gets the VideoRenderer associated with |reader|.
+  // Gets the MediaStreamVideoSink associated with |reader|.
   // Made it public only for testing purpose.
-  cricket::VideoRenderer* GetReceiver(FrameReaderInterface* reader);
+  MediaStreamVideoSink* GetReceiver(FrameReaderInterface* reader);
 
  private:
   struct SourceInfo {
-    SourceInfo(scoped_refptr<webrtc::VideoSourceInterface> source,
+    SourceInfo(const blink::WebMediaStreamTrack& blink_track,
                FrameReaderInterface* reader);
     ~SourceInfo();
 
     scoped_ptr<PpFrameReceiver> receiver_;
-    scoped_refptr<webrtc::VideoSourceInterface> source_;
+    blink::WebMediaStreamTrack track_;
   };
 
   typedef std::map<FrameReaderInterface*, SourceInfo*> SourceInfoMap;
 
-  scoped_refptr<webrtc::VideoSourceInterface> GetFirstVideoSource(
-      const std::string& url);
+  blink::WebMediaStreamTrack GetFirstVideoTrack(const std::string& url);
 
   MediaStreamRegistryInterface* registry_;
   SourceInfoMap reader_to_receiver_;
 
+  base::ThreadChecker thread_checker_;
+
   DISALLOW_COPY_AND_ASSIGN(VideoSourceHandler);
 };
 
diff --git a/content/renderer/media/video_source_handler_unittest.cc b/content/renderer/media/video_source_handler_unittest.cc
index 3c8fa56..d5ffa03 100644
--- a/content/renderer/media/video_source_handler_unittest.cc
+++ b/content/renderer/media/video_source_handler_unittest.cc
@@ -5,20 +5,16 @@
 #include <string>
 
 #include "base/strings/utf_string_conversions.h"
+#include "content/public/renderer/media_stream_video_sink.h"
 #include "content/renderer/media/media_stream.h"
 #include "content/renderer/media/media_stream_registry_interface.h"
-#include "content/renderer/media/mock_media_stream_dependency_factory.h"
 #include "content/renderer/media/mock_media_stream_registry.h"
 #include "content/renderer/media/video_source_handler.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/WebKit/public/platform/WebMediaStreamTrack.h"
 #include "third_party/WebKit/public/platform/WebString.h"
-#include "third_party/libjingle/source/talk/media/base/videocapturer.h"
-#include "third_party/libjingle/source/talk/media/base/videorenderer.h"
-#include "third_party/libjingle/source/talk/media/webrtc/webrtcvideoframe.h"
 
-using cricket::VideoFrame;
 
 namespace content {
 
@@ -28,22 +24,23 @@ static const std::string kUnknownStreamUrl = "unknown_stream_url";
 
 class FakeFrameReader : public FrameReaderInterface {
  public:
-  virtual bool GotFrame(VideoFrame* frame) OVERRIDE {
-    last_frame_.reset(frame);
+  virtual bool GotFrame(
+      const scoped_refptr<media::VideoFrame>& frame) OVERRIDE {
+    last_frame_ = frame;
     return true;
   }
 
-  const VideoFrame* last_frame() {
+  const media::VideoFrame* last_frame() {
     return last_frame_.get();
   }
 
  private:
-  scoped_ptr<VideoFrame> last_frame_;
+  scoped_refptr<media::VideoFrame> last_frame_;
 };
 
 class VideoSourceHandlerTest : public ::testing::Test {
  public:
-  VideoSourceHandlerTest() : registry_(&dependency_factory_) {
+  VideoSourceHandlerTest() : registry_() {
     handler_.reset(new VideoSourceHandler(&registry_));
     registry_.Init(kTestStreamUrl);
     registry_.AddVideoTrack(kTestVideoTrackId);
@@ -51,7 +48,6 @@ class VideoSourceHandlerTest : public ::testing::Test {
 
  protected:
   scoped_ptr<VideoSourceHandler> handler_;
-  MockMediaStreamDependencyFactory dependency_factory_;
   MockMediaStreamRegistry registry_;
 };
 
@@ -61,57 +57,27 @@ TEST_F(VideoSourceHandlerTest, OpenClose) {
   EXPECT_FALSE(handler_->Open(kUnknownStreamUrl, &reader));
   EXPECT_TRUE(handler_->Open(kTestStreamUrl, &reader));
 
-  size_t width = 640;
-  size_t height = 360;
-  int64 et = 123456;
-  int64 ts = 789012;
-  size_t size = VideoFrame::SizeOf(width, height);
-  std::vector<uint8_t> test_buffer(size);
-  for (size_t i = 0; i < size; ++i) {
-    test_buffer[i] = (i & 0xFF);
-  }
+  int width = 640;
+  int height = 360;
+  base::TimeDelta ts = base::TimeDelta::FromInternalValue(789012);
 
   // A new frame is captured.
-  cricket::CapturedFrame captured_frame;
-  captured_frame.width = width;
-  captured_frame.height = height;
-  captured_frame.fourcc = cricket::FOURCC_I420;
-  // cricket::CapturedFrame time is in nanoseconds.
-  captured_frame.elapsed_time = et;
-  captured_frame.time_stamp = ts;
-  captured_frame.data = &test_buffer[0];
-  captured_frame.data_size = size;
-  captured_frame.pixel_height = 1;
-  captured_frame.pixel_width = 1;
-
-  // The frame is delivered to VideoSourceHandler as cricket::VideoFrame.
-  cricket::WebRtcVideoFrame i420_frame;
-  EXPECT_TRUE(i420_frame.Alias(&captured_frame, width, height));
-  cricket::VideoRenderer* receiver = handler_->GetReceiver(&reader);
-  ASSERT(receiver != NULL);
-  receiver->RenderFrame(&i420_frame);
+  scoped_refptr<media::VideoFrame> captured_frame =
+      media::VideoFrame::CreateBlackFrame(gfx::Size(width, height));
+  captured_frame->SetTimestamp(ts);
+
+  // The frame is delivered to VideoSourceHandler.
+  MediaStreamVideoSink* receiver = handler_->GetReceiver(&reader);
+  receiver->OnVideoFrame(captured_frame);
 
   // Compare |frame| to |captured_frame|.
-  const VideoFrame* frame = reader.last_frame();
+  const media::VideoFrame* frame = reader.last_frame();
   ASSERT_TRUE(frame != NULL);
-  EXPECT_EQ(width, frame->GetWidth());
-  EXPECT_EQ(height, frame->GetHeight());
-  EXPECT_EQ(et, frame->GetElapsedTime());
-  EXPECT_EQ(ts, frame->GetTimeStamp());
-  std::vector<uint8_t> tmp_buffer1(size);
-  EXPECT_EQ(size, frame->CopyToBuffer(&tmp_buffer1[0], size));
-  EXPECT_TRUE(std::equal(test_buffer.begin(), test_buffer.end(),
-                         tmp_buffer1.begin()));
-
-  // Invalid the original frame
-  memset(&test_buffer[0], 0, size);
-  test_buffer.clear();
-
-  // We should still have the same |frame|.
-  std::vector<uint8_t> tmp_buffer2(size);
-  EXPECT_EQ(size, frame->CopyToBuffer(&tmp_buffer2[0], size));
-  EXPECT_TRUE(std::equal(tmp_buffer1.begin(), tmp_buffer1.end(),
-                         tmp_buffer2.begin()));
+  EXPECT_EQ(width, frame->coded_size().width());
+  EXPECT_EQ(height, frame->coded_size().height());
+  EXPECT_EQ(ts, frame->GetTimestamp());
+  EXPECT_EQ(captured_frame->data(media::VideoFrame::kYPlane),
+            frame->data(media::VideoFrame::kYPlane));
 
   EXPECT_FALSE(handler_->Close(NULL));
   EXPECT_TRUE(handler_->Close(&reader));
diff --git a/content/renderer/media/webrtc/video_destination_handler_unittest.cc b/content/renderer/media/webrtc/video_destination_handler_unittest.cc
index 7a99b38..d99f9f2 100644
--- a/content/renderer/media/webrtc/video_destination_handler_unittest.cc
+++ b/content/renderer/media/webrtc/video_destination_handler_unittest.cc
@@ -25,7 +25,7 @@ static const std::string kUnknownStreamUrl = "unknown_stream_url";
 
 class VideoDestinationHandlerTest : public PpapiUnittest {
  public:
-  VideoDestinationHandlerTest() : registry_(&factory_) {
+  VideoDestinationHandlerTest() : registry_() {
     registry_.Init(kTestStreamUrl);
   }