Report some PNaCl UMA earlier, instead of in one chunk at the end.

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 110 matching lines @@
 
 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;
 
 void HistogramTime(pp::UMAPrivate& uma,
-                   const std::string& name, int64_t ms) {
+                   const nacl::string& name, int64_t ms) {
   if (ms < 0) return;
   uma.HistogramCustomTimes(name,
                            ms,
                            kTimeLargeMin, kTimeLargeMax,
                            kTimeLargeBuckets);
 }
 
 void HistogramSizeKB(pp::UMAPrivate& uma,
-                     const std::string& name, int32_t kb) {
+                     const nacl::string& name, int32_t kb) {
   if (kb < 0) return;
   uma.HistogramCustomCounts(name,
                             kb,
                             kSizeKBMin, kSizeKBMax,
                             kSizeKBBuckets);
 }
 
 void HistogramRatio(pp::UMAPrivate& uma,
-                    const std::string& name, int64_t a, int64_t b) {
+                    const nacl::string& name, int64_t a, int64_t b) {
   if (a < 0 || b <= 0) return;
   uma.HistogramCustomCounts(name,
                             100 * a / b,
                             kRatioMin, kRatioMax,
                             kRatioBuckets);
 }
 
 void HistogramKBPerSec(pp::UMAPrivate& uma,
-                       const std::string& name, double kb, double s) {
+                       const nacl::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 HistogramEnumerateTranslationCache(pp::UMAPrivate& uma, bool hit) {
   uma.HistogramEnumeration("NaCl.Perf.PNaClCache.IsHit",
                            hit, 2);
@@ skipping 163 matching lines @@
     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(plugin_->uma_interface(), pnacl_options_.opt_level());
-  const plugin::PnaclTimeStats& time_stats = translate_thread_->GetTimeStats();
-  HistogramTime(plugin_->uma_interface(),
-                "NaCl.Perf.PNaClLoadTime.LoadCompiler",
-                time_stats.pnacl_llc_load_time / NACL_MICROS_PER_MILLI);
-  HistogramTime(plugin_->uma_interface(), "NaCl.Perf.PNaClLoadTime.CompileTime",
-                time_stats.pnacl_compile_time / NACL_MICROS_PER_MILLI);
   HistogramKBPerSec(plugin_->uma_interface(),
                     "NaCl.Perf.PNaClLoadTime.CompileKBPerSec",
                     pexe_size_ / 1024.0,
-                    time_stats.pnacl_compile_time / 1000000.0);
-  HistogramTime(plugin_->uma_interface(), "NaCl.Perf.PNaClLoadTime.LoadLinker",
-                time_stats.pnacl_ld_load_time / NACL_MICROS_PER_MILLI);
-  HistogramTime(plugin_->uma_interface(), "NaCl.Perf.PNaClLoadTime.LinkTime",
-                time_stats.pnacl_link_time / NACL_MICROS_PER_MILLI);
+                    translate_thread_->GetCompileTime() / 1000000.0);
   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 {
@@ skipping 248 matching lines @@
   }
 }
 
 StreamCallback PnaclCoordinator::GetCallback() {
   return callback_factory_.NewCallbackWithOutput(
       &PnaclCoordinator::BitcodeStreamGotData);
 }
 
 void PnaclCoordinator::BitcodeGotCompiled(int32_t pp_error,
                                           int64_t bytes_compiled) {
+  DCHECK(pp_error == PP_OK);
   pexe_bytes_compiled_ += bytes_compiled;
   // If we don't know the expected total yet, ask.
   if (!ExpectedProgressKnown()) {
     int64_t amount_downloaded;  // dummy variable.
     streaming_downloader_->GetDownloadProgress(&amount_downloaded,
                                                &expected_pexe_size_);
   }
   // Hold off reporting the last few bytes of progress, since we don't know
   // when they are actually completely compiled.  "bytes_compiled" only means
   // that bytes were sent to the compiler.
@@ skipping 13 matching lines @@
                                   expected_pexe_size_);
   }
 }
 
 pp::CompletionCallback PnaclCoordinator::GetCompileProgressCallback(
     int64_t bytes_compiled) {
   return callback_factory_.NewCallback(&PnaclCoordinator::BitcodeGotCompiled,
                                        bytes_compiled);
 }
 
+void PnaclCoordinator::DoUMATimeMeasure(int32_t pp_error,
+                                        const nacl::string& event_name,
+                                        int64_t microsecs) {
+  DCHECK(pp_error == PP_OK);
+  HistogramTime(
+      plugin_->uma_interface(), event_name, microsecs / NACL_MICROS_PER_MILLI);
+}
+
+pp::CompletionCallback PnaclCoordinator::GetUMATimeCallback(
+    const nacl::string& event_name, int64_t microsecs) {
+  return callback_factory_.NewCallback(&PnaclCoordinator::DoUMATimeMeasure,
+                                       event_name,
+                                       microsecs);
+}
+
 void PnaclCoordinator::GetCurrentProgress(int64_t* bytes_loaded,
                                           int64_t* bytes_total) {
   *bytes_loaded = pexe_bytes_compiled_;
   *bytes_total = expected_pexe_size_;
 }
 
 void PnaclCoordinator::ObjectFileDidOpen(int32_t pp_error) {
   PLUGIN_PRINTF(("PnaclCoordinator::ObjectFileDidOpen (pp_error=%"
                  NACL_PRId32 ")\n", pp_error));
   if (pp_error != PP_OK) {
@@ skipping 27 matching lines @@
                                   temp_nexe_file_.get(),
                                   invalid_desc_wrapper_.get(),
                                   &error_info_,
                                   resources_.get(),
                                   &pnacl_options_,
                                   this,
                                   plugin_);
 }
 
 }  // namespace plugin