Added asynchronous notification of readiness to the StatisticsProvider, and

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/cancelable_callback.h"
 #include "base/gtest_prod_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
 #include "base/process_util.h"
 #include "chrome/browser/metrics/metrics_log.h"
 #include "chrome/browser/metrics/tracking_synchronizer_observer.h"
 #include "chrome/common/metrics/metrics_service_base.h"
 #include "chrome/installer/util/google_update_settings.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"
+#include "chrome/browser/chromeos/system/statistics_provider.h"
 #endif
 
 class BookmarkModel;
 class BookmarkNode;
 class MetricsReportingScheduler;
 class PrefService;
 class Profile;
 class TemplateURLService;
 
 namespace base {
@@ skipping 18 matching lines @@
 }
 
 namespace webkit {
 struct WebPluginInfo;
 }
 
 class MetricsService
     : public chrome_browser_metrics::TrackingSynchronizerObserver,
       public content::NotificationObserver,
       public content::URLFetcherDelegate,
+#if defined(OS_CHROMEOS)
+      public chromeos::system::StatisticsProvider::Observer,
+#endif
       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();
@@ skipping 72 matching lines @@
     INITIAL_LOG_READY,      // Initial log generated, and waiting for reply.
     SENDING_OLD_LOGS,       // Sending unsent logs from previous session.
     SENDING_CURRENT_LOGS,   // Sending standard current logs as they acrue.
   };
 
   enum ShutdownCleanliness {
     CLEANLY_SHUTDOWN = 0xdeadbeef,
     NEED_TO_SHUTDOWN = ~CLEANLY_SHUTDOWN
   };
 
-  // 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);
+  // First init task, that starts retrieving the hardware class. It proceeds
+  // to InitTaskGetPluginInfo after reading the hardware_class, or after
+  // timing out waiting for it.
+  void InitTaskGetHardwareClass();
 
-  // Callback from InitTaskGetHardwareClass() that continues the init task by
-  // loading plugin information.
-  void OnInitTaskGotHardwareClass(const std::string& hardware_class);
+#if defined(OS_CHROMEOS)
+  // chromeos::system::StatisticsProvider::Observer implementation:
+  virtual void OnMachineStatisticsReady() OVERRIDE;
+
+  // Handles a timeout while waiting for the StatisticsProvider to become ready
+  // during initialization.
+  void OnStatisticsProviderTimeout();
+#endif
+
+  // Second init task, that starts retrieving plugin info.
+  void InitTaskGetPluginInfo();
 
   // Callback from PluginService::GetPlugins() that continues the init task by
   // launching a task to gather Google Update statistics.
   void OnInitTaskGotPluginInfo(
       const std::vector<webkit::WebPluginInfo>& plugins);
 
   // Task launched by OnInitTaskGotPluginInfo() that continues the init task by
   // loading Google Update statistics.  Called on a blocking pool thread.
   static void InitTaskGetGoogleUpdateData(base::WeakPtr<MetricsService> self,
                                           base::MessageLoopProxy* target_loop);
@@ skipping 254 matching lines @@
   // The scheduler for determining when uploads should happen.
   scoped_ptr<MetricsReportingScheduler> scheduler_;
 
   // Indicates that an asynchronous reporting step is running.
   // This is used only for debugging.
   bool waiting_for_asynchronus_reporting_step_;
 
 #if defined(OS_CHROMEOS)
   // The external metric service is used to log ChromeOS UMA events.
   scoped_refptr<chromeos::ExternalMetrics> external_metrics_;
+
+  // Used to resume initialization of the MetricsService when the
+  // StatisticsProvider becomes ready, or after timing out while waiting for it.
+  base::CancelableClosure on_timeout_callback_;
+  base::CancelableClosure on_ready_callback_;
 #endif
 
   // Reduntant marker to check that we completed our shutdown, and set the
   // exited-cleanly bit in the prefs.
   static ShutdownCleanliness clean_shutdown_status_;
 
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, ClientIdCorrectlyFormatted);
   FRIEND_TEST_ALL_PREFIXES(MetricsServiceTest, IsPluginProcess);
 
   DISALLOW_COPY_AND_ASSIGN(MetricsService);
 };
 
 // This class limits and documents access to the IsMetricsReportingEnabled()
 // method. Since the method is private, each user has to be explicitly declared
 // as a 'friend' below.
 class MetricsServiceHelper {
  private:
   friend class InstantFieldTrial;
   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_