base::Bind: Convert FilePathWatcher.

base/files/file_path_watcher_browsertest.cc

 // Copyright (c) 2011 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 "base/files/file_path_watcher.h"
 
 #include <set>
 
 #if defined(OS_WIN)
 #include <windows.h>
@@ skipping 54 matching lines @@
   }
 
  private:
   void RecordChange(TestDelegate* delegate) {
     ASSERT_TRUE(loop_->BelongsToCurrentThread());
     ASSERT_TRUE(delegates_.count(delegate));
     signaled_.insert(delegate);
 
     // Check whether all delegates have been signaled.
     if (signaled_ == delegates_)
-      loop_->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+      loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   // Set of registered delegates.
   std::set<TestDelegate*> delegates_;
 
   // Set of signaled delegates.
   std::set<TestDelegate*> signaled_;
 
   // The loop we should break after all delegates signaled.
   scoped_refptr<base::MessageLoopProxy> loop_;
@@ skipping 20 matching lines @@
   virtual void OnFilePathError(const FilePath& path) {
     ADD_FAILURE() << "Error " << path.value();
   }
 
  private:
   scoped_refptr<NotificationCollector> collector_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDelegate);
 };
 
-// A helper class for setting up watches on the file thread.
-class SetupWatchTask : public Task {
- public:
-  SetupWatchTask(const FilePath& target,
-                 FilePathWatcher* watcher,
-                 FilePathWatcher::Delegate* delegate,
-                 bool* result,
-                 base::WaitableEvent* completion)
-      : target_(target),
-        watcher_(watcher),
-        delegate_(delegate),
-        result_(result),
-        completion_(completion) {}
-
-  void Run() {
-    *result_ = watcher_->Watch(target_, delegate_);
-    completion_->Signal();
-  }
-
- private:
-  const FilePath target_;
-  FilePathWatcher* watcher_;
-  FilePathWatcher::Delegate* delegate_;
-  bool* result_;
-  base::WaitableEvent* completion_;
-
-  DISALLOW_COPY_AND_ASSIGN(SetupWatchTask);
-};
+void SetupWatchCallback(const FilePath& target,
+                        FilePathWatcher* watcher,
+                        FilePathWatcher::Delegate* delegate,
+                        bool* result,
+                        base::WaitableEvent* completion) {
+  *result = watcher->Watch(target, delegate);
+  completion->Signal();
+}
 
 class FilePathWatcherTest : public testing::Test {
  public:
   FilePathWatcherTest()
       : file_thread_("FilePathWatcherTest") {}
 
   virtual ~FilePathWatcherTest() {}
 
  protected:
   virtual void SetUp() {
@@ skipping 21 matching lines @@
     int write_size = file_util::WriteFile(file, content.c_str(),
                                           content.length());
     return write_size == static_cast<int>(content.length());
   }
 
   bool SetupWatch(const FilePath& target,
                   FilePathWatcher* watcher,
                   FilePathWatcher::Delegate* delegate) WARN_UNUSED_RESULT {
     base::WaitableEvent completion(false, false);
     bool result;
-    file_thread_.message_loop_proxy()->PostTask(FROM_HERE,
-         new SetupWatchTask(target,
-                            watcher,
-                            delegate,
-                            &result,
-                            &completion));
+    file_thread_.message_loop_proxy()->PostTask(
+        FROM_HERE,
+        base::Bind(SetupWatchCallback, target, watcher,
+                   make_scoped_refptr(delegate), &result, &completion));
     completion.Wait();
     return result;
   }
 
   bool WaitForEvents() WARN_UNUSED_RESULT {
     collector_->Reset();
     loop_.Run();
     return collector_->Success();
   }
 
@@ skipping 58 matching lines @@
 // Deletes the FilePathWatcher when it's notified.
 class Deleter : public FilePathWatcher::Delegate {
  public:
   Deleter(FilePathWatcher* watcher, MessageLoop* loop)
       : watcher_(watcher),
         loop_(loop) {
   }
 
   virtual void OnFilePathChanged(const FilePath& path) {
     watcher_.reset();
-    loop_->PostTask(FROM_HERE, new MessageLoop::QuitTask());
+    loop_->PostTask(FROM_HERE, MessageLoop::QuitClosure());
   }
 
   scoped_ptr<FilePathWatcher> watcher_;
   MessageLoop* loop_;
 };
 
 // Verify that deleting a watcher during the callback doesn't crash.
 TEST_F(FilePathWatcherTest, DeleteDuringNotify) {
   FilePathWatcher* watcher = new FilePathWatcher;
   // Takes ownership of watcher.
@@ skipping 491 matching lines @@
   ASSERT_TRUE(WriteFile(test_file, "content"));
 
   FilePathWatcher watcher;
   scoped_refptr<TestDelegate> delegate(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(test_file, &watcher, delegate.get()));
 
   // We should not get notified in this case as it hasn't affected our ability
   // to access the file.
   ASSERT_TRUE(ChangeFilePermissions(test_dir1, Read, false));
   loop_.PostDelayedTask(FROM_HERE,
-                        new MessageLoop::QuitTask,
+                        MessageLoop::QuitClosure(),
                         TestTimeouts::tiny_timeout_ms());
   ASSERT_FALSE(WaitForEvents());
   ASSERT_TRUE(ChangeFilePermissions(test_dir1, Read, true));
 
   // We should get notified in this case because filepathwatcher can no
   // longer access the file
   ASSERT_TRUE(ChangeFilePermissions(test_dir1, Execute, false));
   ASSERT_TRUE(WaitForEvents());
   ASSERT_TRUE(ChangeFilePermissions(test_dir1, Execute, true));
 }
 
 #endif  // OS_MACOSX
 }  // namespace
 
 }  // namespace files
 }  // namespace base