Attempt to fallback to some matching font in the GetMatchingDirectWriteFontForTypeface function in …

ui/gfx/platform_font_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/platform_font_win.h"
 
 #include <algorithm>
 #include <dwrite.h>
 #include <math.h>
 #include <windows.h>
 
+#include "base/debug/alias.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_gdi_object.h"
 #include "base/win/scoped_hdc.h"
 #include "base/win/scoped_select_object.h"
 #include "base/win/win_util.h"
@@ skipping 60 matching lines @@
   base::win::ScopedComPtr<IDWriteFontCollection> font_collection;
   HRESULT hr = factory->GetSystemFontCollection(font_collection.Receive());
   if (FAILED(hr)) {
     CHECK(false);
     return hr;
   }
 
   base::win::ScopedComPtr<IDWriteFontFamily> font_family;
   BOOL exists = FALSE;
   uint32 index = 0;
   hr = font_collection->FindFamilyName(face_name, &index, &exists);

[Shrikant Kelkar, 2014/11/19 22:59:25]

Besides FAILED(hr) can you add check for index == UINT_MAX and exists == TRUE
and font_family != NULL?

Same with function below?

In the dump that I saw, font_family was NULL and index -1 and exists FALSE. Not
sure hr was S_OK after this statement.

http://msdn.microsoft.com/en-us/library/windows/desktop/dd368217(v=vs.85).aspx

[ananta, 2014/11/19 23:19:28]

Done.

   // If we fail to find a match then fallback to the default font on the
   // system. This is what skia does as well.
   if (FAILED(hr)) {
     NONCLIENTMETRICS metrics = {0};
     metrics.cbSize = sizeof(metrics);
     if (!SystemParametersInfoW(SPI_GETNONCLIENTMETRICS,
                                sizeof(metrics),
                                &metrics,
                                0)) {
       CHECK(false);
@@ skipping 15 matching lines @@
     return hr;
   }
 
   DWRITE_FONT_WEIGHT weight = (font_style & SkTypeface::kBold)
                             ? DWRITE_FONT_WEIGHT_BOLD
                             : DWRITE_FONT_WEIGHT_NORMAL;
   DWRITE_FONT_STRETCH stretch = DWRITE_FONT_STRETCH_NORMAL;
   DWRITE_FONT_STYLE italic = (font_style & SkTypeface::kItalic)
                             ? DWRITE_FONT_STYLE_ITALIC
                             : DWRITE_FONT_STYLE_NORMAL;
+
+  // The IDWriteFontFamily::GetFirstMatchingFont call fails on certain machines
+  // for fonts like MS UI Gothic, Segoe UI, etc. It is not clear why these
+  // fonts could be accessible to GDI and not to DirectWrite.
+  // The code below adds some debug fields to help track down these failures.
+  // 1. We get the matching font list for the font attributes passed in.
+  // 2. We get the font count in the family with a debug alias variable.
+  // 3. If we fail to get the font via the GetFirstMatchingFont call then we
+  //    try to get the first matching font in the IDWriteFontList.
+  // 4. If GetFirstMatchingFont and IDWriteFontList both fail then we CHECK as
+  //    before.
+  // Next step would be to remove the CHECKs in this function and fallback to
+  // GDI.
+  // http://crbug.com/434425

[Shrikant Kelkar, 2014/11/19 23:30:47]

If you want to look for specific fonts that are causing this.. add something
similar to dwrite_font_platform_win.cc

    base::debug::SetCrashKeyValue(kFontKeyName,
                                  base::WideToUTF8(font_key_name));

[ananta, 2014/11/19 23:38:58]

Will do that in a followup. Dunno what the clean up implications are here.

+  base::win::ScopedComPtr<IDWriteFontList> matching_font_list;
+  hr = font_family->GetMatchingFonts(weight, stretch, italic,
+                                     matching_font_list.Receive());
+  uint32 matching_font_count = 0;
+  if (SUCCEEDED(hr))
+    matching_font_count = matching_font_list->GetFontCount();
+
+  bool fallback_to_matching_font = false;
+
   hr = font_family->GetFirstMatchingFont(weight, stretch, italic,
                                          dwrite_font);
-  if (FAILED(hr))
+  if (FAILED(hr)) {
+    if (matching_font_list) {
+      hr = matching_font_list->GetFont(0, dwrite_font);
+      if (SUCCEEDED(hr))
+        fallback_to_matching_font = true;
+    }
+  }
+
+  if (FAILED(hr)) {
+    base::debug::Alias(&matching_font_count);
+    base::debug::Alias(&fallback_to_matching_font);

[Shrikant Kelkar, 2014/11/19 23:30:47]

fallback_to_matching_font = true if SUCCEEDED(hr) 
No use of Alias then here?

[ananta, 2014/11/19 23:38:58]

Moved the alias for fallback_to_matching_font above.

     CHECK(false);
+  }
   return hr;
 }
 
 }  // namespace
 
 namespace gfx {
 
 // static
 PlatformFontWin::HFontRef* PlatformFontWin::base_font_ref_;
 
@@ skipping 400 matching lines @@
   return new PlatformFontWin(native_font);
 }
 
 // static
 PlatformFont* PlatformFont::CreateFromNameAndSize(const std::string& font_name,
                                                   int font_size) {
   return new PlatformFontWin(font_name, font_size);
 }
 
 }  // namespace gfx