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

content/common/gpu/omx_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/gpu/omx_video_decode_accelerator.h"
+#include "content/common/gpu/omx_video_decode_accelerator.h"
 
+#include "base/string_util.h"
+#include "content/common/gpu/gles2_texture_to_egl_image_translator.h"
 #include "content/common/gpu/gpu_channel.h"
-#include "content/common/gpu_messages.h"
-#include "content/gpu/gles2_texture_to_egl_image_translator.h"
 #include "media/base/bitstream_buffer.h"
-#include "media/base/data_buffer.h"
 #include "media/video/picture.h"
 
 static Gles2TextureToEglImageTranslator* texture2eglImage_translator(
     new Gles2TextureToEglImageTranslator(NULL, 0));
 enum { kNumPictureBuffers = 4 };
 
 // Open the libnvomx here for now.
 void* omx_handle = dlopen("libnvomx.so", RTLD_NOW);
 
 typedef OMX_ERRORTYPE (*OMXInit)();
@@ skipping 29 matching lines @@
       height_(-1),
       input_buffer_count_(0),
       input_buffer_size_(0),
       input_port_(0),
       input_buffers_at_component_(0),
       output_buffer_count_(0),
       output_buffer_size_(0),
       output_port_(0),
       output_buffers_at_component_(0),
       uses_egl_image_(false),
-      client_(client),
-      egl_image_(NULL) {
+      client_(client) {
   if (!AreOMXFunctionPointersInitialized()) {
     LOG(ERROR) << "Failed to load openmax library";
     return;
   }
   OMX_ERRORTYPE result = omx_init();
   if (result != OMX_ErrorNone)
     LOG(ERROR) << "Failed to init OpenMAX core";
 }
 
 OmxVideoDecodeAccelerator::~OmxVideoDecodeAccelerator() {
   DCHECK(free_input_buffers_.empty());
   DCHECK_EQ(0, input_buffers_at_component_);
   DCHECK_EQ(0, output_buffers_at_component_);
   DCHECK(output_pictures_.empty());
 }
 
-const std::vector<uint32>& OmxVideoDecodeAccelerator::GetConfig(
-    const std::vector<uint32>& prototype_config) {
+void OmxVideoDecodeAccelerator::GetConfigs(
+    const std::vector<uint32>& requested_configs,
+    std::vector<uint32>* matched_configs) {
   // TODO(vhiremath@nvidia.com) use this properly
   NOTIMPLEMENTED();
-  return component_config_;
 }
 
 // This is to initialize the OMX data structures to default values.
 template <typename T>
 static void InitParam(const OmxVideoDecodeAccelerator& dec, T* param) {
   memset(param, 0, sizeof(T));
   param->nVersion.nVersion = 0x00000101;
   param->nSize = sizeof(T);
 }
 
 bool OmxVideoDecodeAccelerator::Initialize(const std::vector<uint32>& config) {
-  // TODO(vhiremath@nvidia.com) get these acutal values from config
+  // TODO(vhiremath@nvidia.com) get these actual values from config
   // Assume qvga for now
   width_ = 320;
   height_ = 240;
 
   client_state_ = OMX_StateLoaded;
   if (!CreateComponent()) {
     StopOnError();
     return false;
   }
   // Transition component to Idle state
   on_state_event_func_ =
       &OmxVideoDecodeAccelerator::OnStateChangeLoadedToIdle;
   if (!TransitionToState(OMX_StateIdle))
     return false;
 
   if (!AllocateInputBuffers()) {
     LOG(ERROR) << "OMX_AllocateBuffer() Input buffer error";
     StopOnError();
     return false;
   }
 
   // After AllocateInputBuffers ideally this should be AllocateOutputBuffers.
   // Since in this case app provides the output buffers,
   // we query this through ProvidePictureBuffers.
   // This is call to ppapi to provide the output buffers initially.
   // ProvidePictureBuffers will provide
   // - SharedMemHandle in case of decoding to system memory.
   // - Textures in case of decoding to egl-images.
 
-  // Output buffers will be eventually allocated in AssignPictureBuffer().
-
-  // TODO(vhiremath@nvidia.com) fill buffer_properties
-  std::vector<uint32> buffer_properties;
+  // Output buffers will be eventually handed to us via
+  // Assign{GLES,Sysmem}Buffers().
   output_buffer_count_ = kNumPictureBuffers;
-  client_->ProvidePictureBuffers(output_buffer_count_, buffer_properties);
+  client_->ProvidePictureBuffers(
+      output_buffer_count_, gfx::Size(width_, height_),
+      PICTUREBUFFER_MEMORYTYPE_GL_TEXTURE);
+  // TODO(fischman): we always ask for GLES buffers above.  So why maintain the
+  // !uses_egl_image_ path in this class at all?  Theoretically it could be
+  // useful for testing, but today there's no such testing.  Consider ripping it
+  // out of this class and replacing AssignSysmemBuffers() with
+  // NOTIMPLEMENTED().

[vrk (LEFT CHROMIUM), 2011/05/23 23:35:00]

Sounds like a good idea to me.

[Ami GONE FROM CHROMIUM, 2011/05/24 05:31:50]

Good.  My plan is to wait until this code actually works in something checked in
(tester, sample plugin, *anything*, as long as it's checked in) and then take
the scalpel to it.

   return true;
 }
 
 bool OmxVideoDecodeAccelerator::CreateComponent() {
   OMX_CALLBACKTYPE omx_accelerator_callbacks = {
     &OmxVideoDecodeAccelerator::EventHandler,
     &OmxVideoDecodeAccelerator::EmptyBufferCallback,
     &OmxVideoDecodeAccelerator::FillBufferCallback
   };
   OMX_ERRORTYPE result = OMX_ErrorNone;
@@ skipping 100 matching lines @@
   // OMX_IndexParamPortDefinition on output port to be done in
   // AllocateOutputBuffers.
   // Since at this point we dont know if we will be using system memory
   // or egl-image for decoding.
   // We get this info in AssignPictureBuffers() from plugin.
 
   return true;
 }
 
 bool OmxVideoDecodeAccelerator::Decode(
-    const media::BitstreamBuffer& bitstream_buffer,
-    const media::VideoDecodeAcceleratorCallback& callback) {
+    const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK(!free_input_buffers_.empty());
-  DCHECK(bitstream_buffer);
 
   if (!CanAcceptInput()) {
     return false;
   }
 
   OMX_BUFFERHEADERTYPE* omx_buffer = free_input_buffers_.front();
   free_input_buffers_.pop();
 
   // Setup |omx_buffer|.
   scoped_ptr<base::SharedMemory> shm(
       new base::SharedMemory(bitstream_buffer.handle(), true));
   if (!shm->Map(bitstream_buffer.size())) {
     LOG(ERROR) << "Failed to SharedMemory::Map().";
     return false;
   }
   omx_buffer->pBuffer = static_cast<OMX_U8*>(shm->memory());
-  omx_buffer->nFilledLen = bitstream_buffer->size();
+  omx_buffer->nFilledLen = bitstream_buffer.size();
   omx_buffer->nAllocLen = omx_buffer->nFilledLen;
 
   omx_buffer->nFlags &= ~OMX_BUFFERFLAG_EOS;
   omx_buffer->nTimeStamp = 0;
 
   // Give this buffer to OMX.
   OMX_ERRORTYPE result = OMX_ErrorNone;
   result = OMX_EmptyThisBuffer(component_handle_, omx_buffer);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "OMX_EmptyThisBuffer() failed with result " << result;
     StopOnError();
     return false;
   }
   input_buffers_at_component_++;
   // OMX_EmptyThisBuffer is a non blocking call and should
   // not make any assumptions about its completion.
-  omx_buff_cb_.insert(std::make_pair(
-      omx_buffer, make_pair(shm.release(), callback)));
+  omx_buff_ids_.insert(std::make_pair(
+      omx_buffer, std::make_pair(shm.release(), bitstream_buffer.id())));
   return true;
 }
 
-void OmxVideoDecodeAccelerator::AssignPictureBuffer(
-    std::vector<PictureBuffer*> picture_buffers) {
-  // NOTE: this is only partially-implemented as it only inspects the first
-  // picture buffer passed in each AssignPictureBuffer call, and never unsets
-  // uses_egl_image_ once set.
-  if (PictureBuffer::PICTUREBUFFER_MEMORYTYPE_GL_TEXTURE ==
-      picture_buffers[0]->GetMemoryType()) {
-      uses_egl_image_ = true;
-  }
+// NOTE: this is only partially-implemented as it only inspects the first

[vrk (LEFT CHROMIUM), 2011/05/23 23:35:00]

I don't believe the first part of this comment is relevant anymore?

[Ami GONE FROM CHROMIUM, 2011/05/24 05:31:50]

Done.

+// picture buffer passed in each AssignPictureBuffer call, and never unsets
+// uses_egl_image_ once set.
+void OmxVideoDecodeAccelerator::AssignGLESBuffers(
+    const std::vector<media::GLESBuffer>& buffers) {
+  uses_egl_image_ = true;
+  std::vector<media::BaseBuffer*> base_buffers(buffers.size());
+  for (size_t i = 0; i < buffers.size(); ++i)
+    base_buffers[i] = new media::GLESBuffer(buffers[i]);

[vrk (LEFT CHROMIUM), 2011/05/23 23:35:00]

How does this get deleted? Looks like it should be deleted when you call
DismissPictureBuffer.

[Ami GONE FROM CHROMIUM, 2011/05/24 05:31:50]

Done.

+  AssignBuffersHelper(base_buffers);
+}
 
+void OmxVideoDecodeAccelerator::AssignSysmemBuffers(
+    const std::vector<media::SysmemBuffer>& buffers) {
+  DCHECK(!uses_egl_image_);
+  std::vector<media::BaseBuffer*> base_buffers(buffers.size());
+  for (size_t i = 0; i < buffers.size(); ++i)
+    base_buffers[i] = new media::SysmemBuffer(buffers[i]);

[vrk (LEFT CHROMIUM), 2011/05/23 23:35:00]

Same question w/ deletion.

[Ami GONE FROM CHROMIUM, 2011/05/24 05:31:50]

Done.

+  AssignBuffersHelper(base_buffers);
+}
+
+void OmxVideoDecodeAccelerator::AssignBuffersHelper(
+    const std::vector<media::BaseBuffer*>& buffers) {
   assigned_picture_buffers_.insert(
-      assigned_picture_buffers_.end(),
-      picture_buffers.begin(),
-      picture_buffers.end());
+      assigned_picture_buffers_.end(), buffers.begin(), buffers.end());
 
   if (assigned_picture_buffers_.size() < kNumPictureBuffers)
     return;  // get all the buffers first.
 
   // Obtain the information about the output port.
   OMX_PARAM_PORTDEFINITIONTYPE port_format;
   InitParam(*this, &port_format);
   port_format.nPortIndex = output_port_;
   OMX_ERRORTYPE result = OMX_GetParameter(component_handle_,
                                           OMX_IndexParamPortDefinition,
@@ skipping 32 matching lines @@
     StopOnError();
   }
 }
 
 void OmxVideoDecodeAccelerator::ReusePictureBuffer(int32 picture_buffer_id) {
   // TODO(vhiremath@nvidia.com) Avoid leaking of the picture buffer.
   if (!CanFillBuffer())
     return;
 
   for (int i = 0; i < output_buffer_count_; ++i) {
-    if (picture_buffer_id != assigned_picture_buffers_[i]->GetId())
+    if (picture_buffer_id != assigned_picture_buffers_[i]->id())
       continue;
     output_buffers_at_component_++;
     OMX_ERRORTYPE result =
         OMX_FillThisBuffer(component_handle_, output_pictures_[i].second);
     if (result != OMX_ErrorNone) {
       LOG(ERROR) << "OMX_FillThisBuffer() failed with result " << result;
       StopOnError();
     }
     // Sent one buffer to omx.
     return;
@@ skipping 13 matching lines @@
     output_buffers_at_component_++;
     OMX_ERRORTYPE result = OMX_FillThisBuffer(component_handle_, omx_buffer);
     if (result != OMX_ErrorNone) {
       LOG(ERROR) << "OMX_FillThisBuffer() failed with result " << result;
       StopOnError();
       return;
     }
   }
 }
 
-bool OmxVideoDecodeAccelerator::Flush(
-    const media::VideoDecodeAcceleratorCallback& callback) {
+bool OmxVideoDecodeAccelerator::Flush() {
   OMX_STATETYPE il_state;
   OMX_GetState(component_handle_, &il_state);
   DCHECK_EQ(il_state, OMX_StateExecuting);
   if (il_state != OMX_StateExecuting) {
-    callback.Run();
+    client_->NotifyFlushDone();
     return false;
   }
   on_buffer_flag_event_func_ = &OmxVideoDecodeAccelerator::FlushBegin;
-  flush_done_callback_ = callback;
 
   OMX_BUFFERHEADERTYPE* omx_buffer = free_input_buffers_.front();
   free_input_buffers_.pop();
   omx_buffer->nFilledLen = 0;
   omx_buffer->nAllocLen = omx_buffer->nFilledLen;
   omx_buffer->nFlags |= OMX_BUFFERFLAG_EOS;
   omx_buffer->nTimeStamp = 0;
   // Give this buffer to OMX.
   OMX_ERRORTYPE result = OMX_ErrorNone;
   result = OMX_EmptyThisBuffer(component_handle_, omx_buffer);
@@ skipping 57 matching lines @@
     VLOG(1) << "Output Port had been flushed";
     DCHECK_EQ(output_buffers_at_component_, 0);
   }
 
   client_state_ = OMX_StatePause;
   // So Finally call OnPortCommandFlush which should
   // internally call DismissPictureBuffer();
   OnPortCommandFlush(OMX_StateExecuting);
 }
 
-bool OmxVideoDecodeAccelerator::Abort(
-    const media::VideoDecodeAcceleratorCallback& callback) {
+bool OmxVideoDecodeAccelerator::Abort() {
   // TODO(vhiremath@nvidia.com)
   // Need more thinking on this to handle w.r.t OMX.
   // There is no explicit UnInitialize call for this.
   // Also review again for trick modes.
-  callback.Run();
+  client_->NotifyAbortDone();
   return true;
 }
 
 // Event callback during initialization to handle DoneStateSet to idle
 void OmxVideoDecodeAccelerator::OnStateChangeLoadedToIdle(OMX_STATETYPE state) {
   DCHECK_EQ(client_state_, OMX_StateLoaded);
   DCHECK_EQ(OMX_StateIdle, state);
   VLOG(1) << "OMX video decode engine is in Idle";
 
   on_state_event_func_ =
       &OmxVideoDecodeAccelerator::OnStateChangeIdleToExecuting;
   if (!TransitionToState(OMX_StateExecuting))
     return;
 }
 
 // Event callback during initialization to handle DoneStateSet to executing
 void OmxVideoDecodeAccelerator::OnStateChangeIdleToExecuting(
     OMX_STATETYPE state) {
   DCHECK_EQ(OMX_StateExecuting, state);
   VLOG(1) << "OMX video decode engine is in Executing";
 
   client_state_ = OMX_StateExecuting;
   on_state_event_func_ = NULL;
   // This will kickoff the actual decoding
-  client_->NotifyResourcesAcquired();
   InitialFillBuffer();
 }
 
 // Send state transition command to component.
 bool OmxVideoDecodeAccelerator::TransitionToState(OMX_STATETYPE new_state) {
     OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
                                            OMX_CommandStateSet,
                                            new_state, 0);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "SendCommand(OMX_CommandStateSet) failed";
@@ skipping 39 matching lines @@
 
   if (component_handle_) {
     OMX_ERRORTYPE result = (*omx_free_handle)(component_handle_);
     if (result != OMX_ErrorNone)
         LOG(ERROR) << "OMX_FreeHandle() error. Error code: " << result;
     component_handle_ = NULL;
   }
   client_state_ = OMX_StateLoaded;
   (*omx_deinit)();
   VLOG(1) << "OMX Deinit Clean exit done";
-  flush_done_callback_.Run();
+  client_->NotifyFlushDone();
 }
 
 void OmxVideoDecodeAccelerator::StopOnError() {
   OMX_STATETYPE il_state;
   OMX_GetState(component_handle_, &il_state);
   client_state_ = OMX_StateInvalid;
   switch (il_state) {
     case OMX_StateExecuting:
       OnPortCommandFlush(OMX_StateExecuting);
       return;
@@ skipping 21 matching lines @@
       return false;
     buffer->nInputPortIndex = input_port_;
     buffer->nOffset = 0;
     buffer->nFlags = 0;
     free_input_buffers_.push(buffer);
   }
   return true;
 }
 
 bool OmxVideoDecodeAccelerator::AllocateOutputBuffers() {
-  OMX_BUFFERHEADERTYPE* buffer;
-  Picture* picture;
-  OMX_ERRORTYPE result;
   gfx::Size decoded_pixel_size(width_, height_);
   gfx::Size visible_pixel_size(width_, height_);
-
+  // TODO(fischman): remove garbage bitstream buffer id's below (42 and 24) when
+  // the bitstream_buffer_id field is removed from Picture.
   if (uses_egl_image_) {
-    media::VideoDecodeAccelerator::PictureBuffer::DataPlaneHandle egl_ids;
-    std::vector<PictureBuffer::DataPlaneHandle> planes;
-    uint32 texture;
-
     for (uint32 i = 0; i < assigned_picture_buffers_.size(); i++) {
-      picture = new media::Picture(
-          reinterpret_cast<media::PictureBuffer*>(assigned_picture_buffers_[i]),
-          decoded_pixel_size, visible_pixel_size,
-          static_cast<void*>(component_handle_));
-
-      planes = assigned_picture_buffers_[i]->GetPlaneHandles();
-      egl_ids = planes[i];
-      texture = egl_ids.texture_id;
-      egl_image_ = texture2eglImage_translator->TranslateToEglImage(texture);
-      result = OMX_UseEGLImage(
-          component_handle_,
-          &buffer,
-          output_port_,
-          reinterpret_cast<media::PictureBuffer*>(assigned_picture_buffers_[i]),
-          egl_image_);
-
+      media::GLESBuffer* gles_buffer =
+          reinterpret_cast<media::GLESBuffer*>(assigned_picture_buffers_[i]);
+      OMX_BUFFERHEADERTYPE* omx_buffer;
+      void* egl = texture2eglImage_translator->TranslateToEglImage(
+          gles_buffer->texture_id());
+      OMX_ERRORTYPE result = OMX_UseEGLImage(
+          component_handle_, &omx_buffer, output_port_, gles_buffer, egl);
       if (result != OMX_ErrorNone) {
         LOG(ERROR) << "OMX_UseEGLImage failed";
         return false;
       }
+      omx_buffer->pAppPrivate =
+          new media::Picture(gles_buffer->id(),

[vrk (LEFT CHROMIUM), 2011/05/23 23:35:00]

How does this get deleted? Seems like it should be deleted when you get calls to
ReusePictureBuffer. (ReusePictureBuffer will reuse the GLESBuffer or
SysmemBuffer, but the Picture data structure should be no longer needed.)

[Ami GONE FROM CHROMIUM, 2011/05/24 05:31:50]

AFAIUI this is reused between invocations (i.e. the same Picture will hold
different frames at different times), so I don't think we want to delete in
ReusePictureBuffer.
But we were indeed leaking these.  Now delete'ing in FreeOutputBuffers().

+                             42 /* garbage bitstreambuffer id */,
+                             decoded_pixel_size, visible_pixel_size);
       output_pictures_.push_back(
-          std::make_pair(
-                reinterpret_cast<media::PictureBuffer*>(
-                    assigned_picture_buffers_[i]),
-                buffer));
-      buffer->pAppPrivate = picture;
+          std::make_pair(assigned_picture_buffers_[i]->id(), omx_buffer));
     }
   } else {
     for (uint32 i = 0; i < assigned_picture_buffers_.size(); i++) {
-      picture = new media::Picture(
-          reinterpret_cast<media::PictureBuffer*>(assigned_picture_buffers_[i]),
-          decoded_pixel_size, visible_pixel_size,
-          static_cast<void*>(component_handle_));
-
-      result = OMX_AllocateBuffer(component_handle_, &buffer, output_port_,
-                                  NULL, output_buffer_size_);
+      media::SysmemBuffer* sysmem_buffer =
+          reinterpret_cast<media::SysmemBuffer*>(assigned_picture_buffers_[i]);
+      OMX_BUFFERHEADERTYPE* omx_buffer;
+      OMX_ERRORTYPE result = OMX_AllocateBuffer(
+          component_handle_, &omx_buffer, output_port_, NULL,
+          output_buffer_size_);
       if (result != OMX_ErrorNone)
         return false;
+      omx_buffer->pAppPrivate = new media::Picture(

[vrk (LEFT CHROMIUM), 2011/05/23 23:35:00]

Same question w/ deletion.

[Ami GONE FROM CHROMIUM, 2011/05/24 05:31:50]

Done.

+          sysmem_buffer->id(),
+          24 /* garbage bitstreambuffer id */,
+          decoded_pixel_size, visible_pixel_size);
       output_pictures_.push_back(
-          std::make_pair(
-                reinterpret_cast<media::PictureBuffer*>(
-                    assigned_picture_buffers_[i]),
-                buffer));
-      buffer->pAppPrivate = picture;
+          std::make_pair(sysmem_buffer->id(), omx_buffer));
     }
   }
   return true;
 }
 
 void OmxVideoDecodeAccelerator::FreeInputBuffers() {
   // Calls to OMX to free buffers.
   OMX_ERRORTYPE result;
   OMX_BUFFERHEADERTYPE* omx_buffer;
   while (!free_input_buffers_.empty()) {
@@ skipping 32 matching lines @@
   // In this case, the component detects PortSettingsChanged
   // and sends the particular event to the IL-client.
   // This needs to be handled in this method.
   return;
 }
 
 void OmxVideoDecodeAccelerator::FillBufferDoneTask(
     OMX_BUFFERHEADERTYPE* buffer) {
   DCHECK_GT(output_buffers_at_component_, 0);
   output_buffers_at_component_--;
-  client_->PictureReady(reinterpret_cast<Picture*>(buffer->pAppPrivate));
+  client_->PictureReady(*reinterpret_cast<media::Picture*>(
+      buffer->pAppPrivate));
 }
 
 void OmxVideoDecodeAccelerator::EmptyBufferDoneTask(
     OMX_BUFFERHEADERTYPE* buffer) {
   DCHECK_GT(input_buffers_at_component_, 0);
   free_input_buffers_.push(buffer);
   input_buffers_at_component_--;
   if (buffer->nFlags & OMX_BUFFERFLAG_EOS)
     return;
-  // Retrieve the corresponding callback and run it.
-  OMXBufferCallbackMap::iterator it = omx_buff_cb_.find(buffer);
-  if (it == omx_buff_cb_.end()) {
-    LOG(ERROR) << "Unexpectedly failed to find a buffer callback.";
+  // Retrieve the corresponding BitstreamBuffer's id and notify the client of
+  // its completion.
+  OMXBufferIdMap::iterator it = omx_buff_ids_.find(buffer);
+  if (it == omx_buff_ids_.end()) {
+    LOG(ERROR) << "Unexpectedly failed to find a buffer id.";
     StopOnError();
     return;
   }
   delete it->second.first;
-  it->second.second.Run();
-  omx_buff_cb_.erase(it);
+  client_->NotifyEndOfBitstreamBuffer(it->second.second);
+  omx_buff_ids_.erase(it);
 }
 
 void OmxVideoDecodeAccelerator::EventHandlerCompleteTask(OMX_EVENTTYPE event,
                                                          OMX_U32 data1,
                                                          OMX_U32 data2) {
   switch (event) {
     case OMX_EventCmdComplete: {
       // If the last command was successful, we have completed
       // a state transition. So notify that we have done it
       // accordingly.
@@ skipping 51 matching lines @@
 OMX_ERRORTYPE OmxVideoDecodeAccelerator::EventHandler(OMX_HANDLETYPE component,
                                                       OMX_PTR priv_data,
                                                       OMX_EVENTTYPE event,
                                                       OMX_U32 data1,
                                                       OMX_U32 data2,
                                                       OMX_PTR event_data) {
   OmxVideoDecodeAccelerator* decoder =
       static_cast<OmxVideoDecodeAccelerator*>(priv_data);
   DCHECK_EQ(component, decoder->component_handle_);
 
-  decoder->message_loop_->PostTask(FROM_HERE,
-  NewRunnableMethod(decoder,
-                    &OmxVideoDecodeAccelerator::EventHandlerCompleteTask,
-                    event, data1, data2));
+  decoder->message_loop_->PostTask(
+      FROM_HERE,
+      NewRunnableMethod(decoder,
+                        &OmxVideoDecodeAccelerator::EventHandlerCompleteTask,
+                        event, data1, data2));
 
   return OMX_ErrorNone;
 }
 
 // static
 OMX_ERRORTYPE OmxVideoDecodeAccelerator::EmptyBufferCallback(
     OMX_HANDLETYPE component,
     OMX_PTR priv_data,
     OMX_BUFFERHEADERTYPE* buffer) {
   OmxVideoDecodeAccelerator* decoder =
@@ skipping 10 matching lines @@
 
 // static
 OMX_ERRORTYPE OmxVideoDecodeAccelerator::FillBufferCallback(
     OMX_HANDLETYPE component,
     OMX_PTR priv_data,
     OMX_BUFFERHEADERTYPE* buffer) {
   OmxVideoDecodeAccelerator* decoder =
       static_cast<OmxVideoDecodeAccelerator*>(priv_data);
   DCHECK_EQ(component, decoder->component_handle_);
 
-  decoder->message_loop_->PostTask(FROM_HERE,
+  decoder->message_loop_->PostTask(
+      FROM_HERE,
       NewRunnableMethod(
           decoder,
           &OmxVideoDecodeAccelerator::FillBufferDoneTask, buffer));
   return OMX_ErrorNone;
 }
 
 bool OmxVideoDecodeAccelerator::CanAcceptInput() {
   // We can't take input buffer when in error state.
   return (client_state_ != OMX_StateInvalid &&
           client_state_ != OMX_StatePause &&
@@ skipping 22 matching lines @@
   OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
                                              cmd, port_index, 0);
   if (result != OMX_ErrorNone) {
     LOG(ERROR) << "SendCommand(OMX_CommandPortDisable) failed";
     StopOnError();
     return;
   }
 }
 
 DISABLE_RUNNABLE_METHOD_REFCOUNT(OmxVideoDecodeAccelerator);