[UMA] Add performance profile data to UMA uploads.

chrome/browser/metrics/metrics_service.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.
 
 //------------------------------------------------------------------------------
 // Description of the life cycle of a instance of MetricsService.
 //
 //  OVERVIEW
 //
 // A MetricsService instance is typically created at application startup.  It
@@ skipping 134 matching lines @@
 #include "chrome/browser/metrics/metrics_service.h"
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/md5.h"
 #include "base/metrics/histogram.h"
 #include "base/string_number_conversions.h"
 #include "base/threading/platform_thread.h"
 #include "base/threading/thread.h"
+#include "base/tracked_objects.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/bookmarks/bookmark_model.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/process_map.h"
 #include "chrome/browser/memory_details.h"
 #include "chrome/browser/metrics/histogram_synchronizer.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/metrics/metrics_log_serializer.h"
 #include "chrome/browser/metrics/metrics_reporting_scheduler.h"
+#include "chrome/browser/metrics/tracking_synchronizer.h"
 #include "chrome/browser/net/http_pipelining_compatibility_client.h"
 #include "chrome/browser/net/network_stats.h"
 #include "chrome/browser/prefs/pref_service.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/search_engines/template_url_service.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/common/child_process_logging.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/chrome_switches.h"
@@ skipping 590 matching lines @@
       "hardware_class", &hardware_class);
 #endif  // OS_CHROMEOS
 
   target_loop->PostTask(FROM_HERE,
       base::Bind(&MetricsService::OnInitTaskGotHardwareClass,
           self, hardware_class));
 }
 
 void MetricsService::OnInitTaskGotHardwareClass(
     const std::string& hardware_class) {
-  DCHECK_EQ(state_, INIT_TASK_SCHEDULED);
+  DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
   hardware_class_ = hardware_class;
 
   // Start the next part of the init task: loading plugin information.
   PluginService::GetInstance()->GetPlugins(
       base::Bind(&MetricsService::OnInitTaskGotPluginInfo,
           self_ptr_factory_.GetWeakPtr()));
 }
 
 void MetricsService::OnInitTaskGotPluginInfo(
     const std::vector<webkit::WebPluginInfo>& plugins) {
-  DCHECK_EQ(state_, INIT_TASK_SCHEDULED);
+  DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
   plugins_ = plugins;
 
+  // Start the next part of the init task: fetching performance data.  This will
+  // call into |FinishedReceivingProfilerData()| when the task completes.
+  chrome_browser_metrics::TrackingSynchronizer::FetchProfilerDataAsynchronously(
+      self_ptr_factory_.GetWeakPtr());
+}
+
+void MetricsService::ReceivedProfilerData(
+    const tracked_objects::ProcessDataSnapshot& process_data,
+    content::ProcessType process_type) {
+  DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
+
+  // Upon the first callback, create the initial log so that we can immediately
+  // save the profiler data.
+  if (!initial_log_.get())
+    initial_log_.reset(new MetricsLog(client_id_, session_id_));
+
+  initial_log_->RecordProfilerData(process_data, process_type);
+}
+
+void MetricsService::FinishedReceivingProfilerData() {
+  DCHECK_EQ(INIT_TASK_SCHEDULED, state_);
+
+  // TODO(isherman): I'm not following why the IO thread needs to be stored to a
+  // member variable at the end of the init task.  Reviewers, do you know?

[Ilya Sherman, 2012/04/18 01:18:44]

(?)

[jar (doing other things), 2012/04/18 03:18:45]

This seems a bit wrongish.  I think we generally try to use g_brows_process so
that we get to see if the thread still exists.  I would have expected this to
allow us to cache the value.... and then mess up later.

I would expect that we should instead use the value when we need it (testing to
see if it is still available).

[Ilya Sherman, 2012/04/18 21:46:15]

Ok, split this off to https://chromiumcodereview.appspot.com/10117034/

   io_thread_ = g_browser_process->io_thread();
-  if (state_ == INIT_TASK_SCHEDULED)
-    state_ = INIT_TASK_DONE;
+  state_ = INIT_TASK_DONE;
 }
 
 std::string MetricsService::GenerateClientID() {
   return guid::GenerateGUID();
 }
 
 //------------------------------------------------------------------------------
 // State save methods
 
 void MetricsService::ScheduleNextStateSave() {
@@ skipping 205 matching lines @@
     case INITIALIZED:
     case INIT_TASK_SCHEDULED:  // We should be further along by now.
       DCHECK(false);
       return;
 
     case INIT_TASK_DONE:
       // We need to wait for the initial log to be ready before sending
       // anything, because the server will tell us whether it wants to hear
       // from us.
       PrepareInitialLog();
-      DCHECK(state_ == INIT_TASK_DONE);
+      DCHECK_EQ(INIT_TASK_DONE, state_);
       log_manager_.LoadPersistedUnsentLogs();
       state_ = INITIAL_LOG_READY;
       break;
 
     case SENDING_OLD_LOGS:
       if (log_manager_.has_unsent_logs()) {
         log_manager_.StageNextLogForUpload();
         break;
       }
       state_ = SENDING_CURRENT_LOGS;
       // Fall through.
 
     case SENDING_CURRENT_LOGS:
       StopRecording();
       StartRecording();
       log_manager_.StageNextLogForUpload();
       break;
 
     default:
       NOTREACHED();
       return;
   }
 
   DCHECK(log_manager_.has_staged_log());
 }
 
 void MetricsService::PrepareInitialLog() {
-  DCHECK(state_ == INIT_TASK_DONE);
+  DCHECK_EQ(INIT_TASK_DONE, state_);
 
-  MetricsLog* log = new MetricsLog(client_id_, session_id_);
-  log->set_hardware_class(hardware_class_);  // Adds to initial log.
-  log->RecordEnvironment(plugins_, profile_dictionary_.get());
+  DCHECK(initial_log_.get());
+  initial_log_->set_hardware_class(hardware_class_);
+  initial_log_->RecordEnvironment(plugins_, profile_dictionary_.get());
 
   // Histograms only get written to the current log, so make the new log current
   // before writing them.
   log_manager_.PauseCurrentLog();
-  log_manager_.BeginLoggingWithLog(log, MetricsLogManager::INITIAL_LOG);
+  log_manager_.BeginLoggingWithLog(initial_log_.release(),
+                                   MetricsLogManager::INITIAL_LOG);
   RecordCurrentHistograms();
   log_manager_.FinishCurrentLog();
   log_manager_.ResumePausedLog();
 
   DCHECK(!log_manager_.has_staged_log());
   log_manager_.StageNextLogForUpload();
 }
 
 void MetricsService::StoreUnsentLogs() {
   if (state_ < INITIAL_LOG_READY)
@@ skipping 184 matching lines @@
         break;
 
       default:
         NOTREACHED();
         break;
     }
 
     log_manager_.DiscardStagedLog();
 
     if (log_manager_.has_unsent_logs())
-      DCHECK(state_ < SENDING_CURRENT_LOGS);
+      DCHECK_LT(state_, SENDING_CURRENT_LOGS);
   }
 
   // Error 400 indicates a problem with the log, not with the server, so
   // don't consider that a sign that the server is in trouble.
   bool server_is_healthy = upload_succeeded || response_code_ == 400;
 
   scheduler_->UploadFinished(server_is_healthy,
                              log_manager_.has_unsent_logs());
 
   // Collect network stats if UMA upload succeeded.
@@ skipping 399 matching lines @@
   if (local_state) {
     const PrefService::Preference* uma_pref =
         local_state->FindPreference(prefs::kMetricsReportingEnabled);
     if (uma_pref) {
       bool success = uma_pref->GetValue()->GetAsBoolean(&result);
       DCHECK(success);
     }
   }
   return result;
 }