Pipeline: Use WeakPtr for DemuxerHost Calls and Tasks.

media/base/pipeline.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 "media/base/pipeline.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/callback.h"
@@ skipping 251 matching lines @@
 
     case kPlaying:
     case kStopping:
     case kStopped:
       break;
   }
   NOTREACHED() << "State has no transition: " << state_;
   return state_;
 }
 
-// The use of base::Unretained(this) in the following 3 functions is safe
-// because these functions are called by the Demuxer directly, before the stop
-// callback is posted by the Demuxer. So the posted tasks will always be
-// executed before the stop callback is executed, and hence before the Pipeline
-// is destructed.
-
 void Pipeline::OnDemuxerError(PipelineStatus error) {
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&Pipeline::ErrorChangedTask,
-                                    base::Unretained(this),
+                                    weak_this_for_demuxer_,
                                     error));
 }
 
 void Pipeline::AddTextStream(DemuxerStream* text_stream,
                              const TextTrackConfig& config) {
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&Pipeline::AddTextStreamTask,
-                                    base::Unretained(this),
+                                    weak_this_for_demuxer_,
                                     text_stream,
                                     config));
 }
 
 void Pipeline::RemoveTextStream(DemuxerStream* text_stream) {
   task_runner_->PostTask(FROM_HERE,
                          base::Bind(&Pipeline::RemoveTextStreamTask,
-                                    base::Unretained(this),
+                                    weak_this_for_demuxer_,
                                     text_stream));
 }
 
 void Pipeline::OnError(PipelineStatus error) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   DCHECK(IsRunning());
   DCHECK_NE(PIPELINE_OK, error);
   VLOG(1) << "Media pipeline error: " << error;
 
   task_runner_->PostTask(FROM_HERE, base::Bind(
@@ skipping 235 matching lines @@
   DCHECK(!text_renderer_);
   {
     base::AutoLock l(lock_);
     running_ = false;
   }
 
   SetState(kStopped);
   filter_collection_.reset();
   demuxer_ = NULL;
 
+  // Invalid all weak pointers so it's safe to destroy |this| on the render
+  // main thread.
+  weak_factory_.InvalidateWeakPtrs();
+
   // If we stop during initialization/seeking we want to run |seek_cb_|
   // followed by |stop_cb_| so we don't leave outstanding callbacks around.
   if (!seek_cb_.is_null()) {
     base::ResetAndReturn(&seek_cb_).Run(status_);
     error_cb_.Reset();
   }
   if (!stop_cb_.is_null()) {
     error_cb_.Reset();
     base::ResetAndReturn(&stop_cb_).Run();
 
@@ skipping 209 matching lines @@
 }
 
 void Pipeline::RemoveTextStreamTask(DemuxerStream* text_stream) {
   DCHECK(task_runner_->BelongsToCurrentThread());
   text_renderer_->RemoveTextStream(text_stream);
 }
 
 void Pipeline::InitializeDemuxer(const PipelineStatusCB& done_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
+  weak_this_for_demuxer_ = weak_factory_.GetWeakPtr();
   demuxer_ = filter_collection_->GetDemuxer();
   demuxer_->Initialize(this, done_cb, text_renderer_);
 }
 
 void Pipeline::InitializeAudioRenderer(const PipelineStatusCB& done_cb) {
   DCHECK(task_runner_->BelongsToCurrentThread());
 
   audio_renderer_ = filter_collection_->GetAudioRenderer();
   base::WeakPtr<Pipeline> weak_this = weak_factory_.GetWeakPtr();
   audio_renderer_->Initialize(
@@ skipping 125 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (interpolation_state_ != INTERPOLATION_WAITING_FOR_AUDIO_TIME_UPDATE)
     return;
 
   interpolation_state_ = INTERPOLATION_STARTED;
   interpolator_->StartInterpolating();
 }
 
 }  // namespace media