Interface with webrtc through encoded frames

remoting/test/test_video_renderer_unittest.cc

 // Copyright 2015 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 "remoting/test/test_video_renderer.h"
 
 #include <stdint.h>
 
 #include <cmath>
 #include <utility>
@@ skipping 122 matching lines @@
                                                       int screen_height,
                                                       double error_limit) {
   DCHECK(encoder_);
   DCHECK(test_video_renderer_);
 
   // Generate a frame containing a gradient.
   std::unique_ptr<webrtc::DesktopFrame> original_frame =
       CreateDesktopFrameWithGradient(screen_width, screen_height);
   EXPECT_TRUE(original_frame);
 
-  std::unique_ptr<VideoPacket> packet = encoder_->Encode(*original_frame.get());
+  std::unique_ptr<VideoPacket> packet =
+      encoder_->Encode(*original_frame.get(), 0);
 
   DCHECK(!run_loop_ || !run_loop_->running());
   DCHECK(!timer_->IsRunning());
   run_loop_.reset(new base::RunLoop());
 
   // Set an extremely long time: 10 min to prevent bugs from hanging the system.
   // NOTE: We've seen cases which take up to 1 min to process a packet, so an
   // extremely long time as 10 min is chosen to avoid being variable/flaky.
   timer_->Start(FROM_HERE, base::TimeDelta::FromMinutes(10),
                 run_loop_->QuitClosure());
@@ skipping 71 matching lines @@
     int screen_height,
     const webrtc::DesktopRect& expected_rect,
     bool expect_to_match) {
   DCHECK(encoder_);
   DCHECK(test_video_renderer_);
 
   std::unique_ptr<webrtc::DesktopFrame> frame =
       CreateDesktopFrameWithGradient(screen_width, screen_height);
   RGBValue expected_average_color =
       CalculateAverageColorValueForFrame(frame.get(), expected_rect);
-  std::unique_ptr<VideoPacket> packet = encoder_->Encode(*frame.get());
+  std::unique_ptr<VideoPacket> packet = encoder_->Encode(*frame.get(), 0);
 
   if (expect_to_match) {
     EXPECT_TRUE(SendPacketAndWaitForMatch(std::move(packet), expected_rect,
                                           expected_average_color));
   } else {
     // Shift each channel by 128.
     // e.g. (10, 127, 200) -> (138, 255, 73).
     // In this way, the error between expected color and true value is always
     // around 0.5.
     int red_shift = (expected_average_color.red + 128) % 255;
@@ skipping 151 matching lines @@
   // Post multiple tasks to |test_video_renderer_|, and it should not crash.
   // 20 is chosen because it's large enough to make sure that there will be
   // more than one task on the video decode thread, while not too large to wait
   // for too long for the unit test to complete.
   const int task_num = 20;
   ScopedVector<VideoPacket> video_packets;
   for (int i = 0; i < task_num; ++i) {
     std::unique_ptr<webrtc::DesktopFrame> original_frame =
         CreateDesktopFrameWithGradient(kDefaultScreenWidthPx,
                                        kDefaultScreenHeightPx);
-    video_packets.push_back(encoder_->Encode(*original_frame.get()));
+    video_packets.push_back(encoder_->Encode(*original_frame.get(), 0));
   }
 
   for (int i = 0; i < task_num; ++i) {
     // Transfer ownership of video packet.
     VideoPacket* packet = video_packets[i];
     video_packets[i] = nullptr;
     test_video_renderer_->ProcessVideoPacket(base::WrapUnique(packet),
                                              base::Bind(&base::DoNothing));
   }
 }
@@ skipping 28 matching lines @@
 
   // Since we don't care whether expected image pattern is matched or not in
   // this case, an expected color is chosen arbitrarily.
   RGBValue black_color = RGBValue();
 
   // Set expected image pattern.
   test_video_renderer_->ExpectAverageColorInRect(
       kDefaultExpectedRect, black_color, base::Bind(&base::DoNothing));
 
   // Post test video packet.
-  test_video_renderer_->ProcessVideoPacket(encoder_->Encode(*frame.get()),
+  test_video_renderer_->ProcessVideoPacket(encoder_->Encode(*frame.get(), 0),
                                            base::Bind(&base::DoNothing));
 }
 
 // Verify correct image pattern can be matched for VP8.
 TEST_F(TestVideoRendererTest, VerifyImagePatternMatchForVP8) {
   encoder_ = VideoEncoderVpx::CreateForVP8();
   test_video_renderer_->SetCodecForDecoding(
       protocol::ChannelConfig::Codec::CODEC_VP8);
   TestImagePatternMatch(kDefaultScreenWidthPx, kDefaultScreenHeightPx,
                         kDefaultExpectedRect, true);
@@ skipping 39 matching lines @@
 TEST_F(TestVideoRendererTest, VerifyImagePatternNotMatchForVERBATIM) {
   encoder_.reset(new VideoEncoderVerbatim());
   test_video_renderer_->SetCodecForDecoding(
       protocol::ChannelConfig::Codec::CODEC_VERBATIM);
   TestImagePatternMatch(kDefaultScreenWidthPx, kDefaultScreenHeightPx,
                         kDefaultExpectedRect, false);
 }
 
 }  // namespace test
 }  // namespace remoting