Remove reference counting from media::DemuxerStream and friends.

media/filters/video_frame_stream.h

 // Copyright (c) 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.
 
 #ifndef MEDIA_FILTERS_VIDEO_FRAME_STREAM_H_
 #define MEDIA_FILTERS_VIDEO_FRAME_STREAM_H_
 
 #include <list>
 
 #include "base/basictypes.h"
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_vector.h"
 #include "base/memory/weak_ptr.h"
 #include "media/base/decryptor.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/media_export.h"
 #include "media/base/pipeline_status.h"
 #include "media/base/video_decoder.h"
-#include "media/filters/video_decoder_selector.h"
 
 namespace base {
 class MessageLoopProxy;
 }
 
 namespace media {
 
 class DecryptingDemuxerStream;
 class VideoDecoderSelector;
 
 // Wraps a DemuxerStream and a list of VideoDecoders and provides decoded
 // VideoFrames to its client (e.g. VideoRendererBase).
 class MEDIA_EXPORT VideoFrameStream : public DemuxerStream {
  public:
   // Indicates completion of VideoFrameStream initialization.
   typedef base::Callback<void(bool success, bool has_alpha)> InitCB;
 
   VideoFrameStream(const scoped_refptr<base::MessageLoopProxy>& message_loop,
                    ScopedVector<VideoDecoder> decoders,
                    const SetDecryptorReadyCB& set_decryptor_ready_cb);
+  virtual ~VideoFrameStream();
 
   // Initializes the VideoFrameStream and returns the initialization result
   // through |init_cb|. Note that |init_cb| is always called asynchronously.
-  void Initialize(const scoped_refptr<DemuxerStream>& stream,
+  void Initialize(DemuxerStream* stream,
                   const StatisticsCB& statistics_cb,
                   const InitCB& init_cb);
 
   // Reads a decoded VideoFrame and returns it via the |read_cb|. Note that
   // |read_cb| is always called asynchronously. This method should only be
   // called after initialization has succeeded and must not be called during
   // any pending Reset() and/or Stop().
   void ReadFrame(const VideoDecoder::ReadCB& read_cb);
 
   // Resets the decoder, flushes all decoded frames and/or internal buffers,
@@ skipping 14 matching lines @@
   // a VideoFrame.
   bool HasOutputFrameAvailable() const;
 
   // DemuxerStream implementation.
   virtual void Read(const ReadCB& read_cb) OVERRIDE;
   virtual const AudioDecoderConfig& audio_decoder_config() OVERRIDE;
   virtual const VideoDecoderConfig& video_decoder_config() OVERRIDE;
   virtual Type type() OVERRIDE;
   virtual void EnableBitstreamConverter() OVERRIDE;
 
- protected:
-  virtual ~VideoFrameStream();
-
  private:
   enum State {
     UNINITIALIZED,
     NORMAL,
     STOPPED
   };
 
   // Called when |decoder_selector| selected the |selected_decoder|.
   // |decrypting_demuxer_stream| was also populated if a DecryptingDemuxerStream
   // is created to help decrypt the encrypted stream.
   void OnDecoderSelected(
-      scoped_ptr<VideoDecoderSelector> decoder_selector,
       scoped_ptr<VideoDecoder> selected_decoder,
-      const scoped_refptr<DecryptingDemuxerStream>& decrypting_demuxer_stream);
+      scoped_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream);
 
   // Callback for VideoDecoder::Read().
   void OnFrameRead(const VideoDecoder::Status status,
                    const scoped_refptr<VideoFrame>& frame);
 
   void ResetDecoder();
   void OnDecoderReset();
 
   void StopDecoder();
   void OnDecoderStopped();
 
   scoped_refptr<base::MessageLoopProxy> message_loop_;
   base::WeakPtrFactory<VideoFrameStream> weak_factory_;
   base::WeakPtr<VideoFrameStream> weak_this_;
 
   State state_;
 
   InitCB init_cb_;
   VideoDecoder::ReadCB read_cb_;
   base::Closure reset_cb_;
   base::Closure stop_cb_;
 
-  // TODO(scherkus): Replace these with a VideoDecoderSelector instance after
-  // DemuxerStream is no longer refcounted.
-  ScopedVector<VideoDecoder> decoders_;
-  SetDecryptorReadyCB set_decryptor_ready_cb_;
+  DemuxerStream* stream_;
 
-  scoped_refptr<DemuxerStream> stream_;
+  scoped_ptr<VideoDecoderSelector> decoder_selector_;
 
   // These two will be set by VideoDecoderSelector::SelectVideoDecoder().
   scoped_ptr<VideoDecoder> decoder_;
-  scoped_refptr<DecryptingDemuxerStream> decrypting_demuxer_stream_;
+  scoped_ptr<DecryptingDemuxerStream> decrypting_demuxer_stream_;
 
   DISALLOW_COPY_AND_ASSIGN(VideoFrameStream);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_FILTERS_VIDEO_FRAME_STREAM_H_