[Cast] Repurpose CastInitializationStatus for variable frame size support.

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 49 matching lines @@
 namespace media {
 namespace cast {
 
 // See comment in end2end_unittest.cc for details on this value.
 const double kVideoAcceptedPSNR = 38.0;
 
 void SavePipelineStatus(PipelineStatus* out_status, PipelineStatus in_status) {
   *out_status = in_status;
 }
 
-void SaveInitializationStatus(CastInitializationStatus* out_status,
-                              CastInitializationStatus in_status) {
+void SaveOperationalStatus(OperationalStatus* out_status,
+                           OperationalStatus in_status) {
   *out_status = in_status;
 }
 
 class MetadataRecorder : public base::RefCountedThreadSafe<MetadataRecorder> {
  public:
   MetadataRecorder() : count_frames_delivered_(0) {}
 
   int count_frames_delivered() const { return count_frames_delivered_; }
 
   void PushExpectation(uint32 expected_frame_id,
@@ skipping 101 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() {
-    cast_initialization_status_ = STATUS_VIDEO_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),
-        base::Bind(&SaveInitializationStatus, &cast_initialization_status_)));
+        base::Bind(&SaveOperationalStatus, &operational_status_)));
     message_loop_.RunUntilIdle();
-    EXPECT_EQ(STATUS_VIDEO_INITIALIZED, cast_initialization_status_);
+    EXPECT_EQ(STATUS_INITIALIZED, operational_status_);
   }
 
   void TearDown() override {
     encoder_.reset();
     message_loop_.RunUntilIdle();
   }
 
   void AdvanceClockAndVideoFrameTimestamp() {
     clock_->Advance(base::TimeDelta::FromMilliseconds(33));
     frame_->set_timestamp(frame_->timestamp() +
@@ skipping 12 matching lines @@
 
   static void TearDownTestCase() { frame_ = nullptr; }
 
   static scoped_refptr<media::VideoFrame> frame_;
   static VideoSenderConfig video_sender_config_;
 
   base::SimpleTestTickClock* clock_;  // Owned by CastEnvironment.
   base::MessageLoop message_loop_;
   scoped_refptr<CastEnvironment> cast_environment_;
   scoped_ptr<VideoEncoder> encoder_;
-  CastInitializationStatus cast_initialization_status_;
+  OperationalStatus operational_status_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(H264VideoToolboxEncoderTest);
 };
 
 // static
 scoped_refptr<media::VideoFrame> H264VideoToolboxEncoderTest::frame_;
 VideoSenderConfig H264VideoToolboxEncoderTest::video_sender_config_;
 
 TEST_F(H264VideoToolboxEncoderTest, CheckFrameMetadataSequence) {
@@ skipping 48 matching lines @@
   auto video_frame_factory = encoder_->CreateVideoFrameFactory();
   ASSERT_TRUE(video_frame_factory.get());
   CreateFrameAndMemsetPlane(video_frame_factory.get());
   encoder_.reset();
   message_loop_.RunUntilIdle();
   CreateFrameAndMemsetPlane(video_frame_factory.get());
 }
 
 }  // namespace cast
 }  // namespace media