Remove reference counting from media::DemuxerStream and friends.

media/filters/chunk_demuxer.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/filters/chunk_demuxer.h"
 
 #include <algorithm>
 #include <deque>
 #include <limits>
 
@@ skipping 155 matching lines @@
 class ChunkDemuxerStream : public DemuxerStream {
  public:
   typedef std::deque<scoped_refptr<StreamParserBuffer> > BufferQueue;
   typedef std::deque<ReadCB> ReadCBQueue;
   typedef std::deque<base::Closure> ClosureQueue;
 
   ChunkDemuxerStream(const AudioDecoderConfig& audio_config,
                      const LogCB& log_cb);
   ChunkDemuxerStream(const VideoDecoderConfig& video_config,
                      const LogCB& log_cb);
+  virtual ~ChunkDemuxerStream();
 
   void StartWaitingForSeek();
   void Seek(TimeDelta time);
   void CancelPendingSeek();
   bool IsSeekPending() const;
 
   // Add buffers to this stream.  Buffers are stored in SourceBufferStreams,
   // which handle ordering and overlap resolution.
   // Returns true if buffers were successfully added.
   bool Append(const StreamParser::BufferQueue& buffers);
@@ skipping 20 matching lines @@
 
   void Shutdown();
 
   // DemuxerStream methods.
   virtual void Read(const ReadCB& read_cb) OVERRIDE;
   virtual Type type() OVERRIDE;
   virtual void EnableBitstreamConverter() OVERRIDE;
   virtual const AudioDecoderConfig& audio_decoder_config() OVERRIDE;
   virtual const VideoDecoderConfig& video_decoder_config() OVERRIDE;
 
- protected:
-  virtual ~ChunkDemuxerStream();
-
  private:
   enum State {
     RETURNING_DATA_FOR_READS,
     WAITING_FOR_SEEK,
     CANCELED,
     SHUTDOWN,
   };
 
   // Assigns |state_| to |state|
   void ChangeState_Locked(State state);
@@ skipping 379 matching lines @@
 
       status = PIPELINE_OK;
     }
   }
 
   cb.Run(status);
 }
 
 void ChunkDemuxer::OnAudioRendererDisabled() {
   base::AutoLock auto_lock(lock_);
-  audio_ = NULL;
+  audio_->Shutdown();
+  disabled_audio_ = audio_.Pass();

[acolwell GONE FROM CHROMIUM, 2013/04/24 06:09:57]

nit: DCHECK(!disabled_audio_) just so we can catch any case where this
accidentally gets called more than once?

[scherkus (not reviewing), 2013/04/25 00:12:53]

I figured the null pointer dereference on 616 would be a strong enough signal!

 }
 
 // Demuxer implementation.
-scoped_refptr<DemuxerStream> ChunkDemuxer::GetStream(
-    DemuxerStream::Type type) {
+DemuxerStream* ChunkDemuxer::GetStream(DemuxerStream::Type type) {
   base::AutoLock auto_lock(lock_);
   if (type == DemuxerStream::VIDEO)
-    return video_;
+    return video_.get();
 
   if (type == DemuxerStream::AUDIO)
-    return audio_;
+    return audio_.get() ? audio_.get() : disabled_audio_.get();

[acolwell GONE FROM CHROMIUM, 2013/04/24 06:09:57]

Is this change actually needed? Doesn't this change the existing behavior when
OnAudioRendererDisabled() is called.

[scherkus (not reviewing), 2013/04/25 00:12:53]

Done + updated unit test

 
   return NULL;
 }
 
 TimeDelta ChunkDemuxer::GetStartTime() const {
   return TimeDelta();
 }
 
 void ChunkDemuxer::StartWaitingForSeek() {
   DVLOG(1) << "StartWaitingForSeek()";
@@ skipping 495 matching lines @@
         << (has_video ? " specifies" : " does not specify")
         << " a video codec.";
     return false;
   }
 
   bool success = true;
   if (audio_config.IsValidConfig()) {
     if (audio_) {
       success &= audio_->UpdateAudioConfig(audio_config);
     } else {
-      audio_ = new ChunkDemuxerStream(audio_config, log_cb_);
+      audio_.reset(new ChunkDemuxerStream(audio_config, log_cb_));
     }
   }
 
   if (video_config.IsValidConfig()) {
     if (video_) {
       success &= video_->UpdateVideoConfig(video_config);
     } else {
-      video_ = new ChunkDemuxerStream(video_config, log_cb_);
+      video_.reset(new ChunkDemuxerStream(video_config, log_cb_));
     }
   }
 
   DVLOG(1) << "OnNewConfigs() : " << (success ? "success" : "failed");
   return success;
 }
 
 bool ChunkDemuxer::OnAudioBuffers(const StreamParser::BufferQueue& buffers) {
   lock_.AssertAcquired();
   DCHECK_NE(state_, SHUTDOWN);
 
   if (!audio_)
     return false;
 
   CHECK(IsValidId(source_id_audio_));
   if (!audio_->Append(buffers))
     return false;
 
-  IncreaseDurationIfNecessary(buffers, audio_);
+  IncreaseDurationIfNecessary(buffers, audio_.get());
   return true;
 }
 
 bool ChunkDemuxer::OnVideoBuffers(const StreamParser::BufferQueue& buffers) {
   lock_.AssertAcquired();
   DCHECK_NE(state_, SHUTDOWN);
 
   if (!video_)
     return false;
 
   CHECK(IsValidId(source_id_video_));
   if (!video_->Append(buffers))
     return false;
 
-  IncreaseDurationIfNecessary(buffers, video_);
+  IncreaseDurationIfNecessary(buffers, video_.get());
   return true;
 }
 
 // TODO(acolwell): Remove bool from StreamParser::NeedKeyCB so that
 // this method can be removed and need_key_cb_ can be passed directly
 // to the parser.
 bool ChunkDemuxer::OnNeedKey(const std::string& type,
                              scoped_ptr<uint8[]> init_data,
                              int init_data_size) {
   lock_.AssertAcquired();
@@ skipping 22 matching lines @@
 
 void ChunkDemuxer::UpdateDuration(base::TimeDelta new_duration) {
   DCHECK(duration_ != new_duration);
   user_specified_duration_ = -1;
   duration_ = new_duration;
   host_->SetDuration(new_duration);
 }
 
 void ChunkDemuxer::IncreaseDurationIfNecessary(
     const StreamParser::BufferQueue& buffers,
-    const scoped_refptr<ChunkDemuxerStream>& stream) {
+    ChunkDemuxerStream* stream) {
   DCHECK(!buffers.empty());
   if (buffers.back()->GetTimestamp() <= duration_)
     return;
 
   Ranges<TimeDelta> ranges = stream->GetBufferedRanges(kInfiniteDuration());
   DCHECK_GT(ranges.size(), 0u);
 
   base::TimeDelta last_timestamp_buffered = ranges.end(ranges.size() - 1);
   if (last_timestamp_buffered > duration_)
     UpdateDuration(last_timestamp_buffered);
@@ skipping 11 matching lines @@
 
 Ranges<TimeDelta> ChunkDemuxer::GetBufferedRanges() const {
   if (audio_ && !video_)
     return audio_->GetBufferedRanges(duration_);
   else if (!audio_ && video_)
     return video_->GetBufferedRanges(duration_);
   return ComputeIntersection();
 }
 
 }  // namespace media