Added a base::Callback interface to FilePathWatcher.

base/files/file_path_watcher_browsertest.cc

 // Copyright (c) 2012 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 101 matching lines @@
 
  protected:
   virtual ~TestDelegate() {}
 
  private:
   scoped_refptr<NotificationCollector> collector_;
 
   DISALLOW_COPY_AND_ASSIGN(TestDelegate);
 };
 
-void SetupWatchCallback(const FilePath& target,
+void SetupWatchDelegate(const FilePath& target,
                         FilePathWatcher* watcher,
                         FilePathWatcher::Delegate* delegate,
                         bool* result,
                         base::WaitableEvent* completion) {
   *result = watcher->Watch(target, delegate);
   completion->Signal();
 }
 
+void SetupWatchCallback(const FilePath& target,
+                        FilePathWatcher* watcher,
+                        const FilePathWatcher::Callback& callback) {
+  ASSERT_TRUE(watcher->Watch(target, callback));
+}
+
+void QuitLoopWatchCallback(MessageLoop* loop,
+                           const FilePath& expected_path,
+                           bool expected_error,
+                           bool* flag,
+                           const FilePath& path,
+                           bool error) {
+  ASSERT_TRUE(flag);
+  *flag = true;
+  EXPECT_EQ(expected_path, path);
+  EXPECT_EQ(expected_error, error);
+  loop->PostTask(FROM_HERE, loop->QuitClosure());
+}
+
 class FilePathWatcherTest : public testing::Test {
  public:
   FilePathWatcherTest()
       : file_thread_("FilePathWatcherTest") {}
 
   virtual ~FilePathWatcherTest() {}
 
  protected:
   virtual void SetUp() {
     // Create a separate file thread in order to test proper thread usage.
@@ skipping 22 matching lines @@
     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,
-        base::Bind(SetupWatchCallback, target, watcher,
+        base::Bind(SetupWatchDelegate, 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 48 matching lines @@
 
   FilePathWatcher watcher;
   scoped_refptr<TestDelegate> delegate(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get()));
 
   // Now make sure we get notified if the file is deleted.
   file_util::Delete(test_file(), false);
   ASSERT_TRUE(WaitForEvents());
 }
 
+TEST_F(FilePathWatcherTest, Callback) {
+  FilePathWatcher watcher;
+  bool called_back = false;
+
+  MessageLoop* file_loop = file_thread_.message_loop();
+  ASSERT_TRUE(file_loop);
+  // The callback makes |loop_| quit on file events, and flips |called_back|
+  // to true.
+  FilePathWatcher::Callback callback = base::Bind(
+      QuitLoopWatchCallback, &loop_, test_file(), false, &called_back);
+
+  // Start watching on the file thread, and unblock the loop once the callback
+  // has been installed.
+  file_thread_.message_loop_proxy()->PostTaskAndReply(
+      FROM_HERE,
+      base::Bind(SetupWatchCallback, test_file(), &watcher, callback),
+      base::Bind(&MessageLoop::Quit, base::Unretained(&loop_)));
+  loop_.Run();
+  EXPECT_FALSE(called_back);

[Mattias Nissler (ping if slow), 2012/06/04 12:26:39]

Is it safe to test the flag here that got written on a different thread here?
Also, spurious notifications may bite you here.

[Joao da Silva, 2012/06/04 12:45:42]

The flag is written before the UI loop is unblocked, so it's safe to test the
flag below. But testing it here is indeed a bad idea; removed.

+
+  // The watch has been installed. Trigger a file event now, which will unblock
+  // the loop again.
+  ASSERT_TRUE(WriteFile(test_file(), "content"));
+  loop_.Run();
+  EXPECT_TRUE(called_back);
+}
+
 // Used by the DeleteDuringNotify test below.
 // 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) {
@@ skipping 523 matching lines @@
   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