Convert some chromeos related code to not depend on cancelable_request.

This is the second try of http://codereview.chromium.org/11359173/

BUG=155883
TBR=jhawkins@chromium.org

Review URL: https://codereview.chromium.org/11358246

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@167780 0039d316-1c4b-4281-b951-d872f2087c98

14 files changed, 109 insertions, 143 deletions

diff --git a/chrome/browser/chrome_browser_main_linux.cc b/chrome/browser/chrome_browser_main_linux.cc
index e764919..fc4cb9e 100644
--- a/chrome/browser/chrome_browser_main_linux.cc
+++ b/chrome/browser/chrome_browser_main_linux.cc
@@ -34,9 +34,8 @@ namespace {
 
 #if defined(USE_LINUX_BREAKPAD)
 #if defined(OS_CHROMEOS)
-void ChromeOSVersionCallback(chromeos::VersionLoader::Handle,
-                             const std::string& version) {
-  base::SetLinuxDistro(std::string("CrOS ") + version);
+void ChromeOSVersionCallback(const std::string* version) {
+  base::SetLinuxDistro(std::string("CrOS ") + *version);
 }
 #else
 void GetLinuxDistroCallback() {
@@ -93,9 +92,9 @@ ChromeBrowserMainPartsLinux::~ChromeBrowserMainPartsLinux() {
 void ChromeBrowserMainPartsLinux::PreProfileInit() {
 #if defined(USE_LINUX_BREAKPAD)
 #if defined(OS_CHROMEOS)
-  cros_version_loader_.GetVersion(&cros_consumer_,
+  cros_version_loader_.GetVersion(chromeos::VersionLoader::VERSION_FULL,
                                   base::Bind(&ChromeOSVersionCallback),
-                                  chromeos::VersionLoader::VERSION_FULL);
+                                  &tracker_);
 #else
   // Needs to be called after we have chrome::DIR_USER_DATA and
   // g_browser_process.  This happens in PreCreateThreads.
diff --git a/chrome/browser/chrome_browser_main_linux.h b/chrome/browser/chrome_browser_main_linux.h
index bcd99a6..7c8f042 100644
--- a/chrome/browser/chrome_browser_main_linux.h
+++ b/chrome/browser/chrome_browser_main_linux.h
@@ -10,7 +10,7 @@
 #include "base/compiler_specific.h"
 #include "base/memory/ref_counted.h"
 #include "chrome/browser/chrome_browser_main_posix.h"
-#include "chrome/browser/common/cancelable_request.h"
+#include "chrome/common/cancelable_task_tracker.h"
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/version_loader.h"
@@ -41,7 +41,7 @@ class ChromeBrowserMainPartsLinux : public ChromeBrowserMainPartsPosix {
 #if defined(OS_CHROMEOS)
   // TODO(stevenjb): Move these to ChromeBrowserMainChromeos.
   chromeos::VersionLoader cros_version_loader_;
-  CancelableRequestConsumer cros_consumer_;
+  CancelableTaskTracker tracker_;
 #else
   scoped_refptr<chrome::RemovableDeviceNotificationsLinux>
       removable_device_notifications_linux_;
diff --git a/chrome/browser/chromeos/login/version_info_updater.cc b/chrome/browser/chromeos/login/version_info_updater.cc
index 1dc0bb0..2c9ccc5 100644
--- a/chrome/browser/chromeos/login/version_info_updater.cc
+++ b/chrome/browser/chromeos/login/version_info_updater.cc
@@ -54,11 +54,10 @@ VersionInfoUpdater::~VersionInfoUpdater() {
 void VersionInfoUpdater::StartUpdate(bool is_official_build) {
   if (base::chromeos::IsRunningOnChromeOS()) {
     version_loader_.GetVersion(
-        &version_consumer_,
+        is_official_build ? VersionLoader::VERSION_SHORT_WITH_DATE
+                          : VersionLoader::VERSION_FULL,
         base::Bind(&VersionInfoUpdater::OnVersion, base::Unretained(this)),
-        is_official_build ?
-            VersionLoader::VERSION_SHORT_WITH_DATE :
-            VersionLoader::VERSION_FULL);
+        &tracker_);
     boot_times_loader_.GetBootTimes(
         &boot_times_consumer_,
         base::Bind(is_official_build ? &VersionInfoUpdater::OnBootTimesNoop :
@@ -190,8 +189,7 @@ void VersionInfoUpdater::SetEnterpriseInfo(const std::string& domain_name,
   }
 }
 
-void VersionInfoUpdater::OnVersion(
-    VersionLoader::Handle handle, const std::string& version) {
+void VersionInfoUpdater::OnVersion(const std::string& version) {
   version_text_ = version;
   UpdateVersionLabel();
 }
diff --git a/chrome/browser/chromeos/login/version_info_updater.h b/chrome/browser/chromeos/login/version_info_updater.h
index fa458c7..c02ff71 100644
--- a/chrome/browser/chromeos/login/version_info_updater.h
+++ b/chrome/browser/chromeos/login/version_info_updater.h
@@ -73,7 +73,7 @@ class VersionInfoUpdater : public policy::CloudPolicySubsystem::Observer,
                          bool reporting_hint);
 
   // Callback from chromeos::VersionLoader giving the version.
-  void OnVersion(VersionLoader::Handle handle, const std::string& version);
+  void OnVersion(const std::string& version);
   // Callback from chromeos::InfoLoader giving the boot times.
   void OnBootTimes(
       BootTimesLoader::Handle handle, BootTimesLoader::BootTimes boot_times);
@@ -84,7 +84,7 @@ class VersionInfoUpdater : public policy::CloudPolicySubsystem::Observer,
   // Handles asynchronously loading the version.
   VersionLoader version_loader_;
   // Used to request the version.
-  CancelableRequestConsumer version_consumer_;
+  CancelableTaskTracker tracker_;
 
   // Handles asynchronously loading the boot times.
   BootTimesLoader boot_times_loader_;
diff --git a/chrome/browser/chromeos/system/timezone_settings.h b/chrome/browser/chromeos/system/timezone_settings.h
index ad2b92d..8ef5cd8 100644
--- a/chrome/browser/chromeos/system/timezone_settings.h
+++ b/chrome/browser/chromeos/system/timezone_settings.h
@@ -8,14 +8,13 @@
 #include <vector>
 
 #include "base/string16.h"
-#include "chrome/browser/common/cancelable_request.h"
 #include "unicode/timezone.h"
 
 namespace chromeos {
 namespace system {
 
 // This interface provides access to Chrome OS timezone settings.
-class TimezoneSettings : public CancelableRequestProvider {
+class TimezoneSettings {
  public:
   class Observer {
    public:
diff --git a/chrome/browser/chromeos/version_loader.cc b/chrome/browser/chromeos/version_loader.cc
index 4f70e12..5258928 100644
--- a/chrome/browser/chromeos/version_loader.cc
+++ b/chrome/browser/chromeos/version_loader.cc
@@ -9,10 +9,12 @@
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
+#include "base/location.h"
 #include "base/message_loop.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
+#include "base/threading/sequenced_worker_pool.h"
 #include "base/threading/thread.h"
 #include "base/time.h"
 #include "chrome/browser/browser_process.h"
@@ -20,6 +22,17 @@
 
 using content::BrowserThread;
 
+namespace {
+
+// Converts const string* to const string&.
+void VersionLoaderCallbackHelper(
+    base::Callback<void(const std::string&)> callback,
+    const std::string* version) {
+  callback.Run(*version);
+}
+
+}  // namespace
+
 namespace chromeos {
 
 // File to look for version number in.
@@ -45,41 +58,28 @@ const char VersionLoader::kVersionPrefix[] = "CHROMEOS_RELEASE_VERSION=";
 // Beginning of line we look for that gives the firmware version.
 const char VersionLoader::kFirmwarePrefix[] = "version";
 
-VersionLoader::Handle VersionLoader::GetVersion(
-    CancelableRequestConsumerBase* consumer,
-    const VersionLoader::GetVersionCallback& callback,
-    VersionFormat format) {
-  if (!BrowserThread::IsMessageLoopValid(BrowserThread::FILE)) {
-    // This should only happen if Chrome is shutting down, so we don't do
-    // anything.
-    return 0;
-  }
-
-  scoped_refptr<GetVersionRequest> request(new GetVersionRequest(callback));
-  AddRequest(request, consumer);
-
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&Backend::GetVersion, backend_.get(), request, format));
-  return request->handle();
+CancelableTaskTracker::TaskId VersionLoader::GetVersion(
+    VersionFormat format,
+    const GetVersionCallback& callback,
+    CancelableTaskTracker* tracker) {
+  std::string* version = new std::string();
+  return tracker->PostTaskAndReply(
+      BrowserThread::GetBlockingPool(),
+      FROM_HERE,
+      base::Bind(&Backend::GetVersion, backend_.get(), format, version),
+      base::Bind(&VersionLoaderCallbackHelper, callback, base::Owned(version)));
 }
 
-VersionLoader::Handle VersionLoader::GetFirmware(
-    CancelableRequestConsumerBase* consumer,
-    const VersionLoader::GetFirmwareCallback& callback) {
-  if (!BrowserThread::IsMessageLoopValid(BrowserThread::FILE)) {
-    // This should only happen if Chrome is shutting down, so we don't do
-    // anything.
-    return 0;
-  }
-
-  scoped_refptr<GetFirmwareRequest> request(new GetFirmwareRequest(callback));
-  AddRequest(request, consumer);
-
-  BrowserThread::PostTask(
-      BrowserThread::FILE, FROM_HERE,
-      base::Bind(&Backend::GetFirmware, backend_.get(), request));
-  return request->handle();
+CancelableTaskTracker::TaskId VersionLoader::GetFirmware(
+    const GetFirmwareCallback& callback,
+    CancelableTaskTracker* tracker) {
+  std::string* firmware = new std::string();
+  return tracker->PostTaskAndReply(
+      BrowserThread::GetBlockingPool(),
+      FROM_HERE,
+      base::Bind(&Backend::GetFirmware, backend_.get(), firmware),
+      base::Bind(&VersionLoaderCallbackHelper,
+                 callback, base::Owned(firmware)));
 }
 
 // static
@@ -129,18 +129,14 @@ std::string VersionLoader::ParseFirmware(const std::string& contents) {
   return std::string();
 }
 
-void VersionLoader::Backend::GetVersion(
-    scoped_refptr<GetVersionRequest> request,
-    VersionFormat format) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  if (request->canceled())
-    return;
+void VersionLoader::Backend::GetVersion(VersionFormat format,
+                                        std::string* version) {
+  DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
-  std::string version;
   std::string contents;
   const FilePath file_path(kPathVersion);
   if (file_util::ReadFileToString(file_path, &contents)) {
-    version = ParseVersion(
+    *version = ParseVersion(
         contents,
         (format == VERSION_FULL) ? kFullVersionPrefix : kVersionPrefix);
   }
@@ -150,30 +146,22 @@ void VersionLoader::Backend::GetVersion(
     if (file_util::GetFileInfo(file_path, &fileinfo)) {
       base::Time::Exploded ctime;
       fileinfo.creation_time.UTCExplode(&ctime);
-      version += base::StringPrintf("-%02u.%02u.%02u",
-                                    ctime.year % 100,
-                                    ctime.month,
-                                    ctime.day_of_month);
+      *version += base::StringPrintf("-%02u.%02u.%02u",
+                                     ctime.year % 100,
+                                     ctime.month,
+                                     ctime.day_of_month);
     }
   }
-
-  request->ForwardResult(request->handle(), version);
 }
 
-void VersionLoader::Backend::GetFirmware(
-    scoped_refptr<GetFirmwareRequest> request) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-  if (request->canceled())
-    return;
+void VersionLoader::Backend::GetFirmware(std::string* firmware) {
+  DCHECK(BrowserThread::GetBlockingPool()->RunsTasksOnCurrentThread());
 
-  std::string firmware;
   std::string contents;
   const FilePath file_path(kPathFirmware);
   if (file_util::ReadFileToString(file_path, &contents)) {
-    firmware = ParseFirmware(contents);
+    *firmware = ParseFirmware(contents);
   }
-
-  request->ForwardResult(request->handle(), firmware);
 }
 
 }  // namespace chromeos
diff --git a/chrome/browser/chromeos/version_loader.h b/chrome/browser/chromeos/version_loader.h
index c41f8e3..d9ab15d 100644
--- a/chrome/browser/chromeos/version_loader.h
+++ b/chrome/browser/chromeos/version_loader.h
@@ -10,11 +10,12 @@
 #include "base/callback.h"
 #include "base/gtest_prod_util.h"
 #include "chrome/browser/common/cancelable_request.h"
+#include "chrome/common/cancelable_task_tracker.h"
 
 namespace chromeos {
 
 // ChromeOSVersionLoader loads the version of Chrome OS from the file system.
-// Loading is done asynchronously on the file thread. Once loaded,
+// Loading is done asynchronously in the blocking thread pool. Once loaded,
 // ChromeOSVersionLoader callback to a method of your choice with the version
 // (or an empty string if the version couldn't be found).
 // To use ChromeOSVersionLoader do the following:
@@ -40,27 +41,18 @@ class VersionLoader : public CancelableRequestProvider {
   };
 
   // Signature
-  typedef base::Callback<void(Handle, const std::string&)> GetVersionCallback;
-  typedef CancelableRequest<GetVersionCallback> GetVersionRequest;
-
-  typedef base::Callback<void(Handle, const std::string&)> GetFirmwareCallback;
-  typedef CancelableRequest<GetFirmwareCallback> GetFirmwareRequest;
+  typedef base::Callback<void(const std::string&)> GetVersionCallback;
+  typedef base::Callback<void(const std::string&)> GetFirmwareCallback;
 
   // Asynchronously requests the version.
   // If |full_version| is true version string with extra info is extracted,
   // otherwise it's in short format x.x.xx.x.
-  Handle GetVersion(CancelableRequestConsumerBase* consumer,
-                    const GetVersionCallback& callback,
-                    VersionFormat format);
-
-  Handle GetFirmware(CancelableRequestConsumerBase* consumer,
-                     const GetFirmwareCallback& callback);
+  CancelableTaskTracker::TaskId GetVersion(VersionFormat format,
+                                           const GetVersionCallback& callback,
+                                           CancelableTaskTracker* tracker);
 
-  // Parse the version information as a Chrome platfrom, not Chrome OS
-  // TODO(rkc): Change this and everywhere it is used once we switch Chrome OS
-  // over to xx.yyy.zz version numbers instead of 0.xx.yyy.zz
-  // Refer to http://code.google.com/p/chromium-os/issues/detail?id=15789
-  void EnablePlatformVersions(bool enable);
+  CancelableTaskTracker::TaskId GetFirmware(const GetFirmwareCallback& callback,
+                                            CancelableTaskTracker* tracker);
 
   static const char kFullVersionPrefix[];
   static const char kVersionPrefix[];
@@ -71,21 +63,20 @@ class VersionLoader : public CancelableRequestProvider {
   FRIEND_TEST_ALL_PREFIXES(VersionLoaderTest, ParseVersion);
   FRIEND_TEST_ALL_PREFIXES(VersionLoaderTest, ParseFirmware);
 
-  // VersionLoader calls into the Backend on the file thread to load
+  // VersionLoader calls into the Backend in the blocking thread pool to load
   // and extract the version.
   class Backend : public base::RefCountedThreadSafe<Backend> {
    public:
     Backend() {}
 
     // Calls ParseVersion to get the version # and notifies request.
-    // This is invoked on the file thread.
+    // This is invoked in the blocking thread pool.
     // If |full_version| is true then extra info is passed in version string.
-    void GetVersion(scoped_refptr<GetVersionRequest> request,
-                    VersionFormat format);
+    void GetVersion(VersionFormat format, std::string* version);
 
     // Calls ParseFirmware to get the firmware # and notifies request.
-    // This is invoked on the file thread.
-    void GetFirmware(scoped_refptr<GetFirmwareRequest> request);
+    // This is invoked in the blocking thread pool.
+    void GetFirmware(std::string* firmware);
 
    private:
     friend class base::RefCountedThreadSafe<Backend>;
diff --git a/chrome/browser/policy/device_status_collector.cc b/chrome/browser/policy/device_status_collector.cc
index 0cac6ad..4505c554 100644
--- a/chrome/browser/policy/device_status_collector.cc
+++ b/chrome/browser/policy/device_status_collector.cc
@@ -135,13 +135,13 @@ DeviceStatusCollector::DeviceStatusCollector(
   UpdateReportingSettings();
 
   // Get the the OS and firmware version info.
-  version_loader_.GetVersion(&consumer_,
-                             base::Bind(&DeviceStatusCollector::OnOSVersion,
-                                        base::Unretained(this)),
-                             VersionLoader::VERSION_FULL);
-  version_loader_.GetFirmware(&consumer_,
-                              base::Bind(&DeviceStatusCollector::OnOSFirmware,
-                                         base::Unretained(this)));
+  version_loader_.GetVersion(
+      VersionLoader::VERSION_FULL,
+      base::Bind(&DeviceStatusCollector::OnOSVersion, base::Unretained(this)),
+      &tracker_);
+  version_loader_.GetFirmware(
+      base::Bind(&DeviceStatusCollector::OnOSFirmware, base::Unretained(this)),
+      &tracker_);
 }
 
 DeviceStatusCollector::~DeviceStatusCollector() {
@@ -367,13 +367,11 @@ void DeviceStatusCollector::GetStatus(em::DeviceStatusReportRequest* request) {
     GetLocation(request);
 }
 
-void DeviceStatusCollector::OnOSVersion(VersionLoader::Handle handle,
-                                        const std::string& version) {
+void DeviceStatusCollector::OnOSVersion(const std::string& version) {
   os_version_ = version;
 }
 
-void DeviceStatusCollector::OnOSFirmware(VersionLoader::Handle handle,
-                                         const std::string& version) {
+void DeviceStatusCollector::OnOSFirmware(const std::string& version) {
   firmware_version_ = version;
 }
 
diff --git a/chrome/browser/policy/device_status_collector.h b/chrome/browser/policy/device_status_collector.h
index 3ef3a24..a927aa1 100644
--- a/chrome/browser/policy/device_status_collector.h
+++ b/chrome/browser/policy/device_status_collector.h
@@ -12,9 +12,9 @@
 #include "base/memory/weak_ptr.h"
 #include "base/time.h"
 #include "base/timer.h"
-#include "chrome/browser/common/cancelable_request.h"
 #include "chrome/browser/chromeos/version_loader.h"
 #include "chrome/browser/idle.h"
+#include "chrome/common/cancelable_task_tracker.h"
 #include "content/public/browser/geolocation.h"
 #include "content/public/browser/notification_observer.h"
 #include "content/public/common/geoposition.h"
@@ -86,10 +86,8 @@ class DeviceStatusCollector : public content::NotificationObserver {
   void AddActivePeriod(base::Time start, base::Time end);
 
   // Callbacks from chromeos::VersionLoader.
-  void OnOSVersion(chromeos::VersionLoader::Handle handle,
-                   const std::string& version);
-  void OnOSFirmware(chromeos::VersionLoader::Handle handle,
-                    const std::string& version);
+  void OnOSVersion(const std::string& version);
+  void OnOSFirmware(const std::string& version);
 
   // Helpers for the various portions of the status.
   void GetActivityTimes(
@@ -130,7 +128,7 @@ class DeviceStatusCollector : public content::NotificationObserver {
   base::OneShotTimer<DeviceStatusCollector> geolocation_update_timer_;
 
   chromeos::VersionLoader version_loader_;
-  CancelableRequestConsumer consumer_;
+  CancelableTaskTracker tracker_;
 
   std::string os_version_;
   std::string firmware_version_;
diff --git a/chrome/browser/ui/webui/chromeos/register_page_ui.cc b/chrome/browser/ui/webui/chromeos/register_page_ui.cc
index a1f7bca..5069bc1 100644
--- a/chrome/browser/ui/webui/chromeos/register_page_ui.cc
+++ b/chrome/browser/ui/webui/chromeos/register_page_ui.cc
@@ -24,6 +24,7 @@
 #include "chrome/browser/chromeos/version_loader.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/webui/chrome_url_data_manager.h"
+#include "chrome/common/cancelable_task_tracker.h"
 #include "chrome/common/url_constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/web_contents.h"
@@ -129,8 +130,7 @@ class RegisterPageHandler : public WebUIMessageHandler,
   void HandleGetUserInfo(const ListValue* args);
 
   // Callback from chromeos::VersionLoader giving the version.
-  void OnVersion(chromeos::VersionLoader::Handle handle,
-                 const std::string& version);
+  void OnVersion(const std::string& version);
 
   // Skips registration logging |error_msg| with log type ERROR.
   void SkipRegistration(const std::string& error_msg);
@@ -142,7 +142,7 @@ class RegisterPageHandler : public WebUIMessageHandler,
   chromeos::VersionLoader version_loader_;
 
   // Used to request the version.
-  CancelableRequestConsumer version_consumer_;
+  CancelableTaskTracker tracker_;
 
   std::string version_;
 
@@ -220,16 +220,15 @@ void RegisterPageHandler::HandleGetRegistrationUrl(const ListValue* args) {
 void RegisterPageHandler::HandleGetUserInfo(const ListValue* args) {
   if (base::chromeos::IsRunningOnChromeOS()) {
      version_loader_.GetVersion(
-         &version_consumer_,
+         chromeos::VersionLoader::VERSION_FULL,
          base::Bind(&RegisterPageHandler::OnVersion, base::Unretained(this)),
-         chromeos::VersionLoader::VERSION_FULL);
+         &tracker_);
   } else {
     SkipRegistration("Not running on ChromeOS.");
   }
 }
 
-void RegisterPageHandler::OnVersion(chromeos::VersionLoader::Handle handle,
-                                    const std::string& version) {
+void RegisterPageHandler::OnVersion(const std::string& version) {
   version_ = version;
   SendUserInfo();
 }
diff --git a/chrome/browser/ui/webui/help/help_handler.cc b/chrome/browser/ui/webui/help/help_handler.cc
index f120545..49d6086 100644
--- a/chrome/browser/ui/webui/help/help_handler.cc
+++ b/chrome/browser/ui/webui/help/help_handler.cc
@@ -248,11 +248,13 @@ void HelpHandler::Observe(int type, const content::NotificationSource& source,
 void HelpHandler::OnPageLoaded(const ListValue* args) {
 #if defined(OS_CHROMEOS)
   // Version information is loaded from a callback
-  loader_.GetVersion(&consumer_, base::Bind(&HelpHandler::OnOSVersion,
-                                            base::Unretained(this)),
-                     chromeos::VersionLoader::VERSION_FULL);
-  loader_.GetFirmware(&consumer_, base::Bind(&HelpHandler::OnOSFirmware,
-                                             base::Unretained(this)));
+  loader_.GetVersion(
+      chromeos::VersionLoader::VERSION_FULL,
+      base::Bind(&HelpHandler::OnOSVersion, base::Unretained(this)),
+      &tracker_);
+  loader_.GetFirmware(
+      base::Bind(&HelpHandler::OnOSFirmware, base::Unretained(this)),
+      &tracker_);
 
   scoped_ptr<base::Value> can_change_channel_value(
       base::Value::CreateBooleanValue(CanChangeReleaseChannel()));
@@ -397,15 +399,13 @@ void HelpHandler::SetPromotionState(VersionUpdater::PromotionState state) {
 #endif  // defined(OS_MACOSX)
 
 #if defined(OS_CHROMEOS)
-void HelpHandler::OnOSVersion(chromeos::VersionLoader::Handle handle,
-                              const std::string& version) {
+void HelpHandler::OnOSVersion(const std::string& version) {
   scoped_ptr<Value> version_string(Value::CreateStringValue(version));
   web_ui()->CallJavascriptFunction("help.HelpPage.setOSVersion",
                                    *version_string);
 }
 
-void HelpHandler::OnOSFirmware(chromeos::VersionLoader::Handle handle,
-                               const std::string& firmware) {
+void HelpHandler::OnOSFirmware(const std::string& firmware) {
   scoped_ptr<Value> firmware_string(Value::CreateStringValue(firmware));
   web_ui()->CallJavascriptFunction("help.HelpPage.setOSFirmware",
                                    *firmware_string);
diff --git a/chrome/browser/ui/webui/help/help_handler.h b/chrome/browser/ui/webui/help/help_handler.h
index 2d5bef7..b133fbc 100644
--- a/chrome/browser/ui/webui/help/help_handler.h
+++ b/chrome/browser/ui/webui/help/help_handler.h
@@ -70,10 +70,8 @@ class HelpHandler : public content::WebUIMessageHandler,
 
 #if defined(OS_CHROMEOS)
   // Callbacks from VersionLoader.
-  void OnOSVersion(chromeos::VersionLoader::Handle handle,
-                   const std::string& version);
-  void OnOSFirmware(chromeos::VersionLoader::Handle handle,
-                    const std::string& firmware);
+  void OnOSVersion(const std::string& version);
+  void OnOSFirmware(const std::string& firmware);
   void OnReleaseChannel(const std::string& channel);
 
   void ProcessLsbFileInfo(
@@ -94,7 +92,7 @@ class HelpHandler : public content::WebUIMessageHandler,
   chromeos::VersionLoader loader_;
 
   // Used to request the version.
-  CancelableRequestConsumer consumer_;
+  CancelableTaskTracker tracker_;
 #endif  // defined(OS_CHROMEOS)
 
   DISALLOW_COPY_AND_ASSIGN(HelpHandler);
diff --git a/chrome/browser/ui/webui/version_handler_chromeos.cc b/chrome/browser/ui/webui/version_handler_chromeos.cc
index 9a0fcf6..637779c 100644
--- a/chrome/browser/ui/webui/version_handler_chromeos.cc
+++ b/chrome/browser/ui/webui/version_handler_chromeos.cc
@@ -14,17 +14,16 @@ VersionHandlerChromeOS::~VersionHandlerChromeOS() {
 
 void VersionHandlerChromeOS::HandleRequestVersionInfo(const ListValue* args) {
   // Start the asynchronous load of the version.
-  loader_.GetVersion(&consumer_,
-                     base::Bind(&VersionHandlerChromeOS::OnVersion,
-                                base::Unretained(this)),
-                     chromeos::VersionLoader::VERSION_FULL);
+  loader_.GetVersion(
+      chromeos::VersionLoader::VERSION_FULL,
+      base::Bind(&VersionHandlerChromeOS::OnVersion, base::Unretained(this)),
+      &tracker_);
 
   // Parent class takes care of the rest.
   VersionHandler::HandleRequestVersionInfo(args);
 }
 
-void VersionHandlerChromeOS::OnVersion(chromeos::VersionLoader::Handle handle,
-                                       const std::string& version) {
+void VersionHandlerChromeOS::OnVersion(const std::string& version) {
   StringValue arg(version);
   web_ui()->CallJavascriptFunction("returnOsVersion", arg);
 }
diff --git a/chrome/browser/ui/webui/version_handler_chromeos.h b/chrome/browser/ui/webui/version_handler_chromeos.h
index cb4ce2f..8a7c6d1 100644
--- a/chrome/browser/ui/webui/version_handler_chromeos.h
+++ b/chrome/browser/ui/webui/version_handler_chromeos.h
@@ -21,15 +21,14 @@ class VersionHandlerChromeOS : public VersionHandler {
   virtual void HandleRequestVersionInfo(const ListValue* args) OVERRIDE;
 
   // Callback from chromeos::VersionLoader giving the version.
-  void OnVersion(chromeos::VersionLoader::Handle handle,
-                 const std::string& version);
+  void OnVersion(const std::string& version);
 
  private:
   // Handles asynchronously loading the version.
   chromeos::VersionLoader loader_;
 
   // Used to request the version.
-  CancelableRequestConsumer consumer_;
+  CancelableTaskTracker tracker_;
 
   DISALLOW_COPY_AND_ASSIGN(VersionHandlerChromeOS);
 };