VideoDecodeAccelerator now SupportsWeakPtr instead of being RefCountedThreadSafe.

content/common/gpu/media/mac_video_decode_accelerator.mm

 // 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/mac_video_decode_accelerator.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #import "base/mac/foundation_util.h"
 #import "base/memory/ref_counted_memory.h"
@@ skipping 94 matching lines @@
 }
 
 bool MacVideoDecodeAccelerator::Initialize(media::VideoCodecProfile profile) {
   DCHECK(CalledOnValidThread());
 
   IOSurfaceSupport* io_surface_support = IOSurfaceSupport::Initialize();
   if (!io_surface_support)
     return false;
 
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &MacVideoDecodeAccelerator::NotifyInitializeDone, this));
+      &MacVideoDecodeAccelerator::NotifyInitializeDone, base::AsWeakPtr(this)));
   return true;
 }
 
 void MacVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(client_,
                     "Call to Decode() during invalid state.", ILLEGAL_STATE,);
 
   base::SharedMemory memory(bitstream_buffer.handle(), true);
   RETURN_ON_FAILURE(memory.Map(bitstream_buffer.size()),
                     "Failed to SharedMemory::Map().", UNREADABLE_INPUT,);
 
   h264_parser_.SetStream(static_cast<const uint8_t*>(memory.memory()),
                          bitstream_buffer.size());
   while (true) {
     content::H264NALU nalu;
     content::H264Parser::Result result = h264_parser_.AdvanceToNextNALU(&nalu);
     if (result == content::H264Parser::kEOStream) {
       if (bitstream_nalu_count_.count(bitstream_buffer.id()) == 0) {
         MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-            &MacVideoDecodeAccelerator::NotifyInputBufferRead, this,
-            bitstream_buffer.id()));
+            &MacVideoDecodeAccelerator::NotifyInputBufferRead,
+            base::AsWeakPtr(this), bitstream_buffer.id()));
       }
       return;
     }
     RETURN_ON_FAILURE(result == content::H264Parser::kOk,
                       "Unable to parse bitstream.", UNREADABLE_INPUT,);
     if (!did_build_config_record_) {
       std::vector<uint8_t> config_record;
       RETURN_ON_FAILURE(config_record_builder_.ProcessNALU(&h264_parser_, nalu,
                                                            &config_record),
                         "Unable to build AVC configuraiton record.",
@@ skipping 41 matching lines @@
   available_pictures_.push_back(info.picture_buffer);
   SendImages();
 }
 
 void MacVideoDecodeAccelerator::Flush() {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(vda_support_,
                     "Call to Flush() during invalid state.", ILLEGAL_STATE,);
   vda_support_->Flush(true);
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &MacVideoDecodeAccelerator::NotifyFlushDone, this));
+      &MacVideoDecodeAccelerator::NotifyFlushDone, base::AsWeakPtr(this)));
 }
 
 void MacVideoDecodeAccelerator::Reset() {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(vda_support_,
                     "Call to Reset() during invalid state.", ILLEGAL_STATE,);
   vda_support_->Flush(false);
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &MacVideoDecodeAccelerator::NotifyResetDone, this));
+      &MacVideoDecodeAccelerator::NotifyResetDone, base::AsWeakPtr(this)));
 }
 
-void MacVideoDecodeAccelerator::Destroy() {
+void MacVideoDecodeAccelerator::Cleanup() {
   DCHECK(CalledOnValidThread());
   if (vda_support_) {
     vda_support_->Destroy();
     vda_support_ = NULL;
   }
   client_ = NULL;
   decoded_images_.clear();
 }
 
+void MacVideoDecodeAccelerator::Destroy() {
+  DCHECK(CalledOnValidThread());
+  Cleanup();
+  delete this;
+}
+
 MacVideoDecodeAccelerator::~MacVideoDecodeAccelerator() {
   DCHECK(CalledOnValidThread());
-  Destroy();
+  DCHECK(!vda_support_);
+  DCHECK(!client_);
+  DCHECK(decoded_images_.empty());
 }
 
 void MacVideoDecodeAccelerator::OnFrameReady(
     int32 bitstream_buffer_id,
     scoped_refptr<base::RefCountedBytes> bytes,
     CVImageBufferRef image,
     int status) {
   DCHECK(CalledOnValidThread());
   RETURN_ON_FAILURE(status == noErr,
                     "Decoding image failed with error code: " << status,
                     PLATFORM_FAILURE,);
   if (!client_)
     return;
   if (image) {
     DecodedImageInfo info;
     info.image.reset(image, base::scoped_policy::RETAIN);
     info.bitstream_buffer_id = bitstream_buffer_id;
     decoded_images_.push_back(info);
     SendImages();
   }
   std::map<int32, int>::iterator bitstream_count_it =
       bitstream_nalu_count_.find(bitstream_buffer_id);
   if (--bitstream_count_it->second == 0) {
     bitstream_nalu_count_.erase(bitstream_count_it);
     MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-        &MacVideoDecodeAccelerator::NotifyInputBufferRead, this,
-        bitstream_buffer_id));
+        &MacVideoDecodeAccelerator::NotifyInputBufferRead,
+        base::AsWeakPtr(this), bitstream_buffer_id));
   }
 }
 
 void MacVideoDecodeAccelerator::SendImages() {
   if (!client_) {
     DCHECK(decoded_images_.empty());
     return;
   }
 
   while (available_pictures_.size() && decoded_images_.size()) {
@@ skipping 10 matching lines @@
         picture_buffer.id(), UsedPictureInfo(picture_buffer, info.image)));
     client_->PictureReady(
         media::Picture(picture_buffer.id(), info.bitstream_buffer_id));
   }
 }
 
 void MacVideoDecodeAccelerator::StopOnError(
     media::VideoDecodeAccelerator::Error error) {
   if (client_)
     client_->NotifyError(error);
-  Destroy();
+  Cleanup();
 }
 
 bool MacVideoDecodeAccelerator::CreateDecoder(
     const std::vector<uint8_t>& extra_data) {
   DCHECK(client_);
   DCHECK(!vda_support_.get());
 
   vda_support_ = new gfx::VideoDecodeAccelerationSupport();
   gfx::VideoDecodeAccelerationSupport::Status status = vda_support_->Create(
       config_record_builder_.coded_width(),
       config_record_builder_.coded_height(),
       kCVPixelFormatType_422YpCbCr8,
       &extra_data[0], extra_data.size());
   RETURN_ON_FAILURE(status == gfx::VideoDecodeAccelerationSupport::SUCCESS,
                     "Creating video decoder failed with error: " << status,
                     PLATFORM_FAILURE, false);
 
   MessageLoop::current()->PostTask(FROM_HERE, base::Bind(
-      &MacVideoDecodeAccelerator::RequestPictures, this));
+      &MacVideoDecodeAccelerator::RequestPictures, base::AsWeakPtr(this)));
   return true;
 }
 
 void MacVideoDecodeAccelerator::DecodeNALU(const content::H264NALU& nalu,
                                            int32 bitstream_buffer_id) {
   // Assume the NALU length field size is 4 bytes.
   const int kNALULengthFieldSize = 4;
   std::vector<uint8_t> data(kNALULengthFieldSize + nalu.size);
 
   // Store the buffer size at the beginning of the buffer as the decoder
   // expects.
   for (size_t i = 0; i < kNALULengthFieldSize; ++i) {
     size_t shift = kNALULengthFieldSize * 8 - (i + 1) * 8;
     data[i] = (nalu.size >> shift) & 0xff;
   }
 
   // Copy the NALU data.
   memcpy(&data[kNALULengthFieldSize], nalu.data, nalu.size);
 
   // Keep a ref counted copy of the buffer.
   scoped_refptr<base::RefCountedBytes> bytes(
       base::RefCountedBytes::TakeVector(&data));
-  vda_support_->Decode(bytes->front(), bytes->size(),
-                       base::Bind(&MacVideoDecodeAccelerator::OnFrameReady,
-                                  this, bitstream_buffer_id, bytes));
+  vda_support_->Decode(bytes->front(), bytes->size(), base::Bind(
+      &MacVideoDecodeAccelerator::OnFrameReady,
+      base::AsWeakPtr(this), bitstream_buffer_id, bytes));
 }
 
 void MacVideoDecodeAccelerator::NotifyInitializeDone() {
   if (client_)
     client_->NotifyInitializeDone();
 }
 
 void MacVideoDecodeAccelerator::RequestPictures() {
   if (client_) {
     client_->ProvidePictureBuffers(
@@ skipping 28 matching lines @@
 }
 
 MacVideoDecodeAccelerator::UsedPictureInfo::~UsedPictureInfo() {
 }
 
 MacVideoDecodeAccelerator::DecodedImageInfo::DecodedImageInfo() {
 }
 
 MacVideoDecodeAccelerator::DecodedImageInfo::~DecodedImageInfo() {
 }