Add font substitution metric for 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 92 matching lines @@
 // adding too much latency to the display of the final image when the user
 // stops scrolling.
 // Setting a higher value has minimal benefit (scrolling at less than 4 fps will
 // never be a great experience) and there is some cost, since when the user
 // stops scrolling the in-progress painting has to complete or timeout before
 // the final painting can start.
 // The scrollbar will always be responsive since it is managed by a separate
 // process.
 const int32_t kMaxInitialProgressivePaintTimeMs = 250;
 
+PDFiumEngine* g_engine_for_fontmapper = nullptr;
+
 std::vector<uint32_t> GetPageNumbersFromPrintPageNumberRange(
     const PP_PrintPageNumberRange_Dev* page_ranges,
     uint32_t page_range_count) {
   std::vector<uint32_t> page_numbers;
   for (uint32_t index = 0; index < page_range_count; ++index) {
     for (uint32_t page_number = page_ranges[index].first_page_number;
          page_number <= page_ranges[index].last_page_number; ++page_number) {
       page_numbers.push_back(page_number);
     }
   }
@@ skipping 129 matching lines @@
     description.set_face(face_utf8);
     description.set_weight(WeightToBrowserFontTrustedWeight(weight));
     description.set_italic(italic > 0);
   }
 
   if (!pp::PDF::IsAvailable()) {
     NOTREACHED();
     return nullptr;
   }
 
+  if (g_engine_for_fontmapper)
+    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,
@@ skipping 892 matching lines @@
     case FPDF_UNSP_ANNOT_SCREEN_RICHMEDIA:
       feature = "Screen";
       break;
     case FPDF_UNSP_ANNOT_SIG:
       feature = "Digital_Signature";
       break;
   }
   client_->DocumentHasUnsupportedFeature(feature);
 }
 
+void PDFiumEngine::FontSubstituted() {
+  client_->FontSubstituted();
+}
+
 void PDFiumEngine::ContinueFind(int32_t result) {
   StartFind(current_find_text_, result != 0);
 }
 
 bool PDFiumEngine::HandleEvent(const pp::InputEvent& event) {
   DCHECK(!defer_page_unload_);
   defer_page_unload_ = true;
   bool rv = false;
   switch (event.GetType()) {
     case PP_INPUTEVENT_TYPE_MOUSEDOWN:
@@ skipping 32 matching lines @@
   return PP_PRINTOUTPUTFORMAT_PDF;
 }
 
 void PDFiumEngine::PrintBegin() {
   FORM_DoDocumentAAction(form_, FPDFDOC_AACTION_WP);
 }
 
 pp::Resource PDFiumEngine::PrintPages(
     const PP_PrintPageNumberRange_Dev* page_ranges, uint32_t page_range_count,
     const PP_PrintSettings_Dev& print_settings) {
+  ScopedSubstFont scoped_subst_font(this);
   if (HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY))
     return PrintPagesAsPDF(page_ranges, page_range_count, print_settings);
   else if (HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY))
     return PrintPagesAsRasterPDF(page_ranges, page_range_count, print_settings);
   return pp::Resource();
 }
 
 FPDF_DOCUMENT PDFiumEngine::CreateSinglePageRasterPdf(
     double source_page_width,
     double source_page_height,
@@ skipping 132 matching lines @@
     FitContentsToPrintableAreaIfRequired(output_doc, print_settings);
     // Now flatten all the output pages.
     buffer = GetFlattenedPrintData(output_doc);
   }
   FPDF_CloseDocument(output_doc);
   return buffer;
 }
 
 pp::Buffer_Dev PDFiumEngine::GetFlattenedPrintData(const FPDF_DOCUMENT& doc) {
   pp::Buffer_Dev buffer;
+  ScopedSubstFont scoped_subst_font(this);
   int page_count = FPDF_GetPageCount(doc);
   for (int i = 0; i < page_count; ++i) {
     FPDF_PAGE page = FPDF_LoadPage(doc, i);
     DCHECK(page);
     int flatten_ret = FPDFPage_Flatten(page, FLAT_PRINT);
     FPDF_ClosePage(page);
     if (flatten_ret == FLATTEN_FAIL)
       return buffer;
   }
 
@@ skipping 1058 matching lines @@
       !FPDFAvail_IsDocAvail(fpdf_availability_, &download_hints_)) {
     return;
   }
 
   // If we're in the middle of getting a password, just return. We will retry
   // loading the document after we get the password anyway.
   if (getting_password_)
     return;
 
   ScopedUnsupportedFeature scoped_unsupported_feature(this);
+  ScopedSubstFont scoped_subst_font(this);
   bool needs_password = false;
   if (TryLoadingDoc(std::string(), &needs_password)) {
     ContinueLoadingDocument(std::string());
     return;
   }
   if (needs_password)
     GetPasswordAndLoad();
   else
     client_->DocumentLoadFailed();
 }
@@ skipping 44 matching lines @@
   getting_password_ = false;
 
   std::string password_text;
   if (result == PP_OK && password.is_string())
     password_text = password.AsString();
   ContinueLoadingDocument(password_text);
 }
 
 void PDFiumEngine::ContinueLoadingDocument(const std::string& password) {
   ScopedUnsupportedFeature scoped_unsupported_feature(this);
+  ScopedSubstFont scoped_subst_font(this);
 
   bool needs_password = false;
   bool loaded = TryLoadingDoc(password, &needs_password);
   bool password_incorrect = !loaded && needs_password && !password.empty();
   if (password_incorrect && password_tries_remaining_ > 0) {
     GetPasswordAndLoad();
     return;
   }
 
   if (!doc_) {
@@ skipping 1196 matching lines @@
 
 ScopedUnsupportedFeature::ScopedUnsupportedFeature(PDFiumEngine* engine)
     : old_engine_(g_engine_for_unsupported) {
   g_engine_for_unsupported = engine;
 }
 
 ScopedUnsupportedFeature::~ScopedUnsupportedFeature() {
   g_engine_for_unsupported = old_engine_;
 }
 
+ScopedSubstFont::ScopedSubstFont(PDFiumEngine* engine)
+    : old_engine_(g_engine_for_fontmapper) {
+  g_engine_for_fontmapper = engine;
+}
+
+ScopedSubstFont::~ScopedSubstFont() {
+  g_engine_for_fontmapper = old_engine_;
+}
+
 namespace {
 
 base::LazyInstance<PDFiumEngineExports>::Leaky g_pdf_engine_exports =
     LAZY_INSTANCE_INITIALIZER;
 
 int CalculatePosition(FPDF_PAGE page,
                       const PDFiumEngineExports::RenderingSettings& settings,
                       pp::Rect* dest) {
   int page_width = static_cast<int>(ConvertUnitDouble(FPDF_GetPageWidth(page),
                                                       kPointsPerInch,
@@ skipping 83 matching lines @@
 
 #if defined(OS_WIN)
 bool PDFiumEngineExports::RenderPDFPageToDC(const void* pdf_buffer,
                                             int buffer_size,
                                             int page_number,
                                             const RenderingSettings& settings,
                                             HDC dc) {
   FPDF_DOCUMENT doc = FPDF_LoadMemDocument(pdf_buffer, buffer_size, nullptr);
   if (!doc)
     return false;
+  ScopedSubstFont scoped_subst_font(this);
   FPDF_PAGE page = FPDF_LoadPage(doc, page_number);
   if (!page) {
     FPDF_CloseDocument(doc);
     return false;
   }
   RenderingSettings new_settings = settings;
   // calculate the page size
   if (new_settings.dpi_x == -1)
     new_settings.dpi_x = GetDeviceCaps(dc, LOGPIXELSX);
   if (new_settings.dpi_y == -1)
@@ skipping 132 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