WeakPtr destruction order cleanup: media edition.

media/filters/video_renderer_impl.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 "media/filters/video_renderer_impl.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
@@ skipping 12 matching lines @@
 }
 
 VideoRendererImpl::VideoRendererImpl(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner,
     ScopedVector<VideoDecoder> decoders,
     const SetDecryptorReadyCB& set_decryptor_ready_cb,
     const PaintCB& paint_cb,
     const SetOpaqueCB& set_opaque_cb,
     bool drop_frames)
     : task_runner_(task_runner),
-      weak_factory_(this),
-      video_frame_stream_(
-          task_runner, decoders.Pass(), set_decryptor_ready_cb),
+      video_frame_stream_(task_runner, decoders.Pass(), set_decryptor_ready_cb),
       received_end_of_stream_(false),
       frame_available_(&lock_),
       state_(kUninitialized),
       thread_(),
       pending_read_(false),
       drop_frames_(drop_frames),
       playback_rate_(0),
       paint_cb_(paint_cb),
       set_opaque_cb_(set_opaque_cb),
       last_timestamp_(kNoTimestamp()),
       frames_decoded_(0),
-      frames_dropped_(0) {
+      frames_dropped_(0),
+      weak_factory_(this) {
   DCHECK(!paint_cb_.is_null());
 }
 
 VideoRendererImpl::~VideoRendererImpl() {
   base::AutoLock auto_lock(lock_);
   CHECK(state_ == kStopped || state_ == kUninitialized) << state_;
   CHECK(thread_.is_null());
 }
 
 void VideoRendererImpl::Play(const base::Closure& callback) {
@@ skipping 16 matching lines @@
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, kPaused);
   flush_cb_ = callback;
   state_ = kFlushing;
 
   // This is necessary if the |video_frame_stream_| has already seen an end of
   // stream and needs to drain it before flushing it.
   ready_frames_.clear();
   received_end_of_stream_ = false;
-  video_frame_stream_.Reset(base::Bind(
-      &VideoRendererImpl::OnVideoFrameStreamResetDone, weak_this_));
+  video_frame_stream_.Reset(
+      base::Bind(&VideoRendererImpl::OnVideoFrameStreamResetDone,
+                 weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::Stop(const base::Closure& callback) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
   if (state_ == kUninitialized || state_ == kStopped) {
     callback.Run();
     return;
   }
 
@@ skipping 70 matching lines @@
   DCHECK(stream);
   DCHECK_EQ(stream->type(), DemuxerStream::VIDEO);
   DCHECK(!init_cb.is_null());
   DCHECK(!statistics_cb.is_null());
   DCHECK(!max_time_cb.is_null());
   DCHECK(!ended_cb.is_null());
   DCHECK(!get_time_cb.is_null());
   DCHECK(!get_duration_cb.is_null());
   DCHECK_EQ(kUninitialized, state_);
 
-  weak_this_ = weak_factory_.GetWeakPtr();
   init_cb_ = init_cb;
   statistics_cb_ = statistics_cb;
   max_time_cb_ = max_time_cb;
   ended_cb_ = ended_cb;
   error_cb_ = error_cb;
   get_time_cb_ = get_time_cb;
   get_duration_cb_ = get_duration_cb;
   state_ = kInitializing;
 
   video_frame_stream_.Initialize(
       stream,
       statistics_cb,
       base::Bind(&VideoRendererImpl::OnVideoFrameStreamInitialized,
-                 weak_this_));
+                 weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::OnVideoFrameStreamInitialized(bool success,
                                                       bool has_alpha) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(lock_);
 
   if (state_ == kStopped)
     return;
 
@@ skipping 115 matching lines @@
   lock_.AssertAcquired();
 
   scoped_refptr<VideoFrame> next_frame = ready_frames_.front();
   ready_frames_.pop_front();
   frames_decoded_++;
 
   last_timestamp_ = next_frame->GetTimestamp();
 
   paint_cb_.Run(next_frame);
 
-  task_runner_->PostTask(FROM_HERE, base::Bind(
-      &VideoRendererImpl::AttemptRead, weak_this_));
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&VideoRendererImpl::AttemptRead, weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::DropNextReadyFrame_Locked() {
   TRACE_EVENT0("media", "VideoRendererImpl:frameDropped");
 
   lock_.AssertAcquired();
 
   last_timestamp_ = ready_frames_.front()->GetTimestamp();
   ready_frames_.pop_front();
   frames_decoded_++;
   frames_dropped_++;
 
-  task_runner_->PostTask(FROM_HERE, base::Bind(
-      &VideoRendererImpl::AttemptRead, weak_this_));
+  task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&VideoRendererImpl::AttemptRead, weak_factory_.GetWeakPtr()));
 }
 
 void VideoRendererImpl::FrameReady(VideoFrameStream::Status status,
                                    const scoped_refptr<VideoFrame>& frame) {
   base::AutoLock auto_lock(lock_);
   DCHECK_NE(state_, kUninitialized);
   DCHECK_NE(state_, kFlushed);
 
   CHECK(pending_read_);
   pending_read_ = false;
@@ skipping 104 matching lines @@
       ready_frames_.size() == static_cast<size_t>(limits::kMaxVideoFrames)) {
     return;
   }
 
   switch (state_) {
     case kPaused:
     case kPrerolling:
     case kPlaying:
       pending_read_ = true;
       video_frame_stream_.Read(base::Bind(&VideoRendererImpl::FrameReady,
-                                          weak_this_));
+                                          weak_factory_.GetWeakPtr()));
       return;
 
     case kUninitialized:
     case kInitializing:
     case kPrerolled:
     case kFlushing:
     case kFlushed:
     case kEnded:
     case kStopped:
     case kError:
@@ skipping 63 matching lines @@
     statistics_cb_.Run(statistics);
 
     frames_decoded_ = 0;
     frames_dropped_ = 0;
   }
 
   frame_available_.TimedWait(wait_duration);
 }
 
 }  // namespace media