Move FilePathWatcher to base/files.

base/files/file_path_watcher_unittest.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 "content/common/file_path_watcher/file_path_watcher.h"
+#include "base/files/file_path_watcher.h"

[dmac, 2011/04/05 19:55:51]

this was a browsertest because it locks up in failure conditions. Browsertest
would kill off the test eventually. I have a work around I am working on right
now to fix this condition (awaiting review), but for right now I don't think we
can make this a unittest safely.

[Craig, 2011/04/06 15:27:30]

OK. Should I wait for your fix or just turn this back into a browsertest? (eg.
leave the file in the new location with the new name and just hook it into the
original gyp file temporarily with a TODO or put the file back in the old
location etc. etc. ... ugly either way).

[dmac, 2011/04/06 16:19:54]

For right now I would turn it back into a browsertest, and hook it from the
original gyp file with a TODO (please log a bug and refer to it in the TODO).
Put my name on the bug, and then when I hopefully get my change in somebody can
fix it up.

 
 #include <set>
 
 #if defined(OS_WIN)
 #include <windows.h>
 #include <aclapi.h>
 #elif defined(OS_POSIX)
 #include <sys/stat.h>
 #endif

[dmac, 2011/04/05 19:55:51]

instead of prefixes everywhere, how about

using ::base::files;

Would it be better to use a using statement for all of the
file_path_watcher_*.cc files? seems more DRY than prefixing everything.

[Craig, 2011/04/06 15:27:30]

Yes, sorry about that. I've used "using ::base::files::FilePathWatcher;" in the
.cc files now and it's much cleaner.

 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_temp_dir.h"
 #include "base/message_loop.h"
 #include "base/message_loop_proxy.h"
 #include "base/path_service.h"
 #include "base/string_util.h"
@@ skipping 53 matching lines @@
   std::set<TestDelegate*> signaled_;
 
   // The loop we should break after all delegates signaled.
   scoped_refptr<base::MessageLoopProxy> loop_;
 };
 
 // A mock FilePathWatcher::Delegate for testing. I'd rather use gmock, but it's
 // not thread safe for setting expectations, so the test code couldn't safely
 // reset expectations while the file watcher is running. In order to allow this,
 // we keep simple thread safe status flags in TestDelegate.
-class TestDelegate : public FilePathWatcher::Delegate {
+class TestDelegate : public base::files::FilePathWatcher::Delegate {
  public:
   // The message loop specified by |loop| will be quit if a notification is
   // received while the delegate is |armed_|. Note that the testing code must
   // guarantee |loop| outlives the file thread on which OnFilePathChanged runs.
   explicit TestDelegate(NotificationCollector* collector)
       : collector_(collector) {
     collector_->Register(this);
   }
 
   virtual void OnFilePathChanged(const FilePath&) {
     collector_->OnChange(this);
   }
 
   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,
+                 base::files::FilePathWatcher* watcher,
+                 base::files::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_;
+  base::files::FilePathWatcher* watcher_;
+  base::files::FilePathWatcher::Delegate* delegate_;
   bool* result_;
   base::WaitableEvent* completion_;
 
   DISALLOW_COPY_AND_ASSIGN(SetupWatchTask);
 };
 
 class FilePathWatcherTest : public testing::Test {
  public:
   FilePathWatcherTest()
       : file_thread_("FilePathWatcherTest") {}
@@ skipping 17 matching lines @@
     return temp_dir_.path().AppendASCII("FilePathWatcherTest");
   }
 
   // Write |content| to |file|. Returns true on success.
   bool WriteFile(const FilePath& file, const std::string& content) {
     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 {
+  bool SetupWatch(
+      const FilePath& target,
+      base::files::FilePathWatcher* watcher,
+      base::files::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));
     completion.Wait();
     return result;
   }
 
   bool WaitForEvents() WARN_UNUSED_RESULT {
     collector_->Reset();
     loop_.Run();
     return collector_->Success();
   }
 
   NotificationCollector* collector() { return collector_.get(); }
 
   MessageLoop loop_;
   base::Thread file_thread_;
   ScopedTempDir temp_dir_;
   scoped_refptr<NotificationCollector> collector_;
 };
 
 // Basic test: Create the file and verify that we notice.
 TEST_F(FilePathWatcherTest, NewFile) {
-  FilePathWatcher watcher;
+  base::files::FilePathWatcher watcher;
   scoped_refptr<TestDelegate> delegate(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get()));
 
   ASSERT_TRUE(WriteFile(test_file(), "content"));
   ASSERT_TRUE(WaitForEvents());
 }
 
 // Verify that modifying the file is caught.
 TEST_F(FilePathWatcherTest, ModifiedFile) {
   ASSERT_TRUE(WriteFile(test_file(), "content"));
 
-  FilePathWatcher watcher;
+  base::files::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 modified.
   ASSERT_TRUE(WriteFile(test_file(), "new content"));
   ASSERT_TRUE(WaitForEvents());
 }
 
 // Verify that moving the file into place is caught.
 TEST_F(FilePathWatcherTest, MovedFile) {
   FilePath source_file(temp_dir_.path().AppendASCII("source"));
   ASSERT_TRUE(WriteFile(source_file, "content"));
 
-  FilePathWatcher watcher;
+  base::files::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 modified.
   ASSERT_TRUE(file_util::Move(source_file, test_file()));
   ASSERT_TRUE(WaitForEvents());
 }
 
 TEST_F(FilePathWatcherTest, DeletedFile) {
   ASSERT_TRUE(WriteFile(test_file(), "content"));
 
-  FilePathWatcher watcher;
+  base::files::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());
 }
 
 // Used by the DeleteDuringNotify test below.
 // Deletes the FilePathWatcher when it's notified.
-class Deleter : public FilePathWatcher::Delegate {
+class Deleter : public base::files::FilePathWatcher::Delegate {
  public:
-  Deleter(FilePathWatcher* watcher, MessageLoop* loop)
+  Deleter(base::files::FilePathWatcher* watcher, MessageLoop* loop)
       : watcher_(watcher),
         loop_(loop) {
   }
 
   virtual void OnFilePathChanged(const FilePath& path) {
     watcher_.reset();
     loop_->PostTask(FROM_HERE, new MessageLoop::QuitTask());
   }
 
-  scoped_ptr<FilePathWatcher> watcher_;
+  scoped_ptr<base::files::FilePathWatcher> watcher_;
   MessageLoop* loop_;
 };
 
 // Verify that deleting a watcher during the callback doesn't crash.
 TEST_F(FilePathWatcherTest, DeleteDuringNotify) {
-  FilePathWatcher* watcher = new FilePathWatcher;
+  base::files::FilePathWatcher* watcher = new base::files::FilePathWatcher;
   // Takes ownership of watcher.
   scoped_refptr<Deleter> deleter(new Deleter(watcher, &loop_));
   ASSERT_TRUE(SetupWatch(test_file(), watcher, deleter.get()));
 
   ASSERT_TRUE(WriteFile(test_file(), "content"));
   ASSERT_TRUE(WaitForEvents());
 
   // We win if we haven't crashed yet.
   // Might as well double-check it got deleted, too.
   ASSERT_TRUE(deleter->watcher_.get() == NULL);
 }
 
 // Verify that deleting the watcher works even if there is a pending
 // notification.
 TEST_F(FilePathWatcherTest, DestroyWithPendingNotification) {
   scoped_refptr<TestDelegate> delegate(new TestDelegate(collector()));
-  FilePathWatcher* watcher = new FilePathWatcher;
+  base::files::FilePathWatcher* watcher = new base::files::FilePathWatcher;
   ASSERT_TRUE(SetupWatch(test_file(), watcher, delegate.get()));
   ASSERT_TRUE(WriteFile(test_file(), "content"));
   file_thread_.message_loop_proxy()->DeleteSoon(FROM_HERE, watcher);
 }
 
 TEST_F(FilePathWatcherTest, MultipleWatchersSingleFile) {
-  FilePathWatcher watcher1, watcher2;
+  base::files::FilePathWatcher watcher1, watcher2;
   scoped_refptr<TestDelegate> delegate1(new TestDelegate(collector()));
   scoped_refptr<TestDelegate> delegate2(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(test_file(), &watcher1, delegate1.get()));
   ASSERT_TRUE(SetupWatch(test_file(), &watcher2, delegate2.get()));
 
   ASSERT_TRUE(WriteFile(test_file(), "content"));
   ASSERT_TRUE(WaitForEvents());
 }
 
 // Verify that watching a file whose parent directory doesn't exist yet works if
 // the directory and file are created eventually.
 TEST_F(FilePathWatcherTest, NonExistentDirectory) {
-  FilePathWatcher watcher;
+  base::files::FilePathWatcher watcher;
   FilePath dir(temp_dir_.path().AppendASCII("dir"));
   FilePath file(dir.AppendASCII("file"));
   scoped_refptr<TestDelegate> delegate(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(file, &watcher, delegate.get()));
 
   ASSERT_TRUE(file_util::CreateDirectory(dir));
 
   ASSERT_TRUE(WriteFile(file, "content"));
 
   VLOG(1) << "Waiting for file creation";
@@ skipping 12 matching lines @@
 // are rapidly created.
 TEST_F(FilePathWatcherTest, DirectoryChain) {
   FilePath path(temp_dir_.path());
   std::vector<std::string> dir_names;
   for (int i = 0; i < 20; i++) {
     std::string dir(StringPrintf("d%d", i));
     dir_names.push_back(dir);
     path = path.AppendASCII(dir);
   }
 
-  FilePathWatcher watcher;
+  base::files::FilePathWatcher watcher;
   FilePath file(path.AppendASCII("file"));
   scoped_refptr<TestDelegate> delegate(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(file, &watcher, delegate.get()));
 
   FilePath sub_path(temp_dir_.path());
   for (std::vector<std::string>::const_iterator d(dir_names.begin());
        d != dir_names.end(); ++d) {
     sub_path = sub_path.AppendASCII(*d);
     ASSERT_TRUE(file_util::CreateDirectory(sub_path));
   }
   VLOG(1) << "Create File";
   ASSERT_TRUE(WriteFile(file, "content"));
   VLOG(1) << "Waiting for file creation";
   ASSERT_TRUE(WaitForEvents());
 
   ASSERT_TRUE(WriteFile(file, "content v2"));
   VLOG(1) << "Waiting for file modification";
   ASSERT_TRUE(WaitForEvents());
 }
 
 TEST_F(FilePathWatcherTest, DisappearingDirectory) {
-  FilePathWatcher watcher;
+  base::files::FilePathWatcher watcher;
   FilePath dir(temp_dir_.path().AppendASCII("dir"));
   FilePath file(dir.AppendASCII("file"));
   ASSERT_TRUE(file_util::CreateDirectory(dir));
   ASSERT_TRUE(WriteFile(file, "content"));
   scoped_refptr<TestDelegate> delegate(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(file, &watcher, delegate.get()));
 
   ASSERT_TRUE(file_util::Delete(dir, true));
   ASSERT_TRUE(WaitForEvents());
 }
 
 // Tests that a file that is deleted and reappears is tracked correctly.
 TEST_F(FilePathWatcherTest, DeleteAndRecreate) {
   ASSERT_TRUE(WriteFile(test_file(), "content"));
-  FilePathWatcher watcher;
+  base::files::FilePathWatcher watcher;
   scoped_refptr<TestDelegate> delegate(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get()));
 
   ASSERT_TRUE(file_util::Delete(test_file(), false));
   VLOG(1) << "Waiting for file deletion";
   ASSERT_TRUE(WaitForEvents());
 
   ASSERT_TRUE(WriteFile(test_file(), "content"));
   VLOG(1) << "Waiting for file creation";
   ASSERT_TRUE(WaitForEvents());
 }
 
 TEST_F(FilePathWatcherTest, WatchDirectory) {
-  FilePathWatcher watcher;
+  base::files::FilePathWatcher watcher;
   FilePath dir(temp_dir_.path().AppendASCII("dir"));
   FilePath file1(dir.AppendASCII("file1"));
   FilePath file2(dir.AppendASCII("file2"));
   scoped_refptr<TestDelegate> delegate(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(dir, &watcher, delegate.get()));
 
   ASSERT_TRUE(file_util::CreateDirectory(dir));
   VLOG(1) << "Waiting for directory creation";
   ASSERT_TRUE(WaitForEvents());
 
@@ skipping 11 matching lines @@
   ASSERT_TRUE(file_util::Delete(file1, false));
   VLOG(1) << "Waiting for file1 deletion";
   ASSERT_TRUE(WaitForEvents());
 
   ASSERT_TRUE(WriteFile(file2, "content"));
   VLOG(1) << "Waiting for file2 creation";
   ASSERT_TRUE(WaitForEvents());
 }
 
 TEST_F(FilePathWatcherTest, MoveParent) {
-  FilePathWatcher file_watcher;
-  FilePathWatcher subdir_watcher;
+  base::files::FilePathWatcher file_watcher;
+  base::files::FilePathWatcher subdir_watcher;
   FilePath dir(temp_dir_.path().AppendASCII("dir"));
   FilePath dest(temp_dir_.path().AppendASCII("dest"));
   FilePath subdir(dir.AppendASCII("subdir"));
   FilePath file(subdir.AppendASCII("file"));
   scoped_refptr<TestDelegate> file_delegate(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(file, &file_watcher, file_delegate.get()));
   scoped_refptr<TestDelegate> subdir_delegate(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(subdir, &subdir_watcher, subdir_delegate.get()));
 
   // Setup a directory hierarchy.
   ASSERT_TRUE(file_util::CreateDirectory(subdir));
   ASSERT_TRUE(WriteFile(file, "content"));
   VLOG(1) << "Waiting for file creation";
   ASSERT_TRUE(WaitForEvents());
 
   // Move the parent directory.
   file_util::Move(dir, dest);
   VLOG(1) << "Waiting for directory move";
   ASSERT_TRUE(WaitForEvents());
 }
 
 TEST_F(FilePathWatcherTest, MoveChild) {
-  FilePathWatcher file_watcher;
-  FilePathWatcher subdir_watcher;
+  base::files::FilePathWatcher file_watcher;
+  base::files::FilePathWatcher subdir_watcher;
   FilePath source_dir(temp_dir_.path().AppendASCII("source"));
   FilePath source_subdir(source_dir.AppendASCII("subdir"));
   FilePath source_file(source_subdir.AppendASCII("file"));
   FilePath dest_dir(temp_dir_.path().AppendASCII("dest"));
   FilePath dest_subdir(dest_dir.AppendASCII("subdir"));
   FilePath dest_file(dest_subdir.AppendASCII("file"));
 
   // Setup a directory hierarchy.
   ASSERT_TRUE(file_util::CreateDirectory(source_subdir));
   ASSERT_TRUE(WriteFile(source_file, "content"));
 
   scoped_refptr<TestDelegate> file_delegate(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(dest_file, &file_watcher, file_delegate.get()));
   scoped_refptr<TestDelegate> subdir_delegate(new TestDelegate(collector()));
   ASSERT_TRUE(SetupWatch(dest_subdir, &subdir_watcher, subdir_delegate.get()));
 
   // Move the directory into place, s.t. the watched file appears.
   ASSERT_TRUE(file_util::Move(source_dir, dest_dir));
   ASSERT_TRUE(WaitForEvents());
 }
 
 #if !defined(OS_LINUX)
 // Linux implementation of FilePathWatcher doesn't catch attribute changes.
 // http://crbug.com/78043
 
 // Verify that changing attributes on a file is caught
 TEST_F(FilePathWatcherTest, FileAttributesChanged) {
   ASSERT_TRUE(WriteFile(test_file(), "content"));
-  FilePathWatcher watcher;
+  base::files::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 modified.
   ASSERT_TRUE(file_util::MakeFileUnreadable(test_file()));
   ASSERT_TRUE(WaitForEvents());
 }
 
 #endif  // !OS_LINUX
 
@@ skipping 97 matching lines @@
 // Verify that changing attributes on a directory works.
 TEST_F(FilePathWatcherTest, DirAttributesChanged) {
   FilePath test_dir1(temp_dir_.path().AppendASCII("DirAttributesChangedDir1"));
   FilePath test_dir2(test_dir1.AppendASCII("DirAttributesChangedDir2"));
   FilePath test_file(test_dir2.AppendASCII("DirAttributesChangedFile"));
   // Setup a directory hierarchy.
   ASSERT_TRUE(file_util::CreateDirectory(test_dir1));
   ASSERT_TRUE(file_util::CreateDirectory(test_dir2));
   ASSERT_TRUE(WriteFile(test_file, "content"));
 
-  FilePathWatcher watcher;
+  base::files::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,
                         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