Decouple IPC::MessageFilter from IPC::Channel

content/renderer/media/audio_input_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/renderer/media/audio_input_message_filter.h"
 
 #include "base/bind.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/strings/stringprintf.h"
 #include "content/common/media/audio_messages.h"
 #include "content/renderer/media/webrtc_logging.h"
-#include "ipc/ipc_channel.h"
 #include "ipc/ipc_logging.h"
+#include "ipc/ipc_sender.h"
 
 namespace content {
 
 namespace {
 const int kStreamIDNotSet = -1;
 }
 
 class AudioInputMessageFilter::AudioInputIPCImpl
     : public NON_EXPORTED_BASE(media::AudioInputIPC) {
  public:
@@ skipping 14 matching lines @@
  private:
   const scoped_refptr<AudioInputMessageFilter> filter_;
   const int render_view_id_;
   int stream_id_;
 };
 
 AudioInputMessageFilter* AudioInputMessageFilter::g_filter = NULL;
 
 AudioInputMessageFilter::AudioInputMessageFilter(
     const scoped_refptr<base::MessageLoopProxy>& io_message_loop)
-    : channel_(NULL),
+    : sender_(NULL),
       io_message_loop_(io_message_loop) {
   DCHECK(!g_filter);
   g_filter = this;
 }
 
 AudioInputMessageFilter::~AudioInputMessageFilter() {
   DCHECK_EQ(g_filter, this);
   g_filter = NULL;
 }
 
 // static
 AudioInputMessageFilter* AudioInputMessageFilter::Get() {
   return g_filter;
 }
 
 void AudioInputMessageFilter::Send(IPC::Message* message) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
-  if (!channel_) {
+  if (!sender_) {
     delete message;
   } else {
-    channel_->Send(message);
+    sender_->Send(message);
   }
 }
 
 bool AudioInputMessageFilter::OnMessageReceived(const IPC::Message& message) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(AudioInputMessageFilter, message)
     IPC_MESSAGE_HANDLER(AudioInputMsg_NotifyStreamCreated,
                         OnStreamCreated)
     IPC_MESSAGE_HANDLER(AudioInputMsg_NotifyStreamVolume, OnStreamVolume)
     IPC_MESSAGE_HANDLER(AudioInputMsg_NotifyStreamStateChanged,
                         OnStreamStateChanged)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
-void AudioInputMessageFilter::OnFilterAdded(IPC::Channel* channel) {
+void AudioInputMessageFilter::OnFilterAdded(IPC::Sender* sender) {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
 
-  // Captures the channel for IPC.
-  channel_ = channel;
+  // Captures the sender for IPC.
+  sender_ = sender;
 }
 
 void AudioInputMessageFilter::OnFilterRemoved() {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
 
   // Once removed, a filter will not be used again.  At this time all
   // delegates must be notified so they release their reference.
   OnChannelClosing();
 }
 
 void AudioInputMessageFilter::OnChannelClosing() {
   DCHECK(io_message_loop_->BelongsToCurrentThread());
-  channel_ = NULL;
+  sender_ = NULL;
 
   DLOG_IF(WARNING, !delegates_.IsEmpty())
       << "Not all audio devices have been closed.";
 
   IDMap<media::AudioInputIPCDelegate>::iterator it(&delegates_);
   while (!it.IsAtEnd()) {
     it.GetCurrentValue()->OnIPCClosed();
     delegates_.Remove(it.GetCurrentKey());
     it.Advance();
   }
@@ skipping 99 matching lines @@
 
 void AudioInputMessageFilter::AudioInputIPCImpl::CloseStream() {
   DCHECK(filter_->io_message_loop_->BelongsToCurrentThread());
   DCHECK_NE(stream_id_, kStreamIDNotSet);
   filter_->Send(new AudioInputHostMsg_CloseStream(stream_id_));
   filter_->delegates_.Remove(stream_id_);
   stream_id_ = kStreamIDNotSet;
 }
 
 }  // namespace content