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

media/cast/sender/h264_vt_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 <queue>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/test/launcher/unit_test_launcher.h"
@@ skipping 174 matching lines @@
   CVPixelBufferLockBaseAddress(cv_pixel_buffer, 0);
   auto ptr = CVPixelBufferGetBaseAddressOfPlane(cv_pixel_buffer, 0);
   ASSERT_TRUE(ptr);
   memset(ptr, 0xfe, CVPixelBufferGetBytesPerRowOfPlane(cv_pixel_buffer, 0) *
                         CVPixelBufferGetHeightOfPlane(cv_pixel_buffer, 0));
   CVPixelBufferUnlockBaseAddress(cv_pixel_buffer, 0);
 }
 
 class H264VideoToolboxEncoderTest : public ::testing::Test {
  protected:
-  H264VideoToolboxEncoderTest()
-      : operational_status_(STATUS_UNINITIALIZED) {
+  H264VideoToolboxEncoderTest() : operational_status_(STATUS_UNINITIALIZED) {
     frame_->set_timestamp(base::TimeDelta());
   }
 
   void SetUp() override {
     clock_ = new base::SimpleTestTickClock();
     clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
 
     cast_environment_ = new CastEnvironment(
         scoped_ptr<base::TickClock>(clock_).Pass(),
         message_loop_.message_loop_proxy(), message_loop_.message_loop_proxy(),
         message_loop_.message_loop_proxy());
     encoder_.reset(new H264VideoToolboxEncoder(
-        cast_environment_,
-        video_sender_config_,
-        gfx::Size(kVideoWidth, kVideoHeight),
-        0u,
+        cast_environment_, video_sender_config_,
         base::Bind(&SaveOperationalStatus, &operational_status_)));
     message_loop_.RunUntilIdle();
     EXPECT_EQ(STATUS_INITIALIZED, operational_status_);
   }
 
   void TearDown() override {
     encoder_.reset();
     message_loop_.RunUntilIdle();
   }
 
@@ skipping 30 matching lines @@
 
 // static
 scoped_refptr<media::VideoFrame> H264VideoToolboxEncoderTest::frame_;
 VideoSenderConfig H264VideoToolboxEncoderTest::video_sender_config_;
 
 TEST_F(H264VideoToolboxEncoderTest, CheckFrameMetadataSequence) {
   scoped_refptr<MetadataRecorder> metadata_recorder(new MetadataRecorder());
   VideoEncoder::FrameEncodedCallback cb = base::Bind(
       &MetadataRecorder::CompareFrameWithExpected, metadata_recorder.get());
 
+  // The first call to |EncodeVideoFrame| will return null but post a task to
+  // the encoder to initialize for the specified frame size. We then drain the
+  // message loop. After that, the encoder should have initialized.
+  ASSERT_FALSE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
+  message_loop_.RunUntilIdle();
+
   metadata_recorder->PushExpectation(
       0, 0, TimeDeltaToRtpDelta(frame_->timestamp(), kVideoFrequency),
       clock_->NowTicks());
   EXPECT_TRUE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
   message_loop_.RunUntilIdle();
 
   for (uint32 frame_id = 1; frame_id < 10; ++frame_id) {
     AdvanceClockAndVideoFrameTimestamp();
     metadata_recorder->PushExpectation(
         frame_id, frame_id - 1,
         TimeDeltaToRtpDelta(frame_->timestamp(), kVideoFrequency),
         clock_->NowTicks());
     EXPECT_TRUE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
   }
 
   encoder_.reset();
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(10, metadata_recorder->count_frames_delivered());
 }
 
 #if defined(USE_PROPRIETARY_CODECS)
 TEST_F(H264VideoToolboxEncoderTest, CheckFramesAreDecodable) {
   VideoDecoderConfig config(kCodecH264, H264PROFILE_MAIN, frame_->format(),
                             frame_->coded_size(), frame_->visible_rect(),
                             frame_->natural_size(), nullptr, 0, false);
   scoped_refptr<EndToEndFrameChecker> checker(new EndToEndFrameChecker(config));
-
   VideoEncoder::FrameEncodedCallback cb =
       base::Bind(&EndToEndFrameChecker::EncodeDone, checker.get());
+
+  // The first call to |EncodeVideoFrame| will return null but post a task to
+  // the encoder to initialize for the specified frame size. We then drain the
+  // message loop. After that, the encoder should have initialized.
+  ASSERT_FALSE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
+  message_loop_.RunUntilIdle();
+
   for (uint32 frame_id = 0; frame_id < 6; ++frame_id) {
     checker->PushExpectation(frame_);
     EXPECT_TRUE(encoder_->EncodeVideoFrame(frame_, clock_->NowTicks(), cb));
     AdvanceClockAndVideoFrameTimestamp();
   }
 
   encoder_.reset();
   message_loop_.RunUntilIdle();
 
   EXPECT_EQ(5, checker->count_frames_checked());
 }
 #endif
 
 TEST_F(H264VideoToolboxEncoderTest, CheckVideoFrameFactory) {
   auto video_frame_factory = encoder_->CreateVideoFrameFactory();
   ASSERT_TRUE(video_frame_factory.get());
-  CreateFrameAndMemsetPlane(video_frame_factory.get());
-  // TODO(jfroy): Need to test that the encoder can encode VideoFrames provided
-  // by the VideoFrameFactory.
-  encoder_.reset();
+  // The first call to |MaybeCreateFrame| will return null but post a task to
+  // the encoder to initialize for the specified frame size. We then drain the
+  // message loop. After that, the encoder should have initialized and we
+  // request a frame again.
+  ASSERT_FALSE(video_frame_factory->MaybeCreateFrame(
+      gfx::Size(kVideoWidth, kVideoHeight), base::TimeDelta()));
   message_loop_.RunUntilIdle();
   CreateFrameAndMemsetPlane(video_frame_factory.get());
 }
 
 }  // namespace cast
 }  // namespace media