Refcounted types should not have public destructors, remoting/ edition

remoting/protocol/buffered_socket_writer.cc

 // Copyright (c) 2011 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 "remoting/protocol/buffered_socket_writer.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/message_loop_proxy.h"
 #include "base/stl_util.h"
@@ skipping 27 matching lines @@
 
 BufferedSocketWriterBase::BufferedSocketWriterBase(
     base::MessageLoopProxy* message_loop)
     : buffer_size_(0),
       socket_(NULL),
       message_loop_(message_loop),
       write_pending_(false),
       closed_(false) {
 }
 
-BufferedSocketWriterBase::~BufferedSocketWriterBase() { }
-
 void BufferedSocketWriterBase::Init(net::Socket* socket,
                                     const WriteFailedCallback& callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
   DCHECK(socket);
   socket_ = socket;
   write_failed_callback_ = callback;
 }
 
 bool BufferedSocketWriterBase::Write(
     scoped_refptr<net::IOBufferWithSize> data, const base::Closure& done_task) {
@@ skipping 92 matching lines @@
 int BufferedSocketWriterBase::GetBufferChunks() {
   base::AutoLock auto_lock(lock_);
   return queue_.size();
 }
 
 void BufferedSocketWriterBase::Close() {
   DCHECK(message_loop_->BelongsToCurrentThread());
   closed_ = true;
 }
 
+BufferedSocketWriterBase::~BufferedSocketWriterBase() {}
+
 void BufferedSocketWriterBase::PopQueue() {
   // This also calls |done_task|.
   delete queue_.front();
   queue_.pop_front();
 }
 
 BufferedSocketWriter::BufferedSocketWriter(
     base::MessageLoopProxy* message_loop)
   : BufferedSocketWriterBase(message_loop) {
 }
 
-BufferedSocketWriter::~BufferedSocketWriter() {
-  STLDeleteElements(&queue_);
-}
-
 void BufferedSocketWriter::GetNextPacket_Locked(
     net::IOBuffer** buffer, int* size) {
   if (!current_buf_) {
     if (queue_.empty()) {
       *buffer = NULL;
       return;  // Nothing to write.
     }
     current_buf_ = new net::DrainableIOBuffer(
         queue_.front()->data(), queue_.front()->data()->size());
   }
 
   *buffer = current_buf_;
   *size = current_buf_->BytesRemaining();
 }
 
 void BufferedSocketWriter::AdvanceBufferPosition_Locked(int written) {
   buffer_size_ -= written;
   current_buf_->DidConsume(written);
 
   if (current_buf_->BytesRemaining() == 0) {
     PopQueue();
     current_buf_ = NULL;
   }
 }
 
 void BufferedSocketWriter::OnError_Locked(int result) {
   current_buf_ = NULL;
 }
 
+BufferedSocketWriter::~BufferedSocketWriter() {
+  STLDeleteElements(&queue_);
+}
+
 BufferedDatagramWriter::BufferedDatagramWriter(
     base::MessageLoopProxy* message_loop)
     : BufferedSocketWriterBase(message_loop) {
 }
-BufferedDatagramWriter::~BufferedDatagramWriter() { }
 
 void BufferedDatagramWriter::GetNextPacket_Locked(
     net::IOBuffer** buffer, int* size) {
   if (queue_.empty()) {
     *buffer = NULL;
     return;  // Nothing to write.
   }
   *buffer = queue_.front()->data();
   *size = queue_.front()->data()->size();
 }
 
 void BufferedDatagramWriter::AdvanceBufferPosition_Locked(int written) {
   DCHECK_EQ(written, queue_.front()->data()->size());
   buffer_size_ -= queue_.front()->data()->size();
   PopQueue();
 }
 
 void BufferedDatagramWriter::OnError_Locked(int result) {
   // Nothing to do here.
 }
 
+BufferedDatagramWriter::~BufferedDatagramWriter() {}
+
 }  // namespace protocol
 }  // namespace remoting