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

ppapi/native_client/src/trusted/plugin/pnacl_translate_thread.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_translate_thread.h"
 
 #include <iterator>
 
 #include "native_client/src/trusted/desc/nacl_desc_wrapper.h"
 #include "ppapi/native_client/src/trusted/plugin/plugin.h"
 #include "ppapi/native_client/src/trusted/plugin/plugin_error.h"
 #include "ppapi/native_client/src/trusted/plugin/pnacl_resources.h"
 #include "ppapi/native_client/src/trusted/plugin/srpc_params.h"
 #include "ppapi/native_client/src/trusted/plugin/temporary_file.h"
 #include "ppapi/native_client/src/trusted/plugin/utility.h"
 
 namespace plugin {
 
 PnaclTranslateThread::PnaclTranslateThread() : llc_subprocess_active_(false),
                                                ld_subprocess_active_(false),
                                                done_(false),
-                                               time_stats_(),
+                                               compile_time_(0),
                                                manifest_(NULL),
                                                obj_files_(NULL),
                                                nexe_file_(NULL),
                                                coordinator_error_info_(NULL),
                                                resources_(NULL),
                                                coordinator_(NULL),
                                                plugin_(NULL) {
   NaClXMutexCtor(&subprocess_mu_);
   NaClXMutexCtor(&cond_mu_);
   NaClXCondVarCtor(&buffer_cond_);
@@ skipping 109 matching lines @@
   SrpcParams params;
   std::vector<nacl::DescWrapper*> llc_out_files;
   size_t i;
   for (i = 0; i < obj_files_->size(); i++) {
     llc_out_files.push_back((*obj_files_)[i]->write_wrapper());
   }
   for (; i < PnaclCoordinator::kMaxTranslatorObjectFiles; i++) {
     llc_out_files.push_back(invalid_desc_wrapper_);
   }
 
+  pp::Core* core = pp::Module::Get()->core();
   {
     nacl::MutexLocker ml(&subprocess_mu_);
     int64_t llc_start_time = NaClGetTimeOfDayMicroseconds();
     llc_subprocess_.reset(
       StartSubprocess(resources_->GetLlcUrl(), manifest_, &error_info));
     if (llc_subprocess_ == NULL) {
       TranslateFailed(PP_NACL_ERROR_PNACL_LLC_SETUP,
                       "Compile process could not be created: " +
                       error_info.message());
       return;
     }
     llc_subprocess_active_ = true;
-    time_stats_.pnacl_llc_load_time =
-        (NaClGetTimeOfDayMicroseconds() - llc_start_time);
+    core->CallOnMainThread(0,
+                           coordinator_->GetUMATimeCallback(
+                               "NaCl.Perf.PNaClLoadTime.LoadCompiler",
+                               NaClGetTimeOfDayMicroseconds() - llc_start_time),
+                           PP_OK);
     // Run LLC.
     PluginReverseInterface* llc_reverse =
         llc_subprocess_->service_runtime()->rev_interface();
     for (size_t i = 0; i < obj_files_->size(); i++) {
       llc_reverse->AddTempQuotaManagedFile((*obj_files_)[i]->identifier());
     }
   }
 
   int64_t compile_start_time = NaClGetTimeOfDayMicroseconds();
   bool init_success;
@@ skipping 38 matching lines @@
       // The error message is only present if the error was returned from llc
       TranslateFailed(PP_NACL_ERROR_PNACL_LLC_INTERNAL,
                       nacl::string("Stream init failed: ") +
                       nacl::string(params.outs()[0]->arrays.str));
     } else {
       TranslateFailed(PP_NACL_ERROR_PNACL_LLC_INTERNAL,
                       "Stream init internal error");
     }
     return;
   }
-
   PLUGIN_PRINTF(("PnaclCoordinator: StreamInit successful\n"));
-  pp::Core* core = pp::Module::Get()->core();
 
   // llc process is started.
   while(!done_ || data_buffers_.size() > 0) {
     NaClXMutexLock(&cond_mu_);
     while(!done_ && data_buffers_.size() == 0) {
       NaClXCondVarWait(&buffer_cond_, &cond_mu_);
     }
     PLUGIN_PRINTF(("PnaclTranslateThread awake (done=%d, size=%" NACL_PRIuS
                    ")\n",
                    done_, data_buffers_.size()));
@@ skipping 39 matching lines @@
         NACL_SRPC_RESULT_APP_ERROR) {
       // The error string is only present if the error was sent back from llc.
       TranslateFailed(PP_NACL_ERROR_PNACL_LLC_INTERNAL,
                       params.outs()[3]->arrays.str);
     } else {
       TranslateFailed(PP_NACL_ERROR_PNACL_LLC_INTERNAL,
                       "Compile StreamEnd internal error");
     }
     return;
   }
-  time_stats_.pnacl_compile_time =
-      (NaClGetTimeOfDayMicroseconds() - compile_start_time);
+  compile_time_ = NaClGetTimeOfDayMicroseconds() - compile_start_time;
+  core->CallOnMainThread(0,
+                         coordinator_->GetUMATimeCallback(
+                             "NaCl.Perf.PNaClLoadTime.CompileTime",
+                             compile_time_),
+                         PP_OK);
 
   // Shut down the llc subprocess.
   NaClXMutexLock(&subprocess_mu_);
   llc_subprocess_active_ = false;
   llc_subprocess_.reset(NULL);
   NaClXMutexUnlock(&subprocess_mu_);
 
   if(!RunLdSubprocess()) {
     return;
   }
@@ skipping 13 matching lines @@
                       "Link process could not reset object file");
       return false;
     }
     ld_in_files.push_back((*obj_files_)[i]->read_wrapper());
   }
   for (; i < PnaclCoordinator::kMaxTranslatorObjectFiles; i++) {
     ld_in_files.push_back(invalid_desc_wrapper_);
   }
 
   nacl::DescWrapper* ld_out_file = nexe_file_->write_wrapper();
-
+  pp::Core* core = pp::Module::Get()->core();
   {
     // Create LD process
     nacl::MutexLocker ml(&subprocess_mu_);
     int64_t ld_start_time = NaClGetTimeOfDayMicroseconds();
     ld_subprocess_.reset(
       StartSubprocess(resources_->GetLdUrl(), manifest_, &error_info));
     if (ld_subprocess_ == NULL) {
       TranslateFailed(PP_NACL_ERROR_PNACL_LD_SETUP,
                       "Link process could not be created: " +
                       error_info.message());
       return false;
     }
     ld_subprocess_active_ = true;
-    time_stats_.pnacl_ld_load_time =
-        (NaClGetTimeOfDayMicroseconds() - ld_start_time);
+    core->CallOnMainThread(0,
+                           coordinator_->GetUMATimeCallback(
+                               "NaCl.Perf.PNaClLoadTime.LoadLinker",
+                               NaClGetTimeOfDayMicroseconds() - ld_start_time),
+                           PP_OK);
     PluginReverseInterface* ld_reverse =
         ld_subprocess_->service_runtime()->rev_interface();
     ld_reverse->AddTempQuotaManagedFile(nexe_file_->identifier());
   }
 
   int64_t link_start_time = NaClGetTimeOfDayMicroseconds();
   // Run LD.
   bool success = ld_subprocess_->InvokeSrpcMethod(
       "RunWithSplit",
       "ihhhhhhhhhhhhhhhhh",
@@ skipping 14 matching lines @@
       ld_in_files[12]->desc(),
       ld_in_files[13]->desc(),
       ld_in_files[14]->desc(),
       ld_in_files[15]->desc(),
       ld_out_file->desc());
   if (!success) {
     TranslateFailed(PP_NACL_ERROR_PNACL_LD_INTERNAL,
                     "link failed.");
     return false;
   }
-  time_stats_.pnacl_link_time =
-      NaClGetTimeOfDayMicroseconds() - link_start_time;
+  core->CallOnMainThread(0,
+                         coordinator_->GetUMATimeCallback(
+                             "NaCl.Perf.PNaClLoadTime.LinkTime",
+                             NaClGetTimeOfDayMicroseconds() - link_start_time),
+                         PP_OK);
   PLUGIN_PRINTF(("PnaclCoordinator: link (translator=%p) succeeded\n",
                  this));
   // Shut down the ld subprocess.
   NaClXMutexLock(&subprocess_mu_);
   ld_subprocess_active_ = false;
   ld_subprocess_.reset(NULL);
   NaClXMutexUnlock(&subprocess_mu_);
   return true;
 }
 
@@ skipping 37 matching lines @@
   AbortSubprocesses();
   if (translate_thread_ != NULL)
     NaClThreadJoin(translate_thread_.get());
   PLUGIN_PRINTF(("~PnaclTranslateThread joined\n"));
   NaClCondVarDtor(&buffer_cond_);
   NaClMutexDtor(&cond_mu_);
   NaClMutexDtor(&subprocess_mu_);
 }
 
 } // namespace plugin