[cast] Handle frame size changes directly in the VideoToolbox encoder (v2).

media/cast/sender/video_encoder_unittest.cc

 // Copyright 2014 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 <vector>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 83 matching lines @@
          H264VideoToolboxEncoder::IsSupported(video_config_)) ||
 #endif
         false;
   }
 
   bool is_testing_platform_encoder() const {
     return video_config_.use_external_encoder ||
         is_testing_video_toolbox_encoder();
   }
 
+  bool encoder_has_resize_delay() const {
+    return is_testing_platform_encoder() && !is_testing_video_toolbox_encoder();
+  }
+
   VideoEncoder* video_encoder() const {
     return video_encoder_.get();
   }
 
   void DestroyEncoder() {
     video_encoder_.reset();
   }
 
   base::TimeTicks Now() const {
     return testing_clock_->NowTicks();
@@ skipping 161 matching lines @@
   CreateEncoder(false);
   SetVEAFactoryAutoRespond(true);
 
   EXPECT_EQ(0, count_frames_delivered());
   ExpectVEAResponsesForExternalVideoEncoder(0, 0);
 
   uint32 frame_id = 0;
   uint32 reference_frame_id = 0;
   const gfx::Size frame_size(1280, 720);
 
-  // For the platform encoders, the first one or more frames is dropped while
-  // the encoder initializes.  Then, for all encoders, expect one key frame is
-  // delivered.
+  // Some encoders drop one or more frames initially while the encoder
+  // initializes. Then, for all encoders, expect one key frame is delivered.
   bool accepted_first_frame = false;
   do {
     accepted_first_frame = EncodeAndCheckDelivery(
         CreateTestVideoFrame(frame_size), frame_id, reference_frame_id);
-    if (!is_testing_platform_encoder())
+    if (!encoder_has_resize_delay())
       EXPECT_TRUE(accepted_first_frame);
     RunTasksAndAdvanceClock();
   } while (!accepted_first_frame);
   ExpectVEAResponsesForExternalVideoEncoder(1, 3);
 
   // Expect the remaining frames are encoded as delta frames.
   for (++frame_id; frame_id < 10; ++frame_id, ++reference_frame_id) {
     EXPECT_TRUE(EncodeAndCheckDelivery(CreateTestVideoFrame(frame_size),
                                        frame_id,
                                        reference_frame_id));
@@ skipping 55 matching lines @@
   frame_sizes.push_back(gfx::Size(600, 400));  // Grow both dimensions.
   frame_sizes.push_back(gfx::Size(638, 400));  // Shrink only one dimension.
   frame_sizes.push_back(gfx::Size(638, 398));  // Shrink the other dimension.
   frame_sizes.push_back(gfx::Size(320, 180));  // Shrink both dimensions again.
   frame_sizes.push_back(gfx::Size(322, 180));  // Grow only one dimension.
   frame_sizes.push_back(gfx::Size(322, 182));  // Grow the other dimension.
   frame_sizes.push_back(gfx::Size(1920, 1080));  // Grow both dimensions again.
 
   uint32 frame_id = 0;
 
-  // Encode one frame at each size.  For the platform encoders, expect no frames
-  // to be delivered since each frame size change will sprun re-initialization
-  // of the underlying encoder.  Otherwise, expect all key frames to come out.
+  // Encode one frame at each size. For encoders with a resize delay, except no
+  // frames to be delivered since each frame size change will sprun
+  // re-initialization of the underlying encoder. Otherwise expect all key
+  // frames to come out.
   for (const auto& frame_size : frame_sizes) {
-    EXPECT_EQ(!is_testing_platform_encoder(),
-              EncodeAndCheckDelivery(CreateTestVideoFrame(frame_size),
-                                     frame_id,
+    EXPECT_EQ(!encoder_has_resize_delay(),
+              EncodeAndCheckDelivery(CreateTestVideoFrame(frame_size), frame_id,
                                      frame_id));
     RunTasksAndAdvanceClock();
-    if (!is_testing_platform_encoder())
+    if (!encoder_has_resize_delay())
       ++frame_id;
   }
 
-  // Encode 10+ frames at each size.  For the platform decoders, expect the
-  // first one or more frames are dropped while the encoder re-inits.  Then, for
-  // all encoders, expect one key frame followed by all delta frames.
+  // Encode 10+ frames at each size. For encoders with a resize delay, expect
+  // the first one or more frames are dropped while the encoder re-inits. Then,
+  // for all encoders, expect one key frame followed by all delta frames.
   for (const auto& frame_size : frame_sizes) {
     bool accepted_first_frame = false;
     do {
       accepted_first_frame = EncodeAndCheckDelivery(
           CreateTestVideoFrame(frame_size), frame_id, frame_id);
-      if (!is_testing_platform_encoder())
+      if (!encoder_has_resize_delay())
         EXPECT_TRUE(accepted_first_frame);
       RunTasksAndAdvanceClock();
     } while (!accepted_first_frame);
     ++frame_id;
     for (int i = 1; i < 10; ++i, ++frame_id) {
       EXPECT_TRUE(EncodeAndCheckDelivery(CreateTestVideoFrame(frame_size),
                                          frame_id,
                                          frame_id - 1));
       RunTasksAndAdvanceClock();
     }
@@ skipping 45 matching lines @@
 #endif
   return values;
 }
 }  // namespace
 
 INSTANTIATE_TEST_CASE_P(
     , VideoEncoderTest, ::testing::ValuesIn(DetermineEncodersToTest()));
 
 }  // namespace cast
 }  // namespace media