Ignore Unicode BiDi control characters in missing glyphs check 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 206 matching lines @@
     *font = platform_font->DeriveFontWithHeight(font_height, target_style);
     return;
   }
 
   const int current_style = (font->GetStyle() & kStyleMask);
   const int current_size = font->GetFontSize();
   if (current_style != target_style || current_size != font_size)
     *font = font->DeriveFont(font_size - current_size, font_style);
 }
 
+// Returns true if |c| is a Unicode BiDi control character.
+bool IsUnicodeBidiControlCharacter(char16 c) {
+  return c == base::i18n::kRightToLeftMark ||
+         c == base::i18n::kLeftToRightMark ||
+         c == base::i18n::kLeftToRightEmbeddingMark ||
+         c == base::i18n::kRightToLeftEmbeddingMark ||
+         c == base::i18n::kPopDirectionalFormatting ||
+         c == base::i18n::kLeftToRightOverride ||
+         c == base::i18n::kRightToLeftOverride;
+}
+
 }  // namespace
 
 namespace internal {
 
 TextRun::TextRun()
   : strike(false),
     underline(false),
     width(0),
     preceding_run_widths(0),
     glyph_count(0),
@@ skipping 594 matching lines @@
 
   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

[msw, 2012/06/29 23:17:24]

Does it make sense to limit this case to Windows Vista?
Perhaps not, if we want consistent behavior and this might occur on XP/7/etc.?

[Alexei Svitkine (slow), 2012/06/29 23:26:03]

Yes, I'd rather be safe and check for this always - we've observed this problem
on Vista for a specific font - maybe it occurs on 7 for a different specific
font that we haven't observed. Either way, the check is cheap (and keeping it on
all platforms helps us catch cases like this where there was a legitimate bug in
the logic). If the check was Vista specific, we might have regressed on Vista
without catching it (as soon), since fewer people were testing on Vista.

     // 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])) {
+        !IsWhitespace(run_text[char_index]) &&
+        !IsUnicodeBidiControlCharacter(run_text[char_index])) {

[xji, 2012/06/29 23:13:19]

so, it always return wgBlank && fZeroWidth for bidi-ctrl characters?  which is a
false positive.

but how about there indeed were no glyph for those bidi-ctrl characters? (guess
win7 has them by default).

[Alexei Svitkine (slow), 2012/06/29 23:26:03]

We don't care about the cases where it doesn't return a wgBlank / not zero width
since it won't hit the false positive case.

If there are no glyphs returned for those, then it's fine as well.

       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 =
@@ skipping 39 matching lines @@
     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