Move FilePathWatcher to base/files.

base/files/file_path_watcher_unittest.cc

Index: base/files/file_path_watcher_unittest.cc
diff --git a/content/common/file_path_watcher/file_path_watcher_browsertest.cc b/base/files/file_path_watcher_unittest.cc
similarity index 92%
rename from content/common/file_path_watcher/file_path_watcher_browsertest.cc
rename to base/files/file_path_watcher_unittest.cc
index b847ca9e2901ce12ec3a108ec8bba72426ae88e5..e0448ce48476006dd122c7175b39474ab56772f9 100644
--- a/content/common/file_path_watcher/file_path_watcher_browsertest.cc
+++ b/base/files/file_path_watcher_unittest.cc
@@ -2,7 +2,7 @@
 // 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>
 
@@ -85,7 +85,7 @@ class NotificationCollector
 // 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
@@ -113,8 +113,8 @@ class TestDelegate : public FilePathWatcher::Delegate {
 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),
@@ -130,8 +130,8 @@ class SetupWatchTask : public Task {
 
  private:
   const FilePath target_;
-  FilePathWatcher* watcher_;
-  FilePathWatcher::Delegate* delegate_;
+  base::files::FilePathWatcher* watcher_;
+  base::files::FilePathWatcher::Delegate* delegate_;
   bool* result_;
   base::WaitableEvent* completion_;
 
@@ -169,9 +169,10 @@ class FilePathWatcherTest : public testing::Test {
     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,
@@ -200,7 +201,7 @@ class FilePathWatcherTest : public testing::Test {
 
 // 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()));
 
@@ -212,7 +213,7 @@ TEST_F(FilePathWatcherTest, NewFile) {
 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()));
 
@@ -226,7 +227,7 @@ 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()));
 
@@ -238,7 +239,7 @@ TEST_F(FilePathWatcherTest, MovedFile) {
 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()));
 
@@ -249,9 +250,9 @@ TEST_F(FilePathWatcherTest, DeletedFile) {
 
 // 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) {
   }
@@ -261,13 +262,13 @@ class Deleter : public FilePathWatcher::Delegate {
     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()));
@@ -284,14 +285,14 @@ TEST_F(FilePathWatcherTest, DeleteDuringNotify) {
 // 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()));
@@ -304,7 +305,7 @@ TEST_F(FilePathWatcherTest, MultipleWatchersSingleFile) {
 // 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()));
@@ -337,7 +338,7 @@ TEST_F(FilePathWatcherTest, DirectoryChain) {
     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()));
@@ -359,7 +360,7 @@ TEST_F(FilePathWatcherTest, DirectoryChain) {
 }
 
 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));
@@ -374,7 +375,7 @@ TEST_F(FilePathWatcherTest, DisappearingDirectory) {
 // 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()));
 
@@ -388,7 +389,7 @@ TEST_F(FilePathWatcherTest, DeleteAndRecreate) {
 }
 
 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"));
@@ -420,8 +421,8 @@ TEST_F(FilePathWatcherTest, WatchDirectory) {
 }
 
 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"));
@@ -444,8 +445,8 @@ TEST_F(FilePathWatcherTest, MoveParent) {
 }
 
 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"));
@@ -474,7 +475,7 @@ TEST_F(FilePathWatcherTest, MoveChild) {
 // 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()));
 
@@ -592,7 +593,7 @@ TEST_F(FilePathWatcherTest, DirAttributesChanged) {
   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()));