Fix for 128506: Random Chinese/Japanese characters are missing in documents printed via the syst...

skia/ext/vector_platform_device_emf_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 "skia/ext/vector_platform_device_emf_win.h"
+
 #include <windows.h>
 
-#include "skia/ext/vector_platform_device_emf_win.h"
+#include <string>
 
+#include "base/logging.h"
+#include "content/renderer/render_thread_impl.h"

[Lei Zhang, 2012/11/16 00:14:03]

jam: Is skia allowed to #include content ?

Shouldn't this go through content/public/renderer/render_thread.h at least?

 #include "skia/ext/bitmap_platform_device.h"
 #include "skia/ext/skia_utils_win.h"
+#include "third_party/skia/include/core/SkFontHost.h"
 #include "third_party/skia/include/core/SkPathEffect.h"
 #include "third_party/skia/include/core/SkTemplates.h"
 #include "third_party/skia/include/core/SkUtils.h"
 #include "third_party/skia/include/ports/SkTypeface_win.h"
 
 namespace skia {
 
 #define CHECK_FOR_NODRAW_ANNOTATION(paint) \
     do { if (paint.isNoDrawAnnotation()) { return; } } while (0)
 
@@ skipping 338 matching lines @@
 // encoding is not UTF8 (in which case ExtTextOut can't be used).
 static UINT getTextOutOptions(const SkPaint& paint) {
   if (SkPaint::kGlyphID_TextEncoding == paint.getTextEncoding()) {
     return ETO_GLYPH_INDEX;
   } else {
     SkASSERT(SkPaint::kUTF16_TextEncoding == paint.getTextEncoding());
     return 0;
   }
 }
 
+void SkiaPreCacheFontCharacters(const LOGFONT& logfont,
+                                const wchar_t* text,
+                                unsigned int text_length) {
+  content::RenderThreadImpl* render_thread_impl =
+      content::RenderThreadImpl::current();
+  if (render_thread_impl) {
+    render_thread_impl->PreCacheFontCharacters(logfont,
+                                               std::wstring(text, text_length));
+  }
+}
+
+void EnsureTypefaceCharactersAccessible(
+    const SkTypeface& typeface, const wchar_t* text, unsigned int text_length) {
+  LOGFONT lf;
+  SkLOGFONTFromTypeface(&typeface, &lf);
+  SkiaPreCacheFontCharacters(lf, text, text_length);
+}
+
+bool EnsureExtTextOut(HDC hdc, int x, int y, UINT options, const RECT * lprect,
+                      LPCWSTR text, unsigned int characters, const int * lpDx,
+                      SkTypeface* const typeface) {
+  bool success = ExtTextOut(hdc, x, y, options, lprect, text, characters, lpDx);
+  if (!success) {
+    if (typeface) {
+      EnsureTypefaceCharactersAccessible(*typeface,
+                                         text,
+                                         characters);
+      success = ExtTextOut(hdc, x, y, options, lprect, text, characters, lpDx);
+      if (!success) {
+        LOGFONT lf;
+        SkLOGFONTFromTypeface(typeface, &lf);
+        VLOG(1) << "SkFontHost::EnsureTypefaceCharactersAccessible FAILED for "
+                << " FaceName = " << lf.lfFaceName
+                << " and characters: " << std::wstring(text, characters);
+      }
+    } else {
+      VLOG(1) << "ExtTextOut FAILED for default FaceName "
+              << " and characters: " << std::wstring(text, characters);
+    }
+  }
+  return success;
+}
+
 void VectorPlatformDeviceEmf::drawText(const SkDraw& draw,
                                        const void* text,
                                        size_t byteLength,
                                        SkScalar x,
                                        SkScalar y,
                                        const SkPaint& paint) {
   SkGDIFontSetup setup;
+  bool useDrawPath = true;
+
   if (SkPaint::kUTF8_TextEncoding != paint.getTextEncoding()
       && setup.useGDI(hdc_, paint)) {
     UINT options = getTextOutOptions(paint);
     UINT count = byteLength >> 1;
-    ExtTextOut(hdc_, SkScalarRound(x), SkScalarRound(y + getAscent(paint)),
-        options, 0, reinterpret_cast<const wchar_t*>(text), count, NULL);
-  } else {
+    useDrawPath = !EnsureExtTextOut(hdc_, SkScalarRound(x),
+        SkScalarRound(y + getAscent(paint)), options, 0,
+        reinterpret_cast<const wchar_t*>(text), count, NULL,
+        paint.getTypeface());
+  }
+
+  if (useDrawPath) {
     SkPath path;
     paint.getTextPath(text, byteLength, x, y, &path);
     drawPath(draw, path, paint);
   }
 }
 
 static size_t size_utf8(const char* text) {
   return SkUTF8_CountUTF8Bytes(text);
 }
 
 static size_t size_utf16(const char* text) {
   uint16_t c = *reinterpret_cast<const uint16_t*>(text);
   return SkUTF16_IsHighSurrogate(c) ? 4 : 2;
 }
 
 static size_t size_glyphid(const char* text) {
   return 2;
 }
 
 void VectorPlatformDeviceEmf::drawPosText(const SkDraw& draw,
                                           const void* text,
                                           size_t len,
                                           const SkScalar pos[],
                                           SkScalar constY,
                                           int scalarsPerPos,
                                           const SkPaint& paint) {
   SkGDIFontSetup setup;
+  bool useDrawText = true;
+
   if (2 == scalarsPerPos
       && SkPaint::kUTF8_TextEncoding != paint.getTextEncoding()
       && setup.useGDI(hdc_, paint)) {
     int startX = SkScalarRound(pos[0]);
     int startY = SkScalarRound(pos[1] + getAscent(paint));
     const int count = len >> 1;
     SkAutoSTMalloc<64, INT> storage(count);
     INT* advances = storage.get();
     for (int i = 0; i < count - 1; ++i) {
       advances[i] = SkScalarRound(pos[2] - pos[0]);
       pos += 2;
     }
-    ExtTextOut(hdc_, startX, startY, getTextOutOptions(paint), 0,
-        reinterpret_cast<const wchar_t*>(text), count, advances);
-  } else {
+    useDrawText = !EnsureExtTextOut(hdc_, startX, startY,
+        getTextOutOptions(paint), 0, reinterpret_cast<const wchar_t*>(text),
+        count, advances, paint.getTypeface());
+  }
+
+  if (useDrawText) {
     size_t (*bytesPerCodePoint)(const char*);
     switch (paint.getTextEncoding()) {
     case SkPaint::kUTF8_TextEncoding:
       bytesPerCodePoint = size_utf8;
       break;
     case SkPaint::kUTF16_TextEncoding:
       bytesPerCodePoint = size_utf16;
       break;
     default:
       SkASSERT(SkPaint::kGlyphID_TextEncoding == paint.getTextEncoding());
@@ skipping 430 matching lines @@
                                 pixels,
                                 reinterpret_cast<const BITMAPINFO*>(&hdr),
                                 DIB_RGB_COLORS,
                                 SRCCOPY);
   }
   EndPlatformPaint();
   Cleanup();
 }
 
 }  // namespace skia