base::Bind: Convert the following files.

* sync_test.cc.
* extensions_activity_monitor.cc.
* extensions_activity_monitor_unittest.cc.

BUG=none
TEST=none

R=groby@chromium.org

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

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

2 files changed, 41 insertions, 67 deletions

diff --git a/chrome/browser/sync/util/extensions_activity_monitor.cc b/chrome/browser/sync/util/extensions_activity_monitor.cc
index c06e325..335f148 100644
--- a/chrome/browser/sync/util/extensions_activity_monitor.cc
+++ b/chrome/browser/sync/util/extensions_activity_monitor.cc
@@ -4,7 +4,7 @@
 
 #include "chrome/browser/sync/util/extensions_activity_monitor.h"
 
-#include "base/task.h"
+#include "base/bind.h"
 #include "chrome/browser/bookmarks/bookmark_extension_api.h"
 #include "chrome/common/chrome_notification_types.h"
 #include "chrome/common/extensions/extension.h"
@@ -16,39 +16,29 @@ using content::BrowserThread;
 namespace browser_sync {
 
 namespace {
-// A helper task to register an ExtensionsActivityMonitor as an observer of
+
+// A helper callback to register an ExtensionsActivityMonitor as an observer of
 // events on the UI thread (even though the monitor may live on another thread).
 // This liberates ExtensionsActivityMonitor from having to be ref counted.
-class RegistrationTask : public Task {
- public:
-  RegistrationTask(ExtensionsActivityMonitor* monitor,
-                   content::NotificationRegistrar* registrar)
-      : monitor_(monitor), registrar_(registrar) {}
-  virtual ~RegistrationTask() {}
-
-  virtual void Run() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+void RegistrationCallback(ExtensionsActivityMonitor* monitor,
+                          content::NotificationRegistrar* registrar) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
-    // It would be nice if we could specify a Source for each specific function
-    // we wanted to observe, but the actual function objects are allocated on
-    // the fly so there is no reliable object to point to (same problem if we
-    // wanted to use the string name).  Thus, we use all sources and filter in
-    // Observe.
-    registrar_->Add(monitor_,
-                    chrome::NOTIFICATION_EXTENSION_BOOKMARKS_API_INVOKED,
-                    content::NotificationService::AllSources());
-  }
+  // It would be nice if we could specify a Source for each specific function
+  // we wanted to observe, but the actual function objects are allocated on
+  // the fly so there is no reliable object to point to (same problem if we
+  // wanted to use the string name).  Thus, we use all sources and filter in
+  // Observe.
+  registrar->Add(monitor,
+                 chrome::NOTIFICATION_EXTENSION_BOOKMARKS_API_INVOKED,
+                 content::NotificationService::AllSources());
+}
 
- private:
-  ExtensionsActivityMonitor* monitor_;
-  content::NotificationRegistrar* registrar_;
-  DISALLOW_COPY_AND_ASSIGN(RegistrationTask);
-};
 }  // namespace
 
 ExtensionsActivityMonitor::ExtensionsActivityMonitor() {
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-                          new RegistrationTask(this, &registrar_));
+                          base::Bind(&RegistrationCallback, this, &registrar_));
 }
 
 ExtensionsActivityMonitor::~ExtensionsActivityMonitor() {
diff --git a/chrome/browser/sync/util/extensions_activity_monitor_unittest.cc b/chrome/browser/sync/util/extensions_activity_monitor_unittest.cc
index 3bd0694..4340031 100644
--- a/chrome/browser/sync/util/extensions_activity_monitor_unittest.cc
+++ b/chrome/browser/sync/util/extensions_activity_monitor_unittest.cc
@@ -4,6 +4,7 @@
 
 #include "chrome/browser/sync/util/extensions_activity_monitor.h"
 
+#include "base/bind.h"
 #include "base/file_path.h"
 #include "base/string_util.h"
 #include "base/synchronization/waitable_event.h"
@@ -40,33 +41,22 @@ const char* kTestExtensionVersion = "1.0.0.0";
 const char* kTestExtensionName = "foo extension";
 
 template <class FunctionType>
-class BookmarkAPIEventTask : public Task {
- public:
-  BookmarkAPIEventTask(FunctionType* t, Extension* e, size_t repeats,
-                       base::WaitableEvent* done) :
-       extension_(e), function_(t), repeats_(repeats), done_(done) {}
-   virtual void Run() {
-     for (size_t i = 0; i < repeats_; i++) {
-       content::NotificationService::current()->Notify(
-           chrome::NOTIFICATION_EXTENSION_BOOKMARKS_API_INVOKED,
-           content::Source<Extension>(extension_.get()),
-           content::Details<const BookmarksFunction>(function_.get()));
-     }
-     done_->Signal();
+void BookmarkAPIEventCallback(FunctionType* function, Extension* extension,
+                              size_t repeats, base::WaitableEvent* done) {
+  for (size_t i = 0; i < repeats; i++) {
+     content::NotificationService::current()->Notify(
+         chrome::NOTIFICATION_EXTENSION_BOOKMARKS_API_INVOKED,
+         content::Source<Extension>(extension),
+         content::Details<const BookmarksFunction>(function));
    }
- private:
-  scoped_refptr<Extension> extension_;
-  scoped_refptr<FunctionType> function_;
-  size_t repeats_;
-  base::WaitableEvent* done_;
-
-  DISALLOW_COPY_AND_ASSIGN(BookmarkAPIEventTask);
-};
+   done->Signal();
+}
 
 class BookmarkAPIEventGenerator {
  public:
   BookmarkAPIEventGenerator() {}
   virtual ~BookmarkAPIEventGenerator() {}
+
   template <class T>
   void NewEvent(const FilePath::StringType& extension_path,
       T* bookmarks_function, size_t repeats) {
@@ -79,32 +69,25 @@ class BookmarkAPIEventGenerator {
         Extension::STRICT_ERROR_CHECKS, &error));
     bookmarks_function->set_name(T::function_name());
     base::WaitableEvent done_event(false, false);
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        new BookmarkAPIEventTask<T>(bookmarks_function, extension,
-                                    repeats, &done_event));
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&BookmarkAPIEventCallback<T>,
+                   make_scoped_refptr(bookmarks_function), extension, repeats,
+                   &done_event));
     done_event.Wait();
   }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(BookmarkAPIEventGenerator);
 };
+
 }  // namespace
 
-class DoUIThreadSetupTask : public Task {
- public:
-  DoUIThreadSetupTask(content::NotificationService** service,
-                      base::WaitableEvent* done)
-      : service_(service), signal_when_done_(done) {}
-  virtual ~DoUIThreadSetupTask() {}
-  virtual void Run() {
-    *service_ = new NotificationServiceImpl();
-    signal_when_done_->Signal();
-  }
- private:
-  content::NotificationService** service_;
-  base::WaitableEvent* signal_when_done_;
-  DISALLOW_COPY_AND_ASSIGN(DoUIThreadSetupTask);
-};
+void DoUIThreadSetupCallback(content::NotificationService** service,
+                             base::WaitableEvent* done) {
+  *service = new NotificationServiceImpl();
+  done->Signal();
+}
 
 class ExtensionsActivityMonitorTest : public testing::Test {
  public:
@@ -115,8 +98,9 @@ class ExtensionsActivityMonitorTest : public testing::Test {
   virtual void SetUp() {
     ui_thread_.Start();
     base::WaitableEvent service_created(false, false);
-    BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
-        new DoUIThreadSetupTask(&service_, &service_created));
+    BrowserThread::PostTask(
+        BrowserThread::UI, FROM_HERE,
+        base::Bind(&DoUIThreadSetupCallback, &service_, &service_created));
     service_created.Wait();
   }