Refcounted types should not have public destructors, remoting/ edition

BUG=123295
TEST=none


Review URL: http://codereview.chromium.org/10066042

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@133801 0039d316-1c4b-4281-b951-d872f2087c98

12 files changed, 50 insertions, 43 deletions

diff --git a/remoting/base/capture_data.h b/remoting/base/capture_data.h
index 61bc2e8..cea18ac 100644
--- a/remoting/base/capture_data.h
+++ b/remoting/base/capture_data.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -60,6 +60,9 @@ class CaptureData : public base::RefCountedThreadSafe<CaptureData> {
   }
 
  private:
+  friend class base::RefCountedThreadSafe<CaptureData>;
+  virtual ~CaptureData();
+
   const DataPlanes data_planes_;
   SkRegion dirty_region_;
   SkISize size_;
@@ -70,9 +73,6 @@ class CaptureData : public base::RefCountedThreadSafe<CaptureData> {
 
   // Sequence number supplied by client for performance tracking.
   int64 client_sequence_number_;
-
-  friend class base::RefCountedThreadSafe<CaptureData>;
-  virtual ~CaptureData();
 };
 
 }  // namespace remoting
diff --git a/remoting/client/frame_consumer_proxy.cc b/remoting/client/frame_consumer_proxy.cc
index 7344b36..b65f324 100644
--- a/remoting/client/frame_consumer_proxy.cc
+++ b/remoting/client/frame_consumer_proxy.cc
@@ -15,10 +15,6 @@ FrameConsumerProxy::FrameConsumerProxy(
     : frame_consumer_message_loop_(frame_consumer_message_loop) {
 }
 
-FrameConsumerProxy::~FrameConsumerProxy() {
-  DCHECK(frame_consumer_message_loop_->BelongsToCurrentThread());
-}
-
 void FrameConsumerProxy::ApplyBuffer(const SkISize& view_size,
                                      const SkIRect& clip_area,
                                      pp::ImageData* buffer,
@@ -63,4 +59,8 @@ void FrameConsumerProxy::Attach(
   frame_consumer_ = frame_consumer;
 }
 
+FrameConsumerProxy::~FrameConsumerProxy() {
+  DCHECK(frame_consumer_message_loop_->BelongsToCurrentThread());
+}
+
 }  // namespace remoting
diff --git a/remoting/client/frame_consumer_proxy.h b/remoting/client/frame_consumer_proxy.h
index 7e62f2e..0ee6e46 100644
--- a/remoting/client/frame_consumer_proxy.h
+++ b/remoting/client/frame_consumer_proxy.h
@@ -28,7 +28,6 @@ class FrameConsumerProxy
   // to |frame_consumer_message_loop|.
   FrameConsumerProxy(
       scoped_refptr<base::MessageLoopProxy> frame_consumer_message_loop);
-  virtual ~FrameConsumerProxy();
 
   // FrameConsumer implementation.
   virtual void ApplyBuffer(const SkISize& view_size,
@@ -43,6 +42,9 @@ class FrameConsumerProxy
   void Attach(const base::WeakPtr<FrameConsumer>& frame_consumer);
 
  private:
+  friend class base::RefCountedThreadSafe<FrameConsumerProxy>;
+  virtual ~FrameConsumerProxy();
+
   base::WeakPtr<FrameConsumer> frame_consumer_;
   scoped_refptr<base::MessageLoopProxy> frame_consumer_message_loop_;
 
diff --git a/remoting/client/rectangle_update_decoder.h b/remoting/client/rectangle_update_decoder.h
index 892301c..eee0e76 100644
--- a/remoting/client/rectangle_update_decoder.h
+++ b/remoting/client/rectangle_update_decoder.h
@@ -60,7 +60,6 @@ class RectangleUpdateDecoder :
 
  private:
   friend class base::RefCountedThreadSafe<RectangleUpdateDecoder>;
-
   virtual ~RectangleUpdateDecoder();
 
   // Paints the invalidated region to the next available buffer and returns it
diff --git a/remoting/host/differ_block_unittest.cc b/remoting/host/differ_block_unittest.cc
index 1bfdb19..035d5cc 100644
--- a/remoting/host/differ_block_unittest.cc
+++ b/remoting/host/differ_block_unittest.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -18,12 +18,6 @@ static void GenerateData(uint8* data, int size) {
   }
 }
 
-class EncodeDoneHandler
-    : public base::RefCountedThreadSafe<EncodeDoneHandler> {
- public:
-  MOCK_METHOD0(EncodeDone, void());
-};
-
 // Memory buffer large enough for 2 blocks aligned to 16 bytes.
 static const int kSizeOfBlock = kBlockSize * kBlockSize * kBytesPerPixel;
 uint8 block_buffer[kSizeOfBlock * 2 + 16];
diff --git a/remoting/host/gaia_oauth_client.cc b/remoting/host/gaia_oauth_client.cc
index f20cb82..d9d049f 100644
--- a/remoting/host/gaia_oauth_client.cc
+++ b/remoting/host/gaia_oauth_client.cc
@@ -31,15 +31,17 @@ class GaiaOAuthClient::Core
        net::URLRequestContextGetter* request_context_getter)
       : gaia_url_(gaia_url),
         request_context_getter_(request_context_getter),
-        delegate_(NULL) { }
-
-  virtual ~Core() { }
+        delegate_(NULL) {
+  }
 
   void RefreshToken(const OAuthClientInfo& oauth_client_info,
                     const std::string& refresh_token,
                     GaiaOAuthClient::Delegate* delegate);
 
  private:
+  friend class base::RefCountedThreadSafe<Core>;
+  virtual ~Core() {}
+
   void OnUrlFetchComplete(const net::URLRequestStatus& status,
                           int response_code,
                           const std::string& response);
diff --git a/remoting/host/screen_recorder.cc b/remoting/host/screen_recorder.cc
index 31b8a47..da9ab8b 100644
--- a/remoting/host/screen_recorder.cc
+++ b/remoting/host/screen_recorder.cc
@@ -52,9 +52,6 @@ ScreenRecorder::ScreenRecorder(
   DCHECK(network_loop_);
 }
 
-ScreenRecorder::~ScreenRecorder() {
-}
-
 // Public methods --------------------------------------------------------------
 
 void ScreenRecorder::Start() {
@@ -112,7 +109,10 @@ void ScreenRecorder::UpdateSequenceNumber(int64 sequence_number) {
   sequence_number_ = sequence_number;
 }
 
-// Private accessors -----------------------------------------------------------
+// Private methods -----------------------------------------------------------
+
+ScreenRecorder::~ScreenRecorder() {
+}
 
 Capturer* ScreenRecorder::capturer() {
   DCHECK_EQ(capture_loop_, MessageLoop::current());
diff --git a/remoting/host/screen_recorder.h b/remoting/host/screen_recorder.h
index 0f364f2..64e079f 100644
--- a/remoting/host/screen_recorder.h
+++ b/remoting/host/screen_recorder.h
@@ -84,8 +84,6 @@ class ScreenRecorder : public base::RefCountedThreadSafe<ScreenRecorder> {
                  Capturer* capturer,
                  Encoder* encoder);
 
-  virtual ~ScreenRecorder();
-
   // Start recording.
   void Start();
 
@@ -106,6 +104,9 @@ class ScreenRecorder : public base::RefCountedThreadSafe<ScreenRecorder> {
   void UpdateSequenceNumber(int64 sequence_number);
 
  private:
+  friend class base::RefCountedThreadSafe<ScreenRecorder>;
+  virtual ~ScreenRecorder();
+
   // Getters for capturer and encoder.
   Capturer* capturer();
   Encoder* encoder();
diff --git a/remoting/protocol/buffered_socket_writer.cc b/remoting/protocol/buffered_socket_writer.cc
index b05f467..f0e497c 100644
--- a/remoting/protocol/buffered_socket_writer.cc
+++ b/remoting/protocol/buffered_socket_writer.cc
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -45,8 +45,6 @@ BufferedSocketWriterBase::BufferedSocketWriterBase(
       closed_(false) {
 }
 
-BufferedSocketWriterBase::~BufferedSocketWriterBase() { }
-
 void BufferedSocketWriterBase::Init(net::Socket* socket,
                                     const WriteFailedCallback& callback) {
   DCHECK(message_loop_->BelongsToCurrentThread());
@@ -159,6 +157,8 @@ void BufferedSocketWriterBase::Close() {
   closed_ = true;
 }
 
+BufferedSocketWriterBase::~BufferedSocketWriterBase() {}
+
 void BufferedSocketWriterBase::PopQueue() {
   // This also calls |done_task|.
   delete queue_.front();
@@ -170,10 +170,6 @@ BufferedSocketWriter::BufferedSocketWriter(
   : BufferedSocketWriterBase(message_loop) {
 }
 
-BufferedSocketWriter::~BufferedSocketWriter() {
-  STLDeleteElements(&queue_);
-}
-
 void BufferedSocketWriter::GetNextPacket_Locked(
     net::IOBuffer** buffer, int* size) {
   if (!current_buf_) {
@@ -203,11 +199,14 @@ 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) {
@@ -229,5 +228,7 @@ void BufferedDatagramWriter::OnError_Locked(int result) {
   // Nothing to do here.
 }
 
+BufferedDatagramWriter::~BufferedDatagramWriter() {}
+
 }  // namespace protocol
 }  // namespace remoting
diff --git a/remoting/protocol/buffered_socket_writer.h b/remoting/protocol/buffered_socket_writer.h
index 7bc1b09..ea93bda 100644
--- a/remoting/protocol/buffered_socket_writer.h
+++ b/remoting/protocol/buffered_socket_writer.h
@@ -1,4 +1,4 @@
-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// 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.
 
@@ -39,7 +39,6 @@ class BufferedSocketWriterBase
   typedef base::Callback<void(int)> WriteFailedCallback;
 
   explicit BufferedSocketWriterBase(base::MessageLoopProxy* message_loop);
-  virtual ~BufferedSocketWriterBase();
 
   // Initializes the writer. Must be called on the thread that will be used
   // to access the socket in the future. |callback| will be called after each
@@ -64,9 +63,13 @@ class BufferedSocketWriterBase
   void Close();
 
  protected:
+  friend class base::RefCountedThreadSafe<BufferedSocketWriterBase>;
+
   class PendingPacket;
   typedef std::list<PendingPacket*> DataQueue;
 
+  virtual ~BufferedSocketWriterBase();
+
   DataQueue queue_;
   int buffer_size_;
 
@@ -105,7 +108,6 @@ class BufferedSocketWriterBase
 class BufferedSocketWriter : public BufferedSocketWriterBase {
  public:
   explicit BufferedSocketWriter(base::MessageLoopProxy* message_loop);
-  virtual ~BufferedSocketWriter();
 
  protected:
   virtual void GetNextPacket_Locked(net::IOBuffer** buffer, int* size) OVERRIDE;
@@ -113,18 +115,22 @@ class BufferedSocketWriter : public BufferedSocketWriterBase {
   virtual void OnError_Locked(int result) OVERRIDE;
 
  private:
+  virtual ~BufferedSocketWriter();
+
   scoped_refptr<net::DrainableIOBuffer> current_buf_;
 };
 
 class BufferedDatagramWriter : public BufferedSocketWriterBase {
  public:
   explicit BufferedDatagramWriter(base::MessageLoopProxy* message_loop);
-  virtual ~BufferedDatagramWriter();
 
  protected:
   virtual void GetNextPacket_Locked(net::IOBuffer** buffer, int* size) OVERRIDE;
   virtual void AdvanceBufferPosition_Locked(int written) OVERRIDE;
   virtual void OnError_Locked(int result) OVERRIDE;
+
+ private:
+  virtual ~BufferedDatagramWriter();
 };
 
 }  // namespace protocol
diff --git a/remoting/protocol/message_reader.cc b/remoting/protocol/message_reader.cc
index c64a7d9..5bf540f 100644
--- a/remoting/protocol/message_reader.cc
+++ b/remoting/protocol/message_reader.cc
@@ -25,10 +25,6 @@ MessageReader::MessageReader()
       closed_(false) {
 }
 
-MessageReader::~MessageReader() {
-  CHECK_EQ(pending_messages_, 0);
-}
-
 void MessageReader::Init(net::Socket* socket,
                          const MessageReceivedCallback& callback) {
   message_received_callback_ = callback;
@@ -37,6 +33,10 @@ void MessageReader::Init(net::Socket* socket,
   DoRead();
 }
 
+MessageReader::~MessageReader() {
+  CHECK_EQ(pending_messages_, 0);
+}
+
 void MessageReader::DoRead() {
   // Don't try to read again if there is another read pending or we
   // have messages that we haven't finished processing yet.
diff --git a/remoting/protocol/message_reader.h b/remoting/protocol/message_reader.h
index a7c1c00..a2cfca3 100644
--- a/remoting/protocol/message_reader.h
+++ b/remoting/protocol/message_reader.h
@@ -41,13 +41,15 @@ class MessageReader : public base::RefCountedThreadSafe<MessageReader> {
       MessageReceivedCallback;
 
   MessageReader();
-  virtual ~MessageReader();
 
   // Initialize the MessageReader with a socket. If a message is received
   // |callback| is called.
   void Init(net::Socket* socket, const MessageReceivedCallback& callback);
 
  private:
+  friend class base::RefCountedThreadSafe<MessageReader>;
+  virtual ~MessageReader();
+
   void DoRead();
   void OnRead(int result);
   void HandleReadResult(int result);