[Cast] Repurpose CastInitializationStatus for variable frame size support.

media/cast/sender/video_encoder_impl_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 "base/bind.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "media/base/video_frame.h"
@@ skipping 12 matching lines @@
  protected:
   VideoEncoderImplTest()
       : testing_clock_(new base::SimpleTestTickClock()),
         task_runner_(new test::FakeSingleThreadTaskRunner(testing_clock_)),
         cast_environment_(new CastEnvironment(
             scoped_ptr<base::TickClock>(testing_clock_).Pass(),
             task_runner_,
             task_runner_,
             task_runner_)),
         video_config_(GetDefaultVideoSenderConfig()),
+        operational_status_(STATUS_UNINITIALIZED),
         count_frames_delivered_(0) {
     testing_clock_->Advance(base::TimeTicks::Now() - base::TimeTicks());
     first_frame_time_ = testing_clock_->NowTicks();
   }
 
   ~VideoEncoderImplTest() override {}
 
   void SetUp() override {
     video_config_.codec = GetParam();
   }
 
   void TearDown() override {
     video_encoder_.reset();
     task_runner_->RunTasks();
   }
 
   void CreateEncoder(bool three_buffer_mode) {
+    ASSERT_EQ(STATUS_UNINITIALIZED, operational_status_);
     video_config_.max_number_of_video_buffers_used =
         (three_buffer_mode ? 3 : 1);
     video_encoder_.reset(new VideoEncoderImpl(
         cast_environment_,
         video_config_,
-        CastInitializationCallback()));
+        base::Bind(&VideoEncoderImplTest::OnOperationalStatusChange,
+                   base::Unretained(this))));
     task_runner_->RunTasks();
+    ASSERT_EQ(STATUS_INITIALIZED, operational_status_);
   }
 
   VideoEncoder* video_encoder() const {
     return video_encoder_.get();
   }
 
   void AdvanceClock() {
     testing_clock_->Advance(base::TimeDelta::FromMilliseconds(33));
   }
 
@@ skipping 29 matching lines @@
       const gfx::Size& size) const {
     const scoped_refptr<media::VideoFrame> frame =
         media::VideoFrame::CreateFrame(
             VideoFrame::I420, size, gfx::Rect(size), size,
             testing_clock_->NowTicks() - first_frame_time_);
     PopulateVideoFrame(frame.get(), 123);
     return frame;
   }
 
  private:
+  void OnOperationalStatusChange(OperationalStatus status) {
+    operational_status_ = status;
+  }
+
   // Checks that |encoded_frame| matches expected values.  This is the method
   // bound in the callback returned from CreateFrameDeliverCallback().
   void DeliverEncodedVideoFrame(
       uint32 expected_frame_id,
       uint32 expected_last_referenced_frame_id,
       uint32 expected_rtp_timestamp,
       const base::TimeTicks& expected_reference_time,
       scoped_ptr<EncodedFrame> encoded_frame) {
     if (expected_frame_id != expected_last_referenced_frame_id) {
       EXPECT_EQ(EncodedFrame::DEPENDENT, encoded_frame->dependency);
     } else if (video_config_.max_number_of_video_buffers_used == 1) {
       EXPECT_EQ(EncodedFrame::KEY, encoded_frame->dependency);
     }
     EXPECT_EQ(expected_frame_id, encoded_frame->frame_id);
     EXPECT_EQ(expected_last_referenced_frame_id,
               encoded_frame->referenced_frame_id)
         << "frame id: " << expected_frame_id;
     EXPECT_EQ(expected_rtp_timestamp, encoded_frame->rtp_timestamp);
     EXPECT_EQ(expected_reference_time, encoded_frame->reference_time);
     EXPECT_FALSE(encoded_frame->data.empty());
     ++count_frames_delivered_;
   }
 
   base::SimpleTestTickClock* const testing_clock_;  // Owned by CastEnvironment.
   const scoped_refptr<test::FakeSingleThreadTaskRunner> task_runner_;
   const scoped_refptr<CastEnvironment> cast_environment_;
   VideoSenderConfig video_config_;
   base::TimeTicks first_frame_time_;
+  OperationalStatus operational_status_;
   scoped_ptr<VideoEncoder> video_encoder_;
 
   int count_frames_delivered_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoEncoderImplTest);
 };
 
 // A simple test to encode ten frames of video, expecting to see one key frame
 // followed by nine delta frames.
 TEST_P(VideoEncoderImplTest, GeneratesKeyFrameThenOnlyDeltaFrames) {
@@ skipping 151 matching lines @@
 
   EXPECT_EQ(static_cast<int>(frame_id), count_frames_delivered());
 }
 
 INSTANTIATE_TEST_CASE_P(,
                         VideoEncoderImplTest,
                         ::testing::Values(CODEC_VIDEO_FAKE, CODEC_VIDEO_VP8));
 
 }  // namespace cast
 }  // namespace media