WeakPtr destruction order cleanup: media edition.

content/renderer/media/rtc_video_decoder.cc

 // Copyright 2013 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/renderer/media/rtc_video_decoder.h"
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop_proxy.h"
@@ skipping 69 matching lines @@
       vda_task_runner_(factories->GetTaskRunner()),
       decoder_texture_target_(0),
       next_picture_buffer_id_(0),
       state_(UNINITIALIZED),
       decode_complete_callback_(NULL),
       num_shm_buffers_(0),
       next_bitstream_buffer_id_(0),
       reset_bitstream_buffer_id_(ID_INVALID),
       weak_factory_(this) {
   DCHECK(!vda_task_runner_->BelongsToCurrentThread());
-  weak_this_ = weak_factory_.GetWeakPtr();
 }
 
 RTCVideoDecoder::~RTCVideoDecoder() {
   DVLOG(2) << "~RTCVideoDecoder";
   DCHECK(vda_task_runner_->BelongsToCurrentThread());
   DestroyVDA();
 
   // Delete all shared memories.
   STLDeleteElements(&available_shm_segments_);
   STLDeleteValues(&bitstream_buffers_in_decoder_);
@@ skipping 55 matching lines @@
 
   base::AutoLock auto_lock(lock_);
   if (state_ == UNINITIALIZED || state_ == DECODE_ERROR) {
     LOG(ERROR) << "VDA is not initialized. state=" << state_;
     return RecordInitDecodeUMA(WEBRTC_VIDEO_CODEC_UNINITIALIZED);
   }
   // Create some shared memory if the queue is empty.
   if (available_shm_segments_.size() == 0) {
     vda_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&RTCVideoDecoder::CreateSHM,
-                                          weak_this_,
+                                          weak_factory_.GetWeakPtr(),
                                           kMaxInFlightDecodes,
                                           kSharedMemorySegmentBytes));
   }
   return RecordInitDecodeUMA(WEBRTC_VIDEO_CODEC_OK);
 }
 
 int32_t RTCVideoDecoder::Decode(
     const webrtc::EncodedImage& inputImage,
     bool missingFrames,
     const webrtc::RTPFragmentationHeader* /*fragmentation*/,
@@ skipping 67 matching lines @@
     if (!SaveToPendingBuffers_Locked(inputImage, buffer_data))
       return WEBRTC_VIDEO_CODEC_ERROR;
     if (need_to_reset_for_midstream_resize) {
       base::AutoUnlock auto_unlock(lock_);
       Reset();
     }
     return WEBRTC_VIDEO_CODEC_OK;
   }
 
   SaveToDecodeBuffers_Locked(inputImage, shm_buffer.Pass(), buffer_data);
-  vda_task_runner_->PostTask(
-      FROM_HERE, base::Bind(&RTCVideoDecoder::RequestBufferDecode, weak_this_));
+  vda_task_runner_->PostTask(FROM_HERE,
+                             base::Bind(&RTCVideoDecoder::RequestBufferDecode,
+                                        weak_factory_.GetWeakPtr()));
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 int32_t RTCVideoDecoder::RegisterDecodeCompleteCallback(
     webrtc::DecodedImageCallback* callback) {
   DVLOG(2) << "RegisterDecodeCompleteCallback";
   base::AutoLock auto_lock(lock_);
   decode_complete_callback_ = callback;
   return WEBRTC_VIDEO_CODEC_OK;
 }
@@ skipping 12 matching lines @@
     LOG(ERROR) << "Decoder not initialized.";
     return WEBRTC_VIDEO_CODEC_UNINITIALIZED;
   }
   if (next_bitstream_buffer_id_ != 0)
     reset_bitstream_buffer_id_ = next_bitstream_buffer_id_ - 1;
   else
     reset_bitstream_buffer_id_ = ID_LAST;
   // If VDA is already resetting, no need to request the reset again.
   if (state_ != RESETTING) {
     state_ = RESETTING;
-    vda_task_runner_->PostTask(
-        FROM_HERE, base::Bind(&RTCVideoDecoder::ResetInternal, weak_this_));
+    vda_task_runner_->PostTask(FROM_HERE,
+                               base::Bind(&RTCVideoDecoder::ResetInternal,
+                                          weak_factory_.GetWeakPtr()));
   }
   return WEBRTC_VIDEO_CODEC_OK;
 }
 
 void RTCVideoDecoder::NotifyInitializeDone() {
   DVLOG(2) << "NotifyInitializeDone";
   NOTREACHED();
 }
 
 void RTCVideoDecoder::ProvidePictureBuffers(uint32 count,
@@ skipping 134 matching lines @@
     size_t size) {
   gfx::Rect visible_rect(width, height);
   DCHECK(decoder_texture_target_);
   // Convert timestamp from 90KHz to ms.
   base::TimeDelta timestamp_ms = base::TimeDelta::FromInternalValue(
       base::checked_cast<uint64_t>(timestamp) * 1000 / 90);
   return media::VideoFrame::WrapNativeTexture(
       make_scoped_ptr(new gpu::MailboxHolder(
           pb.texture_mailbox(), decoder_texture_target_, 0)),
       media::BindToCurrentLoop(base::Bind(&RTCVideoDecoder::ReusePictureBuffer,
-                                          weak_this_,
+                                          weak_factory_.GetWeakPtr(),
                                           picture.picture_buffer_id())),
       pb.size(),
       visible_rect,
       visible_rect.size(),
       timestamp_ms,
       base::Bind(&ReadPixelsSync, factories_, pb.texture_id(), visible_rect));
 }
 
 void RTCVideoDecoder::NotifyEndOfBitstreamBuffer(int32 id) {
   DVLOG(3) << "NotifyEndOfBitstreamBuffer. id=" << id;
@@ skipping 256 matching lines @@
   SHMBuffer* ret = NULL;
   if (!available_shm_segments_.empty() &&
       available_shm_segments_.back()->size >= min_size) {
     ret = available_shm_segments_.back();
     available_shm_segments_.pop_back();
   }
   // Post to vda thread to create shared memory if SHM cannot be reused or the
   // queue is almost empty.
   if (num_shm_buffers_ < kMaxNumSharedMemorySegments &&
       (ret == NULL || available_shm_segments_.size() <= 1)) {
-    vda_task_runner_->PostTask(
-        FROM_HERE,
-        base::Bind(&RTCVideoDecoder::CreateSHM, weak_this_, 1, min_size));
+    vda_task_runner_->PostTask(FROM_HERE,
+                               base::Bind(&RTCVideoDecoder::CreateSHM,
+                                          weak_factory_.GetWeakPtr(),
+                                          1,
+                                          min_size));
   }
   return scoped_ptr<SHMBuffer>(ret);
 }
 
 void RTCVideoDecoder::PutSHM_Locked(scoped_ptr<SHMBuffer> shm_buffer) {
   available_shm_segments_.push_back(shm_buffer.release());
 }
 
 void RTCVideoDecoder::CreateSHM(int number, size_t min_size) {
   DCHECK(vda_task_runner_->BelongsToCurrentThread());
@@ skipping 50 matching lines @@
 
 int32_t RTCVideoDecoder::RecordInitDecodeUMA(int32_t status) {
   // Logging boolean is enough to know if HW decoding has been used. Also,
   // InitDecode is less likely to return an error so enum is not used here.
   bool sample = (status == WEBRTC_VIDEO_CODEC_OK) ? true : false;
   UMA_HISTOGRAM_BOOLEAN("Media.RTCVideoDecoderInitDecodeSuccess", sample);
   return status;
 }
 
 }  // namespace content