Changed policy/ code to use Bind/Callback.

BUG=35223
TEST=Everything works as before

Review URL: http://codereview.chromium.org/8079003

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

15 files changed, 113 insertions, 133 deletions

diff --git a/chrome/browser/policy/asynchronous_policy_loader.cc b/chrome/browser/policy/asynchronous_policy_loader.cc
index 83e0d39..296f7a5 100644
--- a/chrome/browser/policy/asynchronous_policy_loader.cc
+++ b/chrome/browser/policy/asynchronous_policy_loader.cc
@@ -4,8 +4,8 @@
 
 #include "chrome/browser/policy/asynchronous_policy_loader.h"
 
+#include "base/bind.h"
 #include "base/message_loop.h"
-#include "base/task.h"
 #include "content/browser/browser_thread.h"
 
 namespace policy {
@@ -14,7 +14,7 @@ AsynchronousPolicyLoader::AsynchronousPolicyLoader(
     AsynchronousPolicyProvider::Delegate* delegate,
     int reload_interval_minutes)
     : delegate_(delegate),
-      reload_task_(NULL),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       reload_interval_(base::TimeDelta::FromMinutes(reload_interval_minutes)),
       origin_loop_(MessageLoop::current()),
       stopped_(false) {}
@@ -30,9 +30,8 @@ void AsynchronousPolicyLoader::Init(const base::Closure& callback) {
   // initialized.
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(
-          this,
-          &AsynchronousPolicyLoader::InitAfterFileThreadAvailable));
+      base::Bind(&AsynchronousPolicyLoader::InitAfterFileThreadAvailable,
+                 this));
 }
 
 void AsynchronousPolicyLoader::Stop() {
@@ -40,49 +39,22 @@ void AsynchronousPolicyLoader::Stop() {
     stopped_ = true;
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
-        NewRunnableMethod(this, &AsynchronousPolicyLoader::StopOnFileThread));
+        base::Bind(&AsynchronousPolicyLoader::StopOnFileThread, this));
   }
 }
 
 AsynchronousPolicyLoader::~AsynchronousPolicyLoader() {
 }
 
-// Manages the life cycle of a new policy map during until its life cycle is
-// taken over by the policy loader.
-class UpdatePolicyTask : public Task {
- public:
-  UpdatePolicyTask(scoped_refptr<AsynchronousPolicyLoader> loader,
-                   DictionaryValue* new_policy)
-      : loader_(loader),
-        new_policy_(new_policy) {}
-
-  virtual void Run() {
-    loader_->UpdatePolicy(new_policy_.release());
-  }
-
- private:
-  scoped_refptr<AsynchronousPolicyLoader> loader_;
-  scoped_ptr<DictionaryValue> new_policy_;
-  DISALLOW_COPY_AND_ASSIGN(UpdatePolicyTask);
-};
-
 void AsynchronousPolicyLoader::Reload() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   if (delegate_.get()) {
-    DictionaryValue* new_policy = delegate_->Load();
-    PostUpdatePolicyTask(new_policy);
+    PostUpdatePolicyTask(delegate_->Load());
   }
 }
 
 void AsynchronousPolicyLoader::CancelReloadTask() {
-  if (reload_task_) {
-    // Only check the thread if there's still a reload task. During
-    // destruction of unit tests, the message loop destruction can
-    // call this method when the file thread is no longer around,
-    // but in that case reload_task_ is NULL.
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-    reload_task_->Cancel();
-    reload_task_ = NULL;
-  }
+  weak_ptr_factory_.InvalidateWeakPtrs();
 }
 
 void AsynchronousPolicyLoader::ScheduleReloadTask(
@@ -91,10 +63,11 @@ void AsynchronousPolicyLoader::ScheduleReloadTask(
 
   CancelReloadTask();
 
-  reload_task_ =
-      NewRunnableMethod(this, &AsynchronousPolicyLoader::ReloadFromTask);
-  BrowserThread::PostDelayedTask(BrowserThread::FILE, FROM_HERE, reload_task_,
-                                 delay.InMilliseconds());
+  BrowserThread::PostDelayedTask(
+      BrowserThread::FILE, FROM_HERE,
+      base::Bind(&AsynchronousPolicyLoader::ReloadFromTask,
+                 weak_ptr_factory_.GetWeakPtr()),
+      delay.InMilliseconds());
 }
 
 void AsynchronousPolicyLoader::ScheduleFallbackReloadTask() {
@@ -106,11 +79,6 @@ void AsynchronousPolicyLoader::ScheduleFallbackReloadTask() {
 
 void AsynchronousPolicyLoader::ReloadFromTask() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
-
-  // Drop the reference to the reload task, since the task might be the only
-  // referrer that keeps us alive, so we should not Cancel() it.
-  reload_task_ = NULL;
-
   Reload();
 }
 
@@ -124,7 +92,10 @@ void AsynchronousPolicyLoader::StopOnFileThread() {
 
 void AsynchronousPolicyLoader::PostUpdatePolicyTask(
     DictionaryValue* new_policy) {
-  origin_loop_->PostTask(FROM_HERE, new UpdatePolicyTask(this, new_policy));
+  // TODO(joaodasilva): make the callback own |new_policy|.
+  origin_loop_->PostTask(
+      FROM_HERE,
+      base::Bind(&AsynchronousPolicyLoader::UpdatePolicy, this, new_policy));
 }
 
 void AsynchronousPolicyLoader::UpdatePolicy(DictionaryValue* new_policy_raw) {
@@ -139,7 +110,7 @@ void AsynchronousPolicyLoader::InitAfterFileThreadAvailable() {
   if (!stopped_) {
     BrowserThread::PostTask(
         BrowserThread::FILE, FROM_HERE,
-        NewRunnableMethod(this, &AsynchronousPolicyLoader::InitOnFileThread));
+        base::Bind(&AsynchronousPolicyLoader::InitOnFileThread, this));
   }
 }
 
diff --git a/chrome/browser/policy/asynchronous_policy_loader.h b/chrome/browser/policy/asynchronous_policy_loader.h
index 4289d66..c9b93b5 100644
--- a/chrome/browser/policy/asynchronous_policy_loader.h
+++ b/chrome/browser/policy/asynchronous_policy_loader.h
@@ -9,18 +9,18 @@
 #include "base/callback.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
+#include "base/memory/weak_ptr.h"
 #include "base/time.h"
 #include "base/values.h"
 #include "chrome/browser/policy/asynchronous_policy_provider.h"
 #include "chrome/browser/policy/configuration_policy_provider.h"
 
-class CancelableTask;
 class MessageLoop;
 
 namespace policy {
 
 // Used by the implementation of asynchronous policy provider to manage the
-// tasks on the file thread that do the heavy lifting of loading policies.
+// tasks on the FILE thread that do the heavy lifting of loading policies.
 class AsynchronousPolicyLoader
     : public base::RefCountedThreadSafe<AsynchronousPolicyLoader> {
  public:
@@ -32,7 +32,7 @@ class AsynchronousPolicyLoader
   virtual void Init(const base::Closure& callback);
 
   // Reloads policy, sending notification of changes if necessary. Must be
-  // called on the file thread.
+  // called on the FILE thread.
   virtual void Reload();
 
   // Stops any pending reload tasks. Updates callbacks won't be performed
@@ -42,8 +42,6 @@ class AsynchronousPolicyLoader
   const DictionaryValue* policy() const { return policy_.get(); }
 
  protected:
-  friend class UpdatePolicyTask;
-
   // AsynchronousPolicyLoader objects should only be deleted by
   // RefCountedThreadSafe.
   friend class base::RefCountedThreadSafe<AsynchronousPolicyLoader>;
@@ -57,23 +55,23 @@ class AsynchronousPolicyLoader
     return delegate_.get();
   }
 
-  // Performs start operations that must be performed on the file thread.
+  // Performs start operations that must be performed on the FILE thread.
   virtual void InitOnFileThread();
 
-  // Performs stop operations that must be performed on the file thread.
+  // Performs stop operations that must be performed on the FILE thread.
   virtual void StopOnFileThread();
 
   // Schedules a reload task to run when |delay| expires. Must be called on the
-  // file thread.
+  // FILE thread.
   void ScheduleReloadTask(const base::TimeDelta& delay);
 
   // Schedules a reload task to run after the number of minutes specified
-  // in |reload_interval_minutes_|. Must be called on the file thread.
+  // in |reload_interval_minutes_|. Must be called on the FILE thread.
   void ScheduleFallbackReloadTask();
 
   void CancelReloadTask();
 
-  // Invoked from the reload task on the file thread.
+  // Invoked from the reload task on the FILE thread.
   void ReloadFromTask();
 
  private:
@@ -95,9 +93,9 @@ class AsynchronousPolicyLoader
   // Current policy.
   scoped_ptr<DictionaryValue> policy_;
 
-  // The reload task. Access only on the file thread. Holds a reference to the
-  // currently posted task, so we can cancel and repost it if necessary.
-  CancelableTask* reload_task_;
+  // Used to create and invalidate WeakPtrs on the FILE thread. These are only
+  // used to post reload tasks that can be cancelled.
+  base::WeakPtrFactory<AsynchronousPolicyLoader> weak_ptr_factory_;
 
   // The interval at which a policy reload will be triggered as a fallback.
   const base::TimeDelta  reload_interval_;
diff --git a/chrome/browser/policy/browser_policy_connector.cc b/chrome/browser/policy/browser_policy_connector.cc
index 848289d..6225466 100644
--- a/chrome/browser/policy/browser_policy_connector.cc
+++ b/chrome/browser/policy/browser_policy_connector.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/browser/policy/browser_policy_connector.h"
 
+#include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/path_service.h"
@@ -262,7 +263,7 @@ const CloudPolicyDataStore*
 }
 
 BrowserPolicyConnector::BrowserPolicyConnector()
-    : ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
+    : ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
   managed_platform_provider_.reset(CreateManagedPlatformProvider());
   recommended_platform_provider_.reset(CreateRecommendedPlatformProvider());
 
@@ -287,7 +288,7 @@ BrowserPolicyConnector::BrowserPolicyConnector(
       recommended_platform_provider_(recommended_platform_provider),
       managed_cloud_provider_(managed_cloud_provider),
       recommended_cloud_provider_(recommended_cloud_provider),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {}
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {}
 
 void BrowserPolicyConnector::Observe(int type,
                                      const NotificationSource& source,
@@ -336,8 +337,8 @@ void BrowserPolicyConnector::InitializeDevicePolicy() {
     // Initialize the subsystem once the message loops are spinning.
     MessageLoop::current()->PostTask(
         FROM_HERE,
-        method_factory_.NewRunnableMethod(
-            &BrowserPolicyConnector::InitializeDevicePolicySubsystem));
+        base::Bind(&BrowserPolicyConnector::InitializeDevicePolicySubsystem,
+                   weak_ptr_factory_.GetWeakPtr()));
   }
 #endif
 }
diff --git a/chrome/browser/policy/browser_policy_connector.h b/chrome/browser/policy/browser_policy_connector.h
index bcf2de4..34966e3 100644
--- a/chrome/browser/policy/browser_policy_connector.h
+++ b/chrome/browser/policy/browser_policy_connector.h
@@ -10,7 +10,7 @@
 
 #include "base/basictypes.h"
 #include "base/memory/scoped_ptr.h"
-#include "base/task.h"
+#include "base/memory/weak_ptr.h"
 #include "chrome/browser/policy/cloud_policy_data_store.h"
 #include "chrome/browser/policy/enterprise_install_attributes.h"
 #include "content/common/notification_observer.h"
@@ -159,7 +159,9 @@ class BrowserPolicyConnector : public NotificationObserver {
   scoped_ptr<CloudPolicyDataStore> user_data_store_;
   scoped_ptr<CloudPolicySubsystem> user_cloud_policy_subsystem_;
 
-  ScopedRunnableMethodFactory<BrowserPolicyConnector> method_factory_;
+  // Used to initialize the device policy subsystem once the message loops
+  // are spinning.
+  base::WeakPtrFactory<BrowserPolicyConnector> weak_ptr_factory_;
 
   // Registers the provider for notification of successful Gaia logins.
   NotificationRegistrar registrar_;
diff --git a/chrome/browser/policy/device_management_service.cc b/chrome/browser/policy/device_management_service.cc
index 198cae7..3bffeee 100644
--- a/chrome/browser/policy/device_management_service.cc
+++ b/chrome/browser/policy/device_management_service.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/browser/policy/device_management_service.h"
 
+#include "base/bind.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "chrome/browser/browser_process.h"
@@ -144,11 +145,11 @@ DeviceManagementBackend* DeviceManagementService::CreateBackend() {
 void DeviceManagementService::ScheduleInitialization(int64 delay_milliseconds) {
   if (initialized_)
     return;
-  CancelableTask* initialization_task = method_factory_.NewRunnableMethod(
-      &DeviceManagementService::Initialize);
-  MessageLoop::current()->PostDelayedTask(FROM_HERE,
-                                          initialization_task,
-                                          delay_milliseconds);
+  MessageLoop::current()->PostDelayedTask(
+      FROM_HERE,
+      base::Bind(&DeviceManagementService::Initialize,
+                 weak_ptr_factory_.GetWeakPtr()),
+      delay_milliseconds);
 }
 
 void DeviceManagementService::Initialize() {
@@ -179,7 +180,7 @@ DeviceManagementService::DeviceManagementService(
     const std::string& server_url)
     : server_url_(server_url),
       initialized_(false),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
 void DeviceManagementService::AddJob(DeviceManagementJob* job) {
diff --git a/chrome/browser/policy/device_management_service.h b/chrome/browser/policy/device_management_service.h
index 63bfeee1..089bcf0 100644
--- a/chrome/browser/policy/device_management_service.h
+++ b/chrome/browser/policy/device_management_service.h
@@ -12,7 +12,7 @@
 
 #include "base/basictypes.h"
 #include "base/memory/ref_counted.h"
-#include "base/task.h"
+#include "base/memory/weak_ptr.h"
 #include "content/common/net/url_fetcher.h"
 #include "googleurl/src/gurl.h"
 
@@ -107,8 +107,8 @@ class DeviceManagementService : public URLFetcher::Delegate {
   // If it is not initialized, incoming requests are queued.
   bool initialized_;
 
-  // Creates tasks used for running |Initialize| delayed on the UI thread.
-  ScopedRunnableMethodFactory<DeviceManagementService> method_factory_;
+  // Used to create tasks to run |Initialize| delayed on the UI thread.
+  base::WeakPtrFactory<DeviceManagementService> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DeviceManagementService);
 };
diff --git a/chrome/browser/policy/device_policy_cache.cc b/chrome/browser/policy/device_policy_cache.cc
index 090ad76..14109ab 100644
--- a/chrome/browser/policy/device_policy_cache.cc
+++ b/chrome/browser/policy/device_policy_cache.cc
@@ -9,6 +9,8 @@
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/bind.h"
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
@@ -33,11 +35,11 @@ namespace {
 class StorePolicyOperation : public chromeos::SignedSettingsHelper::Callback,
                              public chromeos::OwnerManager::KeyUpdateDelegate {
  public:
-  typedef Callback1<chromeos::SignedSettings::ReturnCode>::Type Callback;
+  typedef base::Callback<void(chromeos::SignedSettings::ReturnCode)> Callback;
 
   StorePolicyOperation(chromeos::SignedSettingsHelper* signed_settings_helper,
                        const em::PolicyFetchResponse& policy,
-                       Callback* callback)
+                       const Callback& callback)
       : signed_settings_helper_(signed_settings_helper),
         policy_(policy),
         callback_(callback) {
@@ -51,7 +53,7 @@ class StorePolicyOperation : public chromeos::SignedSettingsHelper::Callback,
   virtual void OnStorePolicyCompleted(
       chromeos::SignedSettings::ReturnCode code) OVERRIDE {
     if (code != chromeos::SignedSettings::SUCCESS) {
-      callback_->Run(code);
+      callback_.Run(code);
       delete this;
       return;
     }
@@ -67,7 +69,7 @@ class StorePolicyOperation : public chromeos::SignedSettingsHelper::Callback,
       return;
     } else {
       UpdateUserCrosSettings();
-      callback_->Run(chromeos::SignedSettings::SUCCESS);
+      callback_.Run(chromeos::SignedSettings::SUCCESS);
       delete this;
       return;
     }
@@ -76,7 +78,7 @@ class StorePolicyOperation : public chromeos::SignedSettingsHelper::Callback,
   // OwnerManager::KeyUpdateDelegate implementation:
   virtual void OnKeyUpdated() OVERRIDE {
     UpdateUserCrosSettings();
-    callback_->Run(chromeos::SignedSettings::SUCCESS);
+    callback_.Run(chromeos::SignedSettings::SUCCESS);
     delete this;
   }
 
@@ -90,7 +92,7 @@ class StorePolicyOperation : public chromeos::SignedSettingsHelper::Callback,
 
   chromeos::SignedSettingsHelper* signed_settings_helper_;
   em::PolicyFetchResponse policy_;
-  scoped_ptr<Callback> callback_;
+  Callback callback_;
 
   DISALLOW_COPY_AND_ASSIGN(StorePolicyOperation);
 };
@@ -118,7 +120,7 @@ DevicePolicyCache::DevicePolicyCache(
     : data_store_(data_store),
       install_attributes_(install_attributes),
       signed_settings_helper_(chromeos::SignedSettingsHelper::Get()),
-      ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
 DevicePolicyCache::DevicePolicyCache(
@@ -128,7 +130,7 @@ DevicePolicyCache::DevicePolicyCache(
     : data_store_(data_store),
       install_attributes_(install_attributes),
       signed_settings_helper_(signed_settings_helper),
-      ALLOW_THIS_IN_INITIALIZER_LIST(callback_factory_(this)) {
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)) {
 }
 
 DevicePolicyCache::~DevicePolicyCache() {
@@ -178,10 +180,10 @@ void DevicePolicyCache::SetPolicy(const em::PolicyFetchResponse& policy) {
   set_last_policy_refresh_time(base::Time::NowFromSystemTime());
 
   // Start a store operation.
-  new StorePolicyOperation(signed_settings_helper_,
-                           policy,
-                           callback_factory_.NewCallback(
-                               &DevicePolicyCache::PolicyStoreOpCompleted));
+  StorePolicyOperation::Callback callback =
+      base::Bind(&DevicePolicyCache::PolicyStoreOpCompleted,
+                 weak_ptr_factory_.GetWeakPtr());
+  new StorePolicyOperation(signed_settings_helper_, policy, callback);
 }
 
 void DevicePolicyCache::SetUnmanaged() {
diff --git a/chrome/browser/policy/device_policy_cache.h b/chrome/browser/policy/device_policy_cache.h
index b4e2669..63ed1ce 100644
--- a/chrome/browser/policy/device_policy_cache.h
+++ b/chrome/browser/policy/device_policy_cache.h
@@ -6,7 +6,7 @@
 #define CHROME_BROWSER_POLICY_DEVICE_POLICY_CACHE_H_
 #pragma once
 
-#include "base/memory/scoped_callback_factory.h"
+#include "base/memory/weak_ptr.h"
 #include "chrome/browser/chromeos/login/signed_settings.h"
 #include "chrome/browser/chromeos/login/signed_settings_helper.h"
 #include "chrome/browser/policy/cloud_policy_cache_base.h"
@@ -76,7 +76,7 @@ class DevicePolicyCache : public CloudPolicyCacheBase,
 
   chromeos::SignedSettingsHelper* signed_settings_helper_;
 
-  base::ScopedCallbackFactory<DevicePolicyCache> callback_factory_;
+  base::WeakPtrFactory<DevicePolicyCache> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DevicePolicyCache);
 };
diff --git a/chrome/browser/policy/logging_work_scheduler.cc b/chrome/browser/policy/logging_work_scheduler.cc
index 39292e6..c4606b7 100644
--- a/chrome/browser/policy/logging_work_scheduler.cc
+++ b/chrome/browser/policy/logging_work_scheduler.cc
@@ -6,6 +6,7 @@
 
 #include <algorithm>
 
+#include "base/bind.h"
 #include "base/message_loop.h"
 #include "content/browser/browser_thread.h"
 
@@ -79,8 +80,8 @@ base::Closure EventLogger::Task::GetAndResetCallback() {
 }
 
 EventLogger::EventLogger()
-    : step_task_(NULL),
-      ALLOW_THIS_IN_INITIALIZER_LIST(method_factory_(this)),
+    : step_pending_(false),
+      ALLOW_THIS_IN_INITIALIZER_LIST(weak_ptr_factory_(this)),
       current_time_(0),
       task_counter_(0) {
 }
@@ -95,9 +96,11 @@ void EventLogger::PostDelayedWork(
   int64 trigger_time = current_time_ + delay;
   task_counter_++;
   scheduled_tasks_.push(Task(trigger_time, task_counter_, callback));
-  if (!step_task_) {
-    step_task_ = method_factory_.NewRunnableMethod(&EventLogger::Step);
-    MessageLoop::current()->PostTask(FROM_HERE, step_task_);
+  if (!step_pending_) {
+    step_pending_ = true;
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&EventLogger::Step, weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
@@ -124,8 +127,8 @@ int EventLogger::CountEvents(const std::vector<int64>& events,
 }
 
 void EventLogger::Step() {
-  DCHECK(step_task_);
-  step_task_ = NULL;
+  DCHECK(step_pending_);
+  step_pending_ = false;
   if (scheduled_tasks_.empty())
     return;
   // Take the next scheduled task from the queue.
@@ -137,12 +140,14 @@ void EventLogger::Step() {
   // Execute the next scheduled task if it was not cancelled.
   if (!callback.is_null()) {
     current_time_ = trigger_time;
-    callback.Run(); // Note: new items may be added to scheduled_tasks_ here.
+    callback.Run();  // Note: new items may be added to scheduled_tasks_ here.
   }
   // Trigger calling this method if there are remaining tasks.
-  if (!step_task_ && !scheduled_tasks_.empty()) {
-    step_task_ = method_factory_.NewRunnableMethod(&EventLogger::Step);
-    MessageLoop::current()->PostTask(FROM_HERE, step_task_);
+  if (!step_pending_ && !scheduled_tasks_.empty()) {
+    step_pending_ = true;
+    MessageLoop::current()->PostTask(
+        FROM_HERE,
+        base::Bind(&EventLogger::Step, weak_ptr_factory_.GetWeakPtr()));
   }
 }
 
diff --git a/chrome/browser/policy/logging_work_scheduler.h b/chrome/browser/policy/logging_work_scheduler.h
index 3dd867b..383207b 100644
--- a/chrome/browser/policy/logging_work_scheduler.h
+++ b/chrome/browser/policy/logging_work_scheduler.h
@@ -13,7 +13,7 @@
 #include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/memory/linked_ptr.h"
-#include "base/task.h"
+#include "base/memory/weak_ptr.h"
 #include "chrome/browser/policy/delayed_work_scheduler.h"
 
 // Utilities for testing users of DelayedWorkScheduler. There are no
@@ -88,8 +88,8 @@ class EventLogger {
   std::priority_queue<Task> scheduled_tasks_;
 
   // Machinery to put a call to |Step| at the end of the message loop.
-  CancelableTask* step_task_;
-  ScopedRunnableMethodFactory<EventLogger> method_factory_;
+  bool step_pending_;
+  base::WeakPtrFactory<EventLogger> weak_ptr_factory_;
 
   // Ascending list of observation-times of the logged events.
   std::vector<int64> events_;
diff --git a/chrome/browser/policy/url_blacklist_manager.cc b/chrome/browser/policy/url_blacklist_manager.cc
index 8cc32c7..b8502b4 100644
--- a/chrome/browser/policy/url_blacklist_manager.cc
+++ b/chrome/browser/policy/url_blacklist_manager.cc
@@ -295,7 +295,7 @@ void URLBlacklist::AddFilter(const std::string& filter, bool block) {
 }
 
 URLBlacklistManager::URLBlacklistManager(PrefService* pref_service)
-    : ALLOW_THIS_IN_INITIALIZER_LIST(ui_method_factory_(this)),
+    : ALLOW_THIS_IN_INITIALIZER_LIST(ui_weak_ptr_factory_(this)),
       pref_service_(pref_service),
       ALLOW_THIS_IN_INITIALIZER_LIST(io_weak_ptr_factory_(this)),
       blacklist_(new URLBlacklist) {
@@ -314,7 +314,7 @@ URLBlacklistManager::URLBlacklistManager(PrefService* pref_service)
 void URLBlacklistManager::ShutdownOnUIThread() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Cancel any pending updates, and stop listening for pref change updates.
-  ui_method_factory_.RevokeAll();
+  ui_weak_ptr_factory_.InvalidateWeakPtrs();
   pref_change_registrar_.RemoveAll();
 }
 
@@ -337,12 +337,12 @@ void URLBlacklistManager::Observe(int type,
 void URLBlacklistManager::ScheduleUpdate() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // Cancel pending updates, if any.
-  ui_method_factory_.RevokeAll();
-  PostUpdateTask(
-      ui_method_factory_.NewRunnableMethod(&URLBlacklistManager::Update));
+  ui_weak_ptr_factory_.InvalidateWeakPtrs();
+  PostUpdateTask(base::Bind(&URLBlacklistManager::Update,
+                            ui_weak_ptr_factory_.GetWeakPtr()));
 }
 
-void URLBlacklistManager::PostUpdateTask(Task* task) {
+void URLBlacklistManager::PostUpdateTask(const base::Closure& task) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   // This is overridden in tests to post the task without the delay.
   MessageLoop::current()->PostDelayedTask(FROM_HERE, task, kUpdateDelayMs);
diff --git a/chrome/browser/policy/url_blacklist_manager.h b/chrome/browser/policy/url_blacklist_manager.h
index aa4553f..4be5509 100644
--- a/chrome/browser/policy/url_blacklist_manager.h
+++ b/chrome/browser/policy/url_blacklist_manager.h
@@ -10,11 +10,11 @@
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/callback.h"
 #include "base/compiler_specific.h"
 #include "base/hash_tables.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/weak_ptr.h"
-#include "base/task.h"
 #include "chrome/browser/prefs/pref_change_registrar.h"
 #include "content/common/notification_observer.h"
 
@@ -98,7 +98,7 @@ class URLBlacklist {
 // changes are received from, and the IO thread, which owns it (in the
 // ProfileIOData) and checks for blacklisted URLs (from ChromeNetworkDelegate).
 //
-// It must be constructed on the UI thread, to set up |ui_method_factory_| and
+// It must be constructed on the UI thread, to set up |ui_weak_ptr_factory_| and
 // the prefs listeners.
 //
 // ShutdownOnUIThread must be called from UI before destruction, to release
@@ -134,8 +134,9 @@ class URLBlacklistManager : public NotificationObserver {
   // These are used to delay updating the blacklist while the preferences are
   // changing, and execute only one update per simultaneous prefs changes.
   void ScheduleUpdate();
-  virtual void PostUpdateTask(Task* task);  // Virtual for testing.
-  virtual void Update();  // Virtual for testing.
+  // The following methods are virtual for testing.
+  virtual void PostUpdateTask(const base::Closure& task);
+  virtual void Update();
 
   // Starts the blacklist update on the IO thread, using the filters in
   // |block| and |allow|. Protected for testing.
@@ -151,7 +152,7 @@ class URLBlacklistManager : public NotificationObserver {
   // ---------
 
   // Used to post update tasks to the UI thread.
-  ScopedRunnableMethodFactory<URLBlacklistManager> ui_method_factory_;
+  base::WeakPtrFactory<URLBlacklistManager> ui_weak_ptr_factory_;
 
   // Used to track the policies and update the blacklist on changes.
   PrefChangeRegistrar pref_change_registrar_;
diff --git a/chrome/browser/policy/url_blacklist_manager_unittest.cc b/chrome/browser/policy/url_blacklist_manager_unittest.cc
index 8101ec9..816208a 100644
--- a/chrome/browser/policy/url_blacklist_manager_unittest.cc
+++ b/chrome/browser/policy/url_blacklist_manager_unittest.cc
@@ -37,7 +37,7 @@ class TestingURLBlacklistManager : public URLBlacklistManager {
   using URLBlacklistManager::ScheduleUpdate;
 
   // Post tasks without a delay during tests.
-  virtual void PostUpdateTask(Task* task) OVERRIDE {
+  virtual void PostUpdateTask(const base::Closure& task) OVERRIDE {
     MessageLoop::current()->PostTask(FROM_HERE, task);
   }
 
diff --git a/chrome/browser/policy/user_policy_disk_cache.cc b/chrome/browser/policy/user_policy_disk_cache.cc
index 2c8c5c9..0a18e54 100644
--- a/chrome/browser/policy/user_policy_disk_cache.cc
+++ b/chrome/browser/policy/user_policy_disk_cache.cc
@@ -4,10 +4,10 @@
 
 #include "chrome/browser/policy/user_policy_disk_cache.h"
 
+#include "base/bind.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
-#include "base/task.h"
 #include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 #include "content/browser/browser_thread.h"
@@ -25,7 +25,7 @@ void SampleUMAOnUIThread(policy::MetricPolicy sample) {
 void SampleUMA(policy::MetricPolicy sample) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          NewRunnableFunction(&SampleUMAOnUIThread, sample));
+                          base::Bind(&SampleUMAOnUIThread, sample));
 }
 
 }  // namespace
@@ -44,7 +44,7 @@ void UserPolicyDiskCache::Load() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      NewRunnableMethod(this, &UserPolicyDiskCache::LoadOnFileThread));
+      base::Bind(&UserPolicyDiskCache::LoadOnFileThread, this));
 }
 
 void UserPolicyDiskCache::Store(
@@ -52,7 +52,7 @@ void UserPolicyDiskCache::Store(
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      NewRunnableMethod(this, &UserPolicyDiskCache::StoreOnFileThread, policy));
+      base::Bind(&UserPolicyDiskCache::StoreOnFileThread, this, policy));
 }
 
 UserPolicyDiskCache::~UserPolicyDiskCache() {}
@@ -91,9 +91,8 @@ void UserPolicyDiskCache::LoadDone(
     const em::CachedCloudPolicyResponse& policy) {
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(this,
-                        &UserPolicyDiskCache::ReportResultOnUIThread,
-                        result, policy));
+      base::Bind(&UserPolicyDiskCache::ReportResultOnUIThread, this,
+                 result, policy));
 }
 
 void UserPolicyDiskCache::ReportResultOnUIThread(
diff --git a/chrome/browser/policy/user_policy_token_cache.cc b/chrome/browser/policy/user_policy_token_cache.cc
index 0d5c3c5..fd7d9c8 100644
--- a/chrome/browser/policy/user_policy_token_cache.cc
+++ b/chrome/browser/policy/user_policy_token_cache.cc
@@ -4,9 +4,9 @@
 
 #include "chrome/browser/policy/user_policy_token_cache.h"
 
+#include "base/bind.h"
 #include "base/file_util.h"
 #include "base/metrics/histogram.h"
-#include "base/task.h"
 #include "chrome/browser/policy/enterprise_metrics.h"
 #include "chrome/browser/policy/proto/device_management_local.pb.h"
 #include "content/browser/browser_thread.h"
@@ -24,7 +24,7 @@ void SampleUMAOnUIThread(policy::MetricToken sample) {
 void SampleUMA(policy::MetricToken sample) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          NewRunnableFunction(&SampleUMAOnUIThread, sample));
+                          base::Bind(&SampleUMAOnUIThread, sample));
 }
 
 }  // namespace
@@ -45,7 +45,7 @@ void UserPolicyTokenLoader::Load() {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      NewRunnableMethod(this, &UserPolicyTokenLoader::LoadOnFileThread));
+      base::Bind(&UserPolicyTokenLoader::LoadOnFileThread, this));
 }
 
 void UserPolicyTokenLoader::Store(const std::string& token,
@@ -53,10 +53,10 @@ void UserPolicyTokenLoader::Store(const std::string& token,
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
-      NewRunnableMethod(this,
-                        &UserPolicyTokenLoader::StoreOnFileThread,
-                        token,
-                        device_id));
+      base::Bind(&UserPolicyTokenLoader::StoreOnFileThread,
+                 this,
+                 token,
+                 device_id));
 }
 
 UserPolicyTokenLoader::~UserPolicyTokenLoader() {
@@ -82,10 +82,10 @@ void UserPolicyTokenLoader::LoadOnFileThread() {
 
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
-      NewRunnableMethod(this,
-                        &UserPolicyTokenLoader::NotifyOnUIThread,
-                        device_token,
-                        device_id));
+      base::Bind(&UserPolicyTokenLoader::NotifyOnUIThread,
+                 this,
+                 device_token,
+                 device_id));
 }
 
 void UserPolicyTokenLoader::NotifyOnUIThread(const std::string& token,