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

chrome/nacl/nacl_ipc_adapter.h

 // 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.
 
 #ifndef CHROME_NACL_NACL_IPC_ADAPTER_H_
 #define CHROME_NACL_NACL_IPC_ADAPTER_H_
 #pragma once
 
 #include <queue>
 #include <string>
@@ skipping 41 matching lines @@
 
   // Creates an adapter, using the thread associated with the given task
   // runner for posting messages. In normal use, the task runner will post to
   // the I/O thread of the process.
   NaClIPCAdapter(const IPC::ChannelHandle& handle, base::TaskRunner* runner);
 
   // Initializes with a given channel that's already created for testing
   // purposes. This function will take ownership of the given channel.
   NaClIPCAdapter(scoped_ptr<IPC::Channel> channel, base::TaskRunner* runner);
 
-  virtual ~NaClIPCAdapter();
-
   // Implementation of sendmsg. Returns the number of bytes written or -1 on
   // failure.
   int Send(const char* input_data, size_t input_data_len);
 
   // Implementation of recvmsg. Returns the number of bytes read or -1 on
   // failure. This will block until there's an error or there is data to
   // read.
   int BlockingReceive(char* output_buffer, int output_buffer_size);
 
   // Closes the IPC channel.
   void CloseChannel();
 
   // Listener implementation.
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE;
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE;
   virtual void OnChannelError() OVERRIDE;
 
  private:
+  friend class base::RefCountedThreadSafe<NaClIPCAdapter>;
+
   class RewrittenMessage;
 
   // This is the data that must only be accessed inside the lock. This struct
   // just separates it so it's easier to see.
   struct LockedData {
     LockedData();
     ~LockedData();
 
     // Messages that we have read off of the Chrome IPC channel that are waiting
     // to be received by the plugin.
@@ skipping 13 matching lines @@
 
   // This is the data that must only be accessed on the I/O thread (as defined
   // by TaskRunner). This struct just separates it so it's easier to see.
   struct IOThreadData {
     IOThreadData();
     ~IOThreadData();
 
     scoped_ptr<IPC::Channel> channel_;
   };
 
+  virtual ~NaClIPCAdapter();
+
   // Reads up to the given amount of data. Returns 0 if nothing is waiting.
   int LockedReceive(char* output_buffer, int output_buffer_size);
 
   // Sends a message that we know has been completed to the Chrome process.
   bool SendCompleteMessage(const char* buffer, size_t buffer_len);
 
   // Clears the LockedData.to_be_sent_ structure in a way to make sure that
   // the memory is deleted. std::string can sometimes hold onto the buffer
   // for future use which we don't want.
   void ClearToBeSent();
 
   void CloseChannelOnIOThread();
   void SendMessageOnIOThread(scoped_ptr<IPC::Message> message);
 
   base::Lock lock_;
   base::ConditionVariable cond_var_;
 
   scoped_refptr<base::TaskRunner> task_runner_;
 
   // To be accessed inside of lock_ only.
   LockedData locked_data_;
 
   // To be accessed on the I/O thread (via task runner) only.
   IOThreadData io_thread_data_;
 
   DISALLOW_COPY_AND_ASSIGN(NaClIPCAdapter);
 };
 
 #endif  // CHROME_NACL_NACL_IPC_ADAPTER_H_