Refactor MediaSourceDelegate destruction.

content/renderer/media/android/media_source_delegate.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/android/media_source_delegate.h"
 
 #include <limits>
 #include <string>
 #include <vector>
 
@@ skipping 63 matching lines @@
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
   DCHECK(!chunk_demuxer_);
   DCHECK(!demuxer_client_);
   DCHECK(!audio_decrypting_demuxer_stream_);
   DCHECK(!video_decrypting_demuxer_stream_);
   DCHECK(!audio_stream_);
   DCHECK(!video_stream_);
 }
 
-void MediaSourceDelegate::Destroy() {
+void MediaSourceDelegate::Stop(const base::Closure& stop_cb) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
 
   if (!chunk_demuxer_) {
     DCHECK(!demuxer_client_);
-    delete this;
     return;
   }
 
   duration_change_cb_.Reset();
   update_network_state_cb_.Reset();
   media_source_opened_cb_.Reset();
 
   main_weak_factory_.InvalidateWeakPtrs();
   DCHECK(!main_weak_factory_.HasWeakPtrs());
 
   chunk_demuxer_->Shutdown();
 
-  // |this| will be transferred to the callback StopDemuxer() and
-  // OnDemuxerStopDone(). They own |this| and OnDemuxerStopDone() will delete
-  // it when called, hence using base::Unretained(this) is safe here.
-  media_task_runner_->PostTask(FROM_HERE,
-                        base::Bind(&MediaSourceDelegate::StopDemuxer,
-                        base::Unretained(this)));
+  // Continue to stop objects on the media thread.
+  media_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(
+          &MediaSourceDelegate::StopDemuxer, base::Unretained(this), stop_cb));
 }
 
 bool MediaSourceDelegate::IsVideoEncrypted() {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   base::AutoLock auto_lock(is_video_encrypted_lock_);
   return is_video_encrypted_;
 }
 
 base::Time MediaSourceDelegate::GetTimelineOffset() const {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   if (!chunk_demuxer_)
     return base::Time();
 
   return chunk_demuxer_->GetTimelineOffset();
 }
 
-void MediaSourceDelegate::StopDemuxer() {
+void MediaSourceDelegate::StopDemuxer(const base::Closure& stop_cb) {
+  DVLOG(2) << __FUNCTION__;
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DCHECK(chunk_demuxer_);
 
   demuxer_client_->RemoveDelegate(demuxer_client_id_);
   demuxer_client_ = NULL;
 
   audio_stream_ = NULL;
   video_stream_ = NULL;
   // TODO(xhwang): Figure out if we need to Reset the DDSs after Seeking or
   // before destroying them.
   audio_decrypting_demuxer_stream_.reset();
   video_decrypting_demuxer_stream_.reset();
 
   media_weak_factory_.InvalidateWeakPtrs();
   DCHECK(!media_weak_factory_.HasWeakPtrs());
 
   chunk_demuxer_->Stop();
   chunk_demuxer_.reset();
 
-  // The callback DeleteSelf() owns |this| and will delete it when called.
-  // Hence using base::Unretained(this) is safe here.
-  media_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&MediaSourceDelegate::DeleteSelf, base::Unretained(this)));
+  stop_cb.Run();
 }

[scherkus (not reviewing), 2014/09/26 00:45:18]

perhaps add comment here that |this| may be destroyed at this point in time as a
result of running |stop_cb|

[xhwang, 2014/09/26 19:26:59]

Done.

 
 void MediaSourceDelegate::InitializeMediaSource(
     const MediaSourceOpenedCB& media_source_opened_cb,
     const media::Demuxer::NeedKeyCB& need_key_cb,
     const media::SetDecryptorReadyCB& set_decryptor_ready_cb,
     const UpdateNetworkStateCB& update_network_state_cb,
     const DurationChangeCB& duration_change_cb) {
   DCHECK(main_task_runner_->BelongsToCurrentThread());
   DCHECK(!media_source_opened_cb.is_null());
   media_source_opened_cb_ = media_source_opened_cb;
@@ skipping 462 matching lines @@
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
 
   base::AutoLock auto_lock(seeking_lock_);
   DCHECK(seeking_);
   seeking_ = false;
   doing_browser_seek_ = false;
   demuxer_client_->DemuxerSeekDone(demuxer_client_id_, browser_seek_time_);
 }
 
-void MediaSourceDelegate::DeleteSelf() {
-  DCHECK(main_task_runner_->BelongsToCurrentThread());
-  DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
-  delete this;
-}
-
 void MediaSourceDelegate::NotifyDemuxerReady() {
   DCHECK(media_task_runner_->BelongsToCurrentThread());
   DVLOG(1) << __FUNCTION__ << " : " << demuxer_client_id_;
   DCHECK(is_demuxer_ready_);
 
   scoped_ptr<DemuxerConfigs> configs(new DemuxerConfigs());
   GetDemuxerConfigFromStream(configs.get(), true);
   GetDemuxerConfigFromStream(configs.get(), false);
   configs->duration = GetDuration();
 
@@ skipping 102 matching lines @@
     configs->video_size = config.natural_size();
     configs->is_video_encrypted = config.is_encrypted();
     configs->video_extra_data = std::vector<uint8>(
         config.extra_data(), config.extra_data() + config.extra_data_size());
     return true;
   }
   return false;
 }
 
 }  // namespace content