RefCounted types should not have public destructors, media/ and gpu/ edition

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 "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop.h"
 #include "media/base/audio_decoder_config.h"
@@ skipping 105 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;
 
   explicit ChunkDemuxerStream(const AudioDecoderConfig& audio_config);
   explicit ChunkDemuxerStream(const VideoDecoderConfig& video_config);
-  virtual ~ChunkDemuxerStream();
 
   void Flush();
   void Seek(base::TimeDelta time);
 
   // Checks if it is ok to add the |buffers| to the stream.
   bool CanAddBuffers(const BufferQueue& buffers) const;
 
   void AddBuffers(const BufferQueue& buffers);
   void Shutdown();
 
   // Gets the time range buffered by this object.
   // Returns true if there is buffered data. |start_out| & |end_out| are set to
   //    the start and end time of the buffered data respectively.
   // Returns false if no data is buffered.
   bool GetBufferedRange(base::TimeDelta* start_out,
                         base::TimeDelta* end_out) const;
 
   bool GetLastBufferTimestamp(base::TimeDelta* timestamp) const;
 
   // 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,
     RECEIVED_EOS_WHILE_WAITING_FOR_SEEK, // EOS = End of stream.
     RECEIVED_EOS,
     RETURNING_EOS_FOR_READS,
     SHUTDOWN,
   };
 
@@ skipping 33 matching lines @@
 }
 
 
 ChunkDemuxerStream::ChunkDemuxerStream(const VideoDecoderConfig& video_config)
     : type_(VIDEO),
       state_(RETURNING_DATA_FOR_READS),
       last_buffer_timestamp_(kNoTimestamp()) {
   video_config_.CopyFrom(video_config);
 }
 
-ChunkDemuxerStream::~ChunkDemuxerStream() {}
-
 void ChunkDemuxerStream::Flush() {
   DVLOG(1) << "Flush()";
   ReadCBQueue read_cbs;
   {
     base::AutoLock auto_lock(lock_);
     buffers_.clear();
     ChangeState_Locked(WAITING_FOR_SEEK);
     last_buffer_timestamp_ = kNoTimestamp();
 
     std::swap(read_cbs_, read_cbs);
@@ skipping 192 matching lines @@
 const VideoDecoderConfig& ChunkDemuxerStream::video_decoder_config() {
   CHECK_EQ(type_, VIDEO);
   return video_config_;
 }
 
 void ChunkDemuxerStream::ChangeState_Locked(State state) {
   lock_.AssertAcquired();
   state_ = state;
 }
 
+ChunkDemuxerStream::~ChunkDemuxerStream() {}
+
 void ChunkDemuxerStream::DeferRead_Locked(const ReadCB& read_cb) {
   lock_.AssertAcquired();
   // Wrap & store |read_cb| so that it will
   // get called on the current MessageLoop.
   read_cbs_.push_back(base::Bind(&RunOnMessageLoop, read_cb,
                                  MessageLoop::current()));
 }
 
 void ChunkDemuxerStream::CreateReadDoneClosures_Locked(ClosureQueue* closures) {
   lock_.AssertAcquired();
@@ skipping 23 matching lines @@
 
 ChunkDemuxer::ChunkDemuxer(ChunkDemuxerClient* client)
     : state_(WAITING_FOR_INIT),
       host_(NULL),
       client_(client),
       buffered_bytes_(0),
       seek_waits_for_data_(true) {
   DCHECK(client);
 }
 
-ChunkDemuxer::~ChunkDemuxer() {
-  DCHECK_NE(state_, INITIALIZED);
-}
-
 void ChunkDemuxer::Initialize(DemuxerHost* host,
                               const PipelineStatusCB& cb) {
   DVLOG(1) << "Init()";
   {
     base::AutoLock auto_lock(lock_);
     DCHECK_EQ(state_, WAITING_FOR_INIT);
     host_ = host;
 
     ChangeState_Locked(INITIALIZING);
     init_cb_ = cb;
@@ skipping 329 matching lines @@
     cb.Run(PIPELINE_ERROR_ABORT);
 
   client_->DemuxerClosed();
 }
 
 void ChunkDemuxer::ChangeState_Locked(State new_state) {
   lock_.AssertAcquired();
   state_ = new_state;
 }
 
+ChunkDemuxer::~ChunkDemuxer() {
+  DCHECK_NE(state_, INITIALIZED);
+}
+
 void ChunkDemuxer::ReportError_Locked(PipelineStatus error) {
   lock_.AssertAcquired();
   DCHECK_NE(error, PIPELINE_OK);
 
   ChangeState_Locked(PARSE_ERROR);
 
   PipelineStatusCB cb;
 
   if (!init_cb_.is_null()) {
     std::swap(cb, init_cb_);
@@ skipping 87 matching lines @@
   return true;
 }
 
 bool ChunkDemuxer::OnKeyNeeded(scoped_array<uint8> init_data,
                                int init_data_size) {
   client_->KeyNeeded(init_data.Pass(), init_data_size);
   return true;
 }
 
 }  // namespace media