[fsp] Extract ObservedEntry and ObservedEntries to a separate file.

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"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/run_loop.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
 #include "chrome/browser/chromeos/file_system_provider/notification_manager.h"
+#include "chrome/browser/chromeos/file_system_provider/observed_entry.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_interface.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_observer.h"
 #include "chrome/browser/chromeos/file_system_provider/request_manager.h"
 #include "chrome/common/extensions/api/file_system_provider.h"
 #include "chrome/common/extensions/api/file_system_provider_internal.h"
 #include "chrome/test/base/testing_profile.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/browser/event_router.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 98 matching lines @@
       ProvidedFileSystemObserver::ChangeType change_type,
       const ProvidedFileSystemObserver::ChildChanges& child_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));
     base::ThreadTaskRunnerHandle::Get()->PostTask(FROM_HERE, callback);
   }
 
   virtual void OnObservedEntryTagUpdated(
       const ProvidedFileSystemInfo& file_system_info,
-      const base::FilePath& observed_path) override {
+      const base::FilePath& observed_path,
+      const std::string& tag) override {
     EXPECT_EQ(kFileSystemId, file_system_info.file_system_id());
     ++tag_updated_counter_;
   }
 
   virtual void OnObservedEntryListChanged(
-      const ProvidedFileSystemInfo& file_system_info) override {
+      const ProvidedFileSystemInfo& file_system_info,
+      const ObservedEntries& observed_entries) override {
     EXPECT_EQ(kFileSystemId, file_system_info.file_system_id());
     ++list_changed_counter_;
   }
 
   int list_changed_counter() const { return list_changed_counter_; }
   const ScopedVector<ChangeEvent>& change_events() const {
     return change_events_;
   }
   int tag_updated_counter() const { return tag_updated_counter_; }
 
@@ skipping 131 matching lines @@
   provided_file_system_->ObserveDirectory(
       base::FilePath::FromUTF8Unsafe(kDirectoryPath),
       false /* recursive */,
       base::Bind(&LogStatus, base::Unretained(&log)));
   base::RunLoop().RunUntilIdle();
 
   // The directory should not become observed because of an error.
   ASSERT_EQ(1u, log.size());
   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, log[0]);
 
-  ProvidedFileSystemInterface::ObservedEntries* const observed_entries =
+  ObservedEntries* const observed_entries =
       provided_file_system_->GetObservedEntries();
   EXPECT_EQ(0u, observed_entries->size());
 
   // The observer should not be called.
   EXPECT_EQ(0, observer.list_changed_counter());
   EXPECT_EQ(0, observer.tag_updated_counter());
 
   provided_file_system_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderProvidedFileSystemTest, ObserveDirectory) {
   Log log;
   Observer observer;
 
   provided_file_system_->AddObserver(&observer);
 
   provided_file_system_->ObserveDirectory(
       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(1, observer.list_changed_counter());
   EXPECT_EQ(0, observer.tag_updated_counter());
 
-  ProvidedFileSystemInterface::ObservedEntries* const observed_entries =
+  ObservedEntries* const observed_entries =
       provided_file_system_->GetObservedEntries();
   ASSERT_EQ(1u, observed_entries->size());
-  const ProvidedFileSystemInterface::ObservedEntry& observed_entry =
-      observed_entries->begin()->second;
+  const ObservedEntry& observed_entry = observed_entries->begin()->second;
   EXPECT_EQ(kDirectoryPath, observed_entry.entry_path.value());
   EXPECT_FALSE(observed_entry.recursive);
   EXPECT_EQ("", observed_entry.last_tag);
 
   provided_file_system_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderProvidedFileSystemTest, ObserveDirectory_Exists) {
   Observer observer;
   provided_file_system_->AddObserver(&observer);
@@ skipping 37 matching lines @@
         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());
 
-    ProvidedFileSystemInterface::ObservedEntries* const observed_entries =
+    ObservedEntries* const observed_entries =
         provided_file_system_->GetObservedEntries();
     ASSERT_EQ(1u, observed_entries->size());
-    const ProvidedFileSystemInterface::ObservedEntry& observed_entry =
-        observed_entries->begin()->second;
+    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);
   }
 
   {
     // Lastly, create another recursive observer. That should fail, too.
     Log log;
     provided_file_system_->ObserveDirectory(
         base::FilePath::FromUTF8Unsafe(kDirectoryPath),
@@ skipping 36 matching lines @@
         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(1, observer.list_changed_counter());
     EXPECT_EQ(0, observer.tag_updated_counter());
 
-    ProvidedFileSystemInterface::ObservedEntries* const observed_entries =
+    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),
         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());
 
-    ProvidedFileSystemInterface::ObservedEntries* const observed_entries =
+    ObservedEntries* const observed_entries =
         provided_file_system_->GetObservedEntries();
     EXPECT_EQ(0u, observed_entries->size());
   }
 
   {
     // Confirm that it's possible to observe it again.
     Log log;
     provided_file_system_->ObserveDirectory(
         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(3, observer.list_changed_counter());
     EXPECT_EQ(0, observer.tag_updated_counter());
 
-    ProvidedFileSystemInterface::ObservedEntries* const observed_entries =
+    ObservedEntries* const observed_entries =
         provided_file_system_->GetObservedEntries();
     EXPECT_EQ(1u, observed_entries->size());
   }
 
   {
     // 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),
         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());
 
-    ProvidedFileSystemInterface::ObservedEntries* const observed_entries =
+    ObservedEntries* const observed_entries =
         provided_file_system_->GetObservedEntries();
     EXPECT_EQ(0u, observed_entries->size());
   }
 
   provided_file_system_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderProvidedFileSystemTest, Notify) {
   Observer observer;
   provided_file_system_->AddObserver(&observer);
 
   {
     // Observe a directory.
     Log log;
     provided_file_system_->ObserveDirectory(
         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(1, observer.list_changed_counter());
     EXPECT_EQ(0, observer.tag_updated_counter());
 
-    ProvidedFileSystemInterface::ObservedEntries* const observed_entries =
+    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);
   }
 
   {
     // 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),
         change_type,
         make_scoped_ptr(new ProvidedFileSystemObserver::ChildChanges),
         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());
 
     // The tag should not be updated in advance, before all observers handle
     // the notification.
-    ProvidedFileSystemInterface::ObservedEntries* const observed_entries =
+    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.
@@ skipping 19 matching lines @@
     // 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());
   }
 
   // Confirm, that the entry is not observed anymore.
   {
-    ProvidedFileSystemInterface::ObservedEntries* const observed_entries =
+    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