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;
 
+PDFEngine::Client* g_client_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_client_for_fontmapper_)
+    g_client_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 2168 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);
+  g_client_for_fontmapper_ = client_;

[Lei Zhang, 2016/10/11 22:35:59]

I'm worried we set this but never unset it. There is only 1 PDF plugin process,
and it contains multiple engines. If engine A reaches here first, and then
engine B reaches here, and then engine B gets destroyed... we can end up with a
dangling pointer if engine A then reaches MapFont() somehow.

[npm, 2016/10/12 18:19:52]

I see that. But this is how g_last_instance_id works. Maybe the best way is to
set - unset the client on the same method.

[Lei Zhang, 2016/10/12 18:46:58]

However, |g_last_instance_id| is an int, and having an invalid value does not
cause potential use-after-frees.

   bool needs_password = false;
   if (TryLoadingDoc(std::string(), &needs_password)) {
     ContinueLoadingDocument(std::string());
     return;
   }
   if (needs_password)
     GetPasswordAndLoad();
   else
     client_->DocumentLoadFailed();
 }
@@ skipping 1515 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