Enable fire-and-forget Destroy of HW video decoder, and misc other improvements.

content/common/gpu/media/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/common/gpu/media/omx_video_decode_accelerator.h"
 
 #include "base/stl_util-inl.h"
 #include "base/string_util.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/media/gles2_texture_to_egl_image_translator.h"
@@ skipping 39 matching lines @@
 #define RETURN_ON_FAILURE(result, log, error, ret_val)             \
   do {                                                             \
     if (!(result)) {                                               \
       LOG(ERROR) << log;                                           \
       StopOnError(error);                                          \
       return ret_val;                                              \
     }                                                              \
   } while (0)
 
 // OMX-specific version of RETURN_ON_FAILURE which compares with OMX_ErrorNone.
-#define RETURN_ON_OMX_FAILURE(omx_result, log, error, ret_val)            \
-  RETURN_ON_FAILURE(                                                      \
-      ((omx_result) == OMX_ErrorNone),                                    \
-      log << ", OMX result: " << std::hex << std::showbase << omx_result, \
+#define RETURN_ON_OMX_FAILURE(omx_result, log, error, ret_val)          \
+  RETURN_ON_FAILURE(                                                    \
+      ((omx_result) == OMX_ErrorNone),                                  \
+      log << ", OMX result: 0x" << std::hex << omx_result,              \
       error, ret_val)
 
 OmxVideoDecodeAccelerator::OmxVideoDecodeAccelerator(
     media::VideoDecodeAccelerator::Client* client)
     : message_loop_(MessageLoop::current()),
       component_handle_(NULL),
       client_state_(OMX_StateMax),
       current_state_change_(NO_TRANSITION),
       saw_eos_during_flush_(false),
       input_buffer_count_(0),
@@ skipping 101 matching lines @@
   scoped_array<OMX_U8> component(new OMX_U8[OMX_MAX_STRINGNAME_SIZE]);
   OMX_ERRORTYPE result = omx_get_components_of_role(
       role_name, &num_components, reinterpret_cast<OMX_U8**>(&component));
   RETURN_ON_OMX_FAILURE(result, "Unsupport role: " << role_name,
                         VIDEODECODERERROR_UNSUPPORTED, false);
   RETURN_ON_FAILURE(num_components == 1,
                     "No components for: " << role_name,
                     VIDEODECODERERROR_UNSUPPORTED, false);
 
   // Get the handle to the component.
+  AddRef();  // To reflect passing |this| to OMX_GetHandle below.
   result = omx_gethandle(
       &component_handle_, reinterpret_cast<OMX_STRING>(component.get()),
       this, &omx_accelerator_callbacks);
   RETURN_ON_OMX_FAILURE(result,
                         "Failed to OMX_GetHandle on: " << component.get(),
                         VIDEODECODERERROR_INSUFFICIENT_RESOURCES, false);
   client_state_ = OMX_StateLoaded;
 
   // Get the port information. This will obtain information about the number of
   // ports and index of the first port.
@@ skipping 63 matching lines @@
   RETURN_ON_OMX_FAILURE(result,
                         "SetParameter(OMX_IndexParamPortDefinition) failed",
                         VIDEODECODERERROR_INVALIDINPUT, false);
 
   // Fill the component with fake output buffers.  This seems to be required for
   // the component to move from Loaded to Idle.  How bogus.
   for (int i = 0; i < kNumPictureBuffers; ++i) {
     OMX_BUFFERHEADERTYPE* buffer;
     result = OMX_UseBuffer(component_handle_, &buffer, output_port_,
                            NULL, 0, reinterpret_cast<OMX_U8*>(0x1));
-    RETURN_ON_OMX_FAILURE(result, "OMX_UseBuffer failed with: " << result,
+    RETURN_ON_OMX_FAILURE(result, "OMX_UseBuffer failed",
                           VIDEODECODERERROR_INVALIDINPUT, false);
     buffer->pAppPrivate = NULL;
     buffer->nTimeStamp = -1;
     buffer->nOutputPortIndex = output_port_;
     CHECK(fake_output_buffers_.insert(buffer).second);
   }
 
   return true;
 }
 
 void OmxVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK(!free_input_buffers_.empty());
 
   RETURN_ON_FAILURE(current_state_change_ == NO_TRANSITION &&
                     (client_state_ == OMX_StateIdle ||
                      client_state_ == OMX_StateExecuting),
-                    "Call to Decode() during invalid state or transition:"
+                    "Call to Decode() during invalid state or transition: "
                     << current_state_change_ << ", " << client_state_,
                     VIDEODECODERERROR_UNSUPPORTED,);
 
   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));
   RETURN_ON_FAILURE(shm->Map(bitstream_buffer.size()),
@@ skipping 10 matching lines @@
   omx_buffer->nFilledLen = bitstream_buffer.size();
   omx_buffer->nAllocLen = omx_buffer->nFilledLen;
   omx_buffer->nFlags &= ~OMX_BUFFERFLAG_EOS;
   // Abuse the header's nTimeStamp field to propagate the bitstream buffer ID to
   // the output buffer's nTimeStamp field, so we can report it back to the
   // client in PictureReady().
   omx_buffer->nTimeStamp = bitstream_buffer.id();
 
   // Give this buffer to OMX.
   OMX_ERRORTYPE result = OMX_EmptyThisBuffer(component_handle_, omx_buffer);
-  RETURN_ON_OMX_FAILURE(result,
-                        "OMX_EmptyThisBuffer() failed with result " << result,
+  RETURN_ON_OMX_FAILURE(result, "OMX_EmptyThisBuffer() failed",
                         VIDEODECODERERROR_INVALIDINPUT,);
 
   input_buffers_at_component_++;
 }
 
 void OmxVideoDecodeAccelerator::AssignGLESBuffers(
     const std::vector<media::GLESBuffer>& buffers) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   RETURN_ON_FAILURE(CanFillBuffer(), "Can't fill buffer",
                     VIDEODECODERERROR_UNSUPPORTED,);
@@ skipping 28 matching lines @@
 
   OutputPictureById::iterator it = pictures_.find(picture_buffer_id);
   RETURN_ON_FAILURE(it != pictures_.end(),
                     "Missing picture buffer id: " << picture_buffer_id,
                     VIDEODECODERERROR_UNSUPPORTED,);
   OutputPicture& output_picture = it->second;
 
   ++output_buffers_at_component_;
   OMX_ERRORTYPE result =
       OMX_FillThisBuffer(component_handle_, output_picture.omx_buffer_header);
-  RETURN_ON_OMX_FAILURE(result,
-                        "OMX_FillThisBuffer() failed with result " << result,
+  RETURN_ON_OMX_FAILURE(result, "OMX_FillThisBuffer() failed",
                         VIDEODECODERERROR_INVALIDINPUT,);
 }
 
 void OmxVideoDecodeAccelerator::Flush() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK_EQ(current_state_change_, NO_TRANSITION);
   DCHECK_EQ(client_state_, OMX_StateExecuting);
   current_state_change_ = FLUSHING;
 
   // Cook up an empty buffer w/ EOS set and feed it to OMX.
   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 = -2;
   OMX_ERRORTYPE result = OMX_EmptyThisBuffer(component_handle_, omx_buffer);
-  RETURN_ON_OMX_FAILURE(result,
-                        "OMX_EmptyThisBuffer() failed with result " << result,
+  RETURN_ON_OMX_FAILURE(result, "OMX_EmptyThisBuffer() failed",
                         VIDEODECODERERROR_INVALIDINPUT,);
   input_buffers_at_component_++;
 }
 
 void OmxVideoDecodeAccelerator::OnReachedEOSInFlushing() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   BeginTransitionToState(OMX_StatePause);
 }
 
 void OmxVideoDecodeAccelerator::FlushIOPorts() {
@@ skipping 21 matching lines @@
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK_EQ(current_state_change_, NO_TRANSITION);
   DCHECK_EQ(client_state_, OMX_StateExecuting);
   current_state_change_ = RESETTING;
   BeginTransitionToState(OMX_StatePause);
 }
 
 void OmxVideoDecodeAccelerator::Destroy() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK_EQ(current_state_change_, NO_TRANSITION);
+  // If we were never initializeed there's no teardown to do.
+  if (client_state_ == OMX_StateMax)
+    return;
+  // If we can already call OMX_FreeHandle, simply do so.
+  if (client_state_ == OMX_StateInvalid || client_state_ == OMX_StateLoaded) {
+    ShutdownComponent();
+    return;
+  }
   DCHECK_EQ(client_state_, OMX_StateExecuting);
   current_state_change_ = DESTROYING;
+  client_ = NULL;

[vhiremath, 2011/07/14 14:29:15]

Do we really want to do it here ?
What if OVDA has a pending Reset() call from plugin that is about to call
NotifyResetDone. And it also calls Destroy immediately (very common case user
just seeks to new location and close tab immediately)

How will this be handled in plugin.
Will plugin not wait on ResetDone once destroy is called ?

[Ami GONE FROM CHROMIUM, 2011/07/14 16:23:03]

It is incorrect to call Destroy() while a Reset() or Flush() is outstanding
(enforced at line 427 with:
DCHECK_EQ(current_state_change_, NO_TRANSITION);
).

   BeginTransitionToState(OMX_StateIdle);
+  BusyLoopInDestroying();
 }
 
 void OmxVideoDecodeAccelerator::BeginTransitionToState(
     OMX_STATETYPE new_state) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK_NE(current_state_change_, NO_TRANSITION);
+  DCHECK_NE(current_state_change_, ERRORING);
+  if (current_state_change_ == NO_TRANSITION ||
+      current_state_change_ == ERRORING) {
+    return;
+  }
   OMX_ERRORTYPE result = OMX_SendCommand(
       component_handle_, OMX_CommandStateSet, new_state, 0);
   RETURN_ON_OMX_FAILURE(result, "SendCommand(OMX_CommandStateSet) failed",
                         VIDEODECODERERROR_INVALIDINPUT,);
 }
 
 void OmxVideoDecodeAccelerator::OnReachedIdleInInitializing() {
   DCHECK_EQ(client_state_, OMX_StateLoaded);
   client_state_ = OMX_StateIdle;
   BeginTransitionToState(OMX_StateExecuting);
 }
 
 void OmxVideoDecodeAccelerator::OnReachedExecutingInInitializing() {
   DCHECK_EQ(client_state_, OMX_StateIdle);
   client_state_ = OMX_StateExecuting;
   current_state_change_ = NO_TRANSITION;
 
   // Request filling of our fake buffers to trigger decode processing.  In
   // reality as soon as any data is decoded these will get dismissed due to
   // dimension mismatch.
   for (std::set<OMX_BUFFERHEADERTYPE*>::iterator it =
            fake_output_buffers_.begin();
        it != fake_output_buffers_.end(); ++it) {
     OMX_BUFFERHEADERTYPE* buffer = *it;
     OMX_ERRORTYPE result = OMX_FillThisBuffer(component_handle_, buffer);
-    RETURN_ON_OMX_FAILURE(result,
-                          "OMX_FillThisBuffer() failed with: " << result,
+    RETURN_ON_OMX_FAILURE(result, "OMX_FillThisBuffer()",
                           VIDEODECODERERROR_INVALIDINPUT,);
     ++output_buffers_at_component_;
   }
 
-  client_->NotifyInitializeDone();
+  if (client_)
+    client_->NotifyInitializeDone();
 }
 
 void OmxVideoDecodeAccelerator::OnReachedPauseInFlushing() {
   DCHECK_EQ(client_state_, OMX_StateExecuting);
   client_state_ = OMX_StatePause;
   FlushIOPorts();
 }
 
 void OmxVideoDecodeAccelerator::OnReachedExecutingInFlushing() {
   DCHECK_EQ(client_state_, OMX_StatePause);
   client_state_ = OMX_StateExecuting;
   DCHECK(saw_eos_during_flush_);
   saw_eos_during_flush_ = false;
   current_state_change_ = NO_TRANSITION;
-  client_->NotifyFlushDone();
+  if (client_)
+    client_->NotifyFlushDone();
 }
 
 void OmxVideoDecodeAccelerator::OnReachedPauseInResetting() {
   DCHECK_EQ(client_state_, OMX_StateExecuting);
   client_state_ = OMX_StatePause;
   FlushIOPorts();
 }
 
 void OmxVideoDecodeAccelerator::OnReachedExecutingInResetting() {
   DCHECK_EQ(client_state_, OMX_StatePause);
   client_state_ = OMX_StateExecuting;
   current_state_change_ = NO_TRANSITION;
-  client_->NotifyResetDone();
+  if (client_)
+    client_->NotifyResetDone();
+}
+
+// Alert: HORROR ahead!  OMX shutdown is an asynchronous dance but our clients
+// enjoy the fire-and-forget nature of a synchronous Destroy() call that
+// ensures no further callbacks are made.  Since the interface between OMX
+// callbacks and this class is a MessageLoop, we need to ensure the loop
+// outlives the shutdown dance, even during process shutdown.  We do this by
+// repeatedly enqueuing a no-op task until shutdown is complete, since
+// MessageLoop's shutdown drains pending tasks.
+void OmxVideoDecodeAccelerator::BusyLoopInDestroying() {
+  if (!component_handle_) return;
+  // Can't use PostDelayedTask here because MessageLoop doesn't drain delayed
+  // tasks.  Instead we sleep for 5ms.  Really.
+  base::PlatformThread::Sleep(5);

[vhiremath, 2011/07/14 14:29:15]

Why do we want to delay PostTask here ?
May cause any race-condition otherwise ?

[Ami GONE FROM CHROMIUM, 2011/07/14 16:23:03]

To reduce the CPU load of what otherwise would be a spinning busyloop.
No, no race condition.

+  message_loop_->PostTask(
+      FROM_HERE, NewRunnableMethod(
+          this, &OmxVideoDecodeAccelerator::BusyLoopInDestroying));
 }

[vhiremath, 2011/07/14 14:29:15]

Please explain how this logic works.
Note: We have the callbacks registered with openmax.
Those are still valid. 
So we continue to receive callbacks on omx thread till omx-component is alive.
Then from there we do PostTask on MessageLoop to say FillBufferDoneTask
(corresponding to FillBufferCallback).
So how does this loop help to convert that PostTask into NOP ?


Also, it is recursively calling back on itself.
How long does this outlive other threads ?
What is exit criteria ? or i did not understand the whole logic :(

[Ami GONE FROM CHROMIUM, 2011/07/14 16:23:03]

I think so.
The purpose of this method is simple: keep the MessageLoop from exiting during
its Quit() method, until OMX is guaranteed to not make any more callbacks.  That
guarantee is only made after OMX_FreeHandle returns, at which point we set
component_handle_ to NULL (which is why this method checks that at the top and
returns if it is already NULL).
MessageLoop's shutdown semantics are that it drains all pending tasks before
exiting.  As long as there is a pending task, it won't quit.  So this method
keeps enqueuing a new task as long as shutdown isn't complete.  Because
MessageLoop processes tasks FIFO, the eventual shutdown will be processed (i.e.
this semi-busyloop doesn't starve out the shutdown tasks).

Note that this method isn't trying to turn anything into a no-op.
Destroy() sets client_=NULL before returning, guaranteeing no further callbacks
will be made on the client, effectively turning further
{Fill,Empty}BufferDoneTask callbacks into no-op's, as far as the client is
concerned.

 
 void OmxVideoDecodeAccelerator::OnReachedIdleInDestroying() {
   DCHECK_EQ(client_state_, OMX_StateExecuting);
   client_state_ = OMX_StateIdle;
 
   // Note that during the Executing -> Idle transition, the OMX spec guarantees
   // buffers have been returned to the client, so we don't need to do an
   // explicit FlushIOPorts().
 
   BeginTransitionToState(OMX_StateLoaded);
 
   // TODO(fischman): evaluate what these conditionals are doing.  What happens
   // if they're false??
   if (!input_buffers_at_component_)
     FreeInputBuffers();
   if (!output_buffers_at_component_)
     FreeOutputBuffers();
-}
 
-void OmxVideoDecodeAccelerator::ShutdownComponent() {
-  OMX_ERRORTYPE result = omx_free_handle(component_handle_);
-  if (result != OMX_ErrorNone)
-    LOG(ERROR) << "OMX_FreeHandle() error. Error code: " << result;
-  component_handle_ = NULL;
-  omx_deinit();
-  client_state_ = OMX_StateMax;
+  BusyLoopInDestroying();
 }
 
 void OmxVideoDecodeAccelerator::OnReachedLoadedInDestroying() {
   DCHECK_EQ(client_state_, OMX_StateIdle);
   client_state_ = OMX_StateLoaded;
   current_state_change_ = NO_TRANSITION;
   ShutdownComponent();
-  client_->NotifyDestroyDone();
 }
 
 void OmxVideoDecodeAccelerator::OnReachedInvalidInErroring() {
   client_state_ = OMX_StateInvalid;
   ShutdownComponent();
 }
 
+void OmxVideoDecodeAccelerator::ShutdownComponent() {
+  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_StateMax;
+  // This Release() call must happen *after* any access to |*this| because it
+  // might result in |this| being deleted.
+  Release();  // Since OMX no longer has |this| to call back to.
+  omx_deinit();
+}
+
 void OmxVideoDecodeAccelerator::StopOnError(
     media::VideoDecodeAccelerator::Error error) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
-  current_state_change_ = ERRORING;
 
-  client_->NotifyError(error);
+  if (client_)
+    client_->NotifyError(error);
 
   if (client_state_ == OMX_StateInvalid || client_state_ == OMX_StateMax)
       return;
 
   BeginTransitionToState(OMX_StateInvalid);
+  current_state_change_ = ERRORING;
 }
 
 bool OmxVideoDecodeAccelerator::AllocateInputBuffers() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   for (int i = 0; i < input_buffer_count_; ++i) {
     OMX_BUFFERHEADERTYPE* buffer;
     // While registering the buffer header we use fake buffer information
     // (length 0, at memory address 0x1) to fake out the "safety" check in
     // OMX_UseBuffer.  When it comes time to actually use this header in Decode
     // we set these fields to their real values (for the duration of that
@@ skipping 20 matching lines @@
   gfx::Size decoded_pixel_size(pictures_.begin()->second.gles_buffer.size());
   gfx::Size visible_pixel_size(pictures_.begin()->second.gles_buffer.size());
   for (OutputPictureById::iterator it = pictures_.begin();
        it != pictures_.end(); ++it) {
     media::GLESBuffer& gles_buffer = it->second.gles_buffer;
     OMX_BUFFERHEADERTYPE** omx_buffer = &it->second.omx_buffer_header;
     DCHECK(!*omx_buffer);
     OMX_ERRORTYPE result = OMX_UseEGLImage(
         component_handle_, omx_buffer, output_port_, &gles_buffer,
         it->second.egl_image);
-    RETURN_ON_OMX_FAILURE(result, "OMX_UseEGLImage failed with: " << result,
+    RETURN_ON_OMX_FAILURE(result, "OMX_UseEGLImage",
                           VIDEODECODERERROR_MEMFAILURE, false);
     // Here we set a garbage bitstream buffer id, and then overwrite it before
     // passing to PictureReady.
     int garbage_bitstream_buffer_id = -1;
     (*omx_buffer)->pAppPrivate =
         new media::Picture(gles_buffer.id(), garbage_bitstream_buffer_id,
                            decoded_pixel_size, visible_pixel_size);
   }
   return true;
 }
 
 void OmxVideoDecodeAccelerator::FreeInputBuffers() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   // Calls to OMX to free buffers.
   OMX_ERRORTYPE result;
   OMX_BUFFERHEADERTYPE* omx_buffer;
   while (!free_input_buffers_.empty()) {
     omx_buffer = free_input_buffers_.front();
     free_input_buffers_.pop();
     result = OMX_FreeBuffer(component_handle_, input_port_, omx_buffer);
-    RETURN_ON_OMX_FAILURE(result, "OMX_FreeBuffer failed with: " << result,
+    RETURN_ON_OMX_FAILURE(result, "OMX_FreeBuffer",
                           VIDEODECODERERROR_INVALIDINPUT,);
   }
-  VLOG(1) << "Input buffers freed.";
 }
 
 void OmxVideoDecodeAccelerator::FreeOutputBuffers() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   // Calls to OMX to free buffers.
   OMX_ERRORTYPE result;
   static Gles2TextureToEglImageTranslator texture2eglImage_translator;
   for (OutputPictureById::iterator it = pictures_.begin();
        it != pictures_.end(); ++it) {
     OMX_BUFFERHEADERTYPE* omx_buffer = it->second.omx_buffer_header;
     CHECK(omx_buffer);
     delete reinterpret_cast<media::Picture*>(omx_buffer->pAppPrivate);
     result = OMX_FreeBuffer(component_handle_, output_port_, omx_buffer);
-    RETURN_ON_OMX_FAILURE(result, "OMX_FreeBuffer failed with: " << result,
+    RETURN_ON_OMX_FAILURE(result, "OMX_FreeBuffer",
                           VIDEODECODERERROR_INVALIDINPUT,);
     texture2eglImage_translator.DestroyEglImage(egl_display_,
                                                 it->second.egl_image);
-    client_->DismissPictureBuffer(it->first);
+    if (client_)
+      client_->DismissPictureBuffer(it->first);
   }
   pictures_.clear();
 }
 
 void OmxVideoDecodeAccelerator::OnOutputPortDisabled() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   OMX_PARAM_PORTDEFINITIONTYPE port_format;
   InitParam(*this, &port_format);
   port_format.nPortIndex = output_port_;
   OMX_ERRORTYPE result = OMX_GetParameter(
       component_handle_, OMX_IndexParamPortDefinition, &port_format);
-  RETURN_ON_OMX_FAILURE(result, "OMX_GetParameter failed with: " << result,
+  RETURN_ON_OMX_FAILURE(result, "OMX_GetParameter",
                         VIDEODECODERERROR_UNSUPPORTED,);
   DCHECK_EQ(port_format.nBufferCountMin, kNumPictureBuffers);
 
   // TODO(fischman): to support mid-stream resize, need to free/dismiss any
   // |pictures_| we already have.  Make sure that the shutdown-path agrees with
   // this (there's already freeing logic there, which should not be duplicated).
 
   // Request picture buffers to be handed to the component.
   // ProvidePictureBuffers() will trigger AssignGLESBuffers, which ultimately
   // assigns the textures to the component and re-enables the port.
   const OMX_VIDEO_PORTDEFINITIONTYPE& vformat = port_format.format.video;
-  client_->ProvidePictureBuffers(
-      kNumPictureBuffers,
-      gfx::Size(vformat.nFrameWidth, vformat.nFrameHeight),
-      PICTUREBUFFER_MEMORYTYPE_GL_TEXTURE);
+  if (client_) {
+    client_->ProvidePictureBuffers(
+        kNumPictureBuffers,
+        gfx::Size(vformat.nFrameWidth, vformat.nFrameHeight),
+        PICTUREBUFFER_MEMORYTYPE_GL_TEXTURE);
+  }
 }
 
 void OmxVideoDecodeAccelerator::OnOutputPortEnabled() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   if (!CanFillBuffer()) {
     StopOnError(VIDEODECODERERROR_UNSUPPORTED);  // Should be STATE_ERROR.
     return;
   }
 
   // Provide output buffers to decoder.
   for (OutputPictureById::iterator it = pictures_.begin();
        it != pictures_.end(); ++it) {
     OMX_BUFFERHEADERTYPE* omx_buffer = it->second.omx_buffer_header;
     DCHECK(omx_buffer);
     // Clear EOS flag.
     omx_buffer->nFlags &= ~OMX_BUFFERFLAG_EOS;
     omx_buffer->nOutputPortIndex = output_port_;
     ++output_buffers_at_component_;
     OMX_ERRORTYPE result = OMX_FillThisBuffer(component_handle_, omx_buffer);
-    RETURN_ON_OMX_FAILURE(result,
-                          "OMX_FillThisBuffer() failed with result " << result,
+    RETURN_ON_OMX_FAILURE(result, "OMX_FillThisBuffer() failed",
                           VIDEODECODERERROR_INSUFFICIENT_BUFFERS,);
   }
 }
 
 void OmxVideoDecodeAccelerator::FillBufferDoneTask(
     OMX_BUFFERHEADERTYPE* buffer) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DCHECK_GT(output_buffers_at_component_, 0);
   --output_buffers_at_component_;
 
   if (fake_output_buffers_.size() && fake_output_buffers_.count(buffer)) {
     CHECK_EQ(fake_output_buffers_.erase(buffer), 1U);
     OMX_ERRORTYPE result =
         OMX_FreeBuffer(component_handle_, output_port_, buffer);
-    RETURN_ON_OMX_FAILURE(result, "OMX_FreeBuffer failed with: " << result,
+    RETURN_ON_OMX_FAILURE(result, "OMX_FreeBuffer failed",
                           VIDEODECODERERROR_INVALIDINPUT,);
     return;
   }
   CHECK(!fake_output_buffers_.size());
 
   if (current_state_change_ == FLUSHING &&
       buffer->nFlags & OMX_BUFFERFLAG_EOS) {
     DCHECK(!saw_eos_during_flush_);
     saw_eos_during_flush_ = true;
   }
 
   // During the transition from Executing to Idle, and during port-flushing, all
   // pictures are sent back through here.  Avoid giving them to the client.
   // Also avoid sending the (fake) EOS buffer to the client.
   if ((current_state_change_ != NO_TRANSITION &&
        current_state_change_ != FLUSHING) ||
       saw_eos_during_flush_) {
     return;
   }
 
   CHECK(buffer->pAppPrivate);
   media::Picture* picture =
       reinterpret_cast<media::Picture*>(buffer->pAppPrivate);
   // See Decode() for an explanation of this abuse of nTimeStamp.
   picture->set_bitstream_buffer_id(buffer->nTimeStamp);
-  client_->PictureReady(*picture);
+  if (client_)
+    client_->PictureReady(*picture);
 }
 
 void OmxVideoDecodeAccelerator::EmptyBufferDoneTask(
     OMX_BUFFERHEADERTYPE* buffer) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   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 BitstreamBuffer's id and notify the client of
   // its completion.
   SharedMemoryAndId* input_buffer_details =
       reinterpret_cast<SharedMemoryAndId*>(buffer->pAppPrivate);
   DCHECK(input_buffer_details);
   buffer->pAppPrivate = NULL;
-  client_->NotifyEndOfBitstreamBuffer(input_buffer_details->second);
+  if (client_)
+    client_->NotifyEndOfBitstreamBuffer(input_buffer_details->second);
   delete input_buffer_details;
 }
 
 void OmxVideoDecodeAccelerator::DispatchStateReached(OMX_STATETYPE reached) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   switch (current_state_change_) {
     case INITIALIZING:
       switch (reached) {
         case OMX_StateIdle:
           OnReachedIdleInInitializing();
@@ skipping 41 matching lines @@
       NOTREACHED() << "Unexpected state in " << current_state_change_
                    << ": " << reached;
   }
 }
 
 void OmxVideoDecodeAccelerator::EventHandlerCompleteTask(OMX_EVENTTYPE event,
                                                          OMX_U32 data1,
                                                          OMX_U32 data2) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   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.
-      OMX_COMMANDTYPE cmd = static_cast<OMX_COMMANDTYPE>(data1);
-      switch (cmd) {
+    case OMX_EventCmdComplete:
+      switch (data1) {
         case OMX_CommandPortDisable:
           DCHECK_EQ(data2, output_port_);
           OnOutputPortDisabled();
-          break;
+          return;
         case OMX_CommandPortEnable:
           DCHECK_EQ(data2, output_port_);
           OnOutputPortEnabled();
-          break;
+          return;
         case OMX_CommandStateSet:
           DispatchStateReached(static_cast<OMX_STATETYPE>(data2));
-          break;
+          return;
         case OMX_CommandFlush:
           DCHECK(current_state_change_ == FLUSHING ||
                  current_state_change_ == RESETTING ||
                  current_state_change_ == DESTROYING);
           if (data2 == input_port_)
             InputPortFlushDone();
           else if (data2 == output_port_)
             OutputPortFlushDone();
           else
             NOTREACHED() << "Unexpected port flushed: " << data2;
-          break;
+          return;
         default:
           RETURN_ON_FAILURE(false, "Unknown command completed: " << data1,
                             VIDEODECODERERROR_HARDWARE,);
       }
-      break;
-    }
+      return;
     case OMX_EventError:
-      RETURN_ON_FAILURE(false, "EventError: " << data1,
-                        VIDEODECODERERROR_HARDWARE,);
+      if (current_state_change_ != DESTROYING &&
+          current_state_change_ != ERRORING) {
+        RETURN_ON_FAILURE(false, "EventError: 0x" << std::hex << data1,
+                          VIDEODECODERERROR_HARDWARE,);
+      }
+      return;
     case OMX_EventPortSettingsChanged:
       if (data2 == OMX_IndexParamPortDefinition) {
         DCHECK_EQ(data1, output_port_);
         // This event is only used for output resize; kick off handling that by
         // pausing the output port.
         SendCommandToPort(OMX_CommandPortDisable, output_port_);
       } else if (data1 == output_port_ &&
                  data2 == OMX_IndexConfigCommonOutputCrop) {
         // TODO(vjain): Handle video crop rect.
       } else {
         RETURN_ON_FAILURE(false,
                           "Unexpected EventPortSettingsChanged: "
                           << data1 << ", " << data2,
                           VIDEODECODERERROR_HARDWARE,);
       }
-      break;
+      return;
     case OMX_EventBufferFlag:
       if (data1 == output_port_) {
         DCHECK_EQ(current_state_change_, FLUSHING);
         OnReachedEOSInFlushing();
       } else {
         RETURN_ON_FAILURE(false,
                           "Unexpected OMX_EventBufferFlag: "
                           << data1 << ", " << data2,
                           VIDEODECODERERROR_HARDWARE,);
       }
-      break;
+      return;
     default:
       RETURN_ON_FAILURE(false, "Unexpected unhandled event: " << event,
                         VIDEODECODERERROR_HARDWARE,);
   }
 }
 
 // static
 OMX_ERRORTYPE OmxVideoDecodeAccelerator::EventHandler(OMX_HANDLETYPE component,
                                                       OMX_PTR priv_data,
                                                       OMX_EVENTTYPE event,
                                                       OMX_U32 data1,
                                                       OMX_U32 data2,
                                                       OMX_PTR event_data) {
   // Called on the OMX thread.
   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));
+      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) {
   // Called on the OMX thread.
   OmxVideoDecodeAccelerator* decoder =
@@ skipping 19 matching lines @@
   decoder->message_loop_->PostTask(
       FROM_HERE,
       NewRunnableMethod(decoder,
                         &OmxVideoDecodeAccelerator::FillBufferDoneTask,
                         buffer));
   return OMX_ErrorNone;
 }
 
 bool OmxVideoDecodeAccelerator::CanFillBuffer() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
+  if (current_state_change_ == DESTROYING ||
+      current_state_change_ == ERRORING) {
+    return false;
+  }
   return client_state_ == OMX_StateIdle ||
       client_state_ == OMX_StateExecuting ||
       client_state_ == OMX_StatePause;
 }
 
 bool OmxVideoDecodeAccelerator::SendCommandToPort(
     OMX_COMMANDTYPE cmd, int port_index) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   OMX_ERRORTYPE result = OMX_SendCommand(component_handle_,
                                          cmd, port_index, 0);
-  RETURN_ON_OMX_FAILURE(result, "SendCommand() failed" << cmd << ":" << result,
+  RETURN_ON_OMX_FAILURE(result, "SendCommand() failed" << cmd,
                         VIDEODECODERERROR_INVALIDINPUT, false);
   return true;
 }
-
-DISABLE_RUNNABLE_METHOD_REFCOUNT(OmxVideoDecodeAccelerator);