[fsp] Separate recursive and non-recursive watchers.

chrome/browser/chromeos/file_system_provider/provided_file_system_unittest.cc

 // Copyright 2014 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 "chrome/browser/chromeos/file_system_provider/provided_file_system.h"
 
 #include <string>
 #include <vector>
 
 #include "base/files/file.h"
@@ skipping 83 matching lines @@
   base::File::Error reply_result_;
   DISALLOW_COPY_AND_ASSIGN(FakeEventRouter);
 };
 
 // Observes the tested file system.
 class Observer : public ProvidedFileSystemObserver {
  public:
   class ChangeEvent {
    public:
     ChangeEvent(ProvidedFileSystemObserver::ChangeType change_type,
-                const ProvidedFileSystemObserver::ChildChanges& child_changes)
-        : change_type_(change_type), child_changes_(child_changes) {}
+                const ProvidedFileSystemObserver::Changes& changes)
+        : change_type_(change_type), changes_(changes) {}
     virtual ~ChangeEvent() {}
 
     ProvidedFileSystemObserver::ChangeType change_type() const {
       return change_type_;
     }
-    const ProvidedFileSystemObserver::ChildChanges& child_changes() const {
-      return child_changes_;
+    const ProvidedFileSystemObserver::Changes& changes() const {
+      return changes_;
     }
 
    private:
     const ProvidedFileSystemObserver::ChangeType change_type_;
-    const ProvidedFileSystemObserver::ChildChanges child_changes_;
+    const ProvidedFileSystemObserver::Changes changes_;
 
     DISALLOW_COPY_AND_ASSIGN(ChangeEvent);
   };
 
   Observer() : list_changed_counter_(0), tag_updated_counter_(0) {}
 
   // ProvidedFileSystemInterfaceObserver overrides.
   virtual void OnObservedEntryChanged(
       const ProvidedFileSystemInfo& file_system_info,
       const ObservedEntry& observed_entry,
       ProvidedFileSystemObserver::ChangeType change_type,
-      const ProvidedFileSystemObserver::ChildChanges& child_changes,
+      const ProvidedFileSystemObserver::Changes& changes,
       const base::Closure& callback) override {
     EXPECT_EQ(kFileSystemId, file_system_info.file_system_id());
-    change_events_.push_back(new ChangeEvent(change_type, child_changes));
+    change_events_.push_back(new ChangeEvent(change_type, changes));
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
   }
 
   virtual void OnObservedEntryTagUpdated(
       const ProvidedFileSystemInfo& file_system_info,
       const ObservedEntry& observed_entry) override {
     EXPECT_EQ(kFileSystemId, file_system_info.file_system_id());
     ++tag_updated_counter_;
   }
 
@@ skipping 219 matching lines @@
     base::RunLoop().RunUntilIdle();
 
     ASSERT_EQ(1u, log.size());
     EXPECT_EQ(base::File::FILE_ERROR_EXISTS, log[0]);
     EXPECT_EQ(1, observer.list_changed_counter());  // No changes on the list.
     EXPECT_EQ(0, observer.tag_updated_counter());
   }
 
   {
     // Create another observer on the same path, but a recursive one. That
-    // should
-    // succeed.
+    // should succeed.
     Log log;
     provided_file_system_->ObserveDirectory(
         base::FilePath::FromUTF8Unsafe(kDirectoryPath),
         true /* recursive */,
         base::Bind(&LogStatus, base::Unretained(&log)));
     base::RunLoop().RunUntilIdle();
 
     ASSERT_EQ(1u, log.size());
     EXPECT_EQ(base::File::FILE_OK, log[0]);
     EXPECT_EQ(2, observer.list_changed_counter());
     EXPECT_EQ(0, observer.tag_updated_counter());
 
     ObservedEntries* const observed_entries =
         provided_file_system_->GetObservedEntries();
-    ASSERT_EQ(1u, observed_entries->size());
-    const ObservedEntry& observed_entry = observed_entries->begin()->second;
-    EXPECT_EQ(kDirectoryPath, observed_entry.entry_path.value());
-    EXPECT_TRUE(observed_entry.recursive);
-    EXPECT_EQ("", observed_entry.last_tag);
+    const auto& observed_entry_it = observed_entries->find(
+        ObservedEntryKey(base::FilePath(FILE_PATH_LITERAL(kDirectoryPath)),
+                         true /* recursive */));
+    ASSERT_NE(observed_entries->end(), observed_entry_it);
+
+    EXPECT_EQ(kDirectoryPath, observed_entry_it->second.entry_path.value());
+    EXPECT_TRUE(observed_entry_it->second.recursive);
+    EXPECT_EQ("", observed_entry_it->second.last_tag);
   }
 
   {
     // Lastly, create another recursive observer. That should fail, too.
     Log log;
     provided_file_system_->ObserveDirectory(
         base::FilePath::FromUTF8Unsafe(kDirectoryPath),
         true /* recursive */,
         base::Bind(&LogStatus, base::Unretained(&log)));
     base::RunLoop().RunUntilIdle();
@@ skipping 10 matching lines @@
 TEST_F(FileSystemProviderProvidedFileSystemTest, UnobserveEntry) {
   Observer observer;
   provided_file_system_->AddObserver(&observer);
 
   {
     // First, confirm that unobserving an entry which is not observed, results
     // in an error.
     Log log;
     provided_file_system_->UnobserveEntry(
         base::FilePath::FromUTF8Unsafe(kDirectoryPath),
+        false /* recursive */,
         base::Bind(&LogStatus, base::Unretained(&log)));
     base::RunLoop().RunUntilIdle();
 
     ASSERT_EQ(1u, log.size());
     EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, log[0]);
     EXPECT_EQ(0, observer.list_changed_counter());
     EXPECT_EQ(0, observer.tag_updated_counter());
   }
 
   {
@@ skipping 13 matching lines @@
     ObservedEntries* const observed_entries =
         provided_file_system_->GetObservedEntries();
     EXPECT_EQ(1u, observed_entries->size());
   }
 
   {
     // Unobserve it gracefully.
     Log log;
     provided_file_system_->UnobserveEntry(
         base::FilePath::FromUTF8Unsafe(kDirectoryPath),
+        false /* recursive */,
         base::Bind(&LogStatus, base::Unretained(&log)));
     base::RunLoop().RunUntilIdle();
 
     ASSERT_EQ(1u, log.size());
     EXPECT_EQ(base::File::FILE_OK, log[0]);
     EXPECT_EQ(2, observer.list_changed_counter());
     EXPECT_EQ(0, observer.tag_updated_counter());
 
     ObservedEntries* const observed_entries =
         provided_file_system_->GetObservedEntries();
@@ skipping 21 matching lines @@
 
   {
     // Finally, unobserve it, but with an error from extension. That should
     // result
     // in a removed observer, anyway.
     event_router_->set_reply_result(base::File::FILE_ERROR_FAILED);
 
     Log log;
     provided_file_system_->UnobserveEntry(
         base::FilePath::FromUTF8Unsafe(kDirectoryPath),
+        false /* recursive */,
         base::Bind(&LogStatus, base::Unretained(&log)));
     base::RunLoop().RunUntilIdle();
 
     ASSERT_EQ(1u, log.size());
     EXPECT_EQ(base::File::FILE_ERROR_FAILED, log[0]);
     EXPECT_EQ(4, observer.list_changed_counter());
     EXPECT_EQ(0, observer.tag_updated_counter());
 
     ObservedEntries* const observed_entries =
         provided_file_system_->GetObservedEntries();
@@ skipping 28 matching lines @@
     EXPECT_EQ("", observed_entries->begin()->second.last_tag);
   }
 
   {
     // Notify about a change.
     const ProvidedFileSystemObserver::ChangeType change_type =
         ProvidedFileSystemObserver::CHANGED;
     const std::string tag = "hello-world";
     EXPECT_TRUE(provided_file_system_->Notify(
         base::FilePath::FromUTF8Unsafe(kDirectoryPath),
+        false /* recursive */,
         change_type,
-        make_scoped_ptr(new ProvidedFileSystemObserver::ChildChanges),
+        make_scoped_ptr(new ProvidedFileSystemObserver::Changes),
         tag));
 
     // Verify the observer event.
     ASSERT_EQ(1u, observer.change_events().size());
     const Observer::ChangeEvent* const change_event =
         observer.change_events()[0];
     EXPECT_EQ(change_type, change_event->change_type());
-    EXPECT_EQ(0u, change_event->child_changes().size());
+    EXPECT_EQ(0u, change_event->changes().size());
 
     // The tag should not be updated in advance, before all observers handle
     // the notification.
     ObservedEntries* const observed_entries =
         provided_file_system_->GetObservedEntries();
     EXPECT_EQ(1u, observed_entries->size());
     provided_file_system_->GetObservedEntries();
     EXPECT_EQ("", observed_entries->begin()->second.last_tag);
 
     // Wait until all observers finish handling the notification.
     base::RunLoop().RunUntilIdle();
 
     // Confirm, that the entry is still being observed, and that the tag is
     // updated.
     ASSERT_EQ(1u, observed_entries->size());
     EXPECT_EQ(tag, observed_entries->begin()->second.last_tag);
     EXPECT_EQ(1, observer.list_changed_counter());
     EXPECT_EQ(1, observer.tag_updated_counter());
   }
 
   {
     // Notify about deleting of the observed entry.
     const ProvidedFileSystemObserver::ChangeType change_type =
         ProvidedFileSystemObserver::DELETED;
-    const ProvidedFileSystemObserver::ChildChanges child_changes;
+    const ProvidedFileSystemObserver::Changes changes;
     const std::string tag = "chocolate-disco";
     EXPECT_TRUE(provided_file_system_->Notify(
         base::FilePath::FromUTF8Unsafe(kDirectoryPath),
+        false /* recursive */,
         change_type,
-        make_scoped_ptr(new ProvidedFileSystemObserver::ChildChanges),
+        make_scoped_ptr(new ProvidedFileSystemObserver::Changes),
         tag));
     base::RunLoop().RunUntilIdle();
 
     // Verify the observer event.
     ASSERT_EQ(2u, observer.change_events().size());
     const Observer::ChangeEvent* const change_event =
         observer.change_events()[1];
     EXPECT_EQ(change_type, change_event->change_type());
-    EXPECT_EQ(0u, change_event->child_changes().size());
+    EXPECT_EQ(0u, change_event->changes().size());
   }
 
   // Confirm, that the entry is not observed anymore.
   {
     ObservedEntries* const observed_entries =
         provided_file_system_->GetObservedEntries();
     EXPECT_EQ(0u, observed_entries->size());
     EXPECT_EQ(2, observer.list_changed_counter());
     EXPECT_EQ(2, observer.tag_updated_counter());
   }
 
   provided_file_system_->RemoveObserver(&observer);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos