Dispatch the Windows font caching IPCs in one filter. This avoids having the code that calls thos...

content/common/child_process_host.cc

 // Copyright (c) 2011 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/child_process_host.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/third_party/dynamic_annotations/dynamic_annotations.h"
 #include "content/common/child_process_info.h"
 #include "content/common/child_process_messages.h"
 #include "content/public/common/content_paths.h"
 #include "content/public/common/content_switches.h"
 #include "ipc/ipc_logging.h"
 
 #if defined(OS_LINUX)
 #include "base/linux_util.h"
+#elif defined(OS_WIN)
+#include "content/common/font_cache_dispatcher_win.h"
 #endif  // OS_LINUX
 
 #if defined(OS_MACOSX)
 namespace {
 
 // Given |path| identifying a Mac-style child process executable path, adjusts
 // it to correspond to |feature|. For a child process path such as
 // ".../Chromium Helper.app/Contents/MacOS/Chromium Helper", the transformed
 // path for feature "NP" would be
 // ".../Chromium Helper NP.app/Contents/MacOS/Chromium Helper NP". The new
@@ skipping 28 matching lines @@
                                .Append(kContentsName)
                                .Append(kMacOSName)
                                .Append(new_basename);
 
   return new_path;
 }
 
 }  // namespace
 #endif  // OS_MACOSX
 
-#if defined (OS_WIN)
-// Types used in PreCacheFont
-namespace {
-typedef std::vector<string16> FontNameVector;
-typedef std::map<int, FontNameVector> PidToFontNames;
-}
-#endif  // OS_WIN
-
 ChildProcessHost::ChildProcessHost()
     : ALLOW_THIS_IN_INITIALIZER_LIST(listener_(this)),
       opening_channel_(false) {
+#if defined(OS_WIN)
+  AddFilter(new FontCacheDispatcher());
+#endif
 }
 
 ChildProcessHost::~ChildProcessHost() {
   for (size_t i = 0; i < filters_.size(); ++i) {
     filters_[i]->OnChannelClosing();
     filters_[i]->OnFilterRemoved();
   }
   listener_.Shutdown();
 }
 
@@ skipping 41 matching lines @@
     // non-executable heap, but the "EH" feature is provided to allow code
     // intolerant of a non-executable heap to work properly on 10.7. This
     // results in Chromium Helper EH.app or Google Chrome Helper EH.app.
     child_path = TransformPathForFeature(child_path, "EH");
   }
 #endif
 
   return child_path;
 }
 
-#if defined(OS_WIN)
-ChildProcessHost::FontCache::CacheElement::CacheElement()
-    : font_(NULL), dc_(NULL), ref_count_(0) {
-}
-
-ChildProcessHost::FontCache::CacheElement::~CacheElement() {
-  if (font_) {
-    DeleteObject(font_);
-  }
-  if (dc_) {
-    DeleteDC(dc_);
-  }
-}
-
-ChildProcessHost::FontCache::FontCache() {
-}
-
-ChildProcessHost::FontCache::~FontCache() {
-}
-
-// static
-ChildProcessHost::FontCache* ChildProcessHost::FontCache::GetInstance() {
-  return Singleton<ChildProcessHost::FontCache>::get();
-}
-
-void ChildProcessHost::FontCache::PreCacheFont(LOGFONT font, int process_id) {
-  typedef std::map<string16, ChildProcessHost::FontCache::CacheElement>
-          FontNameToElement;
-
-  base::AutoLock lock(mutex_);
-
-  // Fetch the font into memory.
-  // No matter the font is cached or not, we load it to avoid GDI swapping out
-  // that font file.
-  HDC hdc = GetDC(NULL);
-  HFONT font_handle = CreateFontIndirect(&font);
-  DCHECK(NULL != font_handle);
-
-  HGDIOBJ old_font = SelectObject(hdc, font_handle);
-  DCHECK(NULL != old_font);
-
-  TEXTMETRIC tm;
-  BOOL ret = GetTextMetrics(hdc, &tm);
-  DCHECK(ret);
-
-  string16 font_name = font.lfFaceName;
-  int ref_count_inc = 1;
-  FontNameVector::iterator it =
-      std::find(process_id_font_map_[process_id].begin(),
-                process_id_font_map_[process_id].end(),
-                font_name);
-  if (it == process_id_font_map_[process_id].end()) {
-    // Requested font is new to cache.
-    process_id_font_map_[process_id].push_back(font_name);
-  } else {
-    ref_count_inc = 0;
-  }
-
-  if (cache_[font_name].ref_count_ == 0) {  // Requested font is new to cache.
-    cache_[font_name].ref_count_ = 1;
-  } else {  // Requested font is already in cache, release old handles.
-    DeleteObject(cache_[font_name].font_);
-    DeleteDC(cache_[font_name].dc_);
-  }
-  cache_[font_name].font_ = font_handle;
-  cache_[font_name].dc_ = hdc;
-  cache_[font_name].ref_count_ += ref_count_inc;
-}
-
-void ChildProcessHost::FontCache::ReleaseCachedFonts(int process_id) {
-  typedef std::map<string16, ChildProcessHost::FontCache::CacheElement>
-          FontNameToElement;
-
-  base::AutoLock lock(mutex_);
-
-  PidToFontNames::iterator it;
-  it = process_id_font_map_.find(process_id);
-  if (it == process_id_font_map_.end()) {
-    return;
-  }
-
-  for (FontNameVector::iterator i = it->second.begin(), e = it->second.end();
-                                i != e; ++i) {
-    FontNameToElement::iterator element;
-    element = cache_.find(*i);
-    if (element != cache_.end()) {
-      --((*element).second.ref_count_);
-    }
-  }
-
-  process_id_font_map_.erase(it);
-  for (FontNameToElement::iterator i = cache_.begin(); i != cache_.end(); ) {
-    if (i->second.ref_count_ == 0) {
-      cache_.erase(i++);
-    } else {
-      ++i;
-    }
-  }
-}
-
-// static
-void ChildProcessHost::PreCacheFont(LOGFONT font, int pid) {
-  // 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.
-  ChildProcessHost::FontCache::GetInstance()->PreCacheFont(font, pid);
-}
-
-// static
-void ChildProcessHost::ReleaseCachedFonts(int pid) {
-  // Release cached fonts that requested from a pid by decrementing the ref
-  // count.  When ref count is zero, the handles are released.
-  ChildProcessHost::FontCache::GetInstance()->ReleaseCachedFonts(pid);
-}
-#endif  // OS_WIN
-
 void ChildProcessHost::ForceShutdown() {
   Send(new ChildProcessMsg_Shutdown());
 }
 
 bool ChildProcessHost::CreateChannel() {
   channel_id_ = ChildProcessInfo::GenerateRandomChannelID(this);
   channel_.reset(new IPC::Channel(
       channel_id_, IPC::Channel::MODE_SERVER, &listener_));
   if (!channel_->Connect())
     return false;
@@ skipping 146 matching lines @@
     uint32 buffer_size,
     base::SharedMemoryHandle* handle) {
   ChildProcessHost::OnAllocateSharedMemory(
       buffer_size, peer_handle_, handle);
 }
 
 void ChildProcessHost::ListenerHook::OnShutdownRequest() {
   if (host_->CanShutdown())
     host_->Send(new ChildProcessMsg_Shutdown());
 }