Added GDI font emulation support for Flash.

content/common/render_font_warmup_win.cc

 // Copyright 2014 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 "content/public/common/render_font_warmup_win.h"
 
 #include <dwrite.h>
+#include <list>
 
 #include "base/debug/alias.h"
+#include "base/files/file_path.h"
 #include "base/logging.h"
+#include "base/memory/ref_counted.h"
+#include "base/strings/utf_string_conversions.h"
+#include "base/synchronization/lock.h"
 #include "base/win/iat_patch_function.h"
 #include "base/win/windows_version.h"
 #include "content/public/common/dwrite_font_platform_win.h"
+#include "skia/ext/refptr.h"
 #include "third_party/WebKit/public/web/win/WebFontRendering.h"
 #include "third_party/skia/include/core/SkPaint.h"
 #include "third_party/skia/include/ports/SkFontMgr.h"
 #include "third_party/skia/include/ports/SkTypeface_win.h"
 
+
 namespace content {
 
 namespace {
 
 SkFontMgr* g_warmup_fontmgr = NULL;
 
 base::win::IATPatchFunction g_iat_patch_open_sc_manager;
 base::win::IATPatchFunction g_iat_patch_close_service_handle;
 base::win::IATPatchFunction g_iat_patch_open_service;
 base::win::IATPatchFunction g_iat_patch_start_service;
@@ skipping 141 matching lines @@
 
 void PatchDWriteFactory(IDWriteFactory* factory) {
   const unsigned int kGetSystemFontCollectionVTableIndex = 3;
 
   PROC* vtable = *reinterpret_cast<PROC**>(factory);
   PROC* function_ptr = &vtable[kGetSystemFontCollectionVTableIndex];
   void* stub_function = &StubFontCollection;
   base::win::ModifyCode(function_ptr, &stub_function, sizeof(PROC));
 }
 
+// Magic values for the fake GDI objects.
+const uint32_t kFakeDCMagic = 'fkdc';
+const uint32_t kFakeFontMagic = 'fkft';
+
+// Class to fake out a DC or a Font object. Maintains a reference to a
+// SkTypeFace to emulate the simple operation of a DC and Font. We can't
+// be sure that this won't be used in a multi-threaded environment so we
+// need to ensure a lock is taken before updating the static table of
+// issued objects.
+class FakeGdiObject : public base::RefCountedThreadSafe<FakeGdiObject> {
+ public:
+  // Find a corresponding fake GDI object and verify its magic value.
+  // The returned object is either NULL or the new object.
+  static scoped_refptr<FakeGdiObject> Validate(void* obj,
+                                               uint32_t magic) {
+    if (obj) {
+      base::AutoLock scoped_lock(objects_lock_);
+      uintptr_t handle = reinterpret_cast<uintptr_t>(obj);
+      for (const auto& currobj : objects_) {
+        if ((currobj->magic_ == magic) &&
+            (handle == currobj->handle_)) {
+          return currobj;
+        }
+      }
+    }
+
+    return NULL;

[palmer, 2015/09/11 22:34:15]

nullptr? I don't know if it's now-standard in Windows-specific areas of
Chromium, but it is elsewhere.

[forshaw, 2015/09/15 10:27:57]

Will change.

+  }
+
+  static scoped_refptr<FakeGdiObject> Create(uint32_t magic) {
+    base::AutoLock scoped_lock(objects_lock_);
+    scoped_refptr<FakeGdiObject> object(new FakeGdiObject(magic));
+    objects_.push_back(object);
+    return object;
+  }
+
+  static bool DeleteObject(void* obj, uint32_t magic) {
+    uintptr_t handle = reinterpret_cast<uintptr_t>(obj);
+    base::AutoLock scoped_lock(objects_lock_);
+    for (auto i = objects_.begin(); i != objects_.end(); ++i) {

[palmer, 2015/09/11 22:34:16]

Does

  for (const auto& object : objects_) { ... }

work here?

[forshaw, 2015/09/15 10:27:57]

Unless I'm missing something I need the iterator to pass into erase so that the
element can be removed from the vector, so probably not.

+      const auto& fakeobj = *i;
+      if ((fakeobj->magic_ == magic) && (fakeobj->handle_ == handle)) {
+        objects_.erase(i);
+        return true;
+      }
+    }
+    return false;
+  }
+
+  void SetTypeface(const skia::RefPtr<SkTypeface>& typeface) {
+    typeface_ = typeface;
+  }
+
+  skia::RefPtr<SkTypeface> GetTypeface() {
+    return typeface_;
+  }
+
+  void* GetHandle() {
+    return reinterpret_cast<void*>(handle_);
+  }
+
+ private:
+  uint32_t  magic_;
+  uintptr_t handle_;
+  skia::RefPtr<SkTypeface> typeface_;
+  static uintptr_t curr_handle_;
+  static std::list<scoped_refptr<FakeGdiObject>> objects_;
+  static base::Lock objects_lock_;
+  FakeGdiObject(uint32_t magic) : magic_(magic), handle_(++curr_handle_) {}
+  ~FakeGdiObject() {}
+  friend class base::RefCountedThreadSafe<FakeGdiObject>;
+
+  DISALLOW_COPY_AND_ASSIGN(FakeGdiObject);
+};
+
+uintptr_t FakeGdiObject::curr_handle_ = 0;
+std::list<scoped_refptr<FakeGdiObject>> FakeGdiObject::objects_;
+base::Lock FakeGdiObject::objects_lock_;
+
+skia::RefPtr<SkTypeface> GetTypefaceFromLOGFONT(const LOGFONTW* logfont) {
+  CHECK(g_warmup_fontmgr);
+  int weight = logfont->lfWeight;
+  if (weight == FW_DONTCARE)
+    weight = SkFontStyle::kNormal_Weight;
+
+  SkFontStyle style(weight,
+                    logfont->lfWidth,
+                    logfont->lfItalic ?
+                         SkFontStyle::kItalic_Slant :
+                         SkFontStyle::kUpright_Slant);
+
+  std::string family_name = base::WideToUTF8(logfont->lfFaceName);
+  return skia::AdoptRef(g_warmup_fontmgr->matchFamilyStyle(family_name.c_str(),
+                                                           style));
+}
+
+HDC WINAPI CreateCompatibleDCPatch(HDC hdc) {
+  scoped_refptr<FakeGdiObject> ret = FakeGdiObject::Create(kFakeDCMagic);
+  return static_cast<HDC>(ret->GetHandle());
+}
+
+HFONT WINAPI CreateFontIndirectWPatch(const LOGFONTW *lplf) {
+  if (!lplf)
+    return NULL;
+
+  skia::RefPtr<SkTypeface> typeface = GetTypefaceFromLOGFONT(lplf);
+  if (!typeface) {
+    return NULL;
+  }
+
+  scoped_refptr<FakeGdiObject> ret = FakeGdiObject::Create(kFakeFontMagic);
+  ret->SetTypeface(typeface);
+
+  return static_cast<HFONT>(ret->GetHandle());
+}
+
+BOOL WINAPI DeleteDCPatch(HDC hdc) {
+  if (hdc) {
+    return FakeGdiObject::DeleteObject(hdc, kFakeDCMagic);
+  }
+  return FALSE;
+}
+
+BOOL WINAPI DeleteObjectPatch(HGDIOBJ hObject) {
+  if (hObject) {
+    return FakeGdiObject::DeleteObject(hObject, kFakeFontMagic);
+  }
+  return FALSE;
+}
+
+int WINAPI EnumFontFamiliesExWPatch(
+  HDC           hdc,
+  LPLOGFONTW    lpLogfont,
+  FONTENUMPROCW lpEnumFontFamExProc,
+  LPARAM        lParam,
+  DWORD         dwFlags) {
+  scoped_refptr<FakeGdiObject> dcobj =
+          FakeGdiObject::Validate(hdc, kFakeDCMagic);
+  if (!dcobj) {
+    LOG(ERROR) << "Invalid DC Object";
+    return 1;
+  }
+  if (!lpLogfont || !lpEnumFontFamExProc) {
+    return 1;
+  }
+
+  skia::RefPtr<SkTypeface> typeface = GetTypefaceFromLOGFONT(lpLogfont);
+  if (!typeface) {
+    return 1;
+  }
+
+  // TODO: Fill in the rest of the text metric structure.
+  NEWTEXTMETRICEXW text_metric = {0};
+  text_metric.ntmTm.ntmFlags = NTM_PS_OPENTYPE;
+
+  return lpEnumFontFamExProc(lpLogfont,
+                             reinterpret_cast<TEXTMETRIC*>(&text_metric),
+                             TRUETYPE_FONTTYPE,
+                             lParam);
+}
+
+DWORD WINAPI GetFontDataPatch(
+  HDC    hdc,
+  DWORD  dwTable,
+  DWORD  dwOffset,
+  LPVOID lpvBuffer,
+  DWORD  cbData) {
+  scoped_refptr<FakeGdiObject> dcobj =
+          FakeGdiObject::Validate(hdc, kFakeDCMagic);
+  if (!dcobj) {
+    LOG(ERROR) << "Invalid DC Object";
+    return GDI_ERROR;
+  }
+
+  skia::RefPtr<SkTypeface> typeface = dcobj->GetTypeface();
+  if (!typeface) {
+    return GDI_ERROR;
+  }
+
+  if (cbData > INT32_MAX) {
+    return GDI_ERROR;
+  }
+
+  // Swap endian of table identifier.
+  dwTable = ((dwTable & 0xFF) << 24) |
+            ((dwTable & 0xFF00) << 8) |
+            ((dwTable & 0xFF0000) >> 8) |
+             (dwTable >> 24);
+
+  // getTableData takes care of lpvBuffer being NULL. Swap tag to counter
+  // effect of the underlying implementation. Also if the buffer pointer
+  // is NULL then set length INT_MAX otherwise getTableData returns the minimum
+  // length between table size and passed length. If the caller passes 0
+  // as GetFontData allows it then 0 length is returned which is incorrect.
+  size_t length = typeface->getTableData(dwTable,
+                                         dwOffset,
+                                         lpvBuffer ? cbData : INT32_MAX,
+                                         lpvBuffer);
+  // We can't distinguish between an empty table and an error.
+  if (length == 0)
+    return GDI_ERROR;
+
+  // No truncation, we checked against INT_MAX above.
+  return static_cast<DWORD>(length);
+}
+
+HGDIOBJ WINAPI SelectObjectPatch(HDC hdc, HGDIOBJ hgdiobj) {
+  scoped_refptr<FakeGdiObject> dcobj =
+                        FakeGdiObject::Validate(hdc, kFakeDCMagic);
+  if (!dcobj) {
+    LOG(ERROR) << "Invalid DC Object";
+    return NULL;
+  }
+
+  scoped_refptr<FakeGdiObject> fontobj =
+                        FakeGdiObject::Validate(hgdiobj, kFakeFontMagic);
+  if (!fontobj) {
+    LOG(ERROR) << "Invalid Font Object";
+    return NULL;
+  }
+
+  // Construct a new fake font object to handle the old font if there's one.
+  scoped_refptr<FakeGdiObject> newfontobj;
+  skia::RefPtr<SkTypeface> oldfont = dcobj->GetTypeface();
+  if (oldfont) {
+    newfontobj = FakeGdiObject::Create(kFakeFontMagic);
+    newfontobj->SetTypeface(oldfont);
+  }
+  dcobj->SetTypeface(fontobj->GetTypeface());
+
+  if (newfontobj)
+    return static_cast<HGDIOBJ>(newfontobj->GetHandle());
+  return NULL;
+}
+
+void DoSingleGdiPatch(base::win::IATPatchFunction& patch,
+                      const base::FilePath& path,
+                      const char* function_name,
+                      void* new_function) {
+  DWORD error = patch.Patch(path.value().c_str(),
+                             "gdi32.dll",
+                             function_name,
+                             new_function);
+  if (error != 0) {
+    LOG(WARNING) << "Failed patching " << function_name << " " << error;
+  }
+}
+
+class GdiFontPatchDataImpl : public content::GdiFontPatchData {
+ public:
+  GdiFontPatchDataImpl(const base::FilePath& path);
+ private:
+  base::win::IATPatchFunction create_compatible_dc_patch_;
+  base::win::IATPatchFunction create_font_indirect_patch_;
+  base::win::IATPatchFunction create_delete_dc_patch_;
+  base::win::IATPatchFunction create_delete_object_patch_;
+  base::win::IATPatchFunction create_enum_font_families_patch_;
+  base::win::IATPatchFunction create_get_font_data_patch_;
+  base::win::IATPatchFunction create_select_object_patch_;
+};
+
+GdiFontPatchDataImpl::GdiFontPatchDataImpl(const base::FilePath& path) {
+  DoSingleGdiPatch(create_compatible_dc_patch_, path,
+                   "CreateCompatibleDC", CreateCompatibleDCPatch);
+  DoSingleGdiPatch(create_font_indirect_patch_, path,
+                   "CreateFontIndirectW", CreateFontIndirectWPatch);
+  DoSingleGdiPatch(create_delete_dc_patch_, path,
+                   "DeleteDC", DeleteDCPatch);
+  DoSingleGdiPatch(create_delete_object_patch_, path,
+                   "DeleteObject", DeleteObjectPatch);
+  DoSingleGdiPatch(create_enum_font_families_patch_, path,
+                   "EnumFontFamiliesExW", EnumFontFamiliesExWPatch);
+  DoSingleGdiPatch(create_get_font_data_patch_, path,
+                   "GetFontData", GetFontDataPatch);
+  DoSingleGdiPatch(create_select_object_patch_, path,
+                   "SelectObject", SelectObjectPatch);
+}
+
 }  // namespace
 
 void DoPreSandboxWarmupForTypeface(SkTypeface* typeface) {
   SkPaint paint_warmup;
   paint_warmup.setTypeface(typeface);
   wchar_t glyph = L'S';
   paint_warmup.measureText(&glyph, 2);
 }
 
 SkFontMgr* GetPreSandboxWarmupFontMgr() {
   if (!g_warmup_fontmgr) {
     IDWriteFactory* factory;
     CreateDirectWriteFactory(&factory);
 
     GetCustomFontCollection(factory);
 
     PatchDWriteFactory(factory);
 
     blink::WebFontRendering::setDirectWriteFactory(factory);
     g_warmup_fontmgr = SkFontMgr_New_DirectWrite(factory);
   }
   return g_warmup_fontmgr;
 }
 
+GdiFontPatchData* PatchGdiFontEnumeration(const base::FilePath& path) {
+  // We assume the fontmgr is already warmed up before calling this.
+  DCHECK(g_warmup_fontmgr);
+  return new GdiFontPatchDataImpl(path);
+}
+
+void SetPreSandboxWarmupFontMgr(SkFontMgr* fontmgr) {
+  g_warmup_fontmgr = fontmgr;
+}
+
 }  // namespace content