Added FakeGlVideoDecodeEngine to exercise the IPC protocol for hardware video decoding

media/filters/omx_video_decoder.cc

 // Copyright (c) 2010 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/omx_video_decoder.h"
 
 #include "base/callback.h"
 #include "media/base/callback.h"
 #include "media/base/factory.h"
 #include "media/base/filter_host.h"
@@ skipping 77 matching lines @@
       height_ > Limits::kMaxDimension ||
       (width_ * height_) > Limits::kMaxCanvas) {
     VideoCodecInfo info = {0};
     OmxVideoDecoder::OnInitializeComplete(info);
     return;
   }
 
   VideoCodecConfig config;
   switch (av_stream->codec->codec_id) {
     case CODEC_ID_VC1:
-      config.codec_ = kCodecVC1; break;
+      config.codec = kCodecVC1; break;
     case CODEC_ID_H264:
-      config.codec_ = kCodecH264; break;
+      config.codec = kCodecH264; break;
     case CODEC_ID_THEORA:
-      config.codec_ = kCodecTheora; break;
+      config.codec = kCodecTheora; break;
     case CODEC_ID_MPEG2VIDEO:
-      config.codec_ = kCodecMPEG2; break;
+      config.codec = kCodecMPEG2; break;
     case CODEC_ID_MPEG4:
-      config.codec_ = kCodecMPEG4; break;
+      config.codec = kCodecMPEG4; break;
     default:
       NOTREACHED();
   }
-  config.opaque_context_ = NULL;
-  config.width_ = width_;
-  config.height_ = height_;
+  config.opaque_context = NULL;
+  config.width = width_;
+  config.height = height_;
   omx_engine_->Initialize(message_loop(), this, config);
 }
 
 void OmxVideoDecoder::OnInitializeComplete(const VideoCodecInfo& info) {
   DCHECK_EQ(MessageLoop::current(), message_loop());
   DCHECK(initialize_callback_.get());
 
   info_ = info;  // Save a copy.
   AutoCallbackRunner done_runner(initialize_callback_.release());
 
-  if (info.success_) {
+  if (info.success) {
     media_format_.SetAsString(MediaFormat::kMimeType,
                               mime_type::kUncompressedVideo);
     media_format_.SetAsInteger(MediaFormat::kWidth, width_);
     media_format_.SetAsInteger(MediaFormat::kHeight, height_);
     media_format_.SetAsInteger(
         MediaFormat::kSurfaceType,
-        static_cast<int>(info.stream_info_.surface_type_));
+        static_cast<int>(info.stream_info.surface_type));
     media_format_.SetAsInteger(
         MediaFormat::kSurfaceFormat,
-        static_cast<int>(info.stream_info_.surface_format_));
+        static_cast<int>(info.stream_info.surface_format));
   } else {
     host()->SetError(PIPELINE_ERROR_DECODE);
   }
 }
 
 void OmxVideoDecoder::Stop(FilterCallback* callback) {
   if (MessageLoop::current() != message_loop()) {
     message_loop()->PostTask(FROM_HERE,
                              NewRunnableMethod(this,
                                                &OmxVideoDecoder::Stop,
@@ skipping 85 matching lines @@
 
 void OmxVideoDecoder::ProduceVideoFrame(scoped_refptr<VideoFrame> frame) {
   DCHECK(omx_engine_.get());
   message_loop()->PostTask(
      FROM_HERE,
      NewRunnableMethod(omx_engine_.get(),
                        &VideoDecodeEngine::ProduceVideoFrame, frame));
 }
 
 bool OmxVideoDecoder::ProvidesBuffer() {
-  DCHECK(info_.success_);
-  return info_.provides_buffers_;
+  DCHECK(info_.success);
+  return info_.provides_buffers;
 }
 
 void OmxVideoDecoder::DemuxCompleteTask(Buffer* buffer) {
   // We simply delicate the buffer to the right message loop.
   scoped_refptr<Buffer> ref_buffer = buffer;
   DCHECK(omx_engine_.get());
   message_loop()->PostTask(
       FROM_HERE,
       NewRunnableMethod(omx_engine_.get(),
                         &VideoDecodeEngine::ConsumeVideoSample, ref_buffer));
 }
 
 }  // namespace media
 
 // Disable refcounting for the decode engine because it only lives on the
 // video decoder thread.
 DISABLE_RUNNABLE_METHOD_REFCOUNT(media::VideoDecodeEngine);