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

gpu/ipc/service/gpu_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 "gpu/ipc/service/gpu_channel.h"
 
 #include <utility>
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 430 matching lines @@
   channel_lock_.AssertAcquired();
   DCHECK(preemption_state_ == CHECKING || preemption_state_ == PREEMPTING);
   DCHECK(!scheduled_);
 
   preemption_state_ = WOULD_PREEMPT_DESCHEDULED;
   preempting_flag_->Reset();
   TRACE_COUNTER_ID1("gpu", "GpuChannel::Preempting", this, 0);
 }
 
 GpuChannelMessageFilter::GpuChannelMessageFilter()
-    : sender_(nullptr), peer_pid_(base::kNullProcessId) {}
+    : channel_(nullptr), peer_pid_(base::kNullProcessId) {}
 
 GpuChannelMessageFilter::~GpuChannelMessageFilter() {}
 
-void GpuChannelMessageFilter::OnFilterAdded(IPC::Sender* sender) {
-  DCHECK(!sender_);
-  sender_ = sender;
+void GpuChannelMessageFilter::OnFilterAdded(IPC::Channel* channel) {
+  DCHECK(!channel_);
+  channel_ = channel;
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_) {
-    filter->OnFilterAdded(sender_);
+    filter->OnFilterAdded(channel_);
   }
 }
 
 void GpuChannelMessageFilter::OnFilterRemoved() {
-  DCHECK(sender_);
+  DCHECK(channel_);
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_) {
     filter->OnFilterRemoved();
   }
-  sender_ = nullptr;
+  channel_ = nullptr;
   peer_pid_ = base::kNullProcessId;
 }
 
 void GpuChannelMessageFilter::OnChannelConnected(int32_t peer_pid) {
   DCHECK(peer_pid_ == base::kNullProcessId);
   peer_pid_ = peer_pid;
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_) {
     filter->OnChannelConnected(peer_pid);
   }
 }
 
 void GpuChannelMessageFilter::OnChannelError() {
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_) {
     filter->OnChannelError();
   }
 }
 
 void GpuChannelMessageFilter::OnChannelClosing() {
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_) {
     filter->OnChannelClosing();
   }
 }
 
 void GpuChannelMessageFilter::AddChannelFilter(
     scoped_refptr<IPC::MessageFilter> filter) {
   channel_filters_.push_back(filter);
-  if (sender_)
-    filter->OnFilterAdded(sender_);
+  if (channel_)
+    filter->OnFilterAdded(channel_);
   if (peer_pid_ != base::kNullProcessId)
     filter->OnChannelConnected(peer_pid_);
 }
 
 void GpuChannelMessageFilter::RemoveChannelFilter(
     scoped_refptr<IPC::MessageFilter> filter) {
-  if (sender_)
+  if (channel_)
     filter->OnFilterRemoved();
   channel_filters_.erase(
       std::find(channel_filters_.begin(), channel_filters_.end(), filter));
 }
 
 // This gets called from the main thread and assumes that all messages which
 // lead to creation of a new route are synchronous messages.
 // TODO(sunnyps): Create routes (and streams) on the IO thread so that we can
 // make the CreateCommandBuffer/VideoDecoder/VideoEncoder messages asynchronous.
 void GpuChannelMessageFilter::AddRoute(
     int32_t route_id,
     const scoped_refptr<GpuChannelMessageQueue>& queue) {
   base::AutoLock lock(routes_lock_);
   routes_.insert(std::make_pair(route_id, queue));
 }
 
 void GpuChannelMessageFilter::RemoveRoute(int32_t route_id) {
   base::AutoLock lock(routes_lock_);
   routes_.erase(route_id);
 }
 
 bool GpuChannelMessageFilter::OnMessageReceived(const IPC::Message& message) {
-  DCHECK(sender_);
+  DCHECK(channel_);
 
   if (message.should_unblock() || message.is_reply())
     return MessageErrorHandler(message, "Unexpected message type");
 
   if (message.type() == GpuChannelMsg_Nop::ID) {
     IPC::Message* reply = IPC::SyncMessage::GenerateReply(&message);
     Send(reply);
     return true;
   }
 
   for (scoped_refptr<IPC::MessageFilter>& filter : channel_filters_) {
     if (filter->OnMessageReceived(message))
       return true;
   }
 
   scoped_refptr<GpuChannelMessageQueue> message_queue =
       LookupStreamByRoute(message.routing_id());
 
   if (!message_queue)
     return MessageErrorHandler(message, "Could not find message queue");
 
   if (!message_queue->PushBackMessage(message))
     return MessageErrorHandler(message, "Channel destroyed");
 
   return true;
 }
 
 bool GpuChannelMessageFilter::Send(IPC::Message* message) {
-  return sender_->Send(message);
+  return channel_->Send(message);
 }
 
 scoped_refptr<GpuChannelMessageQueue>
 GpuChannelMessageFilter::LookupStreamByRoute(int32_t route_id) {
   base::AutoLock lock(routes_lock_);
   auto it = routes_.find(route_id);
   if (it != routes_.end())
     return it->second;
   return nullptr;
 }
@@ skipping 496 matching lines @@
 
       return manager->gpu_memory_buffer_factory()
           ->AsImageFactory()
           ->CreateImageForGpuMemoryBuffer(handle, size, format, internalformat,
                                           client_id_, surface_handle);
     }
   }
 }
 
 }  // namespace gpu