Merge 49197 - Submitting CL http://codereview.chromium.org/2324001 on behalf ...

chrome/browser/metrics/metrics_service.h

 // Copyright (c) 2010 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_
 
@@ skipping 98 matching lines @@
   void RecordCompletedSessionEnd();
 
   // Saves in the preferences if the crash report registration was successful.
   // This count is eventually send via UMA logs.
   void RecordBreakpadRegistration(bool success);
 
   // Saves in the preferences if the browser is running under a debugger.
   // This count is eventually send via UMA logs.
   void RecordBreakpadHasDebugger(bool has_debugger);
 
-  // Callback to let us knew that the plugin list is warmed up.
-  void OnGetPluginListTaskComplete(const std::vector<WebPluginInfo>& plugins);
-
   // Save any unsent logs into a persistent store in a pref.  We always do this
   // at shutdown, but we can do it as we reduce the list as well.
   void StoreUnsentLogs();
 
 #if defined(OS_CHROMEOS)
+  // Returns the hardware class of the Chrome OS device (e.g.,
+  // hardware qualification ID), or "unknown" if the hardware class is
+  // not available.  The hardware class identifies the configured
+  // system components such us CPU, WiFi adapter, etc.  Note that this
+  // routine invokes an external utility to determine the hardware
+  // class.
+  static std::string GetHardwareClass();
+
   // Start the external metrics service, which collects metrics from Chrome OS
   // and passes them to UMA.
   void StartExternalMetrics();
 #endif
 
   bool recording_active() const;
   bool reporting_active() const;
 
  private:
   // The MetricsService has a lifecycle that is stored as a state.
   // See metrics_service.cc for description of this lifecycle.
   enum State {
     INITIALIZED,            // Constructor was called.
-    PLUGIN_LIST_REQUESTED,  // Waiting for plugin list to be loaded.
-    PLUGIN_LIST_ARRIVED,    // Waiting for timer to send initial log.
+    INIT_TASK_SCHEDULED,    // Waiting for deferred init tasks to complete.
+    INIT_TASK_DONE,         // Waiting for timer to send initial log.
     INITIAL_LOG_READY,      // Initial log generated, and waiting for reply.
     SEND_OLD_INITIAL_LOGS,  // Sending unsent logs from previous session.
     SENDING_OLD_LOGS,       // Sending unsent logs from previous session.
     SENDING_CURRENT_LOGS,   // Sending standard current logs as they acrue.
   };
 
   // Maintain a map of histogram names to the sample stats we've sent.
   typedef std::map<std::string, Histogram::SampleSet> LoggedSampleMap;
 
-  class GetPluginListTask;
-  class GetPluginListTaskComplete;
+  class InitTask;
+  class InitTaskComplete;
+
+  // Callback to let us know that the init task is done.
+  void OnInitTaskComplete(
+      const std::string& hardware_class,
+      const std::vector<WebPluginInfo>& plugins);
 
   // 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.
@@ skipping 252 matching lines @@
   // The variable server_permits_upload_ is set true when the response
   // data forbids uploading.  This should coinside with the "die roll"
   // with probability in the upload tag of the response data came out
   // affirmative.
   bool server_permits_upload_;
 
   // The progession of states made by the browser are recorded in the following
   // state.
   State state_;
 
+  // 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<WebPluginInfo> plugins_;
 
   // A log that we are currently transmiting, or about to try to transmit.
   MetricsLog* pending_log_;
 
   // An alternate form of pending_log_.  We persistently save this text version
   // into prefs if we can't transmit it.  As a result, sometimes all we have is
   // the text version (recalled from a previous session).
   std::string pending_log_text_;
@@ skipping 75 matching lines @@
   scoped_refptr<chromeos::ExternalMetrics> external_metrics_;
 #endif
 
   FRIEND_TEST(MetricsServiceTest, ClientIdGeneratesAllZeroes);
   FRIEND_TEST(MetricsServiceTest, ClientIdGeneratesCorrectly);
   FRIEND_TEST(MetricsServiceTest, ClientIdCorrectlyFormatted);
   DISALLOW_COPY_AND_ASSIGN(MetricsService);
 };
 
 #endif  // CHROME_BROWSER_METRICS_METRICS_SERVICE_H_