FBTF: Move virtual methods to implementation files.

ipc/ipc_channel_proxy.h

 // Copyright (c) 2006-2008 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 37 matching lines @@
 class ChannelProxy : public Message::Sender {
  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 MessageFilter
       : public base::RefCountedThreadSafe<MessageFilter, MessageFilterTraits> {
    public:
-    virtual ~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) {}
+    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() {}
+    virtual void OnFilterRemoved();
 
     // Called to inform the filter that the IPC channel is connected and we
     // have received the internal Hello message from the peer.
-    virtual void OnChannelConnected(int32 peer_pid) {}
+    virtual void OnChannelConnected(int32 peer_pid);
 
     // Called when there is an error on the channel, typically that the channel
     // has been closed.
-    virtual void OnChannelError() {}
+    virtual void OnChannelError();
 
     // Called to inform the filter that the IPC channel will be destroyed.
     // OnFilterRemoved is called immediately after this.
-    virtual void OnChannelClosing() {}
+    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) {
-      return false;
-    }
+    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() {
-      delete this;
-    }
+    virtual void OnDestruct();
   };
 
   struct MessageFilterTraits {
     static void Destruct(MessageFilter* filter) {
       filter->OnDestruct();
     }
   };
 
   // Initializes a channel proxy.  The channel_id and mode parameters are
   // passed directly to the underlying IPC::Channel.  The listener is called on
   // the thread that creates the ChannelProxy.  The filter's OnMessageReceived
   // method is called on the thread where the IPC::Channel is running.  The
   // filter may be null if the consumer is not interested in handling messages
   // on the background thread.  Any message not handled by the filter will be
   // dispatched to the listener.  The given message loop indicates where the
   // IPC::Channel should be created.
   ChannelProxy(const std::string& channel_id, Channel::Mode mode,
                Channel::Listener* listener, MessageFilter* filter,
                MessageLoop* ipc_thread_loop);
 
-  virtual ~ChannelProxy() {
-    Close();
-  }
+  virtual ~ChannelProxy();
 
   // Close the IPC::Channel.  This operation completes asynchronously, once the
   // background thread processes the command to close the channel.  It is ok to
   // call this method multiple times.  Redundant calls are ignored.
   //
   // WARNING: The MessageFilter object held by the ChannelProxy is also
   // released asynchronously, and it may in fact have its final reference
   // released on the background thread.  The caller should be careful to deal
   // with / allow for this possibility.
   void Close();
@@ skipping 103 matching lines @@
 
   // By maintaining this indirection (ref-counted) to our internal state, we
   // can safely be destroyed while the background thread continues to do stuff
   // that involves this data.
   scoped_refptr<Context> context_;
 };
 
 }  // namespace IPC
 
 #endif  // IPC_IPC_CHANNEL_PROXY_H__