Decouple IPC::MessageFilter from IPC::Channel

content/plugin/plugin_channel.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/plugin/plugin_channel.h"
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/process/process_handle.h"
 #include "base/strings/string_util.h"
@@ skipping 25 matching lines @@
 // How long we wait before releasing the plugin process.
 const int kPluginReleaseTimeMinutes = 5;
 
 }  // namespace
 
 // If a sync call to the renderer results in a modal dialog, we need to have a
 // way to know so that we can run a nested message loop to simulate what would
 // happen in a single process browser and avoid deadlock.
 class PluginChannel::MessageFilter : public IPC::MessageFilter {
  public:
-  MessageFilter() : channel_(NULL) { }
+  MessageFilter() : sender_(NULL) { }
 
   base::WaitableEvent* GetModalDialogEvent(int render_view_id) {
     base::AutoLock auto_lock(modal_dialog_event_map_lock_);
     if (!modal_dialog_event_map_.count(render_view_id)) {
       NOTREACHED();
       return NULL;
     }
 
     return modal_dialog_event_map_[render_view_id].event;
   }
@@ skipping 11 matching lines @@
       return;
 
     // Delete the event when the stack unwinds as it could be in use now.
     base::MessageLoop::current()->DeleteSoon(
         FROM_HERE, modal_dialog_event_map_[render_view_id].event);
     modal_dialog_event_map_.erase(render_view_id);
   }
 
   bool Send(IPC::Message* message) {
     // Need this function for the IPC_MESSAGE_HANDLER_DELAY_REPLY macro.
-    return channel_->Send(message);
+    return sender_->Send(message);
   }
 
   // IPC::MessageFilter:
-  virtual void OnFilterAdded(IPC::Channel* channel) OVERRIDE {
-    channel_ = channel;
+  virtual void OnFilterAdded(IPC::Sender* sender) OVERRIDE {
+    sender_ = sender;
   }
 
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
     IPC_BEGIN_MESSAGE_MAP(PluginChannel::MessageFilter, message)
       IPC_MESSAGE_HANDLER_DELAY_REPLY(PluginMsg_Init, OnInit)
       IPC_MESSAGE_HANDLER(PluginMsg_SignalModalDialogEvent,
                           OnSignalModalDialogEvent)
       IPC_MESSAGE_HANDLER(PluginMsg_ResetModalDialogEvent,
                           OnResetModalDialogEvent)
     IPC_END_MESSAGE_MAP()
@@ skipping 37 matching lines @@
   }
 
   struct WaitableEventWrapper {
     base::WaitableEvent* event;
     int refcount;  // There could be multiple plugin instances per tab.
   };
   typedef std::map<int, WaitableEventWrapper> ModalDialogEventMap;
   ModalDialogEventMap modal_dialog_event_map_;
   base::Lock modal_dialog_event_map_lock_;
 
-  IPC::Channel* channel_;
+  IPC::Sender* sender_;
 };
 
 PluginChannel* PluginChannel::GetPluginChannel(
     int renderer_id, base::MessageLoopProxy* ipc_message_loop) {
   // Map renderer ID to a (single) channel to that process.
   std::string channel_key = base::StringPrintf(
       "%d.r%d", base::GetCurrentProcId(), renderer_id);
 
   PluginChannel* channel =
       static_cast<PluginChannel*>(NPChannelBase::GetChannel(
@@ skipping 187 matching lines @@
 void PluginChannel::OnDidAbortLoading(int render_view_id) {
   for (size_t i = 0; i < plugin_stubs_.size(); ++i) {
     if (plugin_stubs_[i]->webplugin()->host_render_view_routing_id() ==
             render_view_id) {
       plugin_stubs_[i]->delegate()->instance()->CloseStreams();
     }
   }
 }
 
 }  // namespace content