Add font substituted metrics for OS other than Linux

pdf/pdfium/pdfium_engine.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 "pdf/pdfium/pdfium_engine.h"
 
 #include <math.h>
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 113 matching lines @@
       page_numbers.push_back(page_number);
     }
   }
   return page_numbers;
 }
 
 #if defined(OS_LINUX)
 
 PP_Instance g_last_instance_id;
 
+// TODO(npm): Move font stuff to another file to reduce the size of this one
 PP_BrowserFont_Trusted_Weight WeightToBrowserFontTrustedWeight(int weight) {
   static_assert(PP_BROWSERFONT_TRUSTED_WEIGHT_100 == 0,
                 "PP_BrowserFont_Trusted_Weight min");
   static_assert(PP_BROWSERFONT_TRUSTED_WEIGHT_900 == 8,
                 "PP_BrowserFont_Trusted_Weight max");
   const int kMinimumWeight = 100;
   const int kMaximumWeight = 900;
   int normalized_weight =
       std::min(std::max(weight, kMinimumWeight), kMaximumWeight);
   normalized_weight = (normalized_weight / 100) - 1;
   return static_cast<PP_BrowserFont_Trusted_Weight>(normalized_weight);
 }
 
 // This list is for CPWL_FontMap::GetDefaultFontByCharset().
 // We pretend to have these font natively and let the browser (or underlying
 // fontconfig) to pick the proper font on the system.
-void EnumFonts(struct _FPDF_SYSFONTINFO* sysfontinfo, void* mapper) {
+void EnumFonts(FPDF_SYSFONTINFO* sysfontinfo, void* mapper) {
   FPDF_AddInstalledFont(mapper, "Arial", FXFONT_DEFAULT_CHARSET);
 
   const FPDF_CharsetFontMap* font_map = FPDF_GetDefaultTTFMap();
   for (; font_map->charset != -1; ++font_map) {
     FPDF_AddInstalledFont(mapper, font_map->fontname, font_map->charset);
   }
 }
 
-void* MapFont(struct _FPDF_SYSFONTINFO*, int weight, int italic,
-              int charset, int pitch_family, const char* face, int* exact) {
+void* MapFont(FPDF_SYSFONTINFO*,
+              int weight,
+              int italic,
+              int charset,
+              int pitch_family,
+              const char* face,
+              int* exact) {
   // Do not attempt to map fonts if pepper is not initialized (for privet local
   // printing).
   // TODO(noamsml): Real font substitution (http://crbug.com/391978)
   if (!pp::Module::Get())
     return nullptr;
 
   pp::BrowserFontDescription description;
 
   // Pretend the system does not have the Symbol font to force a fallback to
   // the built in Symbol font in CFX_FontMapper::FindSubstFont().
@@ skipping 96 matching lines @@
     g_engine_for_fontmapper->FontSubstituted();
 
   PP_Resource font_resource = pp::PDF::GetFontFileWithFallback(
       pp::InstanceHandle(g_last_instance_id),
       &description.pp_font_description(),
       static_cast<PP_PrivateFontCharset>(charset));
   long res_id = font_resource;
   return reinterpret_cast<void*>(res_id);
 }
 
-unsigned long GetFontData(struct _FPDF_SYSFONTINFO*, void* font_id,
-                          unsigned int table, unsigned char* buffer,
+unsigned long GetFontData(FPDF_SYSFONTINFO*,
+                          void* font_id,
+                          unsigned int table,
+                          unsigned char* buffer,
                           unsigned long buf_size) {
   if (!pp::PDF::IsAvailable()) {
     NOTREACHED();
     return 0;
   }
 
   uint32_t size = buf_size;
   long res_id = reinterpret_cast<long>(font_id);
   if (!pp::PDF::GetFontTableForPrivateFontFile(res_id, table, buffer, &size))
     return 0;
   return size;
 }
 
-void DeleteFont(struct _FPDF_SYSFONTINFO*, void* font_id) {
+void DeleteFont(FPDF_SYSFONTINFO*, void* font_id) {
   long res_id = reinterpret_cast<long>(font_id);
   pp::Module::Get()->core()->ReleaseResource(res_id);
 }
 
 FPDF_SYSFONTINFO g_font_info = {
   1,
   0,
   EnumFonts,
   MapFont,
   0,
   GetFontData,
   0,
   0,
   DeleteFont
 };
+#else
+struct FPDF_SYSFONTINFO_WITHMETRICS : public FPDF_SYSFONTINFO {
+  explicit FPDF_SYSFONTINFO_WITHMETRICS(FPDF_SYSFONTINFO* default_sysfontinfo) {
+    version = default_sysfontinfo->version;
+    default_sysfontinfo_ = default_sysfontinfo;
+  }
+
+  ~FPDF_SYSFONTINFO_WITHMETRICS() { delete default_sysfontinfo_; }
+
+  FPDF_SYSFONTINFO* default_sysfontinfo_;
+};
+
+FPDF_SYSFONTINFO_WITHMETRICS* g_font_info = nullptr;
+
+void* MapFontWithMetrics(FPDF_SYSFONTINFO* sysfontinfo,
+                         int weight,
+                         int italic,
+                         int charset,
+                         int pitch_family,
+                         const char* face,
+                         int* exact) {
+  auto* fontinfo_with_metrics =
+      static_cast<FPDF_SYSFONTINFO_WITHMETRICS*>(sysfontinfo);
+  void* mapped_font = fontinfo_with_metrics->default_sysfontinfo_->MapFont(
+      fontinfo_with_metrics->default_sysfontinfo_, weight, italic, charset,
+      pitch_family, face, exact);
+  if (mapped_font && g_engine_for_fontmapper)
+    g_engine_for_fontmapper->FontSubstituted();
+  return mapped_font;
+}
+
+void DeleteFont(FPDF_SYSFONTINFO* sysfontinfo, void* font_id) {
+  auto* fontinfo_with_metrics =
+      static_cast<FPDF_SYSFONTINFO_WITHMETRICS*>(sysfontinfo);
+  fontinfo_with_metrics->default_sysfontinfo_->DeleteFont(
+      fontinfo_with_metrics->default_sysfontinfo_, font_id);
+}
+
+void EnumFonts(FPDF_SYSFONTINFO* sysfontinfo, void* mapper) {
+  auto* fontinfo_with_metrics =
+      static_cast<FPDF_SYSFONTINFO_WITHMETRICS*>(sysfontinfo);
+  fontinfo_with_metrics->default_sysfontinfo_->EnumFonts(
+      fontinfo_with_metrics->default_sysfontinfo_, mapper);
+}
+
+unsigned long GetFaceName(FPDF_SYSFONTINFO* sysfontinfo,
+                          void* hFont,
+                          char* buffer,
+                          unsigned long buffer_size) {
+  auto* fontinfo_with_metrics =
+      static_cast<FPDF_SYSFONTINFO_WITHMETRICS*>(sysfontinfo);
+  return fontinfo_with_metrics->default_sysfontinfo_->GetFaceName(
+      fontinfo_with_metrics->default_sysfontinfo_, hFont, buffer, buffer_size);
+}
+
+void* GetFont(FPDF_SYSFONTINFO* sysfontinfo, const char* face) {
+  auto* fontinfo_with_metrics =
+      static_cast<FPDF_SYSFONTINFO_WITHMETRICS*>(sysfontinfo);
+  return fontinfo_with_metrics->default_sysfontinfo_->GetFont(
+      fontinfo_with_metrics->default_sysfontinfo_, face);
+}
+
+int GetFontCharset(FPDF_SYSFONTINFO* sysfontinfo, void* hFont) {
+  auto* fontinfo_with_metrics =
+      static_cast<FPDF_SYSFONTINFO_WITHMETRICS*>(sysfontinfo);
+  return fontinfo_with_metrics->default_sysfontinfo_->GetFontCharset(
+      fontinfo_with_metrics->default_sysfontinfo_, hFont);
+}
+
+unsigned long GetFontData(FPDF_SYSFONTINFO* sysfontinfo,
+                          void* hFont,
+                          unsigned int table,
+                          unsigned char* buffer,
+                          unsigned long buf_size) {
+  auto* fontinfo_with_metrics =
+      static_cast<FPDF_SYSFONTINFO_WITHMETRICS*>(sysfontinfo);
+  return fontinfo_with_metrics->default_sysfontinfo_->GetFontData(
+      fontinfo_with_metrics->default_sysfontinfo_, hFont, table, buffer,
+      buf_size);
+}
+
+void Release(FPDF_SYSFONTINFO* sysfontinfo) {
+  auto* fontinfo_with_metrics =
+      static_cast<FPDF_SYSFONTINFO_WITHMETRICS*>(sysfontinfo);
+  fontinfo_with_metrics->default_sysfontinfo_->Release(
+      fontinfo_with_metrics->default_sysfontinfo_);
+}
 #endif  // defined(OS_LINUX)
 
 PDFiumEngine* g_engine_for_unsupported = nullptr;
 
 void Unsupported_Handler(UNSUPPORT_INFO*, int type) {
   if (!g_engine_for_unsupported) {
     NOTREACHED();
     return;
   }
 
@@ skipping 191 matching lines @@
 bool InitializeSDK() {
   SetUpV8();
 
   FPDF_LIBRARY_CONFIG config;
   config.version = 2;
   config.m_pUserFontPaths = nullptr;
   config.m_pIsolate = v8::Isolate::GetCurrent();
   config.m_v8EmbedderSlot = gin::kEmbedderPDFium;
   FPDF_InitLibraryWithConfig(&config);
 
-#if defined(OS_LINUX)
+#if !defined(OS_LINUX)
+  g_font_info =
+      new FPDF_SYSFONTINFO_WITHMETRICS(FPDF_GetDefaultSystemFontInfo());
+  if (g_font_info->default_sysfontinfo_->Release)

[Tom Sepez, 2016/11/09 17:11:35]

nit: this is OK, but I think I'd be happier if we always set these callbacks,
and had each one of them check to see if the underlying one still exists before
calling it.  The reason I say that is that -- and hopefully this doesn't happen
in a sane world -- is that there isn't a reason to believe the pointers in the
underlying default struct don't change over time -- they might become null after
we've made this check.

[npm, 2016/11/09 19:22:21]

Done.

+    g_font_info->Release = Release;
+  if (g_font_info->default_sysfontinfo_->EnumFonts)
+    g_font_info->EnumFonts = EnumFonts;
+  // Set new MapFont that calculates metrics
+  if (g_font_info->default_sysfontinfo_->MapFont)
+    g_font_info->MapFont = MapFontWithMetrics;
+  if (g_font_info->default_sysfontinfo_->GetFont)
+    g_font_info->GetFont = GetFont;
+  if (g_font_info->default_sysfontinfo_->GetFaceName)
+    g_font_info->GetFaceName = GetFaceName;
+  if (g_font_info->default_sysfontinfo_->GetFontCharset)
+    g_font_info->GetFontCharset = GetFontCharset;
+  // These are required according to documentation
+  g_font_info->GetFontData = GetFontData;
+  g_font_info->DeleteFont = DeleteFont;
+  FPDF_SetSystemFontInfo(g_font_info);
+#else
   // Font loading doesn't work in the renderer sandbox in Linux.
   FPDF_SetSystemFontInfo(&g_font_info);
 #endif
 
   FSDK_SetUnSpObjProcessHandler(&g_unsupported_info);
 
   return true;
 }
 
 void ShutdownSDK() {
+#if !defined(OS_LINUX)
+  FPDF_FreeDefaultSystemFontInfo(g_font_info);
+#endif
   FPDF_DestroyLibrary();
   TearDownV8();
 }
 
 PDFEngine* PDFEngine::Create(PDFEngine::Client* client) {
   return new PDFiumEngine(client);
 }
 
 PDFiumEngine::PDFiumEngine(PDFEngine::Client* client)
     : client_(client),
@@ skipping 3485 matching lines @@
   FPDF_DOCUMENT doc =
       FPDF_LoadMemDocument(pdf_buffer, pdf_buffer_size, nullptr);
   if (!doc)
     return false;
   bool success = FPDF_GetPageSizeByIndex(doc, page_number, width, height) != 0;
   FPDF_CloseDocument(doc);
   return success;
 }
 
 }  // namespace chrome_pdf