Refactor audio and video decoder status into common file.

media/filters/fake_video_decoder.cc

 // Copyright 2013 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/fake_video_decoder.h"
 
 #include "base/location.h"
 #include "media/base/bind_to_current_loop.h"
 #include "media/base/test_helpers.h"
 
@@ skipping 75 matching lines @@
             max_parallel_decoding_requests_);
   DCHECK_NE(state_, STATE_END_OF_STREAM);
 
   int buffer_size = buffer->end_of_stream() ? 0 : buffer->data_size();
   DecodeCB wrapped_decode_cb = base::Bind(&FakeVideoDecoder::OnFrameDecoded,
                                           weak_factory_.GetWeakPtr(),
                                           buffer_size,
                                           BindToCurrentLoop(decode_cb));
 
   if (state_ == STATE_ERROR) {
-    wrapped_decode_cb.Run(kDecodeError);
+    wrapped_decode_cb.Run(DecodeStatus::DECODE_ERROR);
     return;
   }
 
   if (buffer->end_of_stream()) {
     state_ = STATE_END_OF_STREAM;
   } else {
     DCHECK(VerifyFakeVideoBufferForTest(buffer, current_config_));
     scoped_refptr<VideoFrame> video_frame = VideoFrame::CreateColorFrame(
         current_config_.coded_size(), 0, 0, 0, buffer->timestamp());
     decoded_frames_.push_back(video_frame);
@@ skipping 66 matching lines @@
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(held_decode_callbacks_.empty());
   reset_cb_.RunHeldCallback();
 }
 
 void FakeVideoDecoder::SimulateError() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   state_ = STATE_ERROR;
   while (!held_decode_callbacks_.empty()) {
-    held_decode_callbacks_.front().Run(kDecodeError);
+    held_decode_callbacks_.front().Run(DecodeStatus::DECODE_ERROR);
     held_decode_callbacks_.pop_front();
   }
   decoded_frames_.clear();
 }
 
 void FakeVideoDecoder::SimulateFailureToInit() {
   fail_to_initialize_ = true;
 }
 
 int FakeVideoDecoder::GetMaxDecodeRequests() const {
   return max_parallel_decoding_requests_;
 }
 
 void FakeVideoDecoder::OnFrameDecoded(int buffer_size,
                                       const DecodeCB& decode_cb,
-                                      Status status) {
+                                      DecodeStatus status) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
-  if (status == kOk) {
+  if (status == DecodeStatus::OK) {
     total_bytes_decoded_ += buffer_size;
     bytes_decoded_cb_.Run(buffer_size);
   }
   decode_cb.Run(status);
 }
 
 void FakeVideoDecoder::RunOrHoldDecode(const DecodeCB& decode_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (hold_decode_) {
     held_decode_callbacks_.push_back(decode_cb);
   } else {
     DCHECK(held_decode_callbacks_.empty());
     RunDecodeCallback(decode_cb);
   }
 }
 
 void FakeVideoDecoder::RunDecodeCallback(const DecodeCB& decode_cb) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (!reset_cb_.IsNull()) {
     DCHECK(decoded_frames_.empty());
-    decode_cb.Run(kAborted);
+    decode_cb.Run(DecodeStatus::ABORTED);
     return;
   }
 
   // Make sure we leave decoding_delay_ frames in the queue and also frames for
   // all pending decode callbacks, except the current one.
   if (decoded_frames_.size() >
       decoding_delay_ + held_decode_callbacks_.size()) {
     output_cb_.Run(decoded_frames_.front());
     decoded_frames_.pop_front();
   } else if (state_ == STATE_END_OF_STREAM) {
     // Drain the queue if this was the last request in the stream, otherwise
     // just pop the last frame from the queue.
     if (held_decode_callbacks_.empty()) {
       while (!decoded_frames_.empty()) {
         output_cb_.Run(decoded_frames_.front());
         decoded_frames_.pop_front();
       }
       state_ = STATE_NORMAL;
     } else if (!decoded_frames_.empty()) {
       output_cb_.Run(decoded_frames_.front());
       decoded_frames_.pop_front();
     }
   }
 
-  decode_cb.Run(kOk);
+  decode_cb.Run(DecodeStatus::OK);
 }
 
 void FakeVideoDecoder::DoReset() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(held_decode_callbacks_.empty());
   DCHECK(!reset_cb_.IsNull());
 
   reset_cb_.RunOrHold();
 }
 
 }  // namespace media