Update VideoFramePump to pass un-changed frames to encoders.

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 <deque>
 #include <stdlib.h>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 229 matching lines @@
   int memory_size = size.width() * size.height() * kBytesPerPixel;
   for (int i = 0; i < memory_size; ++i) {
     frame->data()[i] = rand() % 256;
   }
 
   return frame.Pass();
 }
 
 static void TestEncodingRects(VideoEncoder* encoder,
                               VideoEncoderTester* tester,
-                              webrtc::DesktopFrame* frame,
+                              DesktopFrame* frame,
                               const DesktopRect* rects,
                               int count) {
   frame->mutable_updated_region()->Clear();
   for (int i = 0; i < count; ++i) {
     frame->mutable_updated_region()->AddRect(rects[i]);
   }
 
   scoped_ptr<VideoPacket> packet = encoder->Encode(*frame);
   tester->DataAvailable(packet.Pass());
 }
 
 void TestVideoEncoder(VideoEncoder* encoder, bool strict) {
   const int kSizes[] = {320, 319, 317, 150};
 
   VideoEncoderTester tester;
 
   for (size_t xi = 0; xi < arraysize(kSizes); ++xi) {
     for (size_t yi = 0; yi < arraysize(kSizes); ++yi) {
       DesktopSize size = DesktopSize(kSizes[xi], kSizes[yi]);
-      scoped_ptr<webrtc::DesktopFrame> frame = PrepareFrame(size);
+      scoped_ptr<DesktopFrame> frame = PrepareFrame(size);
       std::vector<std::vector<DesktopRect> > test_rect_lists =
           MakeTestRectLists(size);
       for (size_t i = 0; i < test_rect_lists.size(); ++i) {
         const std::vector<DesktopRect>& test_rects = test_rect_lists[i];
         TestEncodingRects(encoder, &tester, frame.get(),
                           &test_rects[0], test_rects.size());
       }
+
+      // Pass some empty frames through the encoder.
+      for (int i = 0; i < 10; ++i) {
+        TestEncodingRects(encoder, &tester, frame.get(), nullptr, 0);
+      }
     }
   }
 }
 
+void TestVideoEncoderEmptyFrames(VideoEncoder* encoder, int max_topoff_frames) {
+  const DesktopSize kSize(640, 480);
+  scoped_ptr<DesktopFrame> frame(PrepareFrame(kSize));
+  frame->mutable_updated_region()->SetRect(
+      webrtc::DesktopRect::MakeSize(kSize));
+  EXPECT_TRUE(encoder->Encode(*frame));
+
+  frame->mutable_updated_region()->Clear();
+  int topoff_frame_count = 0;
+  do {

[Sergey Ulanov, 2015/06/09 05:32:43]

nit: this can be a simpler for loop:
  for (int i = 0; i < max_topoff_frames; ++i) {
    ASSERT(encoder->Encode(*frame) != nullptr);
  }
  ASSERT(encoder->Encode(*frame) == nullptr);
 

[Wez, 2015/06/09 22:00:37]

That implementation would enforce that there are exactly |max_topoff_frames|
top-off frames, though - this implementation is supposed to allow up to
|max_topoff_frames|. I'll change it to test for an exact number of top-off
frames, though.

+    bool topped_off = encoder->Encode(*frame) != nullptr;
+    if (!topped_off)
+      break;
+    topoff_frame_count++;
+  } while (topoff_frame_count <= max_topoff_frames);
+  EXPECT_LE(topoff_frame_count, max_topoff_frames);
+}
+
 static void TestEncodeDecodeRects(VideoEncoder* encoder,
                                   VideoEncoderTester* encoder_tester,
                                   VideoDecoderTester* decoder_tester,
                                   DesktopFrame* frame,
                                   const DesktopRect* rects, int count) {
   frame->mutable_updated_region()->Clear();
   for (int i = 0; i < count; ++i) {
     frame->mutable_updated_region()->AddRect(rects[i]);
   }
   decoder_tester->AddRects(rects, count);
@@ skipping 129 matching lines @@
 
     if (frame_count >= kWarmUpFrameCount) {
       elapsed = base::TimeTicks::Now() - start_time;
     }
   }
 
   return (frame_count * base::TimeDelta::FromSeconds(1)) / elapsed;
 }
 
 }  // namespace remoting