Add font substitution metric for Linux

pdf/out_of_process_instance.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/out_of_process_instance.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>  // for min/max()
@@ skipping 264 matching lines @@
       cursor_(PP_CURSORTYPE_POINTER),
       zoom_(1.0),
       device_scale_(1.0),
       full_(false),
       paint_manager_(this, this, true),
       first_paint_(true),
       document_load_state_(LOAD_STATE_LOADING),
       preview_document_load_state_(LOAD_STATE_COMPLETE),
       uma_(this),
       told_browser_about_unsupported_feature_(false),
+      font_substitution_reported(false),
       print_preview_page_count_(0),
       last_progress_sent_(0),
       recently_sent_find_update_(false),
       received_viewport_message_(false),
       did_call_start_loading_(false),
       stop_scrolling_(false),
       background_color_(0),
       top_toolbar_height_(0),
       accessibility_state_(ACCESSIBILITY_STATE_OFF) {
   loader_factory_.Initialize(this);
@@ skipping 1010 matching lines @@
   document_load_state_ = LOAD_STATE_FAILED;
   paint_manager_.InvalidateRect(pp::Rect(pp::Point(), plugin_size_));
 
   // Send a progress value of -1 to indicate a failure.
   pp::VarDictionary message;
   message.Set(pp::Var(kType), pp::Var(kJSLoadProgressType));
   message.Set(pp::Var(kJSProgressPercentage), pp::Var(-1));
   PostMessage(message);
 }
 
+void OutOfProcessInstance::FontSubstituted() {
+  if (font_substitution_reported)
+    return;
+  font_substitution_reported = true;

[rkaplow, 2016/10/05 19:40:28]

UserAction should generally be used when a user has done something explicit to
trigger it. it should be used only when we need the timestamp of the action.

Is the goal here just to count the number of times this has occured?

Also - is this meant to be a beginning step to what we discussed earlier today?

[npm, 2016/10/05 19:53:03]

I see this method being called for LoadFailure, LoadSuccess, and
PreviewDocumentLoadFailure in this same class. I believe those are not
userAction-dependent? What would be ideal here?

The goal is just to count how many times this occurs (but counting it once per
document).

This is much simpler than what we discussed today but still a useful first step.

[rkaplow, 2016/10/05 21:03:10]

Yes, it's not ideal. It is still better for it to be in a histogram since you
don't need the timing info. You can have it be a boolean histogram and just use
the 'true' bucket.

usually we like to have a baseline comparison - in this case I don't see a
natural baseline but if there is one it would be good (generally some sort of
fail case)

+  UserMetricsRecordAction("PDF.FontSubstituted");
+}
+
 void OutOfProcessInstance::PreviewDocumentLoadFailed() {
   UserMetricsRecordAction("PDF.PreviewDocumentLoadFailure");
   if (preview_document_load_state_ != LOAD_STATE_LOADING ||
       preview_pages_info_.empty()) {
     return;
   }
 
   preview_document_load_state_ = LOAD_STATE_FAILED;
   preview_pages_info_.pop();
 
@@ skipping 209 matching lines @@
     const pp::FloatPoint& scroll_offset) {
   float max_x = document_size_.width() * zoom_ - plugin_dip_size_.width();
   float x = std::max(std::min(scroll_offset.x(), max_x), 0.0f);
   float min_y = -top_toolbar_height_;
   float max_y = document_size_.height() * zoom_ - plugin_dip_size_.height();
   float y = std::max(std::min(scroll_offset.y(), max_y), min_y);
   return pp::FloatPoint(x, y);
 }
 
 }  // namespace chrome_pdf