[UMA] Add performance profile data to UMA uploads.

chrome/browser/metrics/metrics_service.h

 // 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.
 
 // This file defines a service that collects information about the user
 // experience in order to help improve future versions of the app.
 
 #ifndef CHROME_BROWSER_METRICS_METRICS_SERVICE_H_
 #define CHROME_BROWSER_METRICS_METRICS_SERVICE_H_
 #pragma once
 
 #include <map>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/gtest_prod_util.h"
-#include "base/memory/weak_ptr.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process_util.h"
+#include "chrome/browser/metrics/tracking_synchronizer_observer.h"
 #include "chrome/common/metrics/metrics_service_base.h"
-#include "content/public/common/process_type.h"
-#include "content/public/common/url_fetcher_delegate.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
+#include "content/public/common/url_fetcher_delegate.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/external_metrics.h"
 #endif
 
 class BookmarkModel;
 class BookmarkNode;
+class MetricsLog;
 class MetricsReportingScheduler;
 class PrefService;
 class Profile;
 class TemplateURLService;
 
 namespace base {
 class DictionaryValue;
 class MessageLoopProxy;
 }
 
 namespace content {
 class RenderProcessHost;
 }
 
 namespace extensions {
 class ExtensionDownloader;
 }
 
 namespace prerender {
 bool IsOmniboxEnabled(Profile* profile);
 }
 
+namespace tracked_objects {
+struct ProcessDataSnapshot;
+}
+
 namespace webkit {
 struct WebPluginInfo;
 }
 
-
-class MetricsService : public content::NotificationObserver,
-                       public content::URLFetcherDelegate,
-                       public MetricsServiceBase {
+class MetricsService
+    : public chrome_browser_metrics::TrackingSynchronizerObserver,
+      public content::NotificationObserver,
+      public content::URLFetcherDelegate,
+      public MetricsServiceBase {
  public:
   MetricsService();
   virtual ~MetricsService();
 
   // Start/stop the metrics recording and uploading machine.  These should be
   // used on startup and when the user clicks the checkbox in the prefs.
   // StartRecordingOnly starts the metrics recording but not reporting, for use
   // in tests only.
   void Start();
   void StartRecordingOnly();
@@ skipping 80 matching lines @@
 
   // First part of the init task. Called on the FILE thread to load hardware
   // class information.
   static void InitTaskGetHardwareClass(base::WeakPtr<MetricsService> self,
                                        base::MessageLoopProxy* target_loop);
 
   // Callback from InitTaskGetHardwareClass() that continues the init task by
   // loading plugin information.
   void OnInitTaskGotHardwareClass(const std::string& hardware_class);
 
-  // Callback from PluginService::GetPlugins() that moves the state to
-  // INIT_TASK_DONE.
+  // Callback from PluginService::GetPlugins() that continues the init task by
+  // loading profiler data.
   void OnInitTaskGotPluginInfo(
       const std::vector<webkit::WebPluginInfo>& plugins);
 
+  // TrackingSynchronizerObserver:
+  virtual void ReceivedProfilerData(
+      const tracked_objects::ProcessDataSnapshot& process_data,
+      content::ProcessType process_type) OVERRIDE;
+  // Callback that moves the state to INIT_TASK_DONE.
+  virtual void FinishedReceivingProfilerData() OVERRIDE;
+
   // When we start a new version of Chromium (different from our last run), we
   // need to discard the old crash stats so that we don't attribute crashes etc.
   // in the old version to the current version (via current logs).
   // Without this, a common reason to finally start a new version is to crash
   // the old version (after an autoupdate has arrived), and so we'd bias
   // initial results towards showing crashes :-(.
   static void DiscardOldStabilityStats(PrefService* local_state);
 
   // Sets and gets whether metrics recording is active.
   // SetRecording(false) also forces a persistent save of logging state (if
@@ skipping 161 matching lines @@
 
   // Chrome OS hardware class (e.g., hardware qualification ID). This
   // class identifies the configured system components such as CPU,
   // WiFi adapter, etc.  For non Chrome OS hosts, this will be an
   // empty string.
   std::string hardware_class_;
 
   // The list of plugins which was retrieved on the file thread.
   std::vector<webkit::WebPluginInfo> plugins_;
 
+  // The initial log, used to record startup metrics.
+  scoped_ptr<MetricsLog> initial_log_;
+
   // The outstanding transmission appears as a URL Fetch operation.
   scoped_ptr<content::URLFetcher> current_fetch_xml_;
   scoped_ptr<content::URLFetcher> current_fetch_proto_;
 
   // Cached responses from the XML request while we wait for a response to the
   // protubuf request.
   int response_code_;
   std::string response_status_;
   std::string response_data_;
 
@@ skipping 72 matching lines @@
   friend bool prerender::IsOmniboxEnabled(Profile* profile);
   friend class extensions::ExtensionDownloader;
 
   // Returns true if prefs::kMetricsReportingEnabled is set.
   static bool IsMetricsReportingEnabled();
 
   DISALLOW_IMPLICIT_CONSTRUCTORS(MetricsServiceHelper);
 };
 
 #endif  // CHROME_BROWSER_METRICS_METRICS_SERVICE_H_