base/files/file_path_watcher_browsertest.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "base/files/file_path_watcher.h"
   6
   7 #if defined(OS_WIN)
   8 #include <windows.h>
   9 #include <aclapi.h>
  10 #elif defined(OS_POSIX)
  11 #include <sys/stat.h>
  12 #endif
  13
  14 #include <set>
  15
  16 #include "base/basictypes.h"
  17 #include "base/bind.h"
  18 #include "base/bind_helpers.h"
  19 #include "base/compiler_specific.h"
  20 #include "base/files/file_path.h"
  21 #include "base/files/file_util.h"
  22 #include "base/files/scoped_temp_dir.h"
  23 #include "base/message_loop/message_loop.h"
  24 #include "base/message_loop/message_loop_proxy.h"
  25 #include "base/run_loop.h"
  26 #include "base/stl_util.h"
  27 #include "base/strings/stringprintf.h"
  28 #include "base/synchronization/waitable_event.h"
  29 #include "base/test/test_file_util.h"
  30 #include "base/test/test_timeouts.h"
  31 #include "base/threading/thread.h"
  32 #include "testing/gtest/include/gtest/gtest.h"
  33
  34 namespace base {
  35
  36 namespace {
  37
  38 class TestDelegate;
  39
  40 // Aggregates notifications from the test delegates and breaks the message loop
  41 // the test thread is waiting on once they all came in.
  42 class NotificationCollector
  43     : public base::RefCountedThreadSafe<NotificationCollector> {
  44  public:
  45   NotificationCollector()
  46       : loop_(base::MessageLoopProxy::current()) {}
  47
  48   // Called from the file thread by the delegates.
  49   void OnChange(TestDelegate* delegate) {
  50     loop_->PostTask(FROM_HERE,
  51                     base::Bind(&NotificationCollector::RecordChange, this,
  52                                base::Unretained(delegate)));
  53   }
  54
  55   void Register(TestDelegate* delegate) {
  56     delegates_.insert(delegate);
  57   }
  58
  59   void Reset() {
  60     signaled_.clear();
  61   }
  62
  63   bool Success() {
  64     return signaled_ == delegates_;
  65   }
  66
  67  private:
  68   friend class base::RefCountedThreadSafe<NotificationCollector>;
  69   ~NotificationCollector() {}
  70
  71   void RecordChange(TestDelegate* delegate) {
  72     // Warning: |delegate| is Unretained. Do not dereference.
  73     ASSERT_TRUE(loop_->BelongsToCurrentThread());
  74     ASSERT_TRUE(delegates_.count(delegate));
  75     signaled_.insert(delegate);
  76
  77     // Check whether all delegates have been signaled.
  78     if (signaled_ == delegates_)
  79       loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
  80   }
  81
  82   // Set of registered delegates.
  83   std::set<TestDelegate*> delegates_;
  84
  85   // Set of signaled delegates.
  86   std::set<TestDelegate*> signaled_;
  87
  88   // The loop we should break after all delegates signaled.
  89   scoped_refptr<base::MessageLoopProxy> loop_;
  90 };
  91
  92 class TestDelegateBase : public SupportsWeakPtr<TestDelegateBase> {
  93  public:
  94   TestDelegateBase() {}
  95   virtual ~TestDelegateBase() {}
  96
  97   virtual void OnFileChanged(const FilePath& path, bool error) = 0;
  98
  99  private:
 100   DISALLOW_COPY_AND_ASSIGN(TestDelegateBase);
 101 };
 102
 103 // A mock class for testing. Gmock is not appropriate because it is not
 104 // thread-safe for setting expectations. Thus the test code cannot safely
 105 // reset expectations while the file watcher is running.
 106 // Instead, TestDelegate gets the notifications from FilePathWatcher and uses
 107 // NotificationCollector to aggregate the results.
 108 class TestDelegate : public TestDelegateBase {
 109  public:
 110   explicit TestDelegate(NotificationCollector* collector)
 111       : collector_(collector) {
 112     collector_->Register(this);
 113   }
 114   ~TestDelegate() override {}
 115
 116   void OnFileChanged(const FilePath& path, bool error) override {
 117     if (error)
 118       ADD_FAILURE() << "Error " << path.value();
 119     else
 120       collector_->OnChange(this);
 121   }
 122
 123  private:
 124   scoped_refptr<NotificationCollector> collector_;
 125
 126   DISALLOW_COPY_AND_ASSIGN(TestDelegate);
 127 };
 128
 129 void SetupWatchCallback(const FilePath& target,
 130                         FilePathWatcher* watcher,
 131                         TestDelegateBase* delegate,
 132                         bool recursive_watch,
 133                         bool* result,
 134                         base::WaitableEvent* completion) {
 135   *result = watcher->Watch(target, recursive_watch,
 136                            base::Bind(&TestDelegateBase::OnFileChanged,
 137                                       delegate->AsWeakPtr()));
 138   completion->Signal();
 139 }
 140
 141 class FilePathWatcherTest : public testing::Test {
 142  public:
 143   FilePathWatcherTest()
 144       : file_thread_("FilePathWatcherTest") {}
 145
 146   ~FilePathWatcherTest() override {}
 147
 148  protected:
 149   void SetUp() override {
 150     // Create a separate file thread in order to test proper thread usage.
 151     base::Thread::Options options(MessageLoop::TYPE_IO, 0);
 152     ASSERT_TRUE(file_thread_.StartWithOptions(options));
 153     ASSERT_TRUE(temp_dir_.CreateUniqueTempDir());
 154     collector_ = new NotificationCollector();
 155   }
 156
 157   void TearDown() override { RunLoop().RunUntilIdle(); }
 158
 159   void DeleteDelegateOnFileThread(TestDelegate* delegate) {
 160     file_thread_.message_loop_proxy()->DeleteSoon(FROM_HERE, delegate);
 161   }
 162
 163   FilePath test_file() {
 164     return temp_dir_.path().AppendASCII("FilePathWatcherTest");
 165   }
 166
 167   FilePath test_link() {
 168     return temp_dir_.path().AppendASCII("FilePathWatcherTest.lnk");
 169   }
 170
 171   // Write |content| to |file|. Returns true on success.
 172   bool WriteFile(const FilePath& file, const std::string& content) {
 173     int write_size = ::base::WriteFile(file, content.c_str(), content.length());
 174     return write_size == static_cast<int>(content.length());
 175   }
 176
 177   bool SetupWatch(const FilePath& target,
 178                   FilePathWatcher* watcher,
 179                   TestDelegateBase* delegate,
 180                   bool recursive_watch) WARN_UNUSED_RESULT;
 181
 182   bool WaitForEvents() WARN_UNUSED_RESULT {
 183     collector_->Reset();
 184     loop_.Run();
 185     return collector_->Success();
 186   }
 187
 188   NotificationCollector* collector() { return collector_.get(); }
 189
 190   MessageLoop loop_;
 191   base::Thread file_thread_;
 192   ScopedTempDir temp_dir_;
 193   scoped_refptr<NotificationCollector> collector_;
 194
 195   DISALLOW_COPY_AND_ASSIGN(FilePathWatcherTest);
 196 };
 197
 198 bool FilePathWatcherTest::SetupWatch(const FilePath& target,
 199                                      FilePathWatcher* watcher,
 200                                      TestDelegateBase* delegate,
 201                                      bool recursive_watch) {
 202   base::WaitableEvent completion(false, false);
 203   bool result;
 204   file_thread_.message_loop_proxy()->PostTask(
 205       FROM_HERE,
 206       base::Bind(SetupWatchCallback, target, watcher, delegate, recursive_watch,
 207                  &result, &completion));
 208   completion.Wait();
 209   return result;
 210 }
 211
 212 // Basic test: Create the file and verify that we notice.
 213 TEST_F(FilePathWatcherTest, NewFile) {
 214   FilePathWatcher watcher;
 215   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 216   ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
 217
 218   ASSERT_TRUE(WriteFile(test_file(), "content"));
 219   ASSERT_TRUE(WaitForEvents());
 220   DeleteDelegateOnFileThread(delegate.release());
 221 }
 222
 223 // Verify that modifying the file is caught.
 224 TEST_F(FilePathWatcherTest, ModifiedFile) {
 225   ASSERT_TRUE(WriteFile(test_file(), "content"));
 226
 227   FilePathWatcher watcher;
 228   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 229   ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
 230
 231   // Now make sure we get notified if the file is modified.
 232   ASSERT_TRUE(WriteFile(test_file(), "new content"));
 233   ASSERT_TRUE(WaitForEvents());
 234   DeleteDelegateOnFileThread(delegate.release());
 235 }
 236
 237 // Verify that moving the file into place is caught.
 238 TEST_F(FilePathWatcherTest, MovedFile) {
 239   FilePath source_file(temp_dir_.path().AppendASCII("source"));
 240   ASSERT_TRUE(WriteFile(source_file, "content"));
 241
 242   FilePathWatcher watcher;
 243   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 244   ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
 245
 246   // Now make sure we get notified if the file is modified.
 247   ASSERT_TRUE(base::Move(source_file, test_file()));
 248   ASSERT_TRUE(WaitForEvents());
 249   DeleteDelegateOnFileThread(delegate.release());
 250 }
 251
 252 TEST_F(FilePathWatcherTest, DeletedFile) {
 253   ASSERT_TRUE(WriteFile(test_file(), "content"));
 254
 255   FilePathWatcher watcher;
 256   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 257   ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
 258
 259   // Now make sure we get notified if the file is deleted.
 260   base::DeleteFile(test_file(), false);
 261   ASSERT_TRUE(WaitForEvents());
 262   DeleteDelegateOnFileThread(delegate.release());
 263 }
 264
 265 // Used by the DeleteDuringNotify test below.
 266 // Deletes the FilePathWatcher when it's notified.
 267 class Deleter : public TestDelegateBase {
 268  public:
 269   Deleter(FilePathWatcher* watcher, MessageLoop* loop)
 270       : watcher_(watcher),
 271         loop_(loop) {
 272   }
 273   ~Deleter() override {}
 274
 275   void OnFileChanged(const FilePath&, bool) override {
 276     watcher_.reset();
 277     loop_->PostTask(FROM_HERE, MessageLoop::QuitWhenIdleClosure());
 278   }
 279
 280   FilePathWatcher* watcher() const { return watcher_.get(); }
 281
 282  private:
 283   scoped_ptr<FilePathWatcher> watcher_;
 284   MessageLoop* loop_;
 285
 286   DISALLOW_COPY_AND_ASSIGN(Deleter);
 287 };
 288
 289 // Verify that deleting a watcher during the callback doesn't crash.
 290 TEST_F(FilePathWatcherTest, DeleteDuringNotify) {
 291   FilePathWatcher* watcher = new FilePathWatcher;
 292   // Takes ownership of watcher.
 293   scoped_ptr<Deleter> deleter(new Deleter(watcher, &loop_));
 294   ASSERT_TRUE(SetupWatch(test_file(), watcher, deleter.get(), false));
 295
 296   ASSERT_TRUE(WriteFile(test_file(), "content"));
 297   ASSERT_TRUE(WaitForEvents());
 298
 299   // We win if we haven't crashed yet.
 300   // Might as well double-check it got deleted, too.
 301   ASSERT_TRUE(deleter->watcher() == NULL);
 302 }
 303
 304 // Verify that deleting the watcher works even if there is a pending
 305 // notification.
 306 // Flaky on MacOS (and ARM linux): http://crbug.com/85930
 307 TEST_F(FilePathWatcherTest, DISABLED_DestroyWithPendingNotification) {
 308   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 309   FilePathWatcher* watcher = new FilePathWatcher;
 310   ASSERT_TRUE(SetupWatch(test_file(), watcher, delegate.get(), false));
 311   ASSERT_TRUE(WriteFile(test_file(), "content"));
 312   file_thread_.message_loop_proxy()->DeleteSoon(FROM_HERE, watcher);
 313   DeleteDelegateOnFileThread(delegate.release());
 314 }
 315
 316 TEST_F(FilePathWatcherTest, MultipleWatchersSingleFile) {
 317   FilePathWatcher watcher1, watcher2;
 318   scoped_ptr<TestDelegate> delegate1(new TestDelegate(collector()));
 319   scoped_ptr<TestDelegate> delegate2(new TestDelegate(collector()));
 320   ASSERT_TRUE(SetupWatch(test_file(), &watcher1, delegate1.get(), false));
 321   ASSERT_TRUE(SetupWatch(test_file(), &watcher2, delegate2.get(), false));
 322
 323   ASSERT_TRUE(WriteFile(test_file(), "content"));
 324   ASSERT_TRUE(WaitForEvents());
 325   DeleteDelegateOnFileThread(delegate1.release());
 326   DeleteDelegateOnFileThread(delegate2.release());
 327 }
 328
 329 // Verify that watching a file whose parent directory doesn't exist yet works if
 330 // the directory and file are created eventually.
 331 TEST_F(FilePathWatcherTest, NonExistentDirectory) {
 332   FilePathWatcher watcher;
 333   FilePath dir(temp_dir_.path().AppendASCII("dir"));
 334   FilePath file(dir.AppendASCII("file"));
 335   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 336   ASSERT_TRUE(SetupWatch(file, &watcher, delegate.get(), false));
 337
 338   ASSERT_TRUE(base::CreateDirectory(dir));
 339
 340   ASSERT_TRUE(WriteFile(file, "content"));
 341
 342   VLOG(1) << "Waiting for file creation";
 343   ASSERT_TRUE(WaitForEvents());
 344
 345   ASSERT_TRUE(WriteFile(file, "content v2"));
 346   VLOG(1) << "Waiting for file change";
 347   ASSERT_TRUE(WaitForEvents());
 348
 349   ASSERT_TRUE(base::DeleteFile(file, false));
 350   VLOG(1) << "Waiting for file deletion";
 351   ASSERT_TRUE(WaitForEvents());
 352   DeleteDelegateOnFileThread(delegate.release());
 353 }
 354
 355 // Exercises watch reconfiguration for the case that directories on the path
 356 // are rapidly created.
 357 TEST_F(FilePathWatcherTest, DirectoryChain) {
 358   FilePath path(temp_dir_.path());
 359   std::vector<std::string> dir_names;
 360   for (int i = 0; i < 20; i++) {
 361     std::string dir(base::StringPrintf("d%d", i));
 362     dir_names.push_back(dir);
 363     path = path.AppendASCII(dir);
 364   }
 365
 366   FilePathWatcher watcher;
 367   FilePath file(path.AppendASCII("file"));
 368   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 369   ASSERT_TRUE(SetupWatch(file, &watcher, delegate.get(), false));
 370
 371   FilePath sub_path(temp_dir_.path());
 372   for (std::vector<std::string>::const_iterator d(dir_names.begin());
 373        d != dir_names.end(); ++d) {
 374     sub_path = sub_path.AppendASCII(*d);
 375     ASSERT_TRUE(base::CreateDirectory(sub_path));
 376   }
 377   VLOG(1) << "Create File";
 378   ASSERT_TRUE(WriteFile(file, "content"));
 379   VLOG(1) << "Waiting for file creation";
 380   ASSERT_TRUE(WaitForEvents());
 381
 382   ASSERT_TRUE(WriteFile(file, "content v2"));
 383   VLOG(1) << "Waiting for file modification";
 384   ASSERT_TRUE(WaitForEvents());
 385   DeleteDelegateOnFileThread(delegate.release());
 386 }
 387
 388 #if defined(OS_MACOSX)
 389 // http://crbug.com/85930
 390 #define DisappearingDirectory DISABLED_DisappearingDirectory
 391 #endif
 392 TEST_F(FilePathWatcherTest, DisappearingDirectory) {
 393   FilePathWatcher watcher;
 394   FilePath dir(temp_dir_.path().AppendASCII("dir"));
 395   FilePath file(dir.AppendASCII("file"));
 396   ASSERT_TRUE(base::CreateDirectory(dir));
 397   ASSERT_TRUE(WriteFile(file, "content"));
 398   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 399   ASSERT_TRUE(SetupWatch(file, &watcher, delegate.get(), false));
 400
 401   ASSERT_TRUE(base::DeleteFile(dir, true));
 402   ASSERT_TRUE(WaitForEvents());
 403   DeleteDelegateOnFileThread(delegate.release());
 404 }
 405
 406 // Tests that a file that is deleted and reappears is tracked correctly.
 407 TEST_F(FilePathWatcherTest, DeleteAndRecreate) {
 408   ASSERT_TRUE(WriteFile(test_file(), "content"));
 409   FilePathWatcher watcher;
 410   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 411   ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
 412
 413   ASSERT_TRUE(base::DeleteFile(test_file(), false));
 414   VLOG(1) << "Waiting for file deletion";
 415   ASSERT_TRUE(WaitForEvents());
 416
 417   ASSERT_TRUE(WriteFile(test_file(), "content"));
 418   VLOG(1) << "Waiting for file creation";
 419   ASSERT_TRUE(WaitForEvents());
 420   DeleteDelegateOnFileThread(delegate.release());
 421 }
 422
 423 TEST_F(FilePathWatcherTest, WatchDirectory) {
 424   FilePathWatcher watcher;
 425   FilePath dir(temp_dir_.path().AppendASCII("dir"));
 426   FilePath file1(dir.AppendASCII("file1"));
 427   FilePath file2(dir.AppendASCII("file2"));
 428   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 429   ASSERT_TRUE(SetupWatch(dir, &watcher, delegate.get(), false));
 430
 431   ASSERT_TRUE(base::CreateDirectory(dir));
 432   VLOG(1) << "Waiting for directory creation";
 433   ASSERT_TRUE(WaitForEvents());
 434
 435   ASSERT_TRUE(WriteFile(file1, "content"));
 436   VLOG(1) << "Waiting for file1 creation";
 437   ASSERT_TRUE(WaitForEvents());
 438
 439 #if !defined(OS_MACOSX)
 440   // Mac implementation does not detect files modified in a directory.
 441   ASSERT_TRUE(WriteFile(file1, "content v2"));
 442   VLOG(1) << "Waiting for file1 modification";
 443   ASSERT_TRUE(WaitForEvents());
 444 #endif  // !OS_MACOSX
 445
 446   ASSERT_TRUE(base::DeleteFile(file1, false));
 447   VLOG(1) << "Waiting for file1 deletion";
 448   ASSERT_TRUE(WaitForEvents());
 449
 450   ASSERT_TRUE(WriteFile(file2, "content"));
 451   VLOG(1) << "Waiting for file2 creation";
 452   ASSERT_TRUE(WaitForEvents());
 453   DeleteDelegateOnFileThread(delegate.release());
 454 }
 455
 456 TEST_F(FilePathWatcherTest, MoveParent) {
 457   FilePathWatcher file_watcher;
 458   FilePathWatcher subdir_watcher;
 459   FilePath dir(temp_dir_.path().AppendASCII("dir"));
 460   FilePath dest(temp_dir_.path().AppendASCII("dest"));
 461   FilePath subdir(dir.AppendASCII("subdir"));
 462   FilePath file(subdir.AppendASCII("file"));
 463   scoped_ptr<TestDelegate> file_delegate(new TestDelegate(collector()));
 464   ASSERT_TRUE(SetupWatch(file, &file_watcher, file_delegate.get(), false));
 465   scoped_ptr<TestDelegate> subdir_delegate(new TestDelegate(collector()));
 466   ASSERT_TRUE(SetupWatch(subdir, &subdir_watcher, subdir_delegate.get(),
 467                          false));
 468
 469   // Setup a directory hierarchy.
 470   ASSERT_TRUE(base::CreateDirectory(subdir));
 471   ASSERT_TRUE(WriteFile(file, "content"));
 472   VLOG(1) << "Waiting for file creation";
 473   ASSERT_TRUE(WaitForEvents());
 474
 475   // Move the parent directory.
 476   base::Move(dir, dest);
 477   VLOG(1) << "Waiting for directory move";
 478   ASSERT_TRUE(WaitForEvents());
 479   DeleteDelegateOnFileThread(file_delegate.release());
 480   DeleteDelegateOnFileThread(subdir_delegate.release());
 481 }
 482
 483 TEST_F(FilePathWatcherTest, RecursiveWatch) {
 484   FilePathWatcher watcher;
 485   FilePath dir(temp_dir_.path().AppendASCII("dir"));
 486   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 487   bool setup_result = SetupWatch(dir, &watcher, delegate.get(), true);
 488   if (!FilePathWatcher::RecursiveWatchAvailable()) {
 489     ASSERT_FALSE(setup_result);
 490     DeleteDelegateOnFileThread(delegate.release());
 491     return;
 492   }
 493   ASSERT_TRUE(setup_result);
 494
 495   // Main directory("dir") creation.
 496   ASSERT_TRUE(base::CreateDirectory(dir));
 497   ASSERT_TRUE(WaitForEvents());
 498
 499   // Create "$dir/file1".
 500   FilePath file1(dir.AppendASCII("file1"));
 501   ASSERT_TRUE(WriteFile(file1, "content"));
 502   ASSERT_TRUE(WaitForEvents());
 503
 504   // Create "$dir/subdir".
 505   FilePath subdir(dir.AppendASCII("subdir"));
 506   ASSERT_TRUE(base::CreateDirectory(subdir));
 507   ASSERT_TRUE(WaitForEvents());
 508
 509   // Create "$dir/subdir/subdir_file1".
 510   FilePath subdir_file1(subdir.AppendASCII("subdir_file1"));
 511   ASSERT_TRUE(WriteFile(subdir_file1, "content"));
 512   ASSERT_TRUE(WaitForEvents());
 513
 514   // Create "$dir/subdir/subdir_child_dir".
 515   FilePath subdir_child_dir(subdir.AppendASCII("subdir_child_dir"));
 516   ASSERT_TRUE(base::CreateDirectory(subdir_child_dir));
 517   ASSERT_TRUE(WaitForEvents());
 518
 519   // Create "$dir/subdir/subdir_child_dir/child_dir_file1".
 520   FilePath child_dir_file1(subdir_child_dir.AppendASCII("child_dir_file1"));
 521   ASSERT_TRUE(WriteFile(child_dir_file1, "content v2"));
 522   ASSERT_TRUE(WaitForEvents());
 523
 524   // Write into "$dir/subdir/subdir_child_dir/child_dir_file1".
 525   ASSERT_TRUE(WriteFile(child_dir_file1, "content"));
 526   ASSERT_TRUE(WaitForEvents());
 527
 528   // Modify "$dir/subdir/subdir_child_dir/child_dir_file1" attributes.
 529   ASSERT_TRUE(base::MakeFileUnreadable(child_dir_file1));
 530   ASSERT_TRUE(WaitForEvents());
 531
 532   // Delete "$dir/subdir/subdir_file1".
 533   ASSERT_TRUE(base::DeleteFile(subdir_file1, false));
 534   ASSERT_TRUE(WaitForEvents());
 535
 536   // Delete "$dir/subdir/subdir_child_dir/child_dir_file1".
 537   ASSERT_TRUE(base::DeleteFile(child_dir_file1, false));
 538   ASSERT_TRUE(WaitForEvents());
 539   DeleteDelegateOnFileThread(delegate.release());
 540 }
 541
 542 #if defined(OS_POSIX)
 543 TEST_F(FilePathWatcherTest, RecursiveWithSymLink) {
 544   if (!FilePathWatcher::RecursiveWatchAvailable())
 545     return;
 546
 547   FilePathWatcher watcher;
 548   FilePath test_dir(temp_dir_.path().AppendASCII("test_dir"));
 549   ASSERT_TRUE(base::CreateDirectory(test_dir));
 550   FilePath symlink(test_dir.AppendASCII("symlink"));
 551   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 552   ASSERT_TRUE(SetupWatch(symlink, &watcher, delegate.get(), true));
 553
 554   // Link creation.
 555   FilePath target1(temp_dir_.path().AppendASCII("target1"));
 556   ASSERT_TRUE(base::CreateSymbolicLink(target1, symlink));
 557   ASSERT_TRUE(WaitForEvents());
 558
 559   // Target1 creation.
 560   ASSERT_TRUE(base::CreateDirectory(target1));
 561   ASSERT_TRUE(WaitForEvents());
 562
 563   // Create a file in target1.
 564   FilePath target1_file(target1.AppendASCII("file"));
 565   ASSERT_TRUE(WriteFile(target1_file, "content"));
 566   ASSERT_TRUE(WaitForEvents());
 567
 568   // Link change.
 569   FilePath target2(temp_dir_.path().AppendASCII("target2"));
 570   ASSERT_TRUE(base::CreateDirectory(target2));
 571   ASSERT_TRUE(base::DeleteFile(symlink, false));
 572   ASSERT_TRUE(base::CreateSymbolicLink(target2, symlink));
 573   ASSERT_TRUE(WaitForEvents());
 574
 575   // Create a file in target2.
 576   FilePath target2_file(target2.AppendASCII("file"));
 577   ASSERT_TRUE(WriteFile(target2_file, "content"));
 578   ASSERT_TRUE(WaitForEvents());
 579
 580   DeleteDelegateOnFileThread(delegate.release());
 581 }
 582 #endif  // OS_POSIX
 583
 584 TEST_F(FilePathWatcherTest, MoveChild) {
 585   FilePathWatcher file_watcher;
 586   FilePathWatcher subdir_watcher;
 587   FilePath source_dir(temp_dir_.path().AppendASCII("source"));
 588   FilePath source_subdir(source_dir.AppendASCII("subdir"));
 589   FilePath source_file(source_subdir.AppendASCII("file"));
 590   FilePath dest_dir(temp_dir_.path().AppendASCII("dest"));
 591   FilePath dest_subdir(dest_dir.AppendASCII("subdir"));
 592   FilePath dest_file(dest_subdir.AppendASCII("file"));
 593
 594   // Setup a directory hierarchy.
 595   ASSERT_TRUE(base::CreateDirectory(source_subdir));
 596   ASSERT_TRUE(WriteFile(source_file, "content"));
 597
 598   scoped_ptr<TestDelegate> file_delegate(new TestDelegate(collector()));
 599   ASSERT_TRUE(SetupWatch(dest_file, &file_watcher, file_delegate.get(), false));
 600   scoped_ptr<TestDelegate> subdir_delegate(new TestDelegate(collector()));
 601   ASSERT_TRUE(SetupWatch(dest_subdir, &subdir_watcher, subdir_delegate.get(),
 602                          false));
 603
 604   // Move the directory into place, s.t. the watched file appears.
 605   ASSERT_TRUE(base::Move(source_dir, dest_dir));
 606   ASSERT_TRUE(WaitForEvents());
 607   DeleteDelegateOnFileThread(file_delegate.release());
 608   DeleteDelegateOnFileThread(subdir_delegate.release());
 609 }
 610
 611 // Verify that changing attributes on a file is caught
 612 TEST_F(FilePathWatcherTest, FileAttributesChanged) {
 613   ASSERT_TRUE(WriteFile(test_file(), "content"));
 614   FilePathWatcher watcher;
 615   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 616   ASSERT_TRUE(SetupWatch(test_file(), &watcher, delegate.get(), false));
 617
 618   // Now make sure we get notified if the file is modified.
 619   ASSERT_TRUE(base::MakeFileUnreadable(test_file()));
 620   ASSERT_TRUE(WaitForEvents());
 621   DeleteDelegateOnFileThread(delegate.release());
 622 }
 623
 624 #if defined(OS_LINUX)
 625
 626 // Verify that creating a symlink is caught.
 627 TEST_F(FilePathWatcherTest, CreateLink) {
 628   FilePathWatcher watcher;
 629   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 630   // Note that we are watching the symlink
 631   ASSERT_TRUE(SetupWatch(test_link(), &watcher, delegate.get(), false));
 632
 633   // Now make sure we get notified if the link is created.
 634   // Note that test_file() doesn't have to exist.
 635   ASSERT_TRUE(CreateSymbolicLink(test_file(), test_link()));
 636   ASSERT_TRUE(WaitForEvents());
 637   DeleteDelegateOnFileThread(delegate.release());
 638 }
 639
 640 // Verify that deleting a symlink is caught.
 641 TEST_F(FilePathWatcherTest, DeleteLink) {
 642   // Unfortunately this test case only works if the link target exists.
 643   // TODO(craig) fix this as part of crbug.com/91561.
 644   ASSERT_TRUE(WriteFile(test_file(), "content"));
 645   ASSERT_TRUE(CreateSymbolicLink(test_file(), test_link()));
 646   FilePathWatcher watcher;
 647   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 648   ASSERT_TRUE(SetupWatch(test_link(), &watcher, delegate.get(), false));
 649
 650   // Now make sure we get notified if the link is deleted.
 651   ASSERT_TRUE(base::DeleteFile(test_link(), false));
 652   ASSERT_TRUE(WaitForEvents());
 653   DeleteDelegateOnFileThread(delegate.release());
 654 }
 655
 656 // Verify that modifying a target file that a link is pointing to
 657 // when we are watching the link is caught.
 658 TEST_F(FilePathWatcherTest, ModifiedLinkedFile) {
 659   ASSERT_TRUE(WriteFile(test_file(), "content"));
 660   ASSERT_TRUE(CreateSymbolicLink(test_file(), test_link()));
 661   FilePathWatcher watcher;
 662   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 663   // Note that we are watching the symlink.
 664   ASSERT_TRUE(SetupWatch(test_link(), &watcher, delegate.get(), false));
 665
 666   // Now make sure we get notified if the file is modified.
 667   ASSERT_TRUE(WriteFile(test_file(), "new content"));
 668   ASSERT_TRUE(WaitForEvents());
 669   DeleteDelegateOnFileThread(delegate.release());
 670 }
 671
 672 // Verify that creating a target file that a link is pointing to
 673 // when we are watching the link is caught.
 674 TEST_F(FilePathWatcherTest, CreateTargetLinkedFile) {
 675   ASSERT_TRUE(CreateSymbolicLink(test_file(), test_link()));
 676   FilePathWatcher watcher;
 677   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 678   // Note that we are watching the symlink.
 679   ASSERT_TRUE(SetupWatch(test_link(), &watcher, delegate.get(), false));
 680
 681   // Now make sure we get notified if the target file is created.
 682   ASSERT_TRUE(WriteFile(test_file(), "content"));
 683   ASSERT_TRUE(WaitForEvents());
 684   DeleteDelegateOnFileThread(delegate.release());
 685 }
 686
 687 // Verify that deleting a target file that a link is pointing to
 688 // when we are watching the link is caught.
 689 TEST_F(FilePathWatcherTest, DeleteTargetLinkedFile) {
 690   ASSERT_TRUE(WriteFile(test_file(), "content"));
 691   ASSERT_TRUE(CreateSymbolicLink(test_file(), test_link()));
 692   FilePathWatcher watcher;
 693   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 694   // Note that we are watching the symlink.
 695   ASSERT_TRUE(SetupWatch(test_link(), &watcher, delegate.get(), false));
 696
 697   // Now make sure we get notified if the target file is deleted.
 698   ASSERT_TRUE(base::DeleteFile(test_file(), false));
 699   ASSERT_TRUE(WaitForEvents());
 700   DeleteDelegateOnFileThread(delegate.release());
 701 }
 702
 703 // Verify that watching a file whose parent directory is a link that
 704 // doesn't exist yet works if the symlink is created eventually.
 705 TEST_F(FilePathWatcherTest, LinkedDirectoryPart1) {
 706   FilePathWatcher watcher;
 707   FilePath dir(temp_dir_.path().AppendASCII("dir"));
 708   FilePath link_dir(temp_dir_.path().AppendASCII("dir.lnk"));
 709   FilePath file(dir.AppendASCII("file"));
 710   FilePath linkfile(link_dir.AppendASCII("file"));
 711   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 712   // dir/file should exist.
 713   ASSERT_TRUE(base::CreateDirectory(dir));
 714   ASSERT_TRUE(WriteFile(file, "content"));
 715   // Note that we are watching dir.lnk/file which doesn't exist yet.
 716   ASSERT_TRUE(SetupWatch(linkfile, &watcher, delegate.get(), false));
 717
 718   ASSERT_TRUE(CreateSymbolicLink(dir, link_dir));
 719   VLOG(1) << "Waiting for link creation";
 720   ASSERT_TRUE(WaitForEvents());
 721
 722   ASSERT_TRUE(WriteFile(file, "content v2"));
 723   VLOG(1) << "Waiting for file change";
 724   ASSERT_TRUE(WaitForEvents());
 725
 726   ASSERT_TRUE(base::DeleteFile(file, false));
 727   VLOG(1) << "Waiting for file deletion";
 728   ASSERT_TRUE(WaitForEvents());
 729   DeleteDelegateOnFileThread(delegate.release());
 730 }
 731
 732 // Verify that watching a file whose parent directory is a
 733 // dangling symlink works if the directory is created eventually.
 734 TEST_F(FilePathWatcherTest, LinkedDirectoryPart2) {
 735   FilePathWatcher watcher;
 736   FilePath dir(temp_dir_.path().AppendASCII("dir"));
 737   FilePath link_dir(temp_dir_.path().AppendASCII("dir.lnk"));
 738   FilePath file(dir.AppendASCII("file"));
 739   FilePath linkfile(link_dir.AppendASCII("file"));
 740   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 741   // Now create the link from dir.lnk pointing to dir but
 742   // neither dir nor dir/file exist yet.
 743   ASSERT_TRUE(CreateSymbolicLink(dir, link_dir));
 744   // Note that we are watching dir.lnk/file.
 745   ASSERT_TRUE(SetupWatch(linkfile, &watcher, delegate.get(), false));
 746
 747   ASSERT_TRUE(base::CreateDirectory(dir));
 748   ASSERT_TRUE(WriteFile(file, "content"));
 749   VLOG(1) << "Waiting for dir/file creation";
 750   ASSERT_TRUE(WaitForEvents());
 751
 752   ASSERT_TRUE(WriteFile(file, "content v2"));
 753   VLOG(1) << "Waiting for file change";
 754   ASSERT_TRUE(WaitForEvents());
 755
 756   ASSERT_TRUE(base::DeleteFile(file, false));
 757   VLOG(1) << "Waiting for file deletion";
 758   ASSERT_TRUE(WaitForEvents());
 759   DeleteDelegateOnFileThread(delegate.release());
 760 }
 761
 762 // Verify that watching a file with a symlink on the path
 763 // to the file works.
 764 TEST_F(FilePathWatcherTest, LinkedDirectoryPart3) {
 765   FilePathWatcher watcher;
 766   FilePath dir(temp_dir_.path().AppendASCII("dir"));
 767   FilePath link_dir(temp_dir_.path().AppendASCII("dir.lnk"));
 768   FilePath file(dir.AppendASCII("file"));
 769   FilePath linkfile(link_dir.AppendASCII("file"));
 770   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 771   ASSERT_TRUE(base::CreateDirectory(dir));
 772   ASSERT_TRUE(CreateSymbolicLink(dir, link_dir));
 773   // Note that we are watching dir.lnk/file but the file doesn't exist yet.
 774   ASSERT_TRUE(SetupWatch(linkfile, &watcher, delegate.get(), false));
 775
 776   ASSERT_TRUE(WriteFile(file, "content"));
 777   VLOG(1) << "Waiting for file creation";
 778   ASSERT_TRUE(WaitForEvents());
 779
 780   ASSERT_TRUE(WriteFile(file, "content v2"));
 781   VLOG(1) << "Waiting for file change";
 782   ASSERT_TRUE(WaitForEvents());
 783
 784   ASSERT_TRUE(base::DeleteFile(file, false));
 785   VLOG(1) << "Waiting for file deletion";
 786   ASSERT_TRUE(WaitForEvents());
 787   DeleteDelegateOnFileThread(delegate.release());
 788 }
 789
 790 #endif  // OS_LINUX
 791
 792 enum Permission {
 793   Read,
 794   Write,
 795   Execute
 796 };
 797
 798 #if defined(OS_MACOSX)
 799 bool ChangeFilePermissions(const FilePath& path, Permission perm, bool allow) {
 800   struct stat stat_buf;
 801
 802   if (stat(path.value().c_str(), &stat_buf) != 0)
 803     return false;
 804
 805   mode_t mode = 0;
 806   switch (perm) {
 807     case Read:
 808       mode = S_IRUSR | S_IRGRP | S_IROTH;
 809       break;
 810     case Write:
 811       mode = S_IWUSR | S_IWGRP | S_IWOTH;
 812       break;
 813     case Execute:
 814       mode = S_IXUSR | S_IXGRP | S_IXOTH;
 815       break;
 816     default:
 817       ADD_FAILURE() << "unknown perm " << perm;
 818       return false;
 819   }
 820   if (allow) {
 821     stat_buf.st_mode |= mode;
 822   } else {
 823     stat_buf.st_mode &= ~mode;
 824   }
 825   return chmod(path.value().c_str(), stat_buf.st_mode) == 0;
 826 }
 827 #endif  // defined(OS_MACOSX)
 828
 829 #if defined(OS_MACOSX)
 830 // Linux implementation of FilePathWatcher doesn't catch attribute changes.
 831 // http://crbug.com/78043
 832 // Windows implementation of FilePathWatcher catches attribute changes that
 833 // don't affect the path being watched.
 834 // http://crbug.com/78045
 835
 836 // Verify that changing attributes on a directory works.
 837 TEST_F(FilePathWatcherTest, DirAttributesChanged) {
 838   FilePath test_dir1(temp_dir_.path().AppendASCII("DirAttributesChangedDir1"));
 839   FilePath test_dir2(test_dir1.AppendASCII("DirAttributesChangedDir2"));
 840   FilePath test_file(test_dir2.AppendASCII("DirAttributesChangedFile"));
 841   // Setup a directory hierarchy.
 842   ASSERT_TRUE(base::CreateDirectory(test_dir1));
 843   ASSERT_TRUE(base::CreateDirectory(test_dir2));
 844   ASSERT_TRUE(WriteFile(test_file, "content"));
 845
 846   FilePathWatcher watcher;
 847   scoped_ptr<TestDelegate> delegate(new TestDelegate(collector()));
 848   ASSERT_TRUE(SetupWatch(test_file, &watcher, delegate.get(), false));
 849
 850   // We should not get notified in this case as it hasn't affected our ability
 851   // to access the file.
 852   ASSERT_TRUE(ChangeFilePermissions(test_dir1, Read, false));
 853   loop_.PostDelayedTask(FROM_HERE,
 854                         MessageLoop::QuitWhenIdleClosure(),
 855                         TestTimeouts::tiny_timeout());
 856   ASSERT_FALSE(WaitForEvents());
 857   ASSERT_TRUE(ChangeFilePermissions(test_dir1, Read, true));
 858
 859   // We should get notified in this case because filepathwatcher can no
 860   // longer access the file
 861   ASSERT_TRUE(ChangeFilePermissions(test_dir1, Execute, false));
 862   ASSERT_TRUE(WaitForEvents());
 863   ASSERT_TRUE(ChangeFilePermissions(test_dir1, Execute, true));
 864   DeleteDelegateOnFileThread(delegate.release());
 865 }
 866
 867 #endif  // OS_MACOSX
 868 }  // namespace
 869
 870 }  // namespace base