Revert 167616 - c/b/chromeos/system/timezone_settings.h

--
Reason: broke interactive_ui_tests on linux_chromeos completely.

http://build.chromium.org/p/chromium.chromiumos/builders/Linux%20ChromiumOS%20Tests%20%28dbg%29%283%29/builds/16268/steps/interactive_ui_tests/logs/stdio

[5772:5799:1113/231216:418284259:FATAL:version_loader.cc(134)] Check failed: BrowserThread::CurrentlyOn(BrowserThread::FILE). 

--

c/b/chromeos/version_loader.h
VersionLoader::GetVersion
VersionLoader::GetFirmware

BUG=155883

Review URL: https://chromiumcodereview.appspot.com/11359173

TBR=kaiwang@chromium.org
Review URL: https://codereview.chromium.org/11363237

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

14 files changed, 137 insertions, 103 deletions

diff --git a/chrome/browser/chrome_browser_main_linux.cc b/chrome/browser/chrome_browser_main_linux.cc
index fc4cb9e..e764919 100644
--- a/chrome/browser/chrome_browser_main_linux.cc
+++ b/chrome/browser/chrome_browser_main_linux.cc
@@ -34,8 +34,9 @@ namespace {
 
 #if defined(USE_LINUX_BREAKPAD)
 #if defined(OS_CHROMEOS)
-void ChromeOSVersionCallback(const std::string* version) {
-  base::SetLinuxDistro(std::string("CrOS ") + *version);
+void ChromeOSVersionCallback(chromeos::VersionLoader::Handle,
+                             const std::string& version) {
+  base::SetLinuxDistro(std::string("CrOS ") + version);
 }
 #else
 void GetLinuxDistroCallback() {
@@ -92,9 +93,9 @@ ChromeBrowserMainPartsLinux::~ChromeBrowserMainPartsLinux() {
 void ChromeBrowserMainPartsLinux::PreProfileInit() {
 #if defined(USE_LINUX_BREAKPAD)
 #if defined(OS_CHROMEOS)
-  cros_version_loader_.GetVersion(chromeos::VersionLoader::VERSION_FULL,
+  cros_version_loader_.GetVersion(&cros_consumer_,
                                   base::Bind(&ChromeOSVersionCallback),
-                                  &tracker_);
+                                  chromeos::VersionLoader::VERSION_FULL);
 #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 7c8f042..bcd99a6 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/common/cancelable_task_tracker.h"
+#include "chrome/browser/common/cancelable_request.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_;
-  CancelableTaskTracker tracker_;
+  CancelableRequestConsumer cros_consumer_;
 #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 2c9ccc5..1dc0bb0 100644
--- a/chrome/browser/chromeos/login/version_info_updater.cc
+++ b/chrome/browser/chromeos/login/version_info_updater.cc
@@ -54,10 +54,11 @@ VersionInfoUpdater::~VersionInfoUpdater() {
 void VersionInfoUpdater::StartUpdate(bool is_official_build) {
   if (base::chromeos::IsRunningOnChromeOS()) {
     version_loader_.GetVersion(
-        is_official_build ? VersionLoader::VERSION_SHORT_WITH_DATE
-                          : VersionLoader::VERSION_FULL,
+        &version_consumer_,
         base::Bind(&VersionInfoUpdater::OnVersion, base::Unretained(this)),
-        &tracker_);
+        is_official_build ?
+            VersionLoader::VERSION_SHORT_WITH_DATE :
+            VersionLoader::VERSION_FULL);
     boot_times_loader_.GetBootTimes(
         &boot_times_consumer_,
         base::Bind(is_official_build ? &VersionInfoUpdater::OnBootTimesNoop :
@@ -189,7 +190,8 @@ void VersionInfoUpdater::SetEnterpriseInfo(const std::string& domain_name,
   }
 }
 
-void VersionInfoUpdater::OnVersion(const std::string& version) {
+void VersionInfoUpdater::OnVersion(
+    VersionLoader::Handle handle, 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 c02ff71..fa458c7 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(const std::string& version);
+  void OnVersion(VersionLoader::Handle handle, 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.
-  CancelableTaskTracker tracker_;
+  CancelableRequestConsumer version_consumer_;
 
   // 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 8ef5cd8..ad2b92d 100644
--- a/chrome/browser/chromeos/system/timezone_settings.h
+++ b/chrome/browser/chromeos/system/timezone_settings.h
@@ -8,13 +8,14 @@
 #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 {
+class TimezoneSettings : public CancelableRequestProvider {
  public:
   class Observer {
    public:
diff --git a/chrome/browser/chromeos/version_loader.cc b/chrome/browser/chromeos/version_loader.cc
index 917219e..4f70e12 100644
--- a/chrome/browser/chromeos/version_loader.cc
+++ b/chrome/browser/chromeos/version_loader.cc
@@ -9,12 +9,10 @@
 #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"
@@ -22,17 +20,6 @@
 
 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.
@@ -58,28 +45,41 @@ const char VersionLoader::kVersionPrefix[] = "CHROMEOS_RELEASE_VERSION=";
 // Beginning of line we look for that gives the firmware version.
 const char VersionLoader::kFirmwarePrefix[] = "version";
 
-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::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::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)));
+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();
 }
 
 // static
@@ -129,14 +129,18 @@ std::string VersionLoader::ParseFirmware(const std::string& contents) {
   return std::string();
 }
 
-void VersionLoader::Backend::GetVersion(VersionFormat format,
-                                        std::string* version) {
+void VersionLoader::Backend::GetVersion(
+    scoped_refptr<GetVersionRequest> request,
+    VersionFormat format) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  if (request->canceled())
+    return;
 
+  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);
   }
@@ -146,22 +150,30 @@ void VersionLoader::Backend::GetVersion(VersionFormat format,
     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(std::string* firmware) {
+void VersionLoader::Backend::GetFirmware(
+    scoped_refptr<GetFirmwareRequest> request) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
+  if (request->canceled())
+    return;
 
+  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 b40d562..c41f8e3 100644
--- a/chrome/browser/chromeos/version_loader.h
+++ b/chrome/browser/chromeos/version_loader.h
@@ -10,7 +10,6 @@
 #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 {
 
@@ -41,18 +40,27 @@ class VersionLoader : public CancelableRequestProvider {
   };
 
   // Signature
-  typedef base::Callback<void(const std::string&)> GetVersionCallback;
-  typedef base::Callback<void(const std::string&)> GetFirmwareCallback;
+  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;
 
   // 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.
-  CancelableTaskTracker::TaskId GetVersion(VersionFormat format,
-                                           const GetVersionCallback& callback,
-                                           CancelableTaskTracker* tracker);
+  Handle GetVersion(CancelableRequestConsumerBase* consumer,
+                    const GetVersionCallback& callback,
+                    VersionFormat format);
+
+  Handle GetFirmware(CancelableRequestConsumerBase* consumer,
+                     const GetFirmwareCallback& callback);
 
-  CancelableTaskTracker::TaskId GetFirmware(const GetFirmwareCallback& 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);
 
   static const char kFullVersionPrefix[];
   static const char kVersionPrefix[];
@@ -72,11 +80,12 @@ class VersionLoader : public CancelableRequestProvider {
     // Calls ParseVersion to get the version # and notifies request.
     // This is invoked on the file thread.
     // If |full_version| is true then extra info is passed in version string.
-    void GetVersion(VersionFormat format, std::string* version);
+    void GetVersion(scoped_refptr<GetVersionRequest> request,
+                    VersionFormat format);
 
     // Calls ParseFirmware to get the firmware # and notifies request.
     // This is invoked on the file thread.
-    void GetFirmware(std::string* firmware);
+    void GetFirmware(scoped_refptr<GetFirmwareRequest> request);
 
    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 4505c554..0cac6ad 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(
-      VersionLoader::VERSION_FULL,
-      base::Bind(&DeviceStatusCollector::OnOSVersion, base::Unretained(this)),
-      &tracker_);
-  version_loader_.GetFirmware(
-      base::Bind(&DeviceStatusCollector::OnOSFirmware, base::Unretained(this)),
-      &tracker_);
+  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)));
 }
 
 DeviceStatusCollector::~DeviceStatusCollector() {
@@ -367,11 +367,13 @@ void DeviceStatusCollector::GetStatus(em::DeviceStatusReportRequest* request) {
     GetLocation(request);
 }
 
-void DeviceStatusCollector::OnOSVersion(const std::string& version) {
+void DeviceStatusCollector::OnOSVersion(VersionLoader::Handle handle,
+                                        const std::string& version) {
   os_version_ = version;
 }
 
-void DeviceStatusCollector::OnOSFirmware(const std::string& version) {
+void DeviceStatusCollector::OnOSFirmware(VersionLoader::Handle handle,
+                                         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 a927aa1..3ef3a24 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,8 +86,10 @@ class DeviceStatusCollector : public content::NotificationObserver {
   void AddActivePeriod(base::Time start, base::Time end);
 
   // Callbacks from chromeos::VersionLoader.
-  void OnOSVersion(const std::string& version);
-  void OnOSFirmware(const std::string& version);
+  void OnOSVersion(chromeos::VersionLoader::Handle handle,
+                   const std::string& version);
+  void OnOSFirmware(chromeos::VersionLoader::Handle handle,
+                    const std::string& version);
 
   // Helpers for the various portions of the status.
   void GetActivityTimes(
@@ -128,7 +130,7 @@ class DeviceStatusCollector : public content::NotificationObserver {
   base::OneShotTimer<DeviceStatusCollector> geolocation_update_timer_;
 
   chromeos::VersionLoader version_loader_;
-  CancelableTaskTracker tracker_;
+  CancelableRequestConsumer consumer_;
 
   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 5069bc1..a1f7bca 100644
--- a/chrome/browser/ui/webui/chromeos/register_page_ui.cc
+++ b/chrome/browser/ui/webui/chromeos/register_page_ui.cc
@@ -24,7 +24,6 @@
 #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"
@@ -130,7 +129,8 @@ class RegisterPageHandler : public WebUIMessageHandler,
   void HandleGetUserInfo(const ListValue* args);
 
   // Callback from chromeos::VersionLoader giving the version.
-  void OnVersion(const std::string& version);
+  void OnVersion(chromeos::VersionLoader::Handle handle,
+                 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.
-  CancelableTaskTracker tracker_;
+  CancelableRequestConsumer version_consumer_;
 
   std::string version_;
 
@@ -220,15 +220,16 @@ void RegisterPageHandler::HandleGetRegistrationUrl(const ListValue* args) {
 void RegisterPageHandler::HandleGetUserInfo(const ListValue* args) {
   if (base::chromeos::IsRunningOnChromeOS()) {
      version_loader_.GetVersion(
-         chromeos::VersionLoader::VERSION_FULL,
+         &version_consumer_,
          base::Bind(&RegisterPageHandler::OnVersion, base::Unretained(this)),
-         &tracker_);
+         chromeos::VersionLoader::VERSION_FULL);
   } else {
     SkipRegistration("Not running on ChromeOS.");
   }
 }
 
-void RegisterPageHandler::OnVersion(const std::string& version) {
+void RegisterPageHandler::OnVersion(chromeos::VersionLoader::Handle handle,
+                                    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 49d6086..f120545 100644
--- a/chrome/browser/ui/webui/help/help_handler.cc
+++ b/chrome/browser/ui/webui/help/help_handler.cc
@@ -248,13 +248,11 @@ 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(
-      chromeos::VersionLoader::VERSION_FULL,
-      base::Bind(&HelpHandler::OnOSVersion, base::Unretained(this)),
-      &tracker_);
-  loader_.GetFirmware(
-      base::Bind(&HelpHandler::OnOSFirmware, base::Unretained(this)),
-      &tracker_);
+  loader_.GetVersion(&consumer_, base::Bind(&HelpHandler::OnOSVersion,
+                                            base::Unretained(this)),
+                     chromeos::VersionLoader::VERSION_FULL);
+  loader_.GetFirmware(&consumer_, base::Bind(&HelpHandler::OnOSFirmware,
+                                             base::Unretained(this)));
 
   scoped_ptr<base::Value> can_change_channel_value(
       base::Value::CreateBooleanValue(CanChangeReleaseChannel()));
@@ -399,13 +397,15 @@ void HelpHandler::SetPromotionState(VersionUpdater::PromotionState state) {
 #endif  // defined(OS_MACOSX)
 
 #if defined(OS_CHROMEOS)
-void HelpHandler::OnOSVersion(const std::string& version) {
+void HelpHandler::OnOSVersion(chromeos::VersionLoader::Handle handle,
+                              const std::string& version) {
   scoped_ptr<Value> version_string(Value::CreateStringValue(version));
   web_ui()->CallJavascriptFunction("help.HelpPage.setOSVersion",
                                    *version_string);
 }
 
-void HelpHandler::OnOSFirmware(const std::string& firmware) {
+void HelpHandler::OnOSFirmware(chromeos::VersionLoader::Handle handle,
+                               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 b133fbc..2d5bef7 100644
--- a/chrome/browser/ui/webui/help/help_handler.h
+++ b/chrome/browser/ui/webui/help/help_handler.h
@@ -70,8 +70,10 @@ class HelpHandler : public content::WebUIMessageHandler,
 
 #if defined(OS_CHROMEOS)
   // Callbacks from VersionLoader.
-  void OnOSVersion(const std::string& version);
-  void OnOSFirmware(const std::string& firmware);
+  void OnOSVersion(chromeos::VersionLoader::Handle handle,
+                   const std::string& version);
+  void OnOSFirmware(chromeos::VersionLoader::Handle handle,
+                    const std::string& firmware);
   void OnReleaseChannel(const std::string& channel);
 
   void ProcessLsbFileInfo(
@@ -92,7 +94,7 @@ class HelpHandler : public content::WebUIMessageHandler,
   chromeos::VersionLoader loader_;
 
   // Used to request the version.
-  CancelableTaskTracker tracker_;
+  CancelableRequestConsumer consumer_;
 #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 637779c..9a0fcf6 100644
--- a/chrome/browser/ui/webui/version_handler_chromeos.cc
+++ b/chrome/browser/ui/webui/version_handler_chromeos.cc
@@ -14,16 +14,17 @@ VersionHandlerChromeOS::~VersionHandlerChromeOS() {
 
 void VersionHandlerChromeOS::HandleRequestVersionInfo(const ListValue* args) {
   // Start the asynchronous load of the version.
-  loader_.GetVersion(
-      chromeos::VersionLoader::VERSION_FULL,
-      base::Bind(&VersionHandlerChromeOS::OnVersion, base::Unretained(this)),
-      &tracker_);
+  loader_.GetVersion(&consumer_,
+                     base::Bind(&VersionHandlerChromeOS::OnVersion,
+                                base::Unretained(this)),
+                     chromeos::VersionLoader::VERSION_FULL);
 
   // Parent class takes care of the rest.
   VersionHandler::HandleRequestVersionInfo(args);
 }
 
-void VersionHandlerChromeOS::OnVersion(const std::string& version) {
+void VersionHandlerChromeOS::OnVersion(chromeos::VersionLoader::Handle handle,
+                                       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 8a7c6d1..cb4ce2f 100644
--- a/chrome/browser/ui/webui/version_handler_chromeos.h
+++ b/chrome/browser/ui/webui/version_handler_chromeos.h
@@ -21,14 +21,15 @@ class VersionHandlerChromeOS : public VersionHandler {
   virtual void HandleRequestVersionInfo(const ListValue* args) OVERRIDE;
 
   // Callback from chromeos::VersionLoader giving the version.
-  void OnVersion(const std::string& version);
+  void OnVersion(chromeos::VersionLoader::Handle handle,
+                 const std::string& version);
 
  private:
   // Handles asynchronously loading the version.
   chromeos::VersionLoader loader_;
 
   // Used to request the version.
-  CancelableTaskTracker tracker_;
+  CancelableRequestConsumer consumer_;
 
   DISALLOW_COPY_AND_ASSIGN(VersionHandlerChromeOS);
 };