Detect missing glyphs as returned by Vista in RenderTextWin.

ui/gfx/render_text_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 "ui/gfx/render_text_win.h"
 
 #include <algorithm>
 
 #include "base/i18n/break_iterator.h"
 #include "base/logging.h"
@@ skipping 589 matching lines @@
 void RenderTextWin::LayoutVisualText() {
   DCHECK(!runs_.empty());
 
   if (!cached_hdc_)
     cached_hdc_ = CreateCompatibleDC(NULL);
 
   HRESULT hr = E_FAIL;
   string_size_.set_height(0);
   for (size_t i = 0; i < runs_.size(); ++i) {
     internal::TextRun* run = runs_[i];
-    size_t run_length = run->range.length();
+    const size_t run_length = run->range.length();
     const wchar_t* run_text = &(text()[run->range.start()]);
     bool tried_fallback = false;
     size_t linked_font_index = 0;
     const std::vector<Font>* linked_fonts = NULL;
     Font original_font = run->font;
 
     // Select the font desired for glyph generation.
     SelectObject(cached_hdc_, run->font.GetNativeFont());
 
-    SCRIPT_FONTPROPERTIES properties;
-    memset(&properties, 0, sizeof(properties));
-    properties.cBytes = sizeof(properties);
-
     run->logical_clusters.reset(new WORD[run_length]);
     run->glyph_count = 0;
     // Max glyph guess: http://msdn.microsoft.com/en-us/library/dd368564.aspx
     size_t max_glyphs = static_cast<size_t>(1.5 * run_length + 16);
     while (max_glyphs < kMaxGlyphs) {
       bool glyphs_missing = false;

[msw, 2012/05/03 17:33:34]

nit: move this down to usage; optionally nix and just do @ line 649:
// Skip font substitution if there are no missing glyphs.
// If |hr| is S_OK, there could still ....
if (hr != USP_E_SCRIPT_NOT_IN_FONT && !HasMissingGlyphs(run))
  break;

[Alexei Svitkine (slow), 2012/05/03 17:47:50]

Done.

       run->glyphs.reset(new WORD[max_glyphs]);
       run->visible_attributes.reset(new SCRIPT_VISATTR[max_glyphs]);
       hr = ScriptShape(cached_hdc_,
                        &run->script_cache,
                        run_text,
                        run_length,
                        max_glyphs,
                        &(run->script_analysis),
                        run->glyphs.get(),
                        run->logical_clusters.get(),
                        run->visible_attributes.get(),
                        &(run->glyph_count));
       if (hr == E_OUTOFMEMORY) {
         max_glyphs *= 2;
         continue;
       } else if (hr == USP_E_SCRIPT_NOT_IN_FONT) {
         glyphs_missing = true;
       } else if (hr == S_OK) {
         // If |hr| is S_OK, there could still be missing glyphs in the output,
         // see: http://msdn.microsoft.com/en-us/library/windows/desktop/dd368564.aspx
-        ScriptGetFontProperties(cached_hdc_, &run->script_cache, &properties);
-        for (int i = 0; i < run->glyph_count; ++i) {
-          if (run->glyphs[i] == properties.wgDefault) {
-            glyphs_missing = true;
-            break;
-          }
-        }
+        glyphs_missing = HasMissingGlyphs(run);
       }
 
       // Skip font substitution if there are no missing glyphs.
       if (!glyphs_missing)
         break;
 
       // If there are missing glyphs, first try finding a fallback font using a
       // meta file, if it hasn't yet been attempted for this run.
       // TODO(msw|asvitkine): Support RenderText's font_list()?
       // TODO(msw|asvitkine): Cache previous successful replacement fonts?
@@ skipping 94 matching lines @@
 void RenderTextWin::ApplySubstituteFont(internal::TextRun* run,
                                         const Font& font) {
   const int font_size = run->font.GetFontSize();
   const int font_height = run->font.GetHeight();
   run->font = font;
   DeriveFontIfNecessary(font_size, font_height, run->font_style, &run->font);
   ScriptFreeCache(&run->script_cache);
   SelectObject(cached_hdc_, run->font.GetNativeFont());
 }
 
+bool RenderTextWin::HasMissingGlyphs(internal::TextRun* run) const {
+  SCRIPT_FONTPROPERTIES properties;
+  memset(&properties, 0, sizeof(properties));
+  properties.cBytes = sizeof(properties);
+  ScriptGetFontProperties(cached_hdc_, &run->script_cache, &properties);
+
+  const wchar_t* run_text = &(text()[run->range.start()]);
+  for (size_t char_index = 0; char_index < run->range.length(); ++char_index) {
+    const int glyph_index = run->logical_clusters[char_index];
+    DCHECK_GE(glyph_index, 0);
+    DCHECK_LT(glyph_index, run->glyph_count);
+
+    if (run->glyphs[glyph_index] == properties.wgDefault)
+      return true;
+
+    // Windows Vista sometimes returns glyphs equal to wgBlank (instead of
+    // wgDefault), with fZeroWidth set. Treat such cases as having missing
+    // glyphs if the corresponding character is not whitespace.
+    // See: http://crbug.com/125629
+    if (run->glyphs[glyph_index] == properties.wgBlank &&
+        run->visible_attributes[glyph_index].fZeroWidth &&
+        !IsWhitespace(run_text[char_index])) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
 const std::vector<Font>* RenderTextWin::GetLinkedFonts(const Font& font) const {
   const std::string& font_name = font.GetFontName();
   std::map<std::string, std::vector<Font> >::const_iterator it =
       cached_linked_fonts_.find(font_name);
   if (it != cached_linked_fonts_.end())
     return &it->second;
 
   cached_linked_fonts_[font_name] = std::vector<Font>();
   std::vector<Font>* linked_fonts = &cached_linked_fonts_[font_name];
   QueryLinkedFontsFromRegistry(font, linked_fonts);
@@ skipping 16 matching lines @@
   // Find the text run containing the argument point (assumed already offset).
   size_t run = 0;
   for (; run < runs_.size(); ++run)
     if (runs_[run]->preceding_run_widths <= point.x() &&
         runs_[run]->preceding_run_widths + runs_[run]->width > point.x())
       break;
   return run;
 }
 
 SelectionModel RenderTextWin::FirstSelectionModelInsideRun(
-    internal::TextRun* run) {
+    const internal::TextRun* run) {
   size_t cursor = IndexOfAdjacentGrapheme(run->range.start(), CURSOR_FORWARD);
   return SelectionModel(cursor, CURSOR_BACKWARD);
 }
 
 SelectionModel RenderTextWin::LastSelectionModelInsideRun(
-    internal::TextRun* run) {
+    const internal::TextRun* run) {
   size_t caret = IndexOfAdjacentGrapheme(run->range.end(), CURSOR_BACKWARD);
   return SelectionModel(caret, CURSOR_FORWARD);
 }
 
 RenderText* RenderText::CreateRenderText() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx