Decouple IPC::MessageFilter from IPC::Channel

content/common/font_cache_dispatcher_win.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/font_cache_dispatcher_win.h"
 
 #include <map>
 #include <vector>
 
 #include "base/logging.h"
 #include "base/strings/string16.h"
 #include "content/common/child_process_messages.h"
-#include "ipc/ipc_channel.h"
 
 namespace content {
 namespace {
 typedef std::vector<base::string16> FontNameVector;
 typedef std::map<FontCacheDispatcher*, FontNameVector> DispatcherToFontNames;
 
 class FontCache {
  public:
   static FontCache* GetInstance() {
     return Singleton<FontCache>::get();
@@ skipping 105 matching lines @@
   std::map<base::string16, CacheElement> cache_;
   DispatcherToFontNames dispatcher_font_map_;
   base::Lock mutex_;
 
   DISALLOW_COPY_AND_ASSIGN(FontCache);
 };
 
 }
 
 FontCacheDispatcher::FontCacheDispatcher()
-    : channel_(NULL) {
+    : sender_(NULL) {
 }
 
 FontCacheDispatcher::~FontCacheDispatcher() {
 }
 
-void FontCacheDispatcher::OnFilterAdded(IPC::Channel* channel) {
-  channel_ = channel;
+void FontCacheDispatcher::OnFilterAdded(IPC::Sender* sender) {
+  sender_ = sender;
 }
 
 bool FontCacheDispatcher::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(FontCacheDispatcher, message)
     IPC_MESSAGE_HANDLER(ChildProcessHostMsg_PreCacheFont, OnPreCacheFont)
     IPC_MESSAGE_HANDLER(ChildProcessHostMsg_ReleaseCachedFonts,
                         OnReleaseCachedFonts)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void FontCacheDispatcher::OnChannelClosing() {
-  channel_ = NULL;
+  sender_ = NULL;
 }
 
 bool FontCacheDispatcher::Send(IPC::Message* message) {
-  if (channel_)
-    return channel_->Send(message);
+  if (sender_)
+    return sender_->Send(message);
 
   delete message;
   return false;
 }
 
 void FontCacheDispatcher::OnPreCacheFont(const LOGFONT& font) {
   // If a child process is running in a sandbox, GetTextMetrics()
   // can sometimes fail. If a font has not been loaded
   // previously, GetTextMetrics() will try to load the font
   // from the font file. However, the sandboxed process does
   // not have permissions to access any font files and
   // the call fails. So we make the browser pre-load the
   // font for us by using a dummy call to GetTextMetrics of
   // the same font.
   // This means the browser process just loads the font into memory so that
   // when GDI attempt to query that font info in child process, it does not
   // need to load that file, hence no permission issues there.  Therefore,
   // when a font is asked to be cached, we always recreates the font object
   // to avoid the case that an in-cache font is swapped out by GDI.
   FontCache::GetInstance()->PreCacheFont(font, this);
 }
 
 void FontCacheDispatcher::OnReleaseCachedFonts() {
   // Release cached fonts that requested from a pid by decrementing the ref
   // count.  When ref count is zero, the handles are released.
   FontCache::GetInstance()->ReleaseCachedFonts(this);
 }
 
 }  // namespace content