Use a FakeVideoTrackSource instead of nullptr in all VideoTrack tests.

webrtc/api/peerconnectioninterface_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 "webrtc/api/audiotrack.h"
 #include "webrtc/api/jsepsessiondescription.h"
 #include "webrtc/api/mediastream.h"
 #include "webrtc/api/mediastreaminterface.h"
 #include "webrtc/api/peerconnection.h"
 #include "webrtc/api/peerconnectioninterface.h"
 #include "webrtc/api/rtpreceiverinterface.h"
 #include "webrtc/api/rtpsenderinterface.h"
 #include "webrtc/api/streamcollection.h"
 #ifdef WEBRTC_ANDROID
 #include "webrtc/api/test/androidtestinitializer.h"
 #endif
 #include "webrtc/api/test/fakeconstraints.h"
 #include "webrtc/api/test/fakedtlsidentitystore.h"
+#include "webrtc/api/test/fakevideotracksource.h"
 #include "webrtc/api/test/mockpeerconnectionobservers.h"
 #include "webrtc/api/test/testsdpstrings.h"
 #include "webrtc/api/videocapturertracksource.h"
 #include "webrtc/api/videotrack.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/ssladapter.h"
 #include "webrtc/base/sslstreamadapter.h"
 #include "webrtc/base/stringutils.h"
 #include "webrtc/base/thread.h"
@@ skipping 296 matching lines @@
     rtc::scoped_refptr<webrtc::MediaStreamInterface> stream(
         webrtc::MediaStream::Create(kStreams[i]));
 
     // Add a local audio track.
     rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         webrtc::AudioTrack::Create(kAudioTracks[i], nullptr));
     stream->AddTrack(audio_track);
 
     // Add a local video track.
     rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
-        webrtc::VideoTrack::Create(kVideoTracks[i], nullptr));
+        webrtc::VideoTrack::Create(kVideoTracks[i],
+                                   webrtc::FakeVideoTrackSource::Create()));
     stream->AddTrack(video_track);
 
     local_collection->AddStream(stream);
   }
   return local_collection;
 }
 
 // Check equality of StreamCollections.
 bool CompareStreamCollections(StreamCollectionInterface* s1,
                               StreamCollectionInterface* s2) {
@@ skipping 268 matching lines @@
                            const std::string& audio_track_label,
                            const std::string& video_track_label) {
     // Create a local stream.
     scoped_refptr<MediaStreamInterface> stream(
         pc_factory_->CreateLocalMediaStream(stream_label));
     scoped_refptr<AudioTrackInterface> audio_track(
         pc_factory_->CreateAudioTrack(
             audio_track_label, static_cast<AudioSourceInterface*>(NULL)));
     stream->AddTrack(audio_track.get());
     scoped_refptr<VideoTrackInterface> video_track(
-        pc_factory_->CreateVideoTrack(video_track_label, NULL));
+        pc_factory_->CreateVideoTrack(
+            video_track_label,
+            pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer())));
     stream->AddTrack(video_track.get());
     EXPECT_TRUE(pc_->AddStream(stream));
     EXPECT_TRUE_WAIT(observer_.renegotiation_needed_, kTimeout);
     observer_.renegotiation_needed_ = false;
   }
 
   bool DoCreateOfferAnswer(rtc::scoped_ptr<SessionDescriptionInterface>* desc,
                            bool offer,
                            MediaConstraintsInterface* constraints) {
     rtc::scoped_refptr<MockCreateSessionDescriptionObserver>
@@ skipping 248 matching lines @@
   void AddAudioTrack(const std::string& track_id,
                      MediaStreamInterface* stream) {
     rtc::scoped_refptr<webrtc::AudioTrackInterface> audio_track(
         webrtc::AudioTrack::Create(track_id, nullptr));
     ASSERT_TRUE(stream->AddTrack(audio_track));
   }
 
   void AddVideoTrack(const std::string& track_id,
                      MediaStreamInterface* stream) {
     rtc::scoped_refptr<webrtc::VideoTrackInterface> video_track(
-        webrtc::VideoTrack::Create(track_id, nullptr));
+        webrtc::VideoTrack::Create(track_id,
+                                   webrtc::FakeVideoTrackSource::Create()));
     ASSERT_TRUE(stream->AddTrack(video_track));
   }
 
   cricket::FakePortAllocator* port_allocator_ = nullptr;
   scoped_refptr<webrtc::PeerConnectionFactoryInterface> pc_factory_;
   scoped_refptr<PeerConnectionInterface> pc_;
   MockPeerConnectionObserver observer_;
   rtc::scoped_refptr<StreamCollection> reference_collection_;
 };
 
@@ skipping 90 matching lines @@
 // Also tests that RemoveTrack removes the tracks from subsequent offers.
 TEST_F(PeerConnectionInterfaceTest, AddTrackRemoveTrack) {
   CreatePeerConnection();
   // Create a dummy stream, so tracks share a stream label.
   scoped_refptr<MediaStreamInterface> stream(
       pc_factory_->CreateLocalMediaStream(kStreamLabel1));
   std::vector<MediaStreamInterface*> stream_list;
   stream_list.push_back(stream.get());
   scoped_refptr<AudioTrackInterface> audio_track(
       pc_factory_->CreateAudioTrack("audio_track", nullptr));
-  scoped_refptr<VideoTrackInterface> video_track(
-      pc_factory_->CreateVideoTrack("video_track", nullptr));
+  scoped_refptr<VideoTrackInterface> video_track(pc_factory_->CreateVideoTrack(
+      "video_track",
+      pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer())));
   auto audio_sender = pc_->AddTrack(audio_track, stream_list);
   auto video_sender = pc_->AddTrack(video_track, stream_list);
   EXPECT_EQ(kStreamLabel1, audio_sender->stream_id());
   EXPECT_EQ("audio_track", audio_sender->id());
   EXPECT_EQ(audio_track, audio_sender->track());
   EXPECT_EQ(kStreamLabel1, video_sender->stream_id());
   EXPECT_EQ("video_track", video_sender->id());
   EXPECT_EQ(video_track, video_sender->track());
 
   // Now create an offer and check for the senders.
@@ skipping 45 matching lines @@
   EXPECT_FALSE(pc_->RemoveTrack(video_sender));
 }
 
 // Test creating senders without a stream specified,
 // expecting a random stream ID to be generated.
 TEST_F(PeerConnectionInterfaceTest, AddTrackWithoutStream) {
   CreatePeerConnection();
   // Create a dummy stream, so tracks share a stream label.
   scoped_refptr<AudioTrackInterface> audio_track(
       pc_factory_->CreateAudioTrack("audio_track", nullptr));
-  scoped_refptr<VideoTrackInterface> video_track(
-      pc_factory_->CreateVideoTrack("video_track", nullptr));
+  scoped_refptr<VideoTrackInterface> video_track(pc_factory_->CreateVideoTrack(
+      "video_track",
+      pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer())));
   auto audio_sender =
       pc_->AddTrack(audio_track, std::vector<MediaStreamInterface*>());
   auto video_sender =
       pc_->AddTrack(video_track, std::vector<MediaStreamInterface*>());
   EXPECT_EQ("audio_track", audio_sender->id());
   EXPECT_EQ(audio_track, audio_sender->track());
   EXPECT_EQ("video_track", video_sender->id());
   EXPECT_EQ(video_track, video_sender->track());
   // If the ID is truly a random GUID, it should be infinitely unlikely they
   // will be the same.
@@ skipping 138 matching lines @@
 // Test that it's possible to call AddTrack on a MediaStream after adding
 // the stream to a PeerConnection.
 // TODO(deadbeef): Remove this test once this behavior is no longer supported.
 TEST_F(PeerConnectionInterfaceTest, AddTrackAfterAddStream) {
   CreatePeerConnection();
   // Create audio stream and add to PeerConnection.
   AddVoiceStream(kStreamLabel1);
   MediaStreamInterface* stream = pc_->local_streams()->at(0);
 
   // Add video track to the audio-only stream.
-  scoped_refptr<VideoTrackInterface> video_track(
-      pc_factory_->CreateVideoTrack("video_label", nullptr));
+  scoped_refptr<VideoTrackInterface> video_track(pc_factory_->CreateVideoTrack(
+      "video_label",
+      pc_factory_->CreateVideoSource(new cricket::FakeVideoCapturer())));
   stream->AddTrack(video_track.get());
 
   scoped_ptr<SessionDescriptionInterface> offer;
   ASSERT_TRUE(DoCreateOffer(&offer, nullptr));
 
   const cricket::MediaContentDescription* video_desc =
       cricket::GetFirstVideoContentDescription(offer->description());
   EXPECT_TRUE(video_desc != nullptr);
 }
 
@@ skipping 1170 matching lines @@
   }
 
   // Mutable, so they can be modified in the above const-declared method.
   mutable bool create_media_controller_called_ = false;
   mutable cricket::MediaConfig create_media_controller_config_;
 };
 
 class PeerConnectionMediaConfigTest : public testing::Test {
  protected:
   void SetUp() override {
-    pcf_= new rtc::RefCountedObject<PeerConnectionFactoryForTest>();
+    pcf_ = new rtc::RefCountedObject<PeerConnectionFactoryForTest>();
     pcf_->Initialize();
   }
   const cricket::MediaConfig& TestCreatePeerConnection(
       const PeerConnectionInterface::RTCConfiguration& config,
       const MediaConstraintsInterface *constraints) {
     pcf_->create_media_controller_called_ = false;
 
     scoped_refptr<PeerConnectionInterface> pc(
         pcf_->CreatePeerConnection(config, constraints, nullptr, nullptr,
                                    &observer_));
@@ skipping 240 matching lines @@
   FakeConstraints updated_answer_c;
   answer_c.SetMandatoryReceiveAudio(false);
   answer_c.SetMandatoryReceiveVideo(false);
 
   cricket::MediaSessionOptions updated_answer_options;
   EXPECT_TRUE(
       ParseConstraintsForAnswer(&updated_answer_c, &updated_answer_options));
   EXPECT_TRUE(updated_answer_options.has_audio());
   EXPECT_TRUE(updated_answer_options.has_video());
 }