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) {
+    const EMREXTCREATEFONTINDIRECTW* create_font_record =
+        reinterpret_cast<const EMREXTCREATEFONTINDIRECTW*>(record);
+    *reinterpret_cast<LOGFONT*>(log_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.
+// Adapted from WebKit's |FontCache::GetFontDataForCharacters()|.
+bool ChooseFallbackFont(HDC hdc,
+                        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.
+        // TODO(msw): Don't use SCRIPT_UNDEFINED. Apparently Uniscribe can crash
+        //            on certain surrogate pairs when using 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);
+          SelectObject(hdc, run->font.GetNativeFont());
+        }
+
         run->script_analysis.eScript = SCRIPT_UNDEFINED;
       } 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