Implement font fallback in RenderTextWin.

ui/gfx/render_text_win.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 "ui/gfx/render_text_win.h"
 
 #include <algorithm>
-#include <map>
 
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/string_util.h"
+#include "base/utf_string_conversions.h"
 #include "base/win/scoped_hdc.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/canvas_skia.h"
+#include "ui/gfx/platform_font.h"
 
 namespace {
 
 // The maximum supported number of Uniscribe runs; a SCRIPT_ITEM is 8 bytes.
 // TODO(msw): Review memory use/failure? Max string length? Alternate approach?
 const int kGuessItems = 100;
 const int kMaxItems = 10000;
 
 // The maximum supported number of Uniscribe glyphs; a glyph is 1 word.
 // TODO(msw): Review memory use/failure? Max string length? Alternate approach?
@@ skipping 28 matching lines @@
     canvas_skia->drawRect(r, paint);
   }
   if (run.strike) {
     SkScalar offset = SkScalarMulAdd(text_size, kStrikeThroughOffset, y);
     r.fTop = offset;
     r.fBottom = offset + height;
     canvas_skia->drawRect(r, paint);
   }
 }
 
+// Callback to |EnumEnhMetaFile()| to intercept font creation.
+int CALLBACK MetaFileEnumProc(HDC hdc,
+                              HANDLETABLE* table,
+                              CONST ENHMETARECORD* record,
+                              int table_entries,
+                              LPARAM log_font) {
+  if (record->iType == EMR_EXTCREATEFONTINDIRECTW) {
+    LOGFONT* font = reinterpret_cast<LOGFONT*>(log_font);

[msw, 2011/11/14 19:43:31]

Can you just assign a reinterpret_cast'ed value to log_font directly?

[Alexei Svitkine (slow), 2011/11/14 19:56:58]

Done.

+    const EMREXTCREATEFONTINDIRECTW* create_font_record =
+        reinterpret_cast<const EMREXTCREATEFONTINDIRECTW*>(record);
+    *font = create_font_record->elfw.elfLogFont;
+  }
+  return 1;
+}
+
+// Finds a fallback font to use to render the specified |text| with respect to
+// an initial |font|. Returns the resulting font via out param |result|. Returns
+// |true| if a fallback font was found.
+bool ChooseFallbackFont(HDC hdc,

[msw, 2011/11/14 19:43:31]

It appears that this has been adapted from WebCore's
FontCache::getFontDataForCharacters. Can you add a comment to that effect?

[Alexei Svitkine (slow), 2011/11/14 19:56:58]

Done.

+                        const gfx::Font& font,
+                        const wchar_t* text,
+                        int text_length,
+                        gfx::Font* result) {
+  // Use a meta file to intercept the fallback font chosen by Uniscribe.
+  HDC meta_file_dc = CreateEnhMetaFile(hdc, NULL, NULL, NULL);
+  if (!meta_file_dc)
+    return false;
+
+  SelectObject(meta_file_dc, font.GetNativeFont());
+
+  SCRIPT_STRING_ANALYSIS script_analysis;
+  HRESULT hresult =
+      ScriptStringAnalyse(meta_file_dc, text, text_length, 0, -1,
+                          SSA_METAFILE | SSA_FALLBACK | SSA_GLYPHS | SSA_LINK,
+                          0, NULL, NULL, NULL, NULL, NULL, &script_analysis);
+
+  if (SUCCEEDED(hresult)) {
+    hresult = ScriptStringOut(script_analysis, 0, 0, 0, NULL, 0, 0, FALSE);
+    ScriptStringFree(&script_analysis);
+  }
+
+  bool found_fallback = false;
+  HENHMETAFILE meta_file = CloseEnhMetaFile(meta_file_dc);
+  if (SUCCEEDED(hresult)) {
+    LOGFONT log_font;
+    log_font.lfFaceName[0] = 0;
+    EnumEnhMetaFile(0, meta_file, MetaFileEnumProc, &log_font, NULL);
+    if (log_font.lfFaceName[0]) {
+      *result = gfx::Font(UTF16ToUTF8(log_font.lfFaceName), font.GetFontSize());
+      found_fallback = true;
+    }
+  }
+  DeleteEnhMetaFile(meta_file);
+
+  return found_fallback;
+}
+
 }  // namespace
 
 namespace gfx {
 
 namespace internal {
 
 TextRun::TextRun()
   : strike(false),
     underline(false),
     width(0),
     preceding_run_widths(0),
-    glyph_count(0) {
+    glyph_count(0),
+    script_cache(NULL) {
 }
 
 }  // namespace internal
 
 RenderTextWin::RenderTextWin()
     : RenderText(),
       script_control_(),
       script_state_(),
-      script_cache_(NULL),
       string_width_(0) {
   // Omitting default constructors for script_* would leave POD uninitialized.
   HRESULT hr = 0;
 
   // TODO(msw): Call ScriptRecordDigitSubstitution on WM_SETTINGCHANGE message.
   // TODO(msw): Use Chrome/profile locale/language settings?
   hr = ScriptRecordDigitSubstitution(LOCALE_USER_DEFAULT, &digit_substitute_);
   DCHECK(SUCCEEDED(hr));
 
   hr = ScriptApplyDigitSubstitution(&digit_substitute_,
                                     &script_control_,
                                     &script_state_);
   DCHECK(SUCCEEDED(hr));
   script_control_.fMergeNeutralItems = true;
 
   MoveCursorTo(LeftEndSelectionModel());
 }
 
 RenderTextWin::~RenderTextWin() {
-  ScriptFreeCache(&script_cache_);
+  for (size_t i = 0; i < runs_.size(); ++i)
+    ScriptFreeCache(&runs_[i]->script_cache);
   STLDeleteContainerPointers(runs_.begin(), runs_.end());
 }
 
 int RenderTextWin::GetStringWidth() {
   return string_width_;
 }
 
 void RenderTextWin::Draw(Canvas* canvas) {
   DrawSelection(canvas);
   DrawVisualText(canvas);
@@ skipping 229 matching lines @@
   STLDeleteContainerPointers(runs_.begin(), runs_.end());
   runs_.clear();
   if (text().empty())
     return;
 
   const wchar_t* raw_text = text().c_str();
   const int text_length = text().length();
 
   HRESULT hr = E_OUTOFMEMORY;
   int script_items_count = 0;
-  scoped_array<SCRIPT_ITEM> script_items;
+  std::vector<SCRIPT_ITEM> script_items;
   for (size_t n = kGuessItems; hr == E_OUTOFMEMORY && n < kMaxItems; n *= 2) {
     // Derive the array of Uniscribe script items from the logical text.
     // ScriptItemize always adds a terminal array item so that the length of the
     // last item can be derived from the terminal SCRIPT_ITEM::iCharPos.
-    script_items.reset(new SCRIPT_ITEM[n]);
+    script_items.resize(n);
     hr = ScriptItemize(raw_text,
                        text_length,
                        n - 1,
                        &script_control_,
                        &script_state_,
-                       script_items.get(),
+                       &script_items[0],
                        &script_items_count);
   }
   DCHECK(SUCCEEDED(hr));
 
   if (script_items_count <= 0)
     return;
 
   // Build the list of runs, merge font/underline styles.
   // TODO(msw): Only break for font changes, not color etc. See TextRun comment.
   // TODO(msw): Apply the overriding selection and composition styles.
   StyleRanges::const_iterator style = style_ranges().begin();
-  SCRIPT_ITEM* script_item = script_items.get();
+  SCRIPT_ITEM* script_item = &script_items[0];
   for (int run_break = 0; run_break < text_length;) {
     internal::TextRun* run = new internal::TextRun();
     run->range.set_start(run_break);
     run->font = style->font;
     run->foreground = style->foreground;
     run->strike = style->strike;
     run->underline = style->underline;
     run->script_analysis = script_item->a;
 
     // Find the range end and advance the structures as needed.
@@ skipping 22 matching lines @@
     SelectObject(hdc, run->font.GetNativeFont());
 
     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) {
       run->glyphs.reset(new WORD[max_glyphs]);
       run->visible_attributes.reset(new SCRIPT_VISATTR[max_glyphs]);
       hr = ScriptShape(hdc,
-                       &script_cache_,
+                       &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;
       } else if (hr == USP_E_SCRIPT_NOT_IN_FONT) {
-        // The run's font doesn't contain the required glyphs, use an alternate.
-        // TODO(msw): Font fallback... Don't use SCRIPT_UNDEFINED.
-        //            See https://bugzilla.mozilla.org/show_bug.cgi?id=341500
-        //            And http://maxradi.us/documents/uniscribe/
         if (run->script_analysis.eScript == SCRIPT_UNDEFINED)
           break;
+
+        // The run's font doesn't contain the required glyphs, use an alternate.
+        if (ChooseFallbackFont(hdc, run->font, run_text, run_length,
+                               &run->font)) {
+          ScriptFreeCache(&run->script_cache);

[msw, 2011/11/14 19:43:31]

Is it okay to call ScriptFreeCache here then re-use the value in the next call
to ScriptShape?

[Alexei Svitkine (slow), 2011/11/14 19:56:58]

Yes, this is fine. ScriptFreeCache() will free it and set it to NULL, which is
the same as the initial value for script_cache. (The next call to ScriptShape
will allocate a new cache.)

[msw, 2011/11/14 20:05:25]

Gotcha, thanks for clarifying.

+          SelectObject(hdc, run->font.GetNativeFont());
+        }
+
         run->script_analysis.eScript = SCRIPT_UNDEFINED;

[msw, 2011/11/14 19:43:31]

I'm not sure, but I think we only ought to set SCRIPT_UNDEFINED if
ChooseFallbackFont fails; and we might want to leave some comment giving context
to the problems with using SCRIPT_UNDEFINED at all.

[Alexei Svitkine (slow), 2011/11/14 19:56:58]

I think it make sense the way it is now. Here's why:

If, for example, there's no font at all on the system that can display a glyph
then ChooseFallbackFont() will still return the font that Uniscribe would use to
render the text (as boxes, presumably). If we only set it on the failure case,
then this code would never break out of the loop in such a case.

On the other hand, if ChooseFallbackFont() succeeds in finding a font that will
work, then setting it to SCRIPT_UNDEFINED here is harmless because eScript will
be overwritten by the next call to ScriptShape().

[msw, 2011/11/14 20:05:25]

Fair enough, but if ChooseFallbackFont doesn't find a suitable font, we may
still hit the same (potential crash) problems described in my comment's URLs
that you are removing. I'd like to leave some context here, in case this does
cause problems. According to the first link:

If you [use SCRIPT_UNDEFINED], note Mozilla bug 341500. Apparently, Uniscribe
occasionally crashes if you disable shaping and there is a UTF-16 surrogate pair
(representing a character above U+FFFF)....

       } else {
         break;
       }
     }
     DCHECK(SUCCEEDED(hr));
 
     if (run->glyph_count > 0) {
       run->advance_widths.reset(new int[run->glyph_count]);
       run->offsets.reset(new GOFFSET[run->glyph_count]);
       hr = ScriptPlace(hdc,
-                       &script_cache_,
+                       &run->script_cache,
                        run->glyphs.get(),
                        run->glyph_count,
                        run->visible_attributes.get(),
                        &(run->script_analysis),
                        run->advance_widths.get(),
                        run->offsets.get(),
                        &(run->abc_widths));
       DCHECK(SUCCEEDED(hr));
     }
   }
@@ skipping 39 matching lines @@
 size_t RenderTextWin::GetRunContainingPoint(const Point& point) const {
   // 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) {
   size_t caret = run->range.start();
   size_t cursor = IndexOfAdjacentGrapheme(caret, true);
   return SelectionModel(cursor, caret, SelectionModel::TRAILING);
 }
 
 SelectionModel RenderTextWin::LastSelectionModelInsideRun(
     internal::TextRun* run) {
   size_t caret = IndexOfAdjacentGrapheme(run->range.end(), false);
@@ skipping 146 matching lines @@
     Rect r(GetUpdatedCursorBounds());
     canvas->DrawRectInt(kCursorColor, r.x(), r.y(), r.width(), r.height());
   }
 }
 
 RenderText* RenderText::CreateRenderText() {
   return new RenderTextWin;
 }
 
 }  // namespace gfx