Decouple IPC::MessageFilter from IPC::Channel

content/public/browser/browser_message_filter.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 "content/public/browser/browser_message_filter.h"
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/logging.h"
@@ skipping 12 matching lines @@
 namespace content {
 
 class BrowserMessageFilter::Internal : public IPC::MessageFilter {
  public:
   explicit Internal(BrowserMessageFilter* filter) : filter_(filter) {}
 
  private:
   virtual ~Internal() {}
 
   // IPC::MessageFilter implementation:
-  virtual void OnFilterAdded(IPC::Channel* channel) OVERRIDE {
-    filter_->channel_ = channel;
-    filter_->OnFilterAdded(channel);
+  virtual void OnFilterAdded(IPC::Sender* sender) OVERRIDE {
+    filter_->sender_ = sender;
+    filter_->OnFilterAdded(sender);
   }
 
   virtual void OnFilterRemoved() OVERRIDE {
     filter_->OnFilterRemoved();
   }
 
   virtual void OnChannelClosing() OVERRIDE {
-    filter_->channel_ = NULL;
+    filter_->sender_ = NULL;
     filter_->OnChannelClosing();
   }
 
   virtual void OnChannelConnected(int32 peer_pid) OVERRIDE {
     filter_->peer_pid_ = peer_pid;
     filter_->OnChannelConnected(peer_pid);
   }
 
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
     BrowserThread::ID thread = BrowserThread::IO;
@@ skipping 40 matching lines @@
     return rv;
   }
 
   scoped_refptr<BrowserMessageFilter> filter_;
 
   DISALLOW_COPY_AND_ASSIGN(Internal);
 };
 
 BrowserMessageFilter::BrowserMessageFilter(uint32 message_class_to_filter)
     : internal_(NULL),
-      channel_(NULL),
+      sender_(NULL),
 #if defined(OS_WIN)
       peer_handle_(base::kNullProcessHandle),
 #endif
       peer_pid_(base::kNullProcessId),
       message_classes_to_filter_(1, message_class_to_filter) {}
 
 BrowserMessageFilter::BrowserMessageFilter(
     const uint32* message_classes_to_filter,
     size_t num_message_classes_to_filter)
     : internal_(NULL),
-      channel_(NULL),
+      sender_(NULL),
 #if defined(OS_WIN)
       peer_handle_(base::kNullProcessHandle),
 #endif
       peer_pid_(base::kNullProcessId),
       message_classes_to_filter_(
           message_classes_to_filter,
           message_classes_to_filter + num_message_classes_to_filter) {
   DCHECK(num_message_classes_to_filter);
 }
 
@@ skipping 28 matching lines @@
 
   if (!BrowserThread::CurrentlyOn(BrowserThread::IO)) {
     BrowserThread::PostTask(
         BrowserThread::IO,
         FROM_HERE,
         base::Bind(base::IgnoreResult(&BrowserMessageFilter::Send), this,
                    message));
     return true;
   }
 
-  if (channel_)
-    return channel_->Send(message);
+  if (sender_)
+    return sender_->Send(message);
 
   delete message;
   return false;
 }
 
 base::TaskRunner* BrowserMessageFilter::OverrideTaskRunnerForMessage(
     const IPC::Message& message) {
   return NULL;
 }
 
@@ skipping 42 matching lines @@
 
 IPC::MessageFilter* BrowserMessageFilter::GetFilter() {
   // We create this on demand so that if a filter is used in a unit test but
   // never attached to a channel, we don't leak Internal and this;
   DCHECK(!internal_) << "Should only be called once.";
   internal_ = new Internal(this);
   return internal_;
 }
 
 }  // namespace content