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));
+}
+

[bbudge, 2014/01/08 19:01:49]

Did you intentionally move this here? It seems better to have it after all the
constant definitions, at the end of the anonymous namespace.

[elijahtaylor1, 2014/01/08 23:59:41]

I don't know how this ended up here.  Done.

 // 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));
-}
-
-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 HistogramTimeSmall(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);
-}
-
-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 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) {
-  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);
-}
-
-void HistogramEnumerateOsArch(const std::string& sandbox_isa) {
-  enum NaClOSArch {
-    kNaClLinux32 = 0,
-    kNaClLinux64,
-    kNaClLinuxArm,
-    kNaClMac32,
-    kNaClMac64,
-    kNaClMacArm,
-    kNaClWin32,
-    kNaClWin64,
-    kNaClWinArm,
-    kNaClOSArchMax
-  };
-
-  NaClOSArch os_arch = kNaClOSArchMax;
-#if NACL_LINUX
-  os_arch = kNaClLinux32;
-#elif NACL_OSX
-  os_arch = kNaClMac32;
-#elif NACL_WINDOWS
-  os_arch = kNaClWin32;
-#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) {
-  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);
-}
-
-void 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) {
-  HistogramEnumerate("NaCl.Manifest.IsDataURI", is_data_uri, 2, -1);
-}
-
-void 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) {
@@ skipping 92 matching lines @@
                  main_subprocess_.detailed_description().c_str()));
 
   // Shut down service runtime. This must be done before all other calls so
   // they don't block forever when waiting for the upcall thread to exit.
   main_subprocess_.Shutdown();
 
   PLUGIN_PRINTF(("Plugin::ShutDownSubprocess (this=%p, return)\n",
                  static_cast<void*>(this)));
 }
 
-void Plugin::StartSelLdrOnMainThread(int32_t pp_error,
-                                     ServiceRuntime* service_runtime,
-                                     const SelLdrStartParams& params,
-                                     bool* success) {
-  if (pp_error != PP_OK) {
-    PLUGIN_PRINTF(("Plugin::StartSelLdrOnMainThread: non-PP_OK arg "
-                   "-- SHOULD NOT HAPPEN\n"));
-    *success = false;
-    return;
+void Plugin::HistogramTimeSmall(const std::string& name,
+                                int64_t ms) {
+  if (ms < 0) return;
+  uma_interface_.HistogramCustomTimes(name,
+                                      ms,
+                                      kTimeSmallMin, kTimeSmallMax,
+                                      kTimeSmallBuckets);
+}
+
+void Plugin::HistogramTimeMedium(const std::string& name,
+                                 int64_t ms) {
+  if (ms < 0) return;
+  uma_interface_.HistogramCustomTimes(name,
+                                      ms,
+                                      kTimeMediumMin, kTimeMediumMax,
+                                      kTimeMediumBuckets);
+}
+
+void Plugin::HistogramTimeLarge(const std::string& name,
+                                int64_t ms) {
+  if (ms < 0) return;
+  uma_interface_.HistogramCustomTimes(name,
+                                      ms,
+                                      kTimeLargeMin, kTimeLargeMax,
+                                      kTimeLargeBuckets);
+}
+
+void Plugin::HistogramSizeKB(const std::string& name,
+                             int32_t sample) {
+  if (sample < 0) return;
+  uma_interface_.HistogramCustomCounts(name,
+                                       sample,
+                                       kSizeKBMin, kSizeKBMax,
+                                       kSizeKBBuckets);
+}
+
+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;
   }
-  *success = service_runtime->StartSelLdr(params);
-  // Signal outside of StartSelLdr here, so that the write to *success
-  // is done before signaling.
-  service_runtime->SignalStartSelLdrDone();
+  uma_interface_.HistogramEnumeration(name, sample, maximum);
+}
+
+void Plugin::HistogramEnumerateOsArch(const std::string& sandbox_isa) {
+  enum NaClOSArch {
+    kNaClLinux32 = 0,
+    kNaClLinux64,
+    kNaClLinuxArm,
+    kNaClMac32,
+    kNaClMac64,
+    kNaClMacArm,
+    kNaClWin32,
+    kNaClWin64,
+    kNaClWinArm,
+    kNaClOSArchMax
+  };
+
+  NaClOSArch os_arch = kNaClOSArchMax;
+#if NACL_LINUX
+  os_arch = kNaClLinux32;
+#elif NACL_OSX
+  os_arch = kNaClMac32;
+#elif NACL_WINDOWS
+  os_arch = kNaClWin32;
+#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 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);
+}
+
+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 Plugin::HistogramEnumerateManifestIsDataURI(bool is_data_uri) {
+  HistogramEnumerate("NaCl.Manifest.IsDataURI", is_data_uri, 2, -1);
+}
+
+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);
 }
 
 bool Plugin::LoadNaClModuleCommon(nacl::DescWrapper* wrapper,
                                   NaClSubprocess* subprocess,
                                   const Manifest* manifest,
                                   bool should_report_uma,
                                   const SelLdrStartParams& params,
                                   const pp::CompletionCallback& init_done_cb,
                                   const pp::CompletionCallback& crash_cb) {
   ServiceRuntime* new_service_runtime =
@@ skipping 34 matching lines @@
                                                            params.error_info,
                                                            crash_cb);
   PLUGIN_PRINTF(("Plugin::LoadNaClModuleCommon (nexe_loaded=%d)\n",
                  nexe_loaded));
   if (!nexe_loaded) {
     return false;
   }
   return true;
 }
 
+void Plugin::StartSelLdrOnMainThread(int32_t pp_error,
+                                     ServiceRuntime* service_runtime,
+                                     const SelLdrStartParams& params,
+                                     bool* success) {
+  if (pp_error != PP_OK) {
+    PLUGIN_PRINTF(("Plugin::StartSelLdrOnMainThread: non-PP_OK arg "
+                   "-- SHOULD NOT HAPPEN\n"));
+    *success = false;
+    return;
+  }
+  *success = service_runtime->StartSelLdr(params);
+  // Signal outside of StartSelLdr here, so that the write to *success
+  // is done before signaling.
+  service_runtime->SignalStartSelLdrDone();
+}
+
 bool Plugin::LoadNaClModule(nacl::DescWrapper* wrapper,
                             ErrorInfo* error_info,
                             bool enable_dyncode_syscalls,
                             bool enable_exception_handling,
                             bool enable_crash_throttling,
                             const pp::CompletionCallback& init_done_cb,
                             const pp::CompletionCallback& crash_cb) {
   // Before forking a new sel_ldr process, ensure that we do not leak
   // the ServiceRuntime object for an existing subprocess, and that any
   // associated listener threads do not go unjoined because if they
@@ skipping 257 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