Decouple IPC::MessageFilter from IPC::Channel

content/common/gpu/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.
 
 #if defined(OS_WIN)
 #include <windows.h>
 #endif
 
 #include "content/common/gpu/gpu_channel.h"
 
@@ skipping 59 matching lines @@
 //   posting a task to insert the GpuCommandBufferMsg_RetireSyncPoint message
 //   into the channel's queue.
 // - it generates mailbox names for clients of the GPU process on the IO thread.
 class GpuChannelMessageFilter : public IPC::MessageFilter {
  public:
   GpuChannelMessageFilter(base::WeakPtr<GpuChannel> gpu_channel,
                           scoped_refptr<SyncPointManager> sync_point_manager,
                           scoped_refptr<base::MessageLoopProxy> message_loop)
       : preemption_state_(IDLE),
         gpu_channel_(gpu_channel),
-        channel_(NULL),
+        sender_(NULL),
         sync_point_manager_(sync_point_manager),
         message_loop_(message_loop),
         messages_forwarded_to_channel_(0),
         a_stub_is_descheduled_(false) {}
 
-  virtual void OnFilterAdded(IPC::Channel* channel) OVERRIDE {
-    DCHECK(!channel_);
-    channel_ = channel;
+  virtual void OnFilterAdded(IPC::Sender* sender) OVERRIDE {
+    DCHECK(!sender_);
+    sender_ = sender;
   }
 
   virtual void OnFilterRemoved() OVERRIDE {
-    DCHECK(channel_);
-    channel_ = NULL;
+    DCHECK(sender_);
+    sender_ = NULL;
   }
 
   virtual bool OnMessageReceived(const IPC::Message& message) OVERRIDE {
-    DCHECK(channel_);
+    DCHECK(sender_);
 
     bool handled = false;
     if (message.type() == GpuCommandBufferMsg_RetireSyncPoint::ID) {
       // This message should not be sent explicitly by the renderer.
       DLOG(ERROR) << "Client should not send "
                      "GpuCommandBufferMsg_RetireSyncPoint message";
       handled = true;
     }
 
     // All other messages get processed by the GpuChannel.
@@ skipping 33 matching lines @@
     preempting_flag_ = preempting_flag;
     a_stub_is_descheduled_ = a_stub_is_descheduled;
   }
 
   void UpdateStubSchedulingState(bool a_stub_is_descheduled) {
     a_stub_is_descheduled_ = a_stub_is_descheduled;
     UpdatePreemptionState();
   }
 
   bool Send(IPC::Message* message) {
-    return channel_->Send(message);
+    return sender_->Send(message);
   }
 
  protected:
   virtual ~GpuChannelMessageFilter() {}
 
  private:
   enum PreemptionState {
     // Either there's no other channel to preempt, there are no messages
     // pending processing, or we just finished preempting and have to wait
     // before preempting again.
@@ skipping 190 matching lines @@
       } else {
         gpu_channel->MessageProcessed();
       }
     }
     manager->RetireSyncPoint(sync_point);
   }
 
   // NOTE: this weak pointer is never dereferenced on the IO thread, it's only
   // passed through - therefore the WeakPtr assumptions are respected.
   base::WeakPtr<GpuChannel> gpu_channel_;
-  IPC::Channel* channel_;
+  IPC::Sender* sender_;
   scoped_refptr<SyncPointManager> sync_point_manager_;
   scoped_refptr<base::MessageLoopProxy> message_loop_;
   scoped_refptr<gpu::PreemptionFlag> preempting_flag_;
 
   std::queue<PendingMessage> pending_messages_;
 
   // Count of the number of IPCs forwarded to the GpuChannel.
   uint64 messages_forwarded_to_channel_;
 
   base::OneShotTimer<GpuChannelMessageFilter> timer_;
@@ skipping 463 matching lines @@
 uint64 GpuChannel::GetMemoryUsage() {
   uint64 size = 0;
   for (StubMap::Iterator<GpuCommandBufferStub> it(&stubs_);
        !it.IsAtEnd(); it.Advance()) {
     size += it.GetCurrentValue()->GetMemoryUsage();
   }
   return size;
 }
 
 }  // namespace content