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

media/filters/ffmpeg_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 "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/stl_util.h"
@@ skipping 17 matching lines @@
 //
 class AVPacketBuffer : public Buffer {
  public:
   AVPacketBuffer(scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet,
                  const base::TimeDelta& timestamp,
                  const base::TimeDelta& duration)
       : Buffer(timestamp, duration),
         packet_(packet.Pass()) {
   }
 
-  virtual ~AVPacketBuffer() {}
-
   // Buffer implementation.
   virtual const uint8* GetData() const {
     return reinterpret_cast<const uint8*>(packet_->data);
   }
 
   virtual int GetDataSize() const {
     return packet_->size;
   }
 
+ protected:
+  virtual ~AVPacketBuffer() {}
+
  private:
   scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet_;
 
   DISALLOW_COPY_AND_ASSIGN(AVPacketBuffer);
 };
 
 
 //
 // FFmpegDemuxerStream
 //
@@ skipping 18 matching lines @@
       break;
     default:
       NOTREACHED();
       break;
   }
 
   // Calculate the duration.
   duration_ = ConvertStreamTimestamp(stream->time_base, stream->duration);
 }
 
-FFmpegDemuxerStream::~FFmpegDemuxerStream() {
-  base::AutoLock auto_lock(lock_);
-  DCHECK(stopped_);
-  DCHECK(read_queue_.empty());
-  DCHECK(buffer_queue_.empty());
-}
-
 bool FFmpegDemuxerStream::HasPendingReads() {
   DCHECK_EQ(MessageLoop::current(), demuxer_->message_loop());
   base::AutoLock auto_lock(lock_);
   DCHECK(!stopped_ || read_queue_.empty())
       << "Read queue should have been emptied if demuxing stream is stopped";
   return !read_queue_.empty();
 }
 
 void FFmpegDemuxerStream::EnqueuePacket(
     scoped_ptr_malloc<AVPacket, ScopedPtrAVFreePacket> packet) {
@@ skipping 153 matching lines @@
 const AudioDecoderConfig& FFmpegDemuxerStream::audio_decoder_config() {
   CHECK_EQ(type_, AUDIO);
   return audio_config_;
 }
 
 const VideoDecoderConfig& FFmpegDemuxerStream::video_decoder_config() {
   CHECK_EQ(type_, VIDEO);
   return video_config_;
 }
 
+FFmpegDemuxerStream::~FFmpegDemuxerStream() {
+  base::AutoLock auto_lock(lock_);
+  DCHECK(stopped_);
+  DCHECK(read_queue_.empty());
+  DCHECK(buffer_queue_.empty());
+}
+
 // static
 base::TimeDelta FFmpegDemuxerStream::ConvertStreamTimestamp(
     const AVRational& time_base, int64 timestamp) {
   if (timestamp == static_cast<int64>(AV_NOPTS_VALUE))
     return kNoTimestamp();
 
   return ConvertFromTimeBase(time_base, timestamp);
 }
 
 //
@@ skipping 445 matching lines @@
   read_event_.Wait();
   return last_read_bytes_;
 }
 
 void FFmpegDemuxer::SignalReadCompleted(int size) {
   last_read_bytes_ = size;
   read_event_.Signal();
 }
 
 }  // namespace media