RefCounted types should not have public destructors, ipc/ edition

ipc/ipc_channel_proxy.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 IPC_IPC_CHANNEL_PROXY_H_
 #define IPC_IPC_CHANNEL_PROXY_H_
 #pragma once
 
 #include <vector>
 
@@ skipping 40 matching lines @@
  public:
 
   struct MessageFilterTraits;
 
   // A class that receives messages on the thread where the IPC channel is
   // running.  It can choose to prevent the default action for an IPC message.
   class IPC_EXPORT MessageFilter
       : public base::RefCountedThreadSafe<MessageFilter, MessageFilterTraits> {
    public:
     MessageFilter();
-    virtual ~MessageFilter();
 
     // Called on the background thread to provide the filter with access to the
     // channel.  Called when the IPC channel is initialized or when AddFilter
     // is called if the channel is already initialized.
     virtual void OnFilterAdded(Channel* channel);
 
     // Called on the background thread when the filter has been removed from
     // the ChannelProxy and when the Channel is closing.  After a filter is
     // removed, it will not be called again.
     virtual void OnFilterRemoved();
@@ skipping 11 matching lines @@
     virtual void OnChannelClosing();
 
     // Return true to indicate that the message was handled, or false to let
     // the message be handled in the default way.
     virtual bool OnMessageReceived(const Message& message);
 
     // Called when the message filter is about to be deleted.  This gives
     // derived classes the option of controlling which thread they're deleted
     // on etc.
     virtual void OnDestruct() const;
+
+   protected:
+    virtual ~MessageFilter();
+
+   private:
+    friend class base::RefCountedThreadSafe<MessageFilter,
+                                            MessageFilterTraits>;
   };
 
   struct MessageFilterTraits {
     static void Destruct(const MessageFilter* filter) {
       filter->OnDestruct();
     }
   };
 
+
   // Interface for a filter to be imposed on outgoing messages which can
   // re-write the message.  Used mainly for testing.
   class OutgoingMessageFilter {
    public:
     // Returns a re-written message, freeing the original, or simply the
     // original unchanged if no rewrite indicated.
     virtual Message *Rewrite(Message *message) = 0;
   };
 
   // Initializes a channel proxy.  The channel_handle and mode parameters are
@@ skipping 115 matching lines @@
 
    private:
     friend class ChannelProxy;
     friend class SendCallbackHelper;
 
     // Create the Channel
     void CreateChannel(const IPC::ChannelHandle& channel_handle,
                        const Channel::Mode& mode);
 
     // Methods called on the IO thread.
-    void OnSendMessage(Message* message_ptr);
+    void OnSendMessage(scoped_ptr<Message> message_ptr);
     void OnAddFilter();
     void OnRemoveFilter(MessageFilter* filter);
 
     // Methods called on the listener thread.
     void AddFilter(MessageFilter* filter);
     void OnDispatchConnected();
     void OnDispatchError();
 
     scoped_refptr<base::MessageLoopProxy> listener_message_loop_;
     Channel::Listener* listener_;
@@ skipping 32 matching lines @@
 
   OutgoingMessageFilter* outgoing_message_filter_;
 
   // Whether the channel has been initialized.
   bool did_init_;
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H_