Add WebrtcVideoEncoder interface

remoting/codec/codec_test.cc

 // Copyright (c) 2012 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/codec/codec_test.h"
 
 #include <stddef.h>
 #include <stdint.h>
 #include <stdlib.h>
 
@@ skipping 201 matching lines @@
   }
 
   return frame;
 }
 
 static void TestEncodingRects(VideoEncoder* encoder,
                               VideoEncoderTester* tester,
                               DesktopFrame* frame,
                               const DesktopRegion& region) {
   *frame->mutable_updated_region() = region;
-  tester->DataAvailable(encoder->Encode(*frame, 0));
+  tester->DataAvailable(encoder->Encode(*frame));
 }
 
 void TestVideoEncoder(VideoEncoder* encoder, bool strict) {
   const int kSizes[] = {80, 79, 77, 54};
 
   VideoEncoderTester tester;
 
   for (size_t xi = 0; xi < arraysize(kSizes); ++xi) {
     for (size_t yi = 0; yi < arraysize(kSizes); ++yi) {
       DesktopSize size(kSizes[xi], kSizes[yi]);
@@ skipping 10 matching lines @@
   }
 }
 
 void TestVideoEncoderEmptyFrames(VideoEncoder* encoder,
                                  int max_topoff_frames) {
   const DesktopSize kSize(100, 100);
   std::unique_ptr<DesktopFrame> frame(PrepareFrame(kSize));
 
   frame->mutable_updated_region()->SetRect(
       webrtc::DesktopRect::MakeSize(kSize));
-  EXPECT_TRUE(encoder->Encode(*frame, 0));
+  EXPECT_TRUE(encoder->Encode(*frame));
 
   int topoff_frames = 0;
   frame->mutable_updated_region()->Clear();
   for (int i = 0; i < max_topoff_frames + 1; ++i) {
-    if (!encoder->Encode(*frame, 0))
+    if (!encoder->Encode(*frame))
       break;
     topoff_frames++;
   }
 
   // If top-off is enabled then our random frame contents should always
   // trigger it, so expect at least one top-off frame - strictly, though,
   // an encoder may not always need to top-off.
   EXPECT_GE(topoff_frames, max_topoff_frames ? 1 : 0);
   EXPECT_LE(topoff_frames, max_topoff_frames);
 }
@@ skipping 12 matching lines @@
     const int row_size = DesktopFrame::kBytesPerPixel * i.rect().width();
     uint8_t* memory = frame->data() + frame->stride() * i.rect().top() +
                     DesktopFrame::kBytesPerPixel * i.rect().left();
     for (int y = 0; y < i.rect().height(); ++y) {
       for (int x = 0; x < row_size; ++x)
         memory[x] = rand() % 256;
       memory += frame->stride();
     }
   }
 
-  encoder_tester->DataAvailable(encoder->Encode(*frame, 0));
+  encoder_tester->DataAvailable(encoder->Encode(*frame));
   decoder_tester->VerifyResults();
   decoder_tester->Reset();
 }
 
 void TestVideoEncoderDecoder(VideoEncoder* encoder,
                              VideoDecoder* decoder,
                              bool strict) {
   DesktopSize kSize = DesktopSize(160, 120);
 
   VideoEncoderTester encoder_tester;
@@ skipping 29 matching lines @@
                                      const DesktopSize& screen_size,
                                      double max_error_limit,
                                      double mean_error_limit) {
   std::unique_ptr<BasicDesktopFrame> frame(new BasicDesktopFrame(screen_size));
   FillWithGradient(frame.get());
   frame->mutable_updated_region()->SetRect(DesktopRect::MakeSize(screen_size));
 
   VideoDecoderTester decoder_tester(decoder, screen_size);
   decoder_tester.set_expected_frame(frame.get());
   decoder_tester.AddRegion(frame->updated_region());
-  decoder_tester.ReceivedPacket(encoder->Encode(*frame, 0));
+  decoder_tester.ReceivedPacket(encoder->Encode(*frame));
 
   decoder_tester.VerifyResultsApprox(max_error_limit, mean_error_limit);
 }
 
 }  // namespace remoting