Refactor audio and video decoder status into common file.

media/filters/gpu_video_decoder.cc

 // Copyright (c) 2012 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/gpu_video_decoder.h"
 
 #include <algorithm>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 281 matching lines @@
 void GpuVideoDecoder::Decode(const scoped_refptr<DecoderBuffer>& buffer,
                              const DecodeCB& decode_cb) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DCHECK(pending_reset_cb_.is_null());
 
   DVLOG(3) << __FUNCTION__ << " " << buffer->AsHumanReadableString();
 
   DecodeCB bound_decode_cb = BindToCurrentLoop(decode_cb);
 
   if (state_ == kError || !vda_) {
-    bound_decode_cb.Run(kDecodeError);
+    bound_decode_cb.Run(DecodeStatus::DECODE_ERROR);
     return;
   }
 
   switch (state_) {
     case kDecoderDrained:
       state_ = kNormal;
       // Fall-through.
     case kNormal:
       break;
     case kDrainingDecoder:
     case kError:
       NOTREACHED();
       return;
   }
 
   DCHECK_EQ(state_, kNormal);
 
   if (buffer->end_of_stream()) {
     DVLOG(3) << __FUNCTION__ << " Initiating Flush for EOS.";
     state_ = kDrainingDecoder;
     eos_decode_cb_ = bound_decode_cb;
     vda_->Flush();
     return;
   }
 
   size_t size = buffer->data_size();
   scoped_ptr<SHMBuffer> shm_buffer = GetSHM(size);
   if (!shm_buffer) {
-    bound_decode_cb.Run(kDecodeError);
+    bound_decode_cb.Run(DecodeStatus::DECODE_ERROR);
     return;
   }
 
   memcpy(shm_buffer->shm->memory(), buffer->data(), size);
   // AndroidVideoDecodeAccelerator needs the timestamp to output frames in
   // presentation order.
   BitstreamBuffer bitstream_buffer(next_bitstream_buffer_id_,
                                    shm_buffer->shm->handle(), size, 0,
                                    buffer->timestamp());
 
@@ skipping 282 matching lines @@
 
   std::map<int32_t, PendingDecoderBuffer>::iterator it =
       bitstream_buffers_in_decoder_.find(id);
   if (it == bitstream_buffers_in_decoder_.end()) {
     NotifyError(VideoDecodeAccelerator::PLATFORM_FAILURE);
     NOTREACHED() << "Missing bitstream buffer: " << id;
     return;
   }
 
   PutSHM(make_scoped_ptr(it->second.shm_buffer));
-  it->second.done_cb.Run(state_ == kError ? kDecodeError : kOk);
+  it->second.done_cb.Run(state_ == kError ? DecodeStatus::DECODE_ERROR
+                                          : DecodeStatus::OK);
   bitstream_buffers_in_decoder_.erase(it);
 }
 
 GpuVideoDecoder::~GpuVideoDecoder() {
   DVLOG(3) << __FUNCTION__;
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
 
   if (vda_)
     DestroyVDA();
   DCHECK(assigned_picture_buffers_.empty());
 
   if (!init_cb_.is_null())
     base::ResetAndReturn(&init_cb_).Run(false);
   if (!request_surface_cb_.is_null())
     base::ResetAndReturn(&request_surface_cb_).Run(SurfaceCreatedCB());
 
   for (size_t i = 0; i < available_shm_segments_.size(); ++i) {
     delete available_shm_segments_[i];
   }
   available_shm_segments_.clear();
 
   for (std::map<int32_t, PendingDecoderBuffer>::iterator it =
            bitstream_buffers_in_decoder_.begin();
        it != bitstream_buffers_in_decoder_.end(); ++it) {
     delete it->second.shm_buffer;
-    it->second.done_cb.Run(kAborted);
+    it->second.done_cb.Run(DecodeStatus::ABORTED);
   }
   bitstream_buffers_in_decoder_.clear();
 
   if (!pending_reset_cb_.is_null())
     base::ResetAndReturn(&pending_reset_cb_).Run();
 }
 
 void GpuVideoDecoder::NotifyFlushDone() {
   DVLOG(3) << "NotifyFlushDone()";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DCHECK_EQ(state_, kDrainingDecoder);
   state_ = kDecoderDrained;
-  base::ResetAndReturn(&eos_decode_cb_).Run(kOk);
+  base::ResetAndReturn(&eos_decode_cb_).Run(DecodeStatus::OK);
 }
 
 void GpuVideoDecoder::NotifyResetDone() {
   DVLOG(3) << "NotifyResetDone()";
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   DCHECK(bitstream_buffers_in_decoder_.empty());
 
   // This needs to happen after the Reset() on vda_ is done to ensure pictures
   // delivered during the reset can find their time data.
   input_buffer_data_.clear();
 
   if (!pending_reset_cb_.is_null())
     base::ResetAndReturn(&pending_reset_cb_).Run();
 }
 
 void GpuVideoDecoder::NotifyError(media::VideoDecodeAccelerator::Error error) {
   DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent();
   if (!vda_)
     return;
 
   state_ = kError;
 
   // If we have any bitstream buffers, then notify one that an error has
   // occurred.  This guarantees that somebody finds out about the error.  If
   // we don't do this, and if the max decodes are already in flight, then there
   // won't be another decode request to report the error.
   if (!bitstream_buffers_in_decoder_.empty()) {
     auto it = bitstream_buffers_in_decoder_.begin();
-    it->second.done_cb.Run(kDecodeError);
+    it->second.done_cb.Run(DecodeStatus::DECODE_ERROR);
     bitstream_buffers_in_decoder_.erase(it);
   }
 
   DLOG(ERROR) << "VDA Error: " << error;
   UMA_HISTOGRAM_ENUMERATION("Media.GpuVideoDecoderError", error,
                             media::VideoDecodeAccelerator::ERROR_MAX + 1);
 
   DestroyVDA();
 }
 
@@ skipping 15 matching lines @@
   }
   return false;
 }
 
 void GpuVideoDecoder::DCheckGpuVideoAcceleratorFactoriesTaskRunnerIsCurrent()
     const {
   DCHECK(factories_->GetTaskRunner()->BelongsToCurrentThread());
 }
 
 }  // namespace media