Add VideoTrackSource implementation.

webrtc/api/rtpsenderreceiver_unittest.cc

 /*
  *  Copyright 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include <string>
 #include <utility>
 
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/api/audiotrack.h"
 #include "webrtc/api/mediastream.h"
 #include "webrtc/api/remoteaudiosource.h"
 #include "webrtc/api/rtpreceiver.h"
 #include "webrtc/api/rtpsender.h"
 #include "webrtc/api/streamcollection.h"
-#include "webrtc/api/videocapturertracksource.h"
+#include "webrtc/api/videotracksource.h"
 #include "webrtc/api/videotrack.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/media/base/fakevideocapturer.h"
 #include "webrtc/media/base/mediachannel.h"
 
 using ::testing::_;
 using ::testing::Exactly;
 
 static const char kStreamLabel1[] = "local_stream_1";
 static const char kVideoTrackId[] = "video_1";
@@ skipping 38 matching lines @@
   MOCK_METHOD3(SetVideoPlayout,
                void(uint32_t ssrc,
                     bool enable,
                     rtc::VideoSinkInterface<cricket::VideoFrame>* sink));
   MOCK_METHOD3(SetVideoSend,
                void(uint32_t ssrc,
                     bool enable,
                     const cricket::VideoOptions* options));
 };
 
-class FakeVideoSource : public Notifier<VideoTrackSourceInterface> {
+class FakeVideoTrackSource : public VideoTrackSource {
  public:
-  static rtc::scoped_refptr<FakeVideoSource> Create(bool remote) {
-    return new rtc::RefCountedObject<FakeVideoSource>(remote);
+  static rtc::scoped_refptr<FakeVideoTrackSource> Create(bool remote) {
+    return new rtc::RefCountedObject<FakeVideoTrackSource>(remote);
   }
   cricket::VideoCapturer* GetVideoCapturer() { return &fake_capturer_; }
-  void Stop() override {}
-  void Restart() override {}
-  void AddOrUpdateSink(
-      rtc::VideoSinkInterface<cricket::VideoFrame>* sink,
-      const rtc::VideoSinkWants& wants) override {}
-  void RemoveSink(
-      rtc::VideoSinkInterface<cricket::VideoFrame>* output) override {}
-  SourceState state() const override { return state_; }
-  bool remote() const override { return remote_; }
-  const cricket::VideoOptions* options() const override { return &options_; }
 
  protected:
-  explicit FakeVideoSource(bool remote) : state_(kLive), remote_(remote) {}
-  ~FakeVideoSource() {}
+  explicit FakeVideoTrackSource(bool remote)
+      : VideoTrackSource(&fake_capturer_, rtc::Thread::Current(), remote) {}
+  ~FakeVideoTrackSource() {}
 
  private:
   cricket::FakeVideoCapturer fake_capturer_;
-  SourceState state_;
-  bool remote_;
-  cricket::VideoOptions options_;
 };
 
 class RtpSenderReceiverTest : public testing::Test {
  public:
   virtual void SetUp() {
     stream_ = MediaStream::Create(kStreamLabel1);
   }
 
   void AddVideoTrack(bool remote) {
     rtc::scoped_refptr<VideoTrackSourceInterface> source(
-        FakeVideoSource::Create(remote));
+        FakeVideoTrackSource::Create(remote));
     video_track_ = VideoTrack::Create(kVideoTrackId, source);
     EXPECT_TRUE(stream_->AddTrack(video_track_));
   }
 
   void CreateAudioRtpSender() {
     audio_track_ = AudioTrack::Create(kAudioTrackId, NULL);
     EXPECT_TRUE(stream_->AddTrack(audio_track_));
     EXPECT_CALL(audio_provider_, SetAudioSend(kAudioSsrc, true, _, _));
     audio_rtp_sender_ =
         new AudioRtpSender(stream_->GetAudioTracks()[0], stream_->label(),
@@ skipping 362 matching lines @@
                                video_track_->GetSource()->GetVideoCapturer()));
   EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc2, true, _));
   sender->SetSsrc(kVideoSsrc2);
 
   // Calls expected from destructor.
   EXPECT_CALL(video_provider_, SetCaptureDevice(kVideoSsrc2, nullptr)).Times(1);
   EXPECT_CALL(video_provider_, SetVideoSend(kVideoSsrc2, false, _)).Times(1);
 }
 
 }  // namespace webrtc