RefCounted types should not have public destructors, chrome/nacl edition

chrome/nacl/nacl_ipc_adapter.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 "chrome/nacl/nacl_ipc_adapter.h"
 
 #include <limits.h>
 #include <string.h>
 
 #include "base/basictypes.h"
@@ skipping 39 matching lines @@
   RewrittenMessage();
 
   bool is_consumed() const { return data_read_cursor_ == data_len_; }
 
   void SetData(const NaClIPCAdapter::NaClMessageHeader& header,
                const void* payload, size_t payload_length);
 
   int Read(char* dest_buffer, int dest_buffer_size);
 
  private:
+  friend class base::RefCounted<RewrittenMessage>;
+  ~RewrittenMessage() {}
+
   scoped_array<char> data_;
   int data_len_;
 
   // Offset into data where the next read will happen. This will be equal to
   // data_len_ when all data has been consumed.
   int data_read_cursor_;
 };
 
 NaClIPCAdapter::RewrittenMessage::RewrittenMessage()
     : data_len_(0),
@@ skipping 49 matching lines @@
 
 NaClIPCAdapter::NaClIPCAdapter(scoped_ptr<IPC::Channel> channel,
                                base::TaskRunner* runner)
     : lock_(),
       cond_var_(&lock_),
       task_runner_(runner),
       locked_data_() {
   io_thread_data_.channel_ = channel.Pass();
 }
 
-NaClIPCAdapter::~NaClIPCAdapter() {
-}
-
 // Note that this message is controlled by the untrusted code. So we should be
 // skeptical of anything it contains and quick to give up if anything is fishy.
 int NaClIPCAdapter::Send(const char* input_data, size_t input_data_len) {
   base::AutoLock lock(lock_);
 
   if (input_data_len > IPC::Channel::kMaximumMessageSize) {
     ClearToBeSent();
     return -1;
   }
 
@@ skipping 106 matching lines @@
   return true;
 }
 
 void NaClIPCAdapter::OnChannelConnected(int32 peer_pid) {
 }
 
 void NaClIPCAdapter::OnChannelError() {
   CloseChannel();
 }
 
+NaClIPCAdapter::~NaClIPCAdapter() {
+}
+
 int NaClIPCAdapter::LockedReceive(char* output_buffer, int output_buffer_size) {
   lock_.AssertAcquired();
 
   if (locked_data_.to_be_received_.empty())
     return 0;
   scoped_refptr<RewrittenMessage> current =
       locked_data_.to_be_received_.front();
 
   int retval = current->Read(output_buffer, output_buffer_size);
 
@@ skipping 41 matching lines @@
   if (locked_data_.channel_closed_)
     return false;  // TODO(brettw) clean up handles here when we add support!
 
   // Actual send must be done on the I/O thread.
   task_runner_->PostTask(FROM_HERE,
       base::Bind(&NaClIPCAdapter::SendMessageOnIOThread, this,
                  base::Passed(&msg)));
   return true;
 }
 
-void NaClIPCAdapter::CloseChannelOnIOThread() {
-  io_thread_data_.channel_->Close();
-}
-
-void NaClIPCAdapter::SendMessageOnIOThread(scoped_ptr<IPC::Message> message) {
-  io_thread_data_.channel_->Send(message.release());
-}
-
 void NaClIPCAdapter::ClearToBeSent() {
   lock_.AssertAcquired();
 
   // Don't let the string keep its buffer behind our back.
   std::string empty;
   locked_data_.to_be_sent_.swap(empty);
 }
+
+void NaClIPCAdapter::CloseChannelOnIOThread() {
+  io_thread_data_.channel_->Close();
+}
+
+void NaClIPCAdapter::SendMessageOnIOThread(scoped_ptr<IPC::Message> message) {
+  io_thread_data_.channel_->Send(message.release());
+}