Updated OMX decoder for recent PPAPI changes, and added to the build.

content/common/gpu/gpu_video_decode_accelerator.cc

 // Copyright (c) 2011 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/common/gpu/gpu_video_decode_accelerator.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 90 matching lines @@
 }
 
 void GpuVideoDecodeAccelerator::OnGetConfigs(
     const std::vector<uint32>& requested, std::vector<uint32>* matched) {
   // TODO(vrk): Need to rethink GetConfigs.
   NOTIMPLEMENTED();
 }
 
 void GpuVideoDecodeAccelerator::OnInitialize(
     const std::vector<uint32>& configs) {
-  if (!video_decode_accelerator_)
+  if (!video_decode_accelerator_.get())
     return;
 
   video_decode_accelerator_->Initialize(configs);
 }
 
 void GpuVideoDecodeAccelerator::OnDecode(int32 id,
                                          base::SharedMemoryHandle handle,
                                          int32 size) {
-  if (!video_decode_accelerator_)
+  if (!video_decode_accelerator_.get())
     return;
   video_decode_accelerator_->Decode(media::BitstreamBuffer(id, handle, size));
 }
 
 void GpuVideoDecodeAccelerator::OnAssignGLESBuffers(
     const std::vector<int32> buffer_ids,
     const std::vector<uint32> texture_ids,
     const std::vector<uint32> context_ids,
     const std::vector<gfx::Size> sizes) {
   // TODO(vrk): Implement.
   NOTIMPLEMENTED();
 }
 
 void GpuVideoDecodeAccelerator::OnAssignSysmemBuffers(
     const std::vector<int32> buffer_ids,
     const std::vector<base::SharedMemoryHandle> data,
     const std::vector<gfx::Size> sizes) {
   // TODO(vrk): Implement.
   NOTIMPLEMENTED();
 }
 
 void GpuVideoDecodeAccelerator::OnReusePictureBuffer(int32 picture_buffer_id) {
-  if (!video_decode_accelerator_)
+  if (!video_decode_accelerator_.get())
     return;
 
   video_decode_accelerator_->ReusePictureBuffer(picture_buffer_id);
 }
 
 void GpuVideoDecodeAccelerator::OnFlush() {
-  if (!video_decode_accelerator_)
+  if (!video_decode_accelerator_.get())
     return;
 
-  if (!video_decode_accelerator_->Flush()) {
+  if (!video_decode_accelerator_.get()->Flush()) {
     NotifyError(
         media::VideoDecodeAccelerator::VIDEODECODERERROR_UNEXPECTED_FLUSH);
   }
 }
 
 void GpuVideoDecodeAccelerator::OnAbort() {
-  if (!video_decode_accelerator_)
+  if (!video_decode_accelerator_.get())
     return;
 
   video_decode_accelerator_->Abort();
 }
 
 void GpuVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
   if (!Send(new AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed(
           route_id_, bitstream_buffer_id))) {
     DLOG(ERROR)
         << "Send(AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed) "
         << "failed";
   }
 }
 
 void GpuVideoDecodeAccelerator::NotifyFlushDone() {
   if (!Send(new AcceleratedVideoDecoderHostMsg_FlushDone(route_id_)))
     LOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_FlushDone) failed";
 }
 
 void GpuVideoDecodeAccelerator::NotifyAbortDone() {
   if (!Send(new AcceleratedVideoDecoderHostMsg_AbortDone(route_id_)))
     LOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_AbortDone) failed";
 }
 
 bool GpuVideoDecodeAccelerator::Send(IPC::Message* message) {
   DCHECK(sender_);
   return sender_->Send(message);
 }