[Cast] Repurpose CastInitializationStatus for variable frame size support.

media/cast/receiver/video_decoder.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 "media/cast/receiver/video_decoder.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/json/json_reader.h"
 #include "base/location.h"
@@ skipping 15 matching lines @@
 // Base class that handles the common problem of detecting dropped frames, and
 // then invoking the Decode() method implemented by the subclasses to convert
 // the encoded payload data into a usable video frame.
 class VideoDecoder::ImplBase
     : public base::RefCountedThreadSafe<VideoDecoder::ImplBase> {
  public:
   ImplBase(const scoped_refptr<CastEnvironment>& cast_environment,
            Codec codec)
       : cast_environment_(cast_environment),
         codec_(codec),
-        cast_initialization_status_(STATUS_VIDEO_UNINITIALIZED),
+        operational_status_(STATUS_UNINITIALIZED),
         seen_first_frame_(false) {}
 
-  CastInitializationStatus InitializationResult() const {
-    return cast_initialization_status_;
+  OperationalStatus InitializationResult() const {
+    return operational_status_;
   }
 
   void DecodeFrame(scoped_ptr<EncodedFrame> encoded_frame,
                    const DecodeFrameCallback& callback) {
-    DCHECK_EQ(cast_initialization_status_, STATUS_VIDEO_INITIALIZED);
+    DCHECK_EQ(operational_status_, STATUS_INITIALIZED);
 
     static_assert(sizeof(encoded_frame->frame_id) == sizeof(last_frame_id_),
                   "size of frame_id types do not match");
     bool is_continuous = true;
     if (seen_first_frame_) {
       const uint32 frames_ahead = encoded_frame->frame_id - last_frame_id_;
       if (frames_ahead > 1) {
         RecoverBecauseFramesWereDropped();
         is_continuous = false;
       }
@@ skipping 16 matching lines @@
   virtual ~ImplBase() {}
 
   virtual void RecoverBecauseFramesWereDropped() {}
 
   // Note: Implementation of Decode() is allowed to mutate |data|.
   virtual scoped_refptr<VideoFrame> Decode(uint8* data, int len) = 0;
 
   const scoped_refptr<CastEnvironment> cast_environment_;
   const Codec codec_;
 
-  // Subclass' ctor is expected to set this to STATUS_VIDEO_INITIALIZED.
-  CastInitializationStatus cast_initialization_status_;
+  // Subclass' ctor is expected to set this to STATUS_INITIALIZED.
+  OperationalStatus operational_status_;
 
  private:
   bool seen_first_frame_;
   uint32 last_frame_id_;
 
   DISALLOW_COPY_AND_ASSIGN(ImplBase);
 };
 
 class VideoDecoder::Vp8Impl : public VideoDecoder::ImplBase {
  public:
   explicit Vp8Impl(const scoped_refptr<CastEnvironment>& cast_environment)
       : ImplBase(cast_environment, CODEC_VIDEO_VP8) {
-    if (ImplBase::cast_initialization_status_ != STATUS_VIDEO_UNINITIALIZED)
+    if (ImplBase::operational_status_ != STATUS_UNINITIALIZED)
       return;
 
     vpx_codec_dec_cfg_t cfg = {0};
     // TODO(miu): Revisit this for typical multi-core desktop use case.  This
     // feels like it should be 4 or 8.
     cfg.threads = 1;
 
     DCHECK(vpx_codec_get_caps(vpx_codec_vp8_dx()) & VPX_CODEC_CAP_POSTPROC);
     if (vpx_codec_dec_init(&context_,
                            vpx_codec_vp8_dx(),
                            &cfg,
                            VPX_CODEC_USE_POSTPROC) != VPX_CODEC_OK) {
-      ImplBase::cast_initialization_status_ =
-          STATUS_INVALID_VIDEO_CONFIGURATION;
+      ImplBase::operational_status_ = STATUS_INVALID_CONFIGURATION;
       return;
     }
-    ImplBase::cast_initialization_status_ = STATUS_VIDEO_INITIALIZED;
+    ImplBase::operational_status_ = STATUS_INITIALIZED;
   }
 
  private:
   ~Vp8Impl() override {
-    if (ImplBase::cast_initialization_status_ == STATUS_VIDEO_INITIALIZED)
+    if (ImplBase::operational_status_ == STATUS_INITIALIZED)
       CHECK_EQ(VPX_CODEC_OK, vpx_codec_destroy(&context_));
   }
 
   scoped_refptr<VideoFrame> Decode(uint8* data, int len) override {
     if (len <= 0 || vpx_codec_decode(&context_,
                                      data,
                                      static_cast<unsigned int>(len),
                                      NULL,
                                      0) != VPX_CODEC_OK) {
       return NULL;
@@ skipping 39 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Vp8Impl);
 };
 
 #ifndef OFFICIAL_BUILD
 // A fake video decoder that always output 2x2 black frames.
 class VideoDecoder::FakeImpl : public VideoDecoder::ImplBase {
  public:
   explicit FakeImpl(const scoped_refptr<CastEnvironment>& cast_environment)
       : ImplBase(cast_environment, CODEC_VIDEO_FAKE),
         last_decoded_id_(-1) {
-    if (ImplBase::cast_initialization_status_ != STATUS_VIDEO_UNINITIALIZED)
+    if (ImplBase::operational_status_ != STATUS_UNINITIALIZED)
       return;
-    ImplBase::cast_initialization_status_ = STATUS_VIDEO_INITIALIZED;
+    ImplBase::operational_status_ = STATUS_INITIALIZED;
   }
 
  private:
   ~FakeImpl() override {}
 
   scoped_refptr<VideoFrame> Decode(uint8* data, int len) override {
     // Make sure this is a JSON string.
     if (!len || data[0] != '{')
       return NULL;
     base::JSONReader reader;
@@ skipping 39 matching lines @@
       NOTIMPLEMENTED();
       break;
     default:
       NOTREACHED() << "Unknown or unspecified codec.";
       break;
   }
 }
 
 VideoDecoder::~VideoDecoder() {}
 
-CastInitializationStatus VideoDecoder::InitializationResult() const {
+OperationalStatus VideoDecoder::InitializationResult() const {
   if (impl_.get())
     return impl_->InitializationResult();
-  return STATUS_UNSUPPORTED_VIDEO_CODEC;
+  return STATUS_UNSUPPORTED_CODEC;
 }
 
 void VideoDecoder::DecodeFrame(
     scoped_ptr<EncodedFrame> encoded_frame,
     const DecodeFrameCallback& callback) {
   DCHECK(encoded_frame.get());
   DCHECK(!callback.is_null());
-  if (!impl_.get() ||
-      impl_->InitializationResult() != STATUS_VIDEO_INITIALIZED) {
+  if (!impl_.get() || impl_->InitializationResult() != STATUS_INITIALIZED) {
     callback.Run(make_scoped_refptr<VideoFrame>(NULL), false);
     return;
   }
   cast_environment_->PostTask(CastEnvironment::VIDEO,
                               FROM_HERE,
                               base::Bind(&VideoDecoder::ImplBase::DecodeFrame,
                                          impl_,
                                          base::Passed(&encoded_frame),
                                          callback));
 }
 
 }  // namespace cast
 }  // namespace media