Refactor audio and video decoder status into common file.

content/renderer/pepper/video_decoder_shim.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 "content/renderer/pepper/video_decoder_shim.h"
 
 #include <GLES2/gl2.h>
 #include <GLES2/gl2ext.h>
 #include <GLES2/gl2extchromium.h>
 #include <utility>
@@ skipping 632 matching lines @@
   ~DecoderImpl();
 
   void Initialize(media::VideoDecoderConfig config);
   void Decode(uint32_t decode_id, scoped_refptr<media::DecoderBuffer> buffer);
   void Reset();
   void Stop();
 
  private:
   void OnInitDone(bool success);
   void DoDecode();
-  void OnDecodeComplete(media::VideoDecoder::Status status);
+  void OnDecodeComplete(media::DecodeStatus status);
   void OnOutputComplete(const scoped_refptr<media::VideoFrame>& frame);
   void OnResetComplete();
 
   // WeakPtr is bound to main_message_loop_. Use only in shim callbacks.
   base::WeakPtr<VideoDecoderShim> shim_;
   scoped_ptr<media::VideoDecoder> decoder_;
   bool initialized_ = false;
   scoped_refptr<base::SingleThreadTaskRunner> main_task_runner_;
   // Queue of decodes waiting for the decoder.
   typedef std::queue<PendingDecode> PendingDecodeQueue;
@@ skipping 61 matching lines @@
   DoDecode();
 }
 
 void VideoDecoderShim::DecoderImpl::Reset() {
   DCHECK(decoder_);
   // Abort all pending decodes.
   while (!pending_decodes_.empty()) {
     const PendingDecode& decode = pending_decodes_.front();
     scoped_ptr<PendingFrame> pending_frame(new PendingFrame(decode.decode_id));
     main_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&VideoDecoderShim::OnDecodeComplete, shim_,
-                              media::VideoDecoder::kAborted, decode.decode_id));
+        FROM_HERE, base::Bind(&VideoDecoderShim::OnDecodeComplete, shim_, PP_OK,
+                              decode.decode_id));
     pending_decodes_.pop();
   }
   // Don't need to call Reset() if the |decoder_| hasn't been initialized.
   if (!initialized_) {
     OnResetComplete();
     return;
   }
 
   decoder_->Reset(base::Bind(&VideoDecoderShim::DecoderImpl::OnResetComplete,
                              weak_ptr_factory_.GetWeakPtr()));
@@ skipping 27 matching lines @@
   awaiting_decoder_ = true;
   const PendingDecode& decode = pending_decodes_.front();
   decode_id_ = decode.decode_id;
   decoder_->Decode(decode.buffer,
                    base::Bind(&VideoDecoderShim::DecoderImpl::OnDecodeComplete,
                               weak_ptr_factory_.GetWeakPtr()));
   pending_decodes_.pop();
 }
 
 void VideoDecoderShim::DecoderImpl::OnDecodeComplete(
-    media::VideoDecoder::Status status) {
+    media::DecodeStatus status) {
   DCHECK(awaiting_decoder_);
   awaiting_decoder_ = false;
 
   int32_t result;
   switch (status) {
-    case media::VideoDecoder::kOk:
-    case media::VideoDecoder::kAborted:
+    case media::DecodeStatus::OK:
+    case media::DecodeStatus::ABORTED:
       result = PP_OK;
       break;
-    case media::VideoDecoder::kDecodeError:
+    case media::DecodeStatus::DECODE_ERROR:
       result = PP_ERROR_RESOURCE_FAILED;
       break;
-    default:
-      NOTREACHED();
-      result = PP_ERROR_FAILED;
-      break;
   }
 
   main_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VideoDecoderShim::OnDecodeComplete, shim_, result,
                             decode_id_));
 
   DoDecode();
 }
 
 void VideoDecoderShim::DecoderImpl::OnOutputComplete(
@@ skipping 309 matching lines @@
 void VideoDecoderShim::DeleteTexture(uint32_t texture_id) {
   gpu::gles2::GLES2Interface* gles2 = context_provider_->ContextGL();
   gles2->DeleteTextures(1, &texture_id);
 }
 
 void VideoDecoderShim::FlushCommandBuffer() {
   context_provider_->ContextGL()->Flush();
 }
 
 }  // namespace content