IPC::MessageFilter::OnFilterAdded: IPC::Sender -> IPC::Channel

ipc/ipc_sync_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 "ipc/ipc_sync_message_filter.h"
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/macros.h"
@@ skipping 149 matching lines @@
 
   {
     base::AutoLock auto_lock(lock_);
     delete pending_message.deserializer;
     pending_sync_messages_.erase(&pending_message);
   }
 
   return pending_message.send_result;
 }
 
-void SyncMessageFilter::OnFilterAdded(Sender* sender) {
+void SyncMessageFilter::OnFilterAdded(Channel* channel) {
   std::vector<std::unique_ptr<Message>> pending_messages;
   {
     base::AutoLock auto_lock(lock_);
-    sender_ = sender;
+    channel_ = channel;
     io_task_runner_ = base::ThreadTaskRunnerHandle::Get();
     shutdown_watcher_.StartWatching(
         shutdown_event_,
         base::Bind(&SyncMessageFilter::OnShutdownEventSignaled, this));
     io_message_loop_observer_->StartOnIOThread();
     std::swap(pending_messages_, pending_messages);
   }
   for (auto& msg : pending_messages)
     SendOnIOThread(msg.release());
 }
 
 void SyncMessageFilter::OnChannelError() {
   base::AutoLock auto_lock(lock_);
-  sender_ = NULL;
+  channel_ = nullptr;
   shutdown_watcher_.StopWatching();
   SignalAllEvents();
 }
 
 void SyncMessageFilter::OnChannelClosing() {
   base::AutoLock auto_lock(lock_);
-  sender_ = NULL;
+  channel_ = nullptr;
   shutdown_watcher_.StopWatching();
   SignalAllEvents();
 }
 
 bool SyncMessageFilter::OnMessageReceived(const Message& message) {
   base::AutoLock auto_lock(lock_);
   for (PendingSyncMessages::iterator iter = pending_sync_messages_.begin();
        iter != pending_sync_messages_.end(); ++iter) {
     if (SyncMessage::IsMessageReplyTo(message, (*iter)->id)) {
       if (!message.is_reply_error()) {
         (*iter)->send_result =
             (*iter)->deserializer->SerializeOutputParameters(message);
       }
       TRACE_EVENT_FLOW_BEGIN0(TRACE_DISABLED_BY_DEFAULT("ipc.flow"),
                               "SyncMessageFilter::OnMessageReceived",
                               (*iter)->done_event);
       (*iter)->done_event->Signal();
       return true;
     }
   }
 
   return false;
 }
 
 SyncMessageFilter::SyncMessageFilter(base::WaitableEvent* shutdown_event)
-    : sender_(NULL),
+    : channel_(nullptr),
       listener_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       shutdown_event_(shutdown_event),
       weak_factory_(this) {
   io_message_loop_observer_ = new IOMessageLoopObserver(
       weak_factory_.GetWeakPtr(), listener_task_runner_);
 }
 
 SyncMessageFilter::~SyncMessageFilter() {
   io_message_loop_observer_->Stop();
 }
 
 void SyncMessageFilter::SendOnIOThread(Message* message) {
-  if (sender_) {
-    sender_->Send(message);
+  if (channel_) {
+    channel_->Send(message);
     return;
   }
 
   if (message->is_sync()) {
     // We don't know which thread sent it, but it doesn't matter, just signal
     // them all.
     base::AutoLock auto_lock(lock_);
     SignalAllEvents();
   }
 
@@ skipping 18 matching lines @@
 
 void SyncMessageFilter::OnIOMessageLoopDestroyed() {
   // Since we use an async WaitableEventWatcher to watch the shutdown event
   // from the IO thread, we can't forward the shutdown signal after the IO
   // message loop is destroyed. Since that destruction indicates shutdown
   // anyway, we manually signal the shutdown event in this case.
   shutdown_mojo_event_.Signal();
 }
 
 }  // namespace IPC