Fix for 128506: Random Chinese/Japanese characters are missing in documents printed via the syst...

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 <string>
 #include <vector>
 #include <map>
 
 #include "base/logging.h"
 #include "base/string16.h"
 #include "content/common/child_process_messages.h"
+#include "content/common/view_messages.h"
 
 namespace {
 typedef std::vector<string16> FontNameVector;
 typedef std::map<FontCacheDispatcher*, FontNameVector> DispatcherToFontNames;
 
 class FontCache {
  public:
   static FontCache* GetInstance() {
     return Singleton<FontCache>::get();
   }
@@ skipping 66 matching lines @@
     dispatcher_font_map_.erase(it);
     for (FontNameToElement::iterator i = cache_.begin(); i != cache_.end(); ) {
       if (i->second.ref_count_ == 0) {
         cache_.erase(i++);
       } else {
         ++i;
       }
     }
   }
 
+  void PreCacheFontCharacters(const LOGFONT& font,
+                              const std::wstring& str,
+                              FontCacheDispatcher* dispatcher) {
+    // The only way windows seem to load properly, it is to create a similar
+    // device (like the one in which we print), then do an ExtTextOut,
+    // as we do in the printing thread, which is sandboxed.
+    HDC hdc = CreateEnhMetaFile(NULL, NULL, NULL, NULL);
+    HFONT font_handle = CreateFontIndirect(&font);
+    DCHECK(NULL != font_handle);
+
+    HGDIOBJ old_font = SelectObject(hdc, font_handle);
+    DCHECK(NULL != old_font);
+
+    ExtTextOut(hdc, 0, 0, ETO_GLYPH_INDEX, 0, str.c_str(), str.length(), NULL);
+
+    SelectObject(hdc, old_font);
+    DeleteObject(font_handle);
+
+    HENHMETAFILE metafile = CloseEnhMetaFile(hdc);
+
+    if (metafile) {
+      DeleteEnhMetaFile(metafile);
+    }
+  }
+
  private:
   struct CacheElement {
     CacheElement()
         : font_(NULL), old_font_(NULL), dc_(NULL), ref_count_(0) {
     }
 
     ~CacheElement() {
       if (font_) {
         if (dc_ && old_font_) {
           SelectObject(dc_, old_font_);
@@ skipping 34 matching lines @@
 void FontCacheDispatcher::OnFilterAdded(IPC::Channel* channel) {
   channel_ = channel;
 }
 
 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_HANDLER(ViewHostMsg_PreCacheFontCharacters,
+                        OnPreCacheFontCharacters)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
 }
 
 void FontCacheDispatcher::OnChannelClosing() {
   channel_ = NULL;
 }
 
 bool FontCacheDispatcher::Send(IPC::Message* message) {
@@ skipping 14 matching lines @@
   // 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::OnPreCacheFontCharacters(const LOGFONT& font,
+                                                   const std::wstring& str) {
+  // First, comments from FontCacheDispatcher::OnPreCacheFont do apply here too.
+  // Except that for True Type fonts,
+  // GetTextMetrics will not load the font in memory.
+  // The only way windows seem to load properly, it is to create a similar
+  // device (like the one in which we print), then do an ExtTextOut,
+  // as we do in the printing thread, which is sandboxed.
+  FontCache::GetInstance()->PreCacheFontCharacters(font, str, 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);
 }