Remove reference counting from media::Demuxer and friends.

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 63 matching lines @@
       playback_rate_(0.0f),
       clock_(new Clock(&default_clock_)),
       waiting_for_clock_update_(false),
       status_(PIPELINE_OK),
       has_audio_(false),
       has_video_(false),
       state_(kCreated),
       audio_ended_(false),
       video_ended_(false),
       audio_disabled_(false),
+      demuxer_(NULL),
       creation_time_(base::Time::Now()) {
   media_log_->AddEvent(media_log_->CreatePipelineStateChangedEvent(kCreated));
   media_log_->AddEvent(
       media_log_->CreateEvent(MediaLogEvent::PIPELINE_CREATED));
 }
 
 Pipeline::~Pipeline() {
   // TODO(scherkus): Reenable after figuring out why this is firing, see
   // http://crbug.com/148405
 #if 0
@@ skipping 483 matching lines @@
     bound_fns.Push(base::Bind(
         &AudioRenderer::Flush, base::Unretained(audio_renderer_.get())));
   }
   if (video_renderer_) {
     bound_fns.Push(base::Bind(
         &VideoRenderer::Flush, base::Unretained(video_renderer_.get())));
   }
 
   // Seek demuxer.
   bound_fns.Push(base::Bind(
-      &Demuxer::Seek, demuxer_, seek_timestamp));
+      &Demuxer::Seek, base::Unretained(demuxer_), seek_timestamp));
 
   // Preroll renderers.
   if (audio_renderer_) {
     bound_fns.Push(base::Bind(
         &AudioRenderer::Preroll, base::Unretained(audio_renderer_.get()),
         seek_timestamp));
   }
 
   if (video_renderer_) {
     bound_fns.Push(base::Bind(
@@ skipping 23 matching lines @@
   }
 
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void Pipeline::DoStop(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(!pending_callbacks_.get());
   SerialRunner::Queue bound_fns;
 
-  if (demuxer_)
-    bound_fns.Push(base::Bind(&Demuxer::Stop, demuxer_));
+  if (demuxer_) {
+    bound_fns.Push(base::Bind(
+        &Demuxer::Stop, base::Unretained(demuxer_)));
+  }
 
   if (audio_renderer_) {
     bound_fns.Push(base::Bind(
         &AudioRenderer::Stop, base::Unretained(audio_renderer_.get())));
   }
 
   if (video_renderer_) {
     bound_fns.Push(base::Bind(
         &VideoRenderer::Stop, base::Unretained(video_renderer_.get())));
   }
 
   pending_callbacks_ = SerialRunner::Run(bound_fns, done_cb);
 }
 
 void Pipeline::OnStopCompleted(PipelineStatus status) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK_EQ(state_, kStopping);
   {
     base::AutoLock l(lock_);
     running_ = false;
   }
 
   SetState(kStopped);
   pending_callbacks_.reset();
   filter_collection_.reset();
   audio_renderer_.reset();
   video_renderer_.reset();
-  demuxer_ = NULL;

[acolwell GONE FROM CHROMIUM, 2013/04/19 18:17:59]

nit: Any harm in keeping this? It will trigger an exception if code tries to use
it after stopped, which could be handy.

[scherkus (not reviewing), 2013/04/19 23:18:45]

Done.

 
   // 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()) {
     base::ResetAndReturn(&stop_cb_).Run();
     error_cb_.Reset();
@@ skipping 233 matching lines @@
 void Pipeline::InitializeDemuxer(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   demuxer_ = filter_collection_->GetDemuxer();
   demuxer_->Initialize(this, done_cb);
 }
 
 void Pipeline::InitializeAudioRenderer(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
-  scoped_refptr<DemuxerStream> stream =
-      demuxer_->GetStream(DemuxerStream::AUDIO);
-  DCHECK(stream);
-
   audio_renderer_ = filter_collection_->GetAudioRenderer();
   audio_renderer_->Initialize(
-      stream,
+      demuxer_->GetStream(DemuxerStream::AUDIO),
       done_cb,
       base::Bind(&Pipeline::OnUpdateStatistics, this),
       base::Bind(&Pipeline::OnAudioUnderflow, this),
       base::Bind(&Pipeline::OnAudioTimeUpdate, this),
       base::Bind(&Pipeline::OnAudioRendererEnded, this),
       base::Bind(&Pipeline::OnAudioDisabled, this),
       base::Bind(&Pipeline::SetError, this));
 }
 
 void Pipeline::InitializeVideoRenderer(const PipelineStatusCB& done_cb) {
   DCHECK(message_loop_->BelongsToCurrentThread());
 
   scoped_refptr<DemuxerStream> stream =
       demuxer_->GetStream(DemuxerStream::VIDEO);
-  DCHECK(stream);
 
   {
     // Get an initial natural size so we have something when we signal
     // the kHaveMetadata buffering state.
     base::AutoLock l(lock_);
     natural_size_ = stream->video_decoder_config().natural_size();
   }
 
   video_renderer_ = filter_collection_->GetVideoRenderer();
   video_renderer_->Initialize(
@@ skipping 25 matching lines @@
 void Pipeline::StartClockIfWaitingForTimeUpdate_Locked() {
   lock_.AssertAcquired();
   if (!waiting_for_clock_update_)
     return;
 
   waiting_for_clock_update_ = false;
   clock_->Play();
 }
 
 }  // namespace media