Add function to CancelableTaskTracker and convert BootTimeLoader (take 2)

chrome/browser/chromeos/boot_times_loader.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.
 
 #ifndef CHROME_BROWSER_CHROMEOS_BOOT_TIMES_LOADER_H_
 #define CHROME_BROWSER_CHROMEOS_BOOT_TIMES_LOADER_H_
 
 #include <set>
 #include <string>
 
 #include "base/atomic_sequence_num.h"
 #include "base/callback_forward.h"
 #include "base/compiler_specific.h"
 #include "base/time.h"
-#include "chrome/browser/common/cancelable_request.h"
+#include "chrome/common/cancelable_task_tracker.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/browser/notification_registrar.h"
 #include "content/public/browser/render_widget_host.h"
 
 namespace chromeos {
 
 // BootTimesLoader loads the bootimes of Chrome OS from the file system.
 // Loading is done asynchronously on the file thread. Once loaded,
 // BootTimesLoader calls back to a method of your choice with the boot times.
-// To use BootTimesLoader do the following:
+// To use BootTimesLoader, do the following:
 //
 // . In your class define a member field of type chromeos::BootTimesLoader and
-//   CancelableRequestConsumerBase.
+//   CancelableTaskTracker.
 // . Define the callback method, something like:
-//   void OnBootTimesLoader(chromeos::BootTimesLoader::Handle,
-//                             BootTimesLoader::BootTimes boot_times);
-// . When you want the version invoke: loader.GetBootTimes(&consumer, callback);
-class BootTimesLoader
-    : public CancelableRequestProvider,
-      public content::NotificationObserver {
+//   void OnBootTimesLoaded(const BootTimesLoader::BootTimes& boot_times);
+// . When you want the version invoke: loader.GetBootTimes(callback, &tracker_);
+class BootTimesLoader : public content::NotificationObserver {
  public:
   BootTimesLoader();
   virtual ~BootTimesLoader();
 
   // All fields are 0.0 if they couldn't be found.
   typedef struct BootTimes {
     double firmware;           // Time from power button to kernel being loaded.
     double pre_startup;        // Time from kernel to system code being called.
     double x_started;          // Time X server is ready to be connected to.
     double chrome_exec;        // Time session manager executed Chrome.
     double chrome_main;        // Time chrome's main() was called.
     double login_prompt_ready; // Time login (or OOB) panel is displayed.
     double system;             // Time system took to start chrome.
     double chrome;             // Time chrome took to display login panel.
     double total;              // Time from power button to login panel.
 
     BootTimes() : firmware(0),
                   pre_startup(0),
                   x_started(0),
                   chrome_exec(0),
                   chrome_main(0),
                   login_prompt_ready(0),
                   system(0),
                   chrome(0),
                   total(0) {}
   } BootTimes;
 
-  // Signature
-  typedef base::Callback<void(Handle, BootTimes)> GetBootTimesCallback;
-
-  typedef CancelableRequest<GetBootTimesCallback> GetBootTimesRequest;
-
   static BootTimesLoader* Get();
 
+  typedef base::Callback<void(const BootTimes&)> GetBootTimesCallback;
+
   // Asynchronously requests the info.
-  Handle GetBootTimes(
-      CancelableRequestConsumerBase* consumer,
-      const GetBootTimesCallback& callback);
+  CancelableTaskTracker::TaskId GetBootTimes(
+      const GetBootTimesCallback& callback,
+      CancelableTaskTracker* tracker);
 
   // Add a time marker for login. A timeline will be dumped to
   // /tmp/login-times-sent after login is done. If |send_to_uma| is true
   // the time between this marker and the last will be sent to UMA with
   // the identifier BootTime.|marker_name|.
   void AddLoginTimeMarker(const std::string& marker_name, bool send_to_uma);
 
   // Add a time marker for logout. A timeline will be dumped to
   // /tmp/logout-times-sent after logout is done. If |send_to_uma| is true
   // the time between this marker and the last will be sent to UMA with
@@ skipping 28 matching lines @@
   // rely on notification service to tell when the logout is done.
   void WriteLogoutTimes();
 
  private:
   // BootTimesLoader calls into the Backend on the file thread to load
   // the boot times.
   class Backend : public base::RefCountedThreadSafe<Backend> {
    public:
     Backend() {}
 
-    void GetBootTimes(const scoped_refptr<GetBootTimesRequest>& request);
+    void GetBootTimesAndRunCallback(
+        const CancelableTaskTracker::IsCanceledCallback& is_canceled_cb,
+        const GetBootTimesCallback& callback);
 
    private:
     friend class base::RefCountedThreadSafe<Backend>;
 
     ~Backend() {}
 
     DISALLOW_COPY_AND_ASSIGN(Backend);
   };
 
   class TimeMarker {
@@ skipping 47 matching lines @@
   std::vector<TimeMarker> login_time_markers_;
   std::vector<TimeMarker> logout_time_markers_;
   std::set<content::RenderWidgetHost*> render_widget_hosts_loading_;
 
   DISALLOW_COPY_AND_ASSIGN(BootTimesLoader);
 };
 
 }  // namespace chromeos
 
 #endif  // CHROME_BROWSER_CHROMEOS_BOOT_TIMES_LOADER_H_