Proxy private UMA pepper interface for out-of-process and NaCl plugins.

ppapi/native_client/src/trusted/plugin/plugin.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.
 
 #ifdef _MSC_VER
 // Do not warn about use of std::copy with raw pointers.
 #pragma warning(disable : 4996)
 #endif
 
 #include "ppapi/native_client/src/trusted/plugin/plugin.h"
@@ skipping 16 matching lines @@
 #include "native_client/src/shared/platform/nacl_check.h"
 #include "native_client/src/trusted/desc/nacl_desc_wrapper.h"
 #include "native_client/src/trusted/nonnacl_util/sel_ldr_launcher.h"
 #include "native_client/src/trusted/service_runtime/nacl_error_code.h"
 
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/ppb_console.h"
 #include "ppapi/c/ppb_var.h"
 #include "ppapi/c/ppp_instance.h"
 #include "ppapi/c/private/ppb_nacl_private.h"
-#include "ppapi/c/private/ppb_uma_private.h"
 #include "ppapi/cpp/dev/url_util_dev.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/text_input_controller.h"
 
 #include "ppapi/native_client/src/trusted/plugin/file_utils.h"
 #include "ppapi/native_client/src/trusted/plugin/json_manifest.h"
 #include "ppapi/native_client/src/trusted/plugin/nacl_entry_points.h"
 #include "ppapi/native_client/src/trusted/plugin/nacl_subprocess.h"
 #include "ppapi/native_client/src/trusted/plugin/nexe_arch.h"
 #include "ppapi/native_client/src/trusted/plugin/plugin_error.h"
@@ skipping 23 matching lines @@
 const size_t kNaClManifestMaxFileBytes = 1024 * 1024;
 
 // Define an argument name to enable 'dev' interfaces. To make sure it doesn't
 // collide with any user-defined HTML attribute, make the first character '@'.
 const char* const kDevAttribute = "@dev";
 
 // URL schemes that we treat in special ways.
 const char* const kChromeExtensionUriScheme = "chrome-extension";
 const char* const kDataUriScheme = "data";
 
+const PPB_NaCl_Private* GetNaClInterface() {
+  pp::Module *module = pp::Module::Get();
+  CHECK(module);
+  return static_cast<const PPB_NaCl_Private*>(
+      module->GetBrowserInterface(PPB_NACL_PRIVATE_INTERFACE));
+}
+
 // Up to 20 seconds
 const int64_t kTimeSmallMin = 1;         // in ms
 const int64_t kTimeSmallMax = 20000;     // in ms
 const uint32_t kTimeSmallBuckets = 100;
 
 // Up to 3 minutes, 20 seconds
 const int64_t kTimeMediumMin = 10;         // in ms
 const int64_t kTimeMediumMax = 200000;     // in ms
 const uint32_t kTimeMediumBuckets = 100;
 
 // Up to 33 minutes.
 const int64_t kTimeLargeMin = 100;         // in ms
 const int64_t kTimeLargeMax = 2000000;     // in ms
 const uint32_t kTimeLargeBuckets = 100;
 
 const int64_t kSizeKBMin = 1;
 const int64_t kSizeKBMax = 512*1024;     // very large .nexe
 const uint32_t kSizeKBBuckets = 100;
 
-const PPB_NaCl_Private* GetNaClInterface() {
-  pp::Module *module = pp::Module::Get();
-  CHECK(module);
-  return static_cast<const PPB_NaCl_Private*>(
-      module->GetBrowserInterface(PPB_NACL_PRIVATE_INTERFACE));
+}  // namespace
+
+void Plugin::HistogramTimeSmall(const std::string& name,

[yzshen1, 2013/12/04 19:32:51]

Please keep the definitions in the same order as declarations in the .h file.

[elijahtaylor1, 2013/12/21 02:26:21]

These Histogram functions were in the correct order (among the Histogram
functions), but I moved them down to above LoadNaClModuleCommon (and switched
that function with StartSelLdrOnMainThread for .h consistency).  There is not
wide agreement though between the order in the .h and .cc file for this class,
and did not want to reorder the whole file and confuse things.  Let me know if
this is sufficient or if I misunderstood something.

[yzshen1, 2014/01/08 00:26:24]

Yeah. It is good enough for me. Thanks!
On 2013/12/21 02:26:21, elijahtaylor1 wrote:

+                                int64_t ms) {
+  if (ms < 0) return;
+  uma_interface_.HistogramCustomTimes(name,
+                                      ms,
+                                      kTimeSmallMin, kTimeSmallMax,
+                                      kTimeSmallBuckets);
 }
 
-const PPB_UMA_Private* GetUMAInterface() {
-  pp::Module *module = pp::Module::Get();
-  CHECK(module);
-  return static_cast<const PPB_UMA_Private*>(
-      module->GetBrowserInterface(PPB_UMA_PRIVATE_INTERFACE));
+void Plugin::HistogramTimeMedium(const std::string& name,
+                                 int64_t ms) {
+  if (ms < 0) return;
+  uma_interface_.HistogramCustomTimes(name,
+                                      ms,
+                                      kTimeMediumMin, kTimeMediumMax,
+                                      kTimeMediumBuckets);
 }
 
-void HistogramTimeSmall(const std::string& name, int64_t ms) {
+void Plugin::HistogramTimeLarge(const std::string& name,
+                                int64_t ms) {
   if (ms < 0) return;
-
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
-
-  ptr->HistogramCustomTimes(pp::Var(name).pp_var(),
-                            ms,
-                            kTimeSmallMin, kTimeSmallMax,
-                            kTimeSmallBuckets);
+  uma_interface_.HistogramCustomTimes(name,
+                                      ms,
+                                      kTimeLargeMin, kTimeLargeMax,
+                                      kTimeLargeBuckets);
 }
 
-void HistogramTimeMedium(const std::string& name, int64_t ms) {
-  if (ms < 0) return;
-
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
-
-  ptr->HistogramCustomTimes(pp::Var(name).pp_var(),
-                            ms,
-                            kTimeMediumMin, kTimeMediumMax,
-                            kTimeMediumBuckets);
+void Plugin::HistogramSizeKB(const std::string& name,
+                             int32_t sample) {
+  if (sample < 0) return;
+  uma_interface_.HistogramCustomCounts(name,
+                                       sample,
+                                       kSizeKBMin, kSizeKBMax,
+                                       kSizeKBBuckets);
 }
 
-void HistogramTimeLarge(const std::string& name, int64_t ms) {
-  if (ms < 0) return;
-
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
-
-  ptr->HistogramCustomTimes(pp::Var(name).pp_var(),
-                            ms,
-                            kTimeLargeMin, kTimeLargeMax,
-                            kTimeLargeBuckets);
-}
-
-void HistogramSizeKB(const std::string& name, int32_t sample) {
-  if (sample < 0) return;
-
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
-
-  ptr->HistogramCustomCounts(pp::Var(name).pp_var(),
-                             sample,
-                             kSizeKBMin, kSizeKBMax,
-                             kSizeKBBuckets);
-}
-
-void HistogramEnumerate(const std::string& name, int sample, int maximum,
-                        int out_of_range_replacement) {
+void Plugin::HistogramEnumerate(const std::string& name,
+                                int sample,
+                                int maximum,
+                                int out_of_range_replacement) {
   if (sample < 0 || sample >= maximum) {
     if (out_of_range_replacement < 0)
       // No replacement for bad input, abort.
       return;
     else
       // Use a specific value to signal a bad input.
       sample = out_of_range_replacement;
   }
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
-  ptr->HistogramEnumeration(pp::Var(name).pp_var(), sample, maximum);
+  uma_interface_.HistogramEnumeration(name, sample, maximum);
 }
 
-void HistogramEnumerateOsArch(const std::string& sandbox_isa) {
+void Plugin::HistogramEnumerateOsArch(const std::string& sandbox_isa) {
   enum NaClOSArch {
     kNaClLinux32 = 0,
     kNaClLinux64,
     kNaClLinuxArm,
     kNaClMac32,
     kNaClMac64,
     kNaClMacArm,
     kNaClWin32,
     kNaClWin64,
     kNaClWinArm,
@@ skipping 10 matching lines @@
 #endif
 
   if (sandbox_isa == "x86-64")
     os_arch = static_cast<NaClOSArch>(os_arch + 1);
   if (sandbox_isa == "arm")
     os_arch = static_cast<NaClOSArch>(os_arch + 2);
 
   HistogramEnumerate("NaCl.Client.OSArch", os_arch, kNaClOSArchMax, -1);
 }
 
-void HistogramEnumerateLoadStatus(PluginErrorCode error_code,
-                                  bool is_installed) {
+void Plugin::HistogramEnumerateLoadStatus(PluginErrorCode error_code,
+                                          bool is_installed) {
   HistogramEnumerate("NaCl.LoadStatus.Plugin", error_code, ERROR_MAX,
                      ERROR_UNKNOWN);
 
   // Gather data to see if being installed changes load outcomes.
   const char* name = is_installed ? "NaCl.LoadStatus.Plugin.InstalledApp" :
       "NaCl.LoadStatus.Plugin.NotInstalledApp";
-  HistogramEnumerate(name, error_code, ERROR_MAX,
-                     ERROR_UNKNOWN);
+  HistogramEnumerate(name, error_code, ERROR_MAX, ERROR_UNKNOWN);
 }
 
-void HistogramEnumerateSelLdrLoadStatus(NaClErrorCode error_code,
-                                        bool is_installed) {
-  HistogramEnumerate("NaCl.LoadStatus.SelLdr", error_code, NACL_ERROR_CODE_MAX,
-                     LOAD_STATUS_UNKNOWN);
+void Plugin::HistogramEnumerateSelLdrLoadStatus(NaClErrorCode error_code,
+                                                bool is_installed) {
+  HistogramEnumerate("NaCl.LoadStatus.SelLdr", error_code,
+                     NACL_ERROR_CODE_MAX, LOAD_STATUS_UNKNOWN);
 
   // Gather data to see if being installed changes load outcomes.
   const char* name = is_installed ? "NaCl.LoadStatus.SelLdr.InstalledApp" :
       "NaCl.LoadStatus.SelLdr.NotInstalledApp";
   HistogramEnumerate(name, error_code, NACL_ERROR_CODE_MAX,
                      LOAD_STATUS_UNKNOWN);
 }
 
-void HistogramEnumerateManifestIsDataURI(bool is_data_uri) {
+void Plugin::HistogramEnumerateManifestIsDataURI(bool is_data_uri) {
   HistogramEnumerate("NaCl.Manifest.IsDataURI", is_data_uri, 2, -1);
 }
 
-void HistogramHTTPStatusCode(const std::string& name, int status) {
+void Plugin::HistogramHTTPStatusCode(const std::string& name,
+                                     int status) {
   // Log the status codes in rough buckets - 1XX, 2XX, etc.
   int sample = status / 100;
   // HTTP status codes only go up to 5XX, using "6" to indicate an internal
   // error.
   // Note: installed files may have "0" for a status code.
   if (status < 0 || status >= 600)
     sample = 6;
   HistogramEnumerate(name, sample, 7, 6);
 }
 
-}  // namespace
-
 void Plugin::AddPropertyGet(const nacl::string& prop_name,
                             Plugin::PropertyGetter getter) {
   PLUGIN_PRINTF(("Plugin::AddPropertyGet (prop_name='%s')\n",
                  prop_name.c_str()));
   property_getters_[nacl::string(prop_name)] = getter;
 }
 
 bool Plugin::HasProperty(const nacl::string& prop_name) {
   PLUGIN_PRINTF(("Plugin::HasProperty (prop_name=%s)\n",
                  prop_name.c_str()));
@@ skipping 435 matching lines @@
       main_subprocess_("main subprocess", NULL, NULL),
       nacl_ready_state_(UNSENT),
       nexe_error_reported_(false),
       wrapper_factory_(NULL),
       enable_dev_interfaces_(false),
       is_installed_(false),
       init_time_(0),
       ready_time_(0),
       nexe_size_(0),
       time_of_last_progress_event_(0),
-      nacl_interface_(NULL) {
+      nacl_interface_(NULL),
+      uma_interface_(this) {
   PLUGIN_PRINTF(("Plugin::Plugin (this=%p, pp_instance=%"
                  NACL_PRId32 ")\n", static_cast<void*>(this), pp_instance));
   callback_factory_.Initialize(this);
   nexe_downloader_.Initialize(this);
   nacl_interface_ = GetNaClInterface();
   CHECK(nacl_interface_ != NULL);
 }
 
 
 Plugin::~Plugin() {
@@ skipping 633 matching lines @@
   EnqueueProgressEvent(
       PP_NACL_EVENT_LOAD, url, length_computable, loaded_bytes, total_bytes);
   EnqueueProgressEvent(
       PP_NACL_EVENT_LOADEND, url, length_computable, loaded_bytes, total_bytes);
 
   // UMA
   HistogramEnumerateLoadStatus(ERROR_LOAD_SUCCESS, is_installed_);
 }
 
 
-// TODO(ncbray): report UMA stats
 void Plugin::ReportLoadError(const ErrorInfo& error_info) {
   PLUGIN_PRINTF(("Plugin::ReportLoadError (error='%s')\n",
                  error_info.message().c_str()));
   // For errors the user (and not just the developer) should know about,
   // report them to the renderer so the browser can display a message.
   if (error_info.error_code() == ERROR_MANIFEST_PROGRAM_MISSING_ARCH) {
     // A special case: the manifest may otherwise be valid but is missing
     // a program/file compatible with the user's sandbox.
     nacl_interface()->ReportNaClError(pp_instance(),
                                       PP_NACL_MANIFEST_MISSING_ARCH);
@@ skipping 230 matching lines @@
                                           static_cast<uint32_t>(text.size()));
   const PPB_Console* console_interface =
       static_cast<const PPB_Console*>(
           module->GetBrowserInterface(PPB_CONSOLE_INTERFACE));
   console_interface->LogWithSource(pp_instance(), PP_LOGLEVEL_LOG, prefix, str);
   var_interface->Release(prefix);
   var_interface->Release(str);
 }
 
 }  // namespace plugin