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
@@ skipping 21 matching lines @@
 class BookmarkNode;
 class MetricsLog;
 class MetricsReportingScheduler;
 class PrefService;
 class Profile;
 class TemplateURLService;
 
 namespace base {
 class DictionaryValue;
 class MessageLoopProxy;
+class Time;
 }
 
 namespace content {
 class RenderProcessHost;
 }
 
 namespace extensions {
 class ExtensionDownloader;
 }
 
@@ skipping 98 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);
+  // Callback for the StatisticsProvider to signal that hardware data has been
+  // loaded. Retrieves the hardware class and stores it in hardware_class_.
+  // |start_time| is a timestamp of when the initialization was first requested.
+  void OnStatisticsProviderReady(const base::Time& start_time);
+
+  // Handles a timeout while waiting for the StatisticsProvider to become ready
+  // during initialization.
+  void OnStatisticsProviderTimeout();
+
+  // Second init task, that starts retrieving plugin info.
+  void InitTaskGetPluginInfo();
 
   // 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;
@@ skipping 227 matching lines @@
   std::map<string16, ChildProcessStats> child_process_stats_buffer_;
 
   // Weak pointers factory used to post task on different threads. All weak
   // pointers managed by this factory have the same lifetime as MetricsService.
   base::WeakPtrFactory<MetricsService> self_ptr_factory_;
 
   // Weak pointers factory used for saving state. All weak pointers managed by
   // this factory are invalidated in ScheduleNextStateSave.
   base::WeakPtrFactory<MetricsService> state_saver_factory_;
 
+  // Weak pointers factory used to post and invalidate the timeout task.
+  base::WeakPtrFactory<MetricsService> timeout_task_factory_;

[Ilya Sherman, 2012/04/30 07:36:41]

nit: Why not just use self_ptr_factory_ here?

[Joao da Silva, 2012/05/15 13:52:47]

Because self_ptr_factory_ is used to post other tasks as well, and they
shouldn't be invalidated when we only want to invalidate the timeout.

This has been redone due to the new Observer interface at the
StatisticsProvider. I've found it clearer to use CancelableCallbacks now.

+
   // Dictionary containing all the profile specific metrics. This is set
   // at creation time from the prefs.
   scoped_ptr<base::DictionaryValue> profile_dictionary_;
 
   // 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_;
@@ skipping 22 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_