Add function to CancelableTaskTracker and convert BootTimeLoader (take 2)

chrome/browser/chromeos/boot_times_loader.cc

 // 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.
 
 #include "chrome/browser/chromeos/boot_times_loader.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/lazy_instance.h"
+#include "base/location.h"
 #include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
 #include "base/metrics/histogram.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/threading/thread.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/time.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chromeos/login/authentication_notification_details.h"
@@ skipping 35 matching lines @@
     Browser* browser = *it;
     for (int i = 0, tab_count = browser->tab_count(); i < tab_count; ++i) {
       WebContents* tab = chrome::GetWebContentsAt(browser, i);
       if (tab->GetRenderWidgetHostView() == rwhv) {
         return tab->GetURL().spec();
       }
     }
   }
   return std::string();
 }
+
+void PostCallbackIfNotCanceled(
+    const CancelableTaskTracker::IsCanceledCallback& is_canceled_cb,
+    base::TaskRunner* task_runner,
+    const chromeos::BootTimesLoader::GetBootTimesCallback& callback,
+    const chromeos::BootTimesLoader::BootTimes& boot_times) {
+  if (is_canceled_cb.Run())
+    return;
+  task_runner->PostTask(FROM_HERE, base::Bind(callback, boot_times));
 }
 
+}  // namespace
+
 namespace chromeos {
 
 #define FPL(value) FILE_PATH_LITERAL(value)
 
 // Dir uptime & disk logs are located in.
 static const FilePath::CharType kLogPath[] = FPL("/tmp");
 // Dir log{in,out} logs are located in.
 static const FilePath::CharType kLoginLogPath[] = FPL("/home/chronos/user");
 // Prefix for the time measurement files.
 static const FilePath::CharType kUptimePrefix[] = FPL("uptime-");
@@ skipping 33 matching lines @@
   logout_time_markers_.reserve(30);
 }
 
 BootTimesLoader::~BootTimesLoader() {}
 
 // static
 BootTimesLoader* BootTimesLoader::Get() {
   return g_boot_times_loader.Pointer();
 }
 
-BootTimesLoader::Handle BootTimesLoader::GetBootTimes(
-    CancelableRequestConsumerBase* consumer,
-    const GetBootTimesCallback& callback) {
+CancelableTaskTracker::TaskId BootTimesLoader::GetBootTimes(
+      const GetBootTimesCallback& callback,
+      CancelableTaskTracker* tracker) {
   if (!BrowserThread::IsMessageLoopValid(BrowserThread::FILE)) {
     // This should only happen if Chrome is shutting down, so we don't do
     // anything.
-    return 0;
+    return CancelableTaskTracker::kBadTaskId;
   }
 
   const CommandLine& command_line = *CommandLine::ForCurrentProcess();
   if (command_line.HasSwitch(switches::kTestType)) {
     // TODO(davemoore) This avoids boottimes for tests. This needs to be
     // replaced with a mock of BootTimesLoader.
-    return 0;
+    return CancelableTaskTracker::kBadTaskId;
   }
 
-  scoped_refptr<CancelableRequest<GetBootTimesCallback> > request(
-      new CancelableRequest<GetBootTimesCallback>(callback));
-  AddRequest(request, consumer);
+  CancelableTaskTracker::IsCanceledCallback is_canceled;
+  CancelableTaskTracker::TaskId id = tracker->NewTrackedTaskId(&is_canceled);
 
+  GetBootTimesCallback callback_runner =
+      base::Bind(&PostCallbackIfNotCanceled,
+                 is_canceled, base::MessageLoopProxy::current(), callback);
   BrowserThread::PostTask(
       BrowserThread::FILE,
       FROM_HERE,
-      base::Bind(&Backend::GetBootTimes, backend_, request));
-  return request->handle();
+      base::Bind(&Backend::GetBootTimesAndRunCallback,
+                 backend_, is_canceled, callback_runner));
+  return id;
 }
 
 // Extracts the uptime value from files located in /tmp, returning the
 // value as a double in value.
 static bool GetTime(const FilePath::StringType& log, double* value) {
   FilePath log_dir(kLogPath);
   FilePath log_file = log_dir.Append(log);
   std::string contents;
   *value = 0.0;
   if (file_util::ReadFileToString(log_file, &contents)) {
@@ skipping 47 matching lines @@
                                                    "chrome: %.2f\n",
                                                    boot_times.total,
                                                    boot_times.firmware,
                                                    boot_times.pre_startup,
                                                    boot_times.system,
                                                    boot_times.chrome);
   file_util::WriteFile(sent, boot_times_text.data(), boot_times_text.size());
   DCHECK(file_util::PathExists(sent));
 }
 
-void BootTimesLoader::Backend::GetBootTimes(
-    const scoped_refptr<GetBootTimesRequest>& request) {
+void BootTimesLoader::Backend::GetBootTimesAndRunCallback(
+    const CancelableTaskTracker::IsCanceledCallback& is_canceled_cb,
+    const GetBootTimesCallback& callback) {
+  if (is_canceled_cb.Run())
+    return;
+
   const FilePath::CharType kFirmwareBootTime[] = FPL("firmware-boot-time");
   const FilePath::CharType kPreStartup[] = FPL("pre-startup");
   const FilePath::CharType kChromeExec[] = FPL("chrome-exec");
   const FilePath::CharType kChromeMain[] = FPL("chrome-main");
   const FilePath::CharType kXStarted[] = FPL("x-started");
   const FilePath::CharType kLoginPromptReady[] = FPL("login-prompt-ready");
   const FilePath::StringType uptime_prefix = kUptimePrefix;
 
-  if (request->canceled())
-    return;
-
   // Wait until firmware-boot-time file exists by reposting.
   FilePath log_dir(kLogPath);
   FilePath log_file = log_dir.Append(kFirmwareBootTime);
   if (!file_util::PathExists(log_file)) {
     BrowserThread::PostDelayedTask(
         BrowserThread::FILE,
         FROM_HERE,
-        base::Bind(&Backend::GetBootTimes, this, request),
+        base::Bind(&Backend::GetBootTimesAndRunCallback,
+                   this, is_canceled_cb, callback),
         base::TimeDelta::FromMilliseconds(kReadAttemptDelayMs));
     return;
   }
 
   BootTimes boot_times;
 
   GetTime(kFirmwareBootTime, &boot_times.firmware);
   GetTime(uptime_prefix + kPreStartup, &boot_times.pre_startup);
   GetTime(uptime_prefix + kXStarted, &boot_times.x_started);
   GetTime(uptime_prefix + kChromeExec, &boot_times.chrome_exec);
   GetTime(uptime_prefix + kChromeMain, &boot_times.chrome_main);
   GetTime(uptime_prefix + kLoginPromptReady, &boot_times.login_prompt_ready);
 
   boot_times.total = boot_times.firmware + boot_times.login_prompt_ready;
   if (boot_times.chrome_exec > 0) {
     boot_times.system = boot_times.chrome_exec - boot_times.pre_startup;
     boot_times.chrome = boot_times.login_prompt_ready - boot_times.chrome_exec;
   } else {
     boot_times.system = boot_times.login_prompt_ready - boot_times.pre_startup;
   }
 
   SendBootTimesToUMA(boot_times);
 
-  request->ForwardResult(request->handle(), boot_times);
+  callback.Run(boot_times);
 }
 
 // Appends the given buffer into the file. Returns the number of bytes
 // written, or -1 on error.
 // TODO(satorux): Move this to file_util.
 static int AppendFile(const FilePath& file_path,
                       const char* data,
                       int size) {
   FILE* file = file_util::OpenFile(file_path, "a");
   if (!file) {
@@ skipping 243 matching lines @@
           GetRenderWidgetHost(&web_contents->GetController());
       render_widget_hosts_loading_.erase(render_widget_host);
       break;
     }
     default:
       break;
   }
 }
 
 }  // namespace chromeos