Use IPC::Sender and IPC::Listener in content.

content/common/gpu/client/gpu_channel_host.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/common/gpu/client/gpu_channel_host.h"
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
@@ skipping 83 matching lines @@
     if (channel_.get()) {
       // http://crbug.com/125264
       base::ThreadRestrictions::ScopedAllowWait allow_wait;
       return channel_->Send(message);
     }
   } else if (MessageLoop::current()) {
     return sync_filter_->Send(message);
   }
 
   // Callee takes ownership of message, regardless of whether Send is
-  // successful. See IPC::Message::Sender.
+  // successful. See IPC::Sender.
   delete message;
   return false;
 }
 
 CommandBufferProxy* GpuChannelHost::CreateViewCommandBuffer(
     int32 surface_id,
     CommandBufferProxy* share_group,
     const std::string& allowed_extensions,
     const std::vector<int32>& attribs,
     const GURL& active_url,
@@ skipping 93 matching lines @@
   Send(new GpuChannelMsg_DestroyCommandBuffer(route_id));
   // Check the proxy has not already been removed after a channel error.
   if (proxies_.find(route_id) != proxies_.end())
     proxies_.erase(route_id);
   RemoveRoute(route_id);
   delete command_buffer;
 #endif
 }
 
 void GpuChannelHost::AddRoute(
-    int route_id, base::WeakPtr<IPC::Channel::Listener> listener) {
+    int route_id, base::WeakPtr<IPC::Listener> listener) {
   DCHECK(MessageLoopProxy::current());
 
   scoped_refptr<base::MessageLoopProxy> io_loop = factory_->GetIOLoopProxy();
   io_loop->PostTask(FROM_HERE,
                     base::Bind(&GpuChannelHost::MessageFilter::AddRoute,
                                channel_filter_.get(), route_id, listener,
                                MessageLoopProxy::current()));
 }
 
 void GpuChannelHost::RemoveRoute(int route_id) {
   scoped_refptr<base::MessageLoopProxy> io_loop = factory_->GetIOLoopProxy();
   io_loop->PostTask(FROM_HERE,
                     base::Bind(&GpuChannelHost::MessageFilter::RemoveRoute,
                                channel_filter_.get(), route_id));
 }
 
 GpuChannelHost::~GpuChannelHost() {}
 
 
 GpuChannelHost::MessageFilter::MessageFilter(GpuChannelHost* parent)
     : parent_(parent) {
 }
 
 GpuChannelHost::MessageFilter::~MessageFilter() {}
 
 void GpuChannelHost::MessageFilter::AddRoute(
     int route_id,
-    base::WeakPtr<IPC::Channel::Listener> listener,
+    base::WeakPtr<IPC::Listener> listener,
     scoped_refptr<MessageLoopProxy> loop) {
   DCHECK(parent_->factory_->IsIOThread());
   DCHECK(listeners_.find(route_id) == listeners_.end());
   GpuListenerInfo info;
   info.listener = listener;
   info.loop = loop;
   listeners_[route_id] = info;
 }
 
 void GpuChannelHost::MessageFilter::RemoveRoute(int route_id) {
@@ skipping 12 matching lines @@
 
   DCHECK(message.routing_id() != MSG_ROUTING_CONTROL);
 
   ListenerMap::iterator it = listeners_.find(message.routing_id());
 
   if (it != listeners_.end()) {
     const GpuListenerInfo& info = it->second;
     info.loop->PostTask(
         FROM_HERE,
         base::Bind(
-            base::IgnoreResult(&IPC::Channel::Listener::OnMessageReceived),
+            base::IgnoreResult(&IPC::Listener::OnMessageReceived),
             info.listener,
             message));
   }
 
   return true;
 }
 
 void GpuChannelHost::MessageFilter::OnChannelError() {
   DCHECK(parent_->factory_->IsIOThread());
   // Inform all the proxies that an error has occurred. This will be reported
   // via OpenGL as a lost context.
   for (ListenerMap::iterator it = listeners_.begin();
        it != listeners_.end();
        it++) {
     const GpuListenerInfo& info = it->second;
     info.loop->PostTask(
         FROM_HERE,
-        base::Bind(&IPC::Channel::Listener::OnChannelError, info.listener));
+        base::Bind(&IPC::Listener::OnChannelError, info.listener));
   }
 
   listeners_.clear();
 
   MessageLoop* main_loop = parent_->factory_->GetMainLoop();
   main_loop->PostTask(FROM_HERE,
                       base::Bind(&GpuChannelHost::OnChannelError, parent_));
 }