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 20 matching lines @@
 void OmxVideoDecodeAccelerator::Reset() {
   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());
+  if (current_state_change_ == ERRORING)
+    return;
   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;
   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);
+  message_loop_->PostTask(
+      FROM_HERE, NewRunnableMethod(
+          this, &OmxVideoDecodeAccelerator::BusyLoopInDestroying));
 }
 
 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);
+  client_ = NULL;
 
   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 30 matching lines @@
       switch (reached) {
         case OMX_StateIdle:
           OnReachedIdleInDestroying();
           return;
         case OMX_StateLoaded:
           OnReachedLoadedInDestroying();
           return;
         default:
           NOTREACHED() << "Unexpected state in DESTROYING: " << reached;
       }
+    case ERRORING:
+      switch (reached) {
+        case OMX_StateInvalid:
+          OnReachedInvalidInErroring();
+          return;
+        default:
+          NOTREACHED() << "Unexpected state in ERRORING: " << reached;
+      }
     default:
       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);