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

ppapi/native_client/src/trusted/plugin/pnacl_coordinator.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 "ppapi/native_client/src/trusted/plugin/pnacl_coordinator.h"
 
 #include <utility>
 #include <vector>
 
 #include "native_client/src/include/checked_cast.h"
@@ skipping 103 matching lines @@
 const uint32_t kSizeKBBuckets = 100;
 
 const int32_t kRatioMin = 10;
 const int32_t kRatioMax = 10*100;          // max of 10x difference.
 const uint32_t kRatioBuckets = 100;
 
 const int32_t kKBPSMin = 1;
 const int32_t kKBPSMax = 30*1000;          // max of 30 MB / sec.
 const uint32_t kKBPSBuckets = 100;
 
-const PPB_UMA_Private* uma_interface = NULL;
-
-const PPB_UMA_Private* GetUMAInterface() {
-  if (uma_interface != NULL) {
-    return uma_interface;
-  }
-  pp::Module *module = pp::Module::Get();
-  DCHECK(module);
-  uma_interface = static_cast<const PPB_UMA_Private*>(
-      module->GetBrowserInterface(PPB_UMA_PRIVATE_INTERFACE));
-  return uma_interface;
+void HistogramTime(const pp::UMAPrivate& uma,
+                   const std::string& name, int64_t ms) {
+  if (ms < 0) return;
+  uma.HistogramCustomTimes(name,
+                           ms,
+                           kTimeLargeMin, kTimeLargeMax,
+                           kTimeLargeBuckets);
 }
 
-void HistogramTime(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 pp::UMAPrivate& uma,
+                     const std::string& name, int32_t kb) {
+  if (kb < 0) return;
+  uma.HistogramCustomCounts(name,
+                            kb,
+                            kSizeKBMin, kSizeKBMax,
+                            kSizeKBBuckets);
 }
 
-void HistogramSizeKB(const std::string& name, int32_t kb) {
-  if (kb < 0) return;
-
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
-
-  ptr->HistogramCustomCounts(pp::Var(name).pp_var(),
-                             kb,
-                             kSizeKBMin, kSizeKBMax,
-                             kSizeKBBuckets);
+void HistogramRatio(const pp::UMAPrivate& uma,
+                    const std::string& name, int64_t a, int64_t b) {
+  if (a < 0 || b <= 0) return;
+  uma.HistogramCustomCounts(name,
+                            100 * a / b,
+                            kRatioMin, kRatioMax,
+                            kRatioBuckets);
 }
 
-void HistogramRatio(const std::string& name, int64_t a, int64_t b) {
-  if (a < 0 || b <= 0) return;
-
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
-
-  ptr->HistogramCustomCounts(pp::Var(name).pp_var(),
-                             100 * a / b,
-                             kRatioMin, kRatioMax,
-                             kRatioBuckets);
+void HistogramKBPerSec(const pp::UMAPrivate& uma,
+                       const std::string& name, double kb, double s) {
+  if (kb < 0.0 || s <= 0.0) return;
+  uma.HistogramCustomCounts(name,
+                            static_cast<int64_t>(kb / s),
+                            kKBPSMin, kKBPSMax,
+                            kKBPSBuckets);
 }
 
-void HistogramKBPerSec(const std::string& name, double kb, double s) {
-  if (kb < 0.0 || s <= 0.0) return;
-
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
-
-  ptr->HistogramCustomCounts(pp::Var(name).pp_var(),
-                             static_cast<int64_t>(kb / s),
-                             kKBPSMin, kKBPSMax,
-                             kKBPSBuckets);
-}
-
-void HistogramEnumerateTranslationCache(bool hit) {
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
-  ptr->HistogramEnumeration(pp::Var("NaCl.Perf.PNaClCache.IsHit").pp_var(),
-                            hit, 2);
+void HistogramEnumerateTranslationCache(const pp::UMAPrivate& uma, bool hit) {
+  uma.HistogramEnumeration("NaCl.Perf.PNaClCache.IsHit",
+                           hit, 2);
 }
 
 // Opt level is expected to be 0 to 3.  Treating 4 as unknown.
 const int8_t kOptUnknown = 4;
 
-void HistogramOptLevel(int8_t opt_level) {
-  const PPB_UMA_Private* ptr = GetUMAInterface();
-  if (ptr == NULL) return;
+void HistogramOptLevel(const pp::UMAPrivate& uma, int8_t opt_level) {
   if (opt_level < 0 || opt_level > 3) {
     opt_level = kOptUnknown;
   }
-  ptr->HistogramEnumeration(pp::Var("NaCl.Options.PNaCl.OptLevel").pp_var(),
-                            opt_level, kOptUnknown+1);
+  uma.HistogramEnumeration("NaCl.Options.PNaCl.OptLevel",
+                           opt_level, kOptUnknown+1);
 }
 
 }  // namespace
 
 
 //////////////////////////////////////////////////////////////////////
 //  The coordinator class.
 //////////////////////////////////////////////////////////////////////
 
 // Out-of-line destructor to keep it from getting put in every .o where
@@ skipping 132 matching lines @@
   if (ExpectedProgressKnown()) {
     pexe_bytes_compiled_ = expected_pexe_size_;
     plugin_->EnqueueProgressEvent(PP_NACL_EVENT_PROGRESS,
                                   pexe_url_,
                                   plugin::Plugin::LENGTH_IS_COMPUTABLE,
                                   pexe_bytes_compiled_,
                                   expected_pexe_size_);
   }
 
   // If there are no errors, report stats from this thread (the main thread).
-  HistogramOptLevel(pnacl_options_.opt_level());
+  HistogramOptLevel(plugin_->uma_interface(), pnacl_options_.opt_level());
   const plugin::PnaclTimeStats& time_stats = translate_thread_->GetTimeStats();
-  HistogramTime("NaCl.Perf.PNaClLoadTime.LoadCompiler",
+  HistogramTime(plugin_->uma_interface(),
+                "NaCl.Perf.PNaClLoadTime.LoadCompiler",
                 time_stats.pnacl_llc_load_time / NACL_MICROS_PER_MILLI);
-  HistogramTime("NaCl.Perf.PNaClLoadTime.CompileTime",
+  HistogramTime(plugin_->uma_interface(), "NaCl.Perf.PNaClLoadTime.CompileTime",
                 time_stats.pnacl_compile_time / NACL_MICROS_PER_MILLI);
-  HistogramKBPerSec("NaCl.Perf.PNaClLoadTime.CompileKBPerSec",
+  HistogramKBPerSec(plugin_->uma_interface(),
+                    "NaCl.Perf.PNaClLoadTime.CompileKBPerSec",
                     pexe_size_ / 1024.0,
                     time_stats.pnacl_compile_time / 1000000.0);
-  HistogramTime("NaCl.Perf.PNaClLoadTime.LoadLinker",
+  HistogramTime(plugin_->uma_interface(), "NaCl.Perf.PNaClLoadTime.LoadLinker",
                 time_stats.pnacl_ld_load_time / NACL_MICROS_PER_MILLI);
-  HistogramTime("NaCl.Perf.PNaClLoadTime.LinkTime",
+  HistogramTime(plugin_->uma_interface(), "NaCl.Perf.PNaClLoadTime.LinkTime",
                 time_stats.pnacl_link_time / NACL_MICROS_PER_MILLI);
-  HistogramSizeKB("NaCl.Perf.Size.Pexe",
+  HistogramSizeKB(plugin_->uma_interface(), "NaCl.Perf.Size.Pexe",
                   static_cast<int64_t>(pexe_size_ / 1024));
 
   struct nacl_abi_stat stbuf;
   struct NaClDesc* desc = temp_nexe_file_->read_wrapper()->desc();
   int stat_ret;
   if (0 != (stat_ret = (*((struct NaClDescVtbl const *) desc->base.vtbl)->
                         Fstat)(desc, &stbuf))) {
     PLUGIN_PRINTF(("PnaclCoordinator::TranslateFinished can't stat nexe.\n"));
   } else {
     size_t nexe_size = stbuf.nacl_abi_st_size;
-    HistogramSizeKB("NaCl.Perf.Size.PNaClTranslatedNexe",
+    HistogramSizeKB(plugin_->uma_interface(),
+                    "NaCl.Perf.Size.PNaClTranslatedNexe",
                     static_cast<int64_t>(nexe_size / 1024));
-    HistogramRatio("NaCl.Perf.Size.PexeNexeSizePct", pexe_size_, nexe_size);
+    HistogramRatio(plugin_->uma_interface(),
+                   "NaCl.Perf.Size.PexeNexeSizePct", pexe_size_, nexe_size);
   }
 
   int64_t total_time = NaClGetTimeOfDayMicroseconds() - pnacl_init_time_;
-  HistogramTime("NaCl.Perf.PNaClLoadTime.TotalUncachedTime",
+  HistogramTime(plugin_->uma_interface(),
+                "NaCl.Perf.PNaClLoadTime.TotalUncachedTime",
                 total_time / NACL_MICROS_PER_MILLI);
-  HistogramKBPerSec("NaCl.Perf.PNaClLoadTime.TotalUncachedKBPerSec",
+  HistogramKBPerSec(plugin_->uma_interface(),
+                    "NaCl.Perf.PNaClLoadTime.TotalUncachedKBPerSec",
                     pexe_size_ / 1024.0,
                     total_time / 1000000.0);
 
   // The nexe is written to the temp_nexe_file_.  We must Reset() the file
   // pointer to be able to read it again from the beginning.
   temp_nexe_file_->Reset();
 
   // Report to the browser that translation finished. The browser will take
   // care of storing the nexe in the cache.
   translation_finished_reported_ = true;
@@ skipping 142 matching lines @@
     return;
   }
 
   if (*temp_nexe_file_->existing_handle() == PP_kInvalidFileHandle) {
     ReportNonPpapiError(
         ERROR_PNACL_CREATE_TEMP,
         nacl::string(
             "PnaclCoordinator: Got bad temp file handle from GetNexeFd"));
     return;
   }
-  HistogramEnumerateTranslationCache(is_cache_hit_);
+  HistogramEnumerateTranslationCache(plugin_->uma_interface(), is_cache_hit_);
 
   if (is_cache_hit_ == PP_TRUE) {
     // Cache hit -- no need to stream the rest of the file.
     streaming_downloader_.reset(NULL);
     // Open it for reading as the cached nexe file.
     pp::CompletionCallback cb =
         callback_factory_.NewCallback(&PnaclCoordinator::NexeReadDidOpen);
     temp_nexe_file_->Open(cb, false);
   } else {
     // Open an object file first so the translator can start writing to it
@@ skipping 29 matching lines @@
       error_info_.SetReport(ERROR_PNACL_PEXE_FETCH_NOACCESS,
                             "PnaclCoordinator: pexe load failed (no access).");
     } else {
       nacl::stringstream ss;
       ss << "PnaclCoordinator: pexe load failed (pp_error=" << pp_error << ").";
       error_info_.SetReport(ERROR_PNACL_PEXE_FETCH_OTHER, ss.str());
     }
     translate_thread_->AbortSubprocesses();
   } else {
     // Compare download completion pct (100% now), to compile completion pct.
-    HistogramRatio("NaCl.Perf.PNaClLoadTime.PctCompiledWhenFullyDownloaded",
+    HistogramRatio(plugin_->uma_interface(),
+                   "NaCl.Perf.PNaClLoadTime.PctCompiledWhenFullyDownloaded",
                    pexe_bytes_compiled_, pexe_size_);
   }
 }
 
 void PnaclCoordinator::BitcodeStreamGotData(int32_t pp_error,
                                             FileStreamData data) {
   PLUGIN_PRINTF(("PnaclCoordinator::BitcodeStreamGotData (pp_error=%"
                  NACL_PRId32 ", data=%p)\n", pp_error, data ? &(*data)[0] : 0));
   DCHECK(translate_thread_.get());
 
@@ skipping 80 matching lines @@
                                   obj_file_.get(),
                                   temp_nexe_file_.get(),
                                   &error_info_,
                                   resources_.get(),
                                   &pnacl_options_,
                                   this,
                                   plugin_);
 }
 
 }  // namespace plugin