New flag is_screencast in VideoOptions.

webrtc/media/base/videoengine_unittest.h

 /*
  *  Copyright (c) 2014 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.
  */
 
@@ skipping 111 matching lines @@
     channel_->SetRecvParameters(parameters);
     EXPECT_TRUE(channel_->AddSendStream(DefaultSendStreamParams()));
     video_capturer_.reset(CreateFakeVideoCapturer());
     cricket::VideoFormat format(640, 480,
                                 cricket::VideoFormat::FpsToInterval(30),
                                 cricket::FOURCC_I420);
     EXPECT_EQ(cricket::CS_RUNNING, video_capturer_->Start(format));
     EXPECT_TRUE(channel_->SetCapturer(kSsrc, video_capturer_.get()));
   }
 
+  virtual cricket::FakeVideoCapturer* CreateFakeVideoCapturer(
+      bool is_screencast) {
+    return new cricket::FakeVideoCapturer(is_screencast);
+  }
   virtual cricket::FakeVideoCapturer* CreateFakeVideoCapturer() {
-    return new cricket::FakeVideoCapturer();
+    return CreateFakeVideoCapturer(false);
   }
 
   // Utility method to setup an additional stream to send and receive video.
   // Used to test send and recv between two streams.
   void SetUpSecondStream() {
     SetUpSecondStreamWithNoRecv();
     // Setup recv for second stream.
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(kSsrc + 2)));
     // Make the second renderer available for use by a new stream.
@@ skipping 408 matching lines @@
         cricket::StreamParams::CreateLegacy(kSsrc)));
     EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer_));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(SendFrame());
     EXPECT_TRUE_WAIT(NumRtpPackets() > 0, kTimeout);
     EXPECT_FRAME_WAIT(1, DefaultCodec().width, DefaultCodec().height, kTimeout);
 
     // Add an additional capturer, and hook up a renderer to receive it.
     cricket::FakeVideoRenderer renderer2;
     std::unique_ptr<cricket::FakeVideoCapturer> capturer(
-        CreateFakeVideoCapturer());
-    capturer->SetScreencast(true);
+        CreateFakeVideoCapturer(true));
     const int kTestWidth = 160;
     const int kTestHeight = 120;
     cricket::VideoFormat format(kTestWidth, kTestHeight,
                                 cricket::VideoFormat::FpsToInterval(5),
                                 cricket::FOURCC_I420);
     EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(format));
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(5678)));
     EXPECT_TRUE(channel_->SetCapturer(5678, capturer.get()));
     EXPECT_TRUE(channel_->AddRecvStream(
@@ skipping 189 matching lines @@
     codec.width = 320;
     codec.height = 240;
     const int time_between_send = TimeBetweenSend(codec);
     EXPECT_TRUE(SetOneCodec(codec));
     EXPECT_TRUE(SetSend(true));
     EXPECT_TRUE(channel_->SetSink(kDefaultReceiveSsrc, &renderer_));
     EXPECT_EQ(0, renderer_.num_rendered_frames());
     EXPECT_TRUE(SendFrame());
     EXPECT_FRAME_WAIT(1, codec.width, codec.height, kTimeout);
     std::unique_ptr<cricket::FakeVideoCapturer> capturer(
-        CreateFakeVideoCapturer());
-    capturer->SetScreencast(true);
+        CreateFakeVideoCapturer(true));
+
+    cricket::VideoOptions video_options;
+    video_options.is_screencast = rtc::Optional<bool>(true);
+    channel_->SetVideoSend(kSsrc, true, &video_options);
+
     cricket::VideoFormat format(480, 360,
                                 cricket::VideoFormat::FpsToInterval(30),
                                 cricket::FOURCC_I420);
     EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(format));
     // All capturers start generating frames with the same timestamp. ViE does
     // not allow the same timestamp to be used. Capture one frame before
     // associating the capturer with the channel.
     EXPECT_TRUE(capturer->CaptureCustomFrame(format.width, format.height,
                                              cricket::FOURCC_I420));
 
@@ skipping 75 matching lines @@
     capture_format.interval = cricket::VideoFormat::FpsToInterval(30);
     // Set up additional stream 1.
     cricket::FakeVideoRenderer renderer1;
     EXPECT_FALSE(channel_->SetSink(1, &renderer1));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(1)));
     EXPECT_TRUE(channel_->SetSink(1, &renderer1));
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(1)));
     std::unique_ptr<cricket::FakeVideoCapturer> capturer1(
-        CreateFakeVideoCapturer());
-    capturer1->SetScreencast(true);
+        CreateFakeVideoCapturer(true));
+
     EXPECT_EQ(cricket::CS_RUNNING, capturer1->Start(capture_format));
     // Set up additional stream 2.
     cricket::FakeVideoRenderer renderer2;
     EXPECT_FALSE(channel_->SetSink(2, &renderer2));
     EXPECT_TRUE(channel_->AddRecvStream(
         cricket::StreamParams::CreateLegacy(2)));
     EXPECT_TRUE(channel_->SetSink(2, &renderer2));
     EXPECT_TRUE(channel_->AddSendStream(
         cricket::StreamParams::CreateLegacy(2)));
     std::unique_ptr<cricket::FakeVideoCapturer> capturer2(
-        CreateFakeVideoCapturer());
-    capturer2->SetScreencast(true);
+        CreateFakeVideoCapturer(true));
     EXPECT_EQ(cricket::CS_RUNNING, capturer2->Start(capture_format));
     // State for all the streams.
     EXPECT_TRUE(SetOneCodec(DefaultCodec()));
     // A limitation in the lmi implementation requires that SetCapturer() is
     // called after SetOneCodec().
     // TODO(hellner): this seems like an unnecessary constraint, fix it.
     EXPECT_TRUE(channel_->SetCapturer(1, capturer1.get()));
     EXPECT_TRUE(channel_->SetCapturer(2, capturer2.get()));
     EXPECT_TRUE(SetSend(true));
     // Test capturer associated with engine.
@@ skipping 34 matching lines @@
     EXPECT_TRUE(channel_->SetSink(kSsrc, &renderer));
     EXPECT_EQ(0, renderer.num_rendered_frames());
 
     EXPECT_TRUE(SendFrame());
     EXPECT_GT_FRAME_ON_RENDERER_WAIT(
         renderer, 1, codec.width, codec.height, kTimeout);
 
     // Registering an external capturer is currently the same as screen casting
     // (update the test when this changes).
     std::unique_ptr<cricket::FakeVideoCapturer> capturer(
-        CreateFakeVideoCapturer());
-    capturer->SetScreencast(true);
+        CreateFakeVideoCapturer(true));
     const std::vector<cricket::VideoFormat>* formats =
         capturer->GetSupportedFormats();
     cricket::VideoFormat capture_format = (*formats)[0];
     EXPECT_EQ(cricket::CS_RUNNING, capturer->Start(capture_format));
     // Capture frame to not get same frame timestamps as previous capturer.
     capturer->CaptureFrame();
     EXPECT_TRUE(channel_->SetCapturer(kSsrc, capturer.get()));
     EXPECT_TRUE(rtc::Thread::Current()->ProcessMessages(30));
     EXPECT_TRUE(capturer->CaptureCustomFrame(kWidth, kHeight,
                                              cricket::FOURCC_ARGB));
@@ skipping 233 matching lines @@
   std::unique_ptr<C> channel_;
   cricket::FakeNetworkInterface network_interface_;
   cricket::FakeVideoRenderer renderer_;
   cricket::VideoMediaChannel::Error media_error_;
 
   // Used by test cases where 2 streams are run on the same channel.
   cricket::FakeVideoRenderer renderer2_;
 };
 
 #endif  // WEBRTC_MEDIA_BASE_VIDEOENGINE_UNITTEST_H_  NOLINT