VideoDecodeAccelerator now SupportsWeakPtr instead of being RefCountedThreadSafe.

content/common/gpu/media/omx_video_decode_accelerator.cc

 // Copyright (c) 2012 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/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
@@ skipping 83 matching lines @@
 #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),
+      weak_this_(base::AsWeakPtr(this)),
       init_begun_(false),
       client_state_(OMX_StateMax),
       current_state_change_(NO_TRANSITION),
       input_buffer_count_(0),
       input_buffer_size_(0),
       input_port_(0),
       input_buffers_at_component_(0),
       output_port_(0),
       output_buffers_at_component_(0),
       client_(client),
@@ skipping 69 matching lines @@
   OMX_U32 num_components = 1;
   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,
                         PLATFORM_FAILURE, false);
   RETURN_ON_FAILURE(num_components == 1, "No components for: " << role_name,
                     PLATFORM_FAILURE, 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(),
                         PLATFORM_FAILURE, false);
   client_state_ = OMX_StateLoaded;
 
   component_name_is_nvidia_h264ext_ = !strcmp(
       reinterpret_cast<char *>(component.get()),
@@ skipping 228 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());
+
+  scoped_ptr<OmxVideoDecodeAccelerator> deleter(this);
+
   if (current_state_change_ == ERRORING ||
       current_state_change_ == DESTROYING) {
     return;
   }
 
   DCHECK(current_state_change_ == NO_TRANSITION ||
          current_state_change_ == FLUSHING ||
          current_state_change_ == RESETTING) << current_state_change_;
 
   // 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(client_state_ == OMX_StateExecuting ||
          client_state_ == OMX_StateIdle ||
          client_state_ == OMX_StatePause);
   current_state_change_ = DESTROYING;
   client_ = NULL;
   BeginTransitionToState(OMX_StateIdle);
-  BusyLoopInDestroying();
+  BusyLoopInDestroying(deleter.Pass());
 }
 
 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;
@@ skipping 79 matching lines @@
   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() {
+void OmxVideoDecodeAccelerator::BusyLoopInDestroying(
+    scoped_ptr<OmxVideoDecodeAccelerator> self) {
   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(base::TimeDelta::FromMilliseconds(5));
-  message_loop_->PostTask(
-      FROM_HERE, base::Bind(
-          &OmxVideoDecodeAccelerator::BusyLoopInDestroying, this));
+  MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
+      &OmxVideoDecodeAccelerator::BusyLoopInDestroying,
+      base::Unretained(this), base::Passed(&self)));
 }
 
 void OmxVideoDecodeAccelerator::OnReachedIdleInDestroying() {
   DCHECK(client_state_ == OMX_StateExecuting ||
          client_state_ == OMX_StateIdle ||
          client_state_ == OMX_StatePause);
   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();
-
-  BusyLoopInDestroying();
 }
 
 void OmxVideoDecodeAccelerator::OnReachedLoadedInDestroying() {
   DCHECK_EQ(client_state_, OMX_StateIdle);
   client_state_ = OMX_StateLoaded;
   current_state_change_ = NO_TRANSITION;
   ShutdownComponent();
 }
 
 void OmxVideoDecodeAccelerator::OnReachedInvalidInErroring() {
   client_state_ = OMX_StateInvalid;
   ShutdownComponent();
 }
 
 void OmxVideoDecodeAccelerator::ShutdownComponent() {
   OMX_ERRORTYPE result = omx_free_handle(component_handle_);
   if (result != OMX_ErrorNone)
     DLOG(ERROR) << "OMX_FreeHandle() error. Error code: " << result;
+  client_state_ = OMX_StateMax;
+  omx_deinit();
+  // Allow BusyLoopInDestroying to exit and delete |this|.
   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());
 
   if (client_ && init_begun_)
     client_->NotifyError(error);
   client_ = NULL;
 
@@ skipping 364 matching lines @@
                                                       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, base::Bind(
-      &OmxVideoDecodeAccelerator::EventHandlerCompleteTask, decoder,
-      event, data1, data2));
+      &OmxVideoDecodeAccelerator::EventHandlerCompleteTask,
+      decoder->weak_this(), event, data1, data2));
   return OMX_ErrorNone;
 }
 
 // static
 OMX_ERRORTYPE OmxVideoDecodeAccelerator::EmptyBufferCallback(
     OMX_HANDLETYPE component,
     OMX_PTR priv_data,
     OMX_BUFFERHEADERTYPE* buffer) {
   TRACE_EVENT1("Video Decoder", "OVDA::EmptyBufferCallback",
                "Buffer id", buffer->nTimeStamp);
   // Called on the OMX thread.
   OmxVideoDecodeAccelerator* decoder =
       static_cast<OmxVideoDecodeAccelerator*>(priv_data);
   DCHECK_EQ(component, decoder->component_handle_);
   decoder->message_loop_->PostTask(FROM_HERE, base::Bind(
-      &OmxVideoDecodeAccelerator::EmptyBufferDoneTask, decoder, buffer));
+      &OmxVideoDecodeAccelerator::EmptyBufferDoneTask, decoder->weak_this(),
+      buffer));
   return OMX_ErrorNone;
 }
 
 // static
 OMX_ERRORTYPE OmxVideoDecodeAccelerator::FillBufferCallback(
     OMX_HANDLETYPE component,
     OMX_PTR priv_data,
     OMX_BUFFERHEADERTYPE* buffer) {
   media::Picture* picture =
       reinterpret_cast<media::Picture*>(buffer->pAppPrivate);
   int picture_buffer_id = picture ? picture->picture_buffer_id() : -1;
   TRACE_EVENT2("Video Decoder", "OVDA::FillBufferCallback",
                "Buffer id", buffer->nTimeStamp,
                "Picture id", picture_buffer_id);
   // Called on the OMX thread.
   OmxVideoDecodeAccelerator* decoder =
       static_cast<OmxVideoDecodeAccelerator*>(priv_data);
   DCHECK_EQ(component, decoder->component_handle_);
   decoder->message_loop_->PostTask(FROM_HERE, base::Bind(
-      &OmxVideoDecodeAccelerator::FillBufferDoneTask, decoder, buffer));
+      &OmxVideoDecodeAccelerator::FillBufferDoneTask, decoder->weak_this(),
+      buffer));
   return OMX_ErrorNone;
 }
 
 bool OmxVideoDecodeAccelerator::CanFillBuffer() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   const CurrentStateChange csc = current_state_change_;
   const OMX_STATETYPE cs = client_state_;
   return (csc != DESTROYING && csc != ERRORING) &&
       (cs == OMX_StateIdle || cs == OMX_StateExecuting || cs == 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,
                         PLATFORM_FAILURE, false);
   return true;
 }