Refactor audio and video decoder status into common file.

media/filters/android/media_codec_audio_decoder.cc

 // Copyright 2016 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/filters/android/media_codec_audio_decoder.h"
 
 #include "base/android/build_info.h"
 #include "base/bind.h"
 #include "base/callback_helpers.h"
 #include "base/logging.h"
@@ skipping 68 matching lines @@
 MediaCodecAudioDecoder::~MediaCodecAudioDecoder() {
   DVLOG(1) << __FUNCTION__;
 
   media_codec_.reset();
 
   if (media_drm_bridge_cdm_context_) {
     DCHECK(cdm_registration_id_);
     media_drm_bridge_cdm_context_->UnregisterPlayer(cdm_registration_id_);
   }
 
-  ClearInputQueue(kAborted);
+  ClearInputQueue(DecodeStatus::ABORTED);
 }
 
 std::string MediaCodecAudioDecoder::GetDisplayName() const {
   return "MediaCodecAudioDecoder";
 }
 
 void MediaCodecAudioDecoder::Initialize(const AudioDecoderConfig& config,
                                         CdmContext* cdm_context,
                                         const InitCB& init_cb,
                                         const OutputCB& output_cb) {
@@ skipping 41 matching lines @@
   bound_init_cb.Run(true);
 }
 
 void MediaCodecAudioDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
                                     const DecodeCB& decode_cb) {
   DecodeCB bound_decode_cb = BindToCurrentLoop(decode_cb);
 
   if (!buffer->end_of_stream() && buffer->timestamp() == kNoTimestamp()) {
     DVLOG(2) << __FUNCTION__ << " " << buffer->AsHumanReadableString()
              << ": no timestamp, skipping this buffer";
-    bound_decode_cb.Run(kDecodeError);
+    bound_decode_cb.Run(DecodeStatus::DECODE_ERROR);
     return;
   }
 
   if (state_ == STATE_ERROR) {
     // We get here if an error happens in DequeueOutput() or Reset().
     DVLOG(2) << __FUNCTION__ << " " << buffer->AsHumanReadableString()
              << ": Error state, returning decode error for all buffers";
-    ClearInputQueue(kDecodeError);
-    bound_decode_cb.Run(kDecodeError);
+    ClearInputQueue(DecodeStatus::DECODE_ERROR);
+    bound_decode_cb.Run(DecodeStatus::DECODE_ERROR);
     return;
   }
 
   DVLOG(2) << __FUNCTION__ << " " << buffer->AsHumanReadableString();
 
   DCHECK_EQ(state_, STATE_READY) << " unexpected state " << AsString(state_);
 
   // AudioDecoder requires that "Only one decode may be in flight at any given
   // time".
   DCHECK(input_queue_.empty());
 
   input_queue_.push_back(std::make_pair(buffer, bound_decode_cb));
 
   DoIOTask();
 }
 
 void MediaCodecAudioDecoder::Reset(const base::Closure& closure) {
   DVLOG(1) << __FUNCTION__;
 
   io_timer_.Stop();
 
-  ClearInputQueue(kAborted);
+  ClearInputQueue(DecodeStatus::ABORTED);
 
   // Flush if we can, otherwise completely recreate and reconfigure the codec.
   // Prior to JellyBean-MR2, flush() had several bugs (b/8125974, b/8347958) so
   // we have to completely destroy and recreate the codec there.
   bool success = false;
   if (state_ != STATE_ERROR && state_ != STATE_DRAINED &&
       base::android::BuildInfo::GetInstance()->sdk_int() >= 18) {
     // media_codec_->Reset() calls MediaCodec.flush().
     success = (media_codec_->Reset() == MEDIA_CODEC_OK);
   }
@@ skipping 118 matching lines @@
 
   if (state_ == STATE_WAITING_FOR_KEY || state_ == STATE_DRAINING ||
       state_ == STATE_DRAINED)
     return false;
 
   // DequeueInputBuffer() may set STATE_ERROR.
   InputBufferInfo input_info = DequeueInputBuffer();
 
   if (input_info.buf_index == kInvalidBufferIndex) {
     if (state_ == STATE_ERROR)
-      ClearInputQueue(kDecodeError);
+      ClearInputQueue(DecodeStatus::DECODE_ERROR);
 
     return false;
   }
 
   // EnqueueInputBuffer() may set STATE_DRAINING, STATE_WAITING_FOR_KEY or
   // STATE_ERROR.
   bool did_work = EnqueueInputBuffer(input_info);
 
   switch (state_) {
     case STATE_READY: {
       const DecodeCB& decode_cb = input_queue_.front().second;
-      decode_cb.Run(kOk);
+      decode_cb.Run(DecodeStatus::OK);
       input_queue_.pop_front();
     } break;
 
     case STATE_DRAINING:
       // After queueing EOS we need to flush decoder, i.e. receive this EOS at
       // the output, and then call corresponding decoder_cb.
       // Keep the EOS buffer in the input queue.
       break;
 
     case STATE_WAITING_FOR_KEY:
       // Keep trying to enqueue the same input buffer.
       // The buffer is owned by us (not the MediaCodec) and is filled with data.
       break;
 
     case STATE_ERROR:
-      ClearInputQueue(kDecodeError);
+      ClearInputQueue(DecodeStatus::DECODE_ERROR);
       break;
 
     default:
       NOTREACHED() << ": internal error, unexpected state " << AsString(state_);
       SetState(STATE_ERROR);
-      ClearInputQueue(kDecodeError);
+      ClearInputQueue(DecodeStatus::DECODE_ERROR);
       did_work = false;
       break;
   }
 
   return did_work;
 }
 
 MediaCodecAudioDecoder::InputBufferInfo
 MediaCodecAudioDecoder::DequeueInputBuffer() {
   DVLOG(2) << __FUNCTION__;
@@ skipping 95 matching lines @@
       break;
 
     default:
       NOTREACHED() << "Unknown Queue(Secure)InputBuffer status " << status;
       SetState(STATE_ERROR);
       break;
   }
   return did_work;
 }
 
-void MediaCodecAudioDecoder::ClearInputQueue(Status decode_status) {
+void MediaCodecAudioDecoder::ClearInputQueue(DecodeStatus decode_status) {
   DVLOG(2) << __FUNCTION__;
 
   for (const auto& entry : input_queue_)
     entry.second.Run(decode_status);
 
   input_queue_.clear();
 }
 
 bool MediaCodecAudioDecoder::DequeueOutput() {
   DVLOG(2) << __FUNCTION__;
@@ skipping 88 matching lines @@
 
   DCHECK_EQ(state_, STATE_DRAINING);
 
   media_codec_->ReleaseOutputBuffer(out.buf_index, false);
 
   // Report the end of decoding for EOS DecoderBuffer.
   DCHECK(!input_queue_.empty());
   DCHECK(input_queue_.front().first->end_of_stream());
 
   const DecodeCB& decode_cb = input_queue_.front().second;
-  decode_cb.Run(kOk);
+  decode_cb.Run(DecodeStatus::OK);
 
   // Remove the EOS buffer from the input queue.
   input_queue_.pop_front();
 
   // Set state STATE_DRAINED after we have received EOS frame at the output.
   // media_decoder_job.cc says: once output EOS has occurred, we should
   // not be asked to decode again.
   SetState(STATE_DRAINED);
 }
 
@@ skipping 77 matching lines @@
     RETURN_STRING(STATE_DRAINED);
     RETURN_STRING(STATE_ERROR);
   }
   NOTREACHED() << "Unknown state " << state;
   return nullptr;
 }
 
 #undef RETURN_STRING
 
 }  // namespace media