VideoDecodeAccelerator now SupportsWeakPtr instead of being RefCountedThreadSafe.

content/common/gpu/media/vaapi_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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
@@ skipping 18 matching lines @@
 using content::VaapiH264Decoder;
 
 VaapiVideoDecodeAccelerator::InputBuffer::InputBuffer() {
 }
 
 VaapiVideoDecodeAccelerator::InputBuffer::~InputBuffer() {
 }
 
 void VaapiVideoDecodeAccelerator::NotifyError(Error error) {
   if (message_loop_ != MessageLoop::current()) {
+    DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
     message_loop_->PostTask(FROM_HERE, base::Bind(
-        &VaapiVideoDecodeAccelerator::NotifyError, this, error));
+        &VaapiVideoDecodeAccelerator::NotifyError, weak_this_, error));
     return;
   }
 
   DVLOG(1) << "Notifying of error " << error;
 
   if (client_) {
     client_->NotifyError(error);
     client_ptr_factory_.InvalidateWeakPtrs();
   }
-  Destroy();
+  Destroy(make_scoped_ptr<media::VideoDecodeAccelerator>(NULL));
 }
 
 VaapiVideoDecodeAccelerator::VaapiVideoDecodeAccelerator(
     Client* client,
     const base::Callback<bool(void)>& make_context_current)
     : make_context_current_(make_context_current),
       state_(kUninitialized),
       input_ready_(&lock_),
       output_ready_(&lock_),
       message_loop_(MessageLoop::current()),
+      weak_this_(base::AsWeakPtr(this)),
       client_ptr_factory_(client),
       client_(client_ptr_factory_.GetWeakPtr()),
       decoder_thread_("VaapiDecoderThread") {
   DCHECK(client);
 }
 
 VaapiVideoDecodeAccelerator::~VaapiVideoDecodeAccelerator() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 }
 
 bool VaapiVideoDecodeAccelerator::Initialize(
     media::VideoCodecProfile profile) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kUninitialized);
   DVLOG(2) << "Initializing VAVDA, profile: " << profile;
 
   bool res = decoder_.Initialize(
       profile, x_display_, glx_context_, make_context_current_,
-      base::Bind(&VaapiVideoDecodeAccelerator::OutputPicCallback, this));
+      base::Bind(&VaapiVideoDecodeAccelerator::OutputPicCallback,
+                 base::Unretained(this)));
   if (!res) {
     DVLOG(1) << "Failed initializing decoder";
     return false;
   }
 
   CHECK(decoder_thread_.Start());
 
   state_ = kInitialized;
 
   message_loop_->PostTask(FROM_HERE, base::Bind(
@@ skipping 82 matching lines @@
           DVLOG(1) << "Requesting " << num_pics << " pictures of size: "
                    << size.width() << "x" << size.height();
           message_loop_->PostTask(FROM_HERE, base::Bind(
               &Client::ProvidePictureBuffers, client_,
               num_pics, size, GL_TEXTURE_2D));
         } else {
           base::AutoLock auto_lock(lock_);
           DCHECK_EQ(state_, kIdle);
           state_ = kDecoding;
           decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
-              &VaapiVideoDecodeAccelerator::DecodeTask, this));
+              &VaapiVideoDecodeAccelerator::DecodeTask,
+              base::Unretained(this)));
         }
         return;
 
       case VaapiH264Decoder::kNeedMoreStreamData:
         ReturnCurrInputBuffer();
         break;
 
       case VaapiH264Decoder::kDecodeError:
         RETURN_AND_NOTIFY_ON_FAILURE(false, "Error in decoding",
                                      PLATFORM_FAILURE, );
@@ skipping 140 matching lines @@
   TRACE_EVENT1("Video Decoder", "VAVDA::Decode", "Buffer id",
                bitstream_buffer.id());
 
   // We got a new input buffer from the client, map it and queue for later use.
   MapAndQueueNewInputBuffer(bitstream_buffer);
 
   base::AutoLock auto_lock(lock_);
   switch (state_) {
     case kInitialized:
       // Initial decode to get the required size of output buffers.
-      decoder_thread_.message_loop()->PostTask(FROM_HERE,
-          base::Bind(&VaapiVideoDecodeAccelerator::InitialDecodeTask, this));
+      decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+          &VaapiVideoDecodeAccelerator::InitialDecodeTask,
+          base::Unretained(this)));
       break;
 
     case kPicturesRequested:
       // Waiting for pictures, return.
       break;
 
     case kDecoding:
       break;
 
     case kIdle:
       // Need to get decoder into suitable stream location to resume.
-      decoder_thread_.message_loop()->PostTask(FROM_HERE,
-          base::Bind(&VaapiVideoDecodeAccelerator::InitialDecodeTask, this));
+      decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+          &VaapiVideoDecodeAccelerator::InitialDecodeTask,
+          base::Unretained(this)));
       break;
 
     default:
       DVLOG(1) << "Decode request from client in invalid state: " << state_;
       return;
   }
 }
 
 void VaapiVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPicturesRequested);
 
   for (size_t i = 0; i < buffers.size(); ++i) {
     DVLOG(2) << "Assigning picture id " << buffers[i].id()
              << " to texture id " << buffers[i].texture_id();
 
     bool res = decoder_.AssignPictureBuffer(buffers[i].id(),
                                             buffers[i].texture_id());
     RETURN_AND_NOTIFY_ON_FAILURE(
         res, "Failed assigning picture buffer id: " << buffers[i].id() <<
         ", texture id: " << buffers[i].texture_id(), PLATFORM_FAILURE, );
   }
 
   state_ = kDecoding;
-  decoder_thread_.message_loop()->PostTask(FROM_HERE,
-      base::Bind(&VaapiVideoDecodeAccelerator::DecodeTask, this));
+  decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+      &VaapiVideoDecodeAccelerator::DecodeTask, base::Unretained(this)));
 }
 
 void VaapiVideoDecodeAccelerator::ReusePictureBuffer(int32 picture_buffer_id) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   TRACE_EVENT1("Video Decoder", "VAVDA::ReusePictureBuffer", "Picture id",
                picture_buffer_id);
 
   base::AutoLock auto_lock(lock_);
   output_buffers_.push(picture_buffer_id);
   output_ready_.Signal();
 }
 
 void VaapiVideoDecodeAccelerator::FlushTask() {
   DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
   DVLOG(1) << "Flush task";
 
   // First flush all the pictures that haven't been outputted, notifying the
   // client to output them.
   bool res = decoder_.Flush();
   RETURN_AND_NOTIFY_ON_FAILURE(res, "Failed flushing the decoder.",
                                PLATFORM_FAILURE, );
 
   // Put the decoder in idle state, ready to resume.
   decoder_.Reset();
 
-  message_loop_->PostTask(FROM_HERE,
-      base::Bind(&VaapiVideoDecodeAccelerator::FinishFlush, this));
+  message_loop_->PostTask(FROM_HERE, base::Bind(
+      &VaapiVideoDecodeAccelerator::FinishFlush, weak_this_));
 }
 
 void VaapiVideoDecodeAccelerator::Flush() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DVLOG(1) << "Got flush request";
 
   base::AutoLock auto_lock(lock_);
   state_ = kFlushing;
   // Queue a flush task after all existing decoding tasks to clean up.
-  decoder_thread_.message_loop()->PostTask(FROM_HERE,
-      base::Bind(&VaapiVideoDecodeAccelerator::FlushTask, this));
+  decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+      &VaapiVideoDecodeAccelerator::FlushTask, base::Unretained(this)));
 
   input_ready_.Signal();
   output_ready_.Signal();
 }
 
 void VaapiVideoDecodeAccelerator::FinishFlush() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   base::AutoLock auto_lock(lock_);
   if (state_ != kFlushing) {
@@ skipping 16 matching lines @@
   // by now, as this task was scheduled after them and client is expected not
   // to call Decode() after Reset() and before NotifyResetDone.
   decoder_.Reset();
 
   // Return current input buffer, if present.
   if (curr_input_buffer_.get())
     ReturnCurrInputBuffer();
 
   // And let client know that we are done with reset.
   message_loop_->PostTask(FROM_HERE, base::Bind(
-      &VaapiVideoDecodeAccelerator::FinishReset, this));
+      &VaapiVideoDecodeAccelerator::FinishReset, weak_this_));
 }
 
 void VaapiVideoDecodeAccelerator::Reset() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
   DVLOG(1) << "Got reset request";
 
   // This will make any new decode tasks exit early.
   base::AutoLock auto_lock(lock_);
   state_ = kResetting;
 
-  decoder_thread_.message_loop()->PostTask(FROM_HERE,
-      base::Bind(&VaapiVideoDecodeAccelerator::ResetTask, this));
+  decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+      &VaapiVideoDecodeAccelerator::ResetTask, base::Unretained(this)));
 
   input_ready_.Signal();
   output_ready_.Signal();
 }
 
 void VaapiVideoDecodeAccelerator::FinishReset() {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   base::AutoLock auto_lock(lock_);
   if (state_ != kResetting) {
@@ skipping 10 matching lines @@
   }
 
   state_ = kIdle;
 
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Client::NotifyResetDone, client_));
 
   DVLOG(1) << "Reset finished";
 }
 
-void VaapiVideoDecodeAccelerator::Destroy() {
+void VaapiVideoDecodeAccelerator::Destroy(
+    scoped_ptr<VideoDecodeAccelerator> self) {
   DCHECK_EQ(message_loop_, MessageLoop::current());
 
   if (state_ == kUninitialized || state_ == kDestroying)
     return;
 
   DVLOG(1) << "Destroying VAVDA";
   base::AutoLock auto_lock(lock_);
   state_ = kDestroying;
 
   client_ptr_factory_.InvalidateWeakPtrs();
 
   {
     base::AutoUnlock auto_unlock(lock_);
     // Post a dummy task to the decoder_thread_ to ensure it is drained.
     base::WaitableEvent waiter(false, false);
     decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
         &base::WaitableEvent::Signal, base::Unretained(&waiter)));
     input_ready_.Signal();
     output_ready_.Signal();
     waiter.Wait();
+    decoder_thread_.Stop();
   }
 
   decoder_.Destroy();
   state_ = kUninitialized;
 }
 
 void VaapiVideoDecodeAccelerator::OutputPicCallback(int32 input_id,
                                                     int32 output_id) {
   TRACE_EVENT2("Video Decoder", "VAVDA::OutputPicCallback",
                "Input id", input_id, "Picture id", output_id);
   DVLOG(4) << "Outputting picture, input id: " << input_id
            << " output id: " << output_id;
 
   // Forward the request to the main thread.
   DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
-  message_loop_->PostTask(FROM_HERE,
-      base::Bind(&VaapiVideoDecodeAccelerator::SyncAndNotifyPictureReady,
-                 this, input_id, output_id));
+  message_loop_->PostTask(FROM_HERE, base::Bind(
+      &VaapiVideoDecodeAccelerator::SyncAndNotifyPictureReady, weak_this_,
+      input_id, output_id));
 }