[fsp] Add support for observing entries and notifying about changes.

chrome/browser/chromeos/file_system_provider/service_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/service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/files/file.h"
@@ skipping 86 matching lines @@
                                        extensions::Extension::NO_FLAGS,
                                        extension_id,
                                        &error);
 }
 
 // Stores a provided file system information in preferences.
 void RememberFakeFileSystem(TestingProfile* profile,
                             const std::string& extension_id,
                             const std::string& file_system_id,
                             const std::string& display_name,
-                            bool writable) {
+                            bool writable,
+                            bool supports_notify_tag) {
   TestingPrefServiceSyncable* const pref_service =
       profile->GetTestingPrefService();
   ASSERT_TRUE(pref_service);
 
   base::DictionaryValue extensions;
   base::DictionaryValue* file_systems = new base::DictionaryValue();
   base::DictionaryValue* file_system = new base::DictionaryValue();
   file_system->SetStringWithoutPathExpansion(kPrefKeyFileSystemId,
                                              kFileSystemId);
   file_system->SetStringWithoutPathExpansion(kPrefKeyDisplayName, kDisplayName);
   file_system->SetBooleanWithoutPathExpansion(kPrefKeyWritable, writable);
+  file_system->SetBooleanWithoutPathExpansion(kPrefKeySupportsNotifyTag,
+                                              supports_notify_tag);
   file_systems->SetWithoutPathExpansion(kFileSystemId, file_system);
   extensions.SetWithoutPathExpansion(kExtensionId, file_systems);
 
   pref_service->Set(prefs::kFileSystemProviderMounted, extensions);
 }
 
 }  // namespace
 
 class FileSystemProviderServiceTest : public testing::Test {
  protected:
@@ skipping 23 matching lines @@
   scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_;
   scoped_ptr<extensions::ExtensionRegistry> extension_registry_;
   scoped_ptr<Service> service_;
   scoped_refptr<extensions::Extension> extension_;
 };
 
 TEST_F(FileSystemProviderServiceTest, MountFileSystem) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
-  EXPECT_TRUE(service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kDisplayName, false /* writable */));
+  EXPECT_TRUE(service_->MountFileSystem(kExtensionId,
+                                        kFileSystemId,
+                                        kDisplayName,
+                                        false /* writable */,
+                                        false /* supports_notify_tag */));
 
   ASSERT_EQ(1u, observer.mounts.size());
   EXPECT_EQ(kExtensionId, observer.mounts[0].file_system_info().extension_id());
   EXPECT_EQ(kFileSystemId,
             observer.mounts[0].file_system_info().file_system_id());
   base::FilePath expected_mount_path =
       util::GetMountPath(profile_, kExtensionId, kFileSystemId);
   EXPECT_EQ(expected_mount_path.AsUTF8Unsafe(),
             observer.mounts[0].file_system_info().mount_path().AsUTF8Unsafe());
   EXPECT_EQ(kDisplayName, observer.mounts[0].file_system_info().display_name());
   EXPECT_FALSE(observer.mounts[0].file_system_info().writable());
+  EXPECT_FALSE(observer.mounts[0].file_system_info().supports_notify_tag());
   EXPECT_EQ(base::File::FILE_OK, observer.mounts[0].error());
   ASSERT_EQ(0u, observer.unmounts.size());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
       service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(1u, file_system_info_list.size());
 
   service_->RemoveObserver(&observer);
 }
 
-TEST_F(FileSystemProviderServiceTest, MountFileSystem_Writable) {
+TEST_F(FileSystemProviderServiceTest,
+       MountFileSystem_WritableAndSupportsNotifyTag) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
-  EXPECT_TRUE(service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kDisplayName, true /* writable */));
+  EXPECT_TRUE(service_->MountFileSystem(kExtensionId,
+                                        kFileSystemId,
+                                        kDisplayName,
+                                        true /* writable */,
+                                        true /* supports_notify_tag */));
 
   ASSERT_EQ(1u, observer.mounts.size());
   EXPECT_TRUE(observer.mounts[0].file_system_info().writable());
+  EXPECT_TRUE(observer.mounts[0].file_system_info().supports_notify_tag());
   ASSERT_EQ(0u, observer.unmounts.size());
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
       service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(1u, file_system_info_list.size());
 
   service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, MountFileSystem_UniqueIds) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
-  EXPECT_TRUE(service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kDisplayName, false /* writable */));
-  EXPECT_FALSE(service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kDisplayName, false /* writable */));
+  EXPECT_TRUE(service_->MountFileSystem(kExtensionId,
+                                        kFileSystemId,
+                                        kDisplayName,
+                                        false /* writable */,
+                                        false /* supports_notify_tag */));
+  EXPECT_FALSE(service_->MountFileSystem(kExtensionId,
+                                         kFileSystemId,
+                                         kDisplayName,
+                                         false /* writable */,
+                                         false /* supports_notify_tag */));
 
   ASSERT_EQ(2u, observer.mounts.size());
   EXPECT_EQ(base::File::FILE_OK, observer.mounts[0].error());
   EXPECT_EQ(base::File::FILE_ERROR_EXISTS, observer.mounts[1].error());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
       service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(1u, file_system_info_list.size());
 
   service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, MountFileSystem_StressTest) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
   const size_t kMaxFileSystems = 16;
   for (size_t i = 0; i < kMaxFileSystems; ++i) {
     const std::string file_system_id =
         std::string("test-") + base::IntToString(i);
-    EXPECT_TRUE(service_->MountFileSystem(
-        kExtensionId, file_system_id, kDisplayName, false /* writable */));
+    EXPECT_TRUE(service_->MountFileSystem(kExtensionId,
+                                          file_system_id,
+                                          kDisplayName,
+                                          false /* writable */,
+                                          false /* supports_notify_tag */));
   }
   ASSERT_EQ(kMaxFileSystems, observer.mounts.size());
 
   // The next file system is out of limit, and registering it should fail.
-  EXPECT_FALSE(service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kDisplayName, false /* writable */));
+  EXPECT_FALSE(service_->MountFileSystem(kExtensionId,
+                                         kFileSystemId,
+                                         kDisplayName,
+                                         false /* writable */,
+                                         false /* supports_notify_tag */));
 
   ASSERT_EQ(kMaxFileSystems + 1, observer.mounts.size());
   EXPECT_EQ(base::File::FILE_ERROR_TOO_MANY_OPENED,
             observer.mounts[kMaxFileSystems].error());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
       service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(kMaxFileSystems, file_system_info_list.size());
 
   service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, UnmountFileSystem) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
-  EXPECT_TRUE(service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kDisplayName, false /* writable */));
+  EXPECT_TRUE(service_->MountFileSystem(kExtensionId,
+                                        kFileSystemId,
+                                        kDisplayName,
+                                        false /* writable */,
+                                        false /* supports_notify_tag */));
   ASSERT_EQ(1u, observer.mounts.size());
 
   EXPECT_TRUE(service_->UnmountFileSystem(
       kExtensionId, kFileSystemId, Service::UNMOUNT_REASON_USER));
   ASSERT_EQ(1u, observer.unmounts.size());
   EXPECT_EQ(base::File::FILE_OK, observer.unmounts[0].error());
 
   EXPECT_EQ(kExtensionId,
             observer.unmounts[0].file_system_info().extension_id());
   EXPECT_EQ(kFileSystemId,
             observer.unmounts[0].file_system_info().file_system_id());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
       service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(0u, file_system_info_list.size());
 
   service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, UnmountFileSystem_OnExtensionUnload) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
-  EXPECT_TRUE(service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kDisplayName, false /* writable */));
+  EXPECT_TRUE(service_->MountFileSystem(kExtensionId,
+                                        kFileSystemId,
+                                        kDisplayName,
+                                        false /* writable */,
+                                        false /* supports_notify_tag */));
   ASSERT_EQ(1u, observer.mounts.size());
 
   // Directly call the observer's method.
   service_->OnExtensionUnloaded(
       profile_,
       extension_.get(),
       extensions::UnloadedExtensionInfo::REASON_DISABLE);
 
   ASSERT_EQ(1u, observer.unmounts.size());
   EXPECT_EQ(base::File::FILE_OK, observer.unmounts[0].error());
 
   EXPECT_EQ(kExtensionId,
             observer.unmounts[0].file_system_info().extension_id());
   EXPECT_EQ(kFileSystemId,
             observer.unmounts[0].file_system_info().file_system_id());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
       service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(0u, file_system_info_list.size());
 
   service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, UnmountFileSystem_WrongExtensionId) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
   const std::string kWrongExtensionId = "helloworldhelloworldhelloworldhe";
 
-  EXPECT_TRUE(service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kDisplayName, false /* writable */));
+  EXPECT_TRUE(service_->MountFileSystem(kExtensionId,
+                                        kFileSystemId,
+                                        kDisplayName,
+                                        false /* writable */,
+                                        false /* supports_notify_tag */));
   ASSERT_EQ(1u, observer.mounts.size());
   ASSERT_EQ(1u, service_->GetProvidedFileSystemInfoList().size());
 
   EXPECT_FALSE(service_->UnmountFileSystem(
       kWrongExtensionId, kFileSystemId, Service::UNMOUNT_REASON_USER));
   ASSERT_EQ(1u, observer.unmounts.size());
   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, observer.unmounts[0].error());
   ASSERT_EQ(1u, service_->GetProvidedFileSystemInfoList().size());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
       service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(1u, file_system_info_list.size());
 
   service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, RestoreFileSystem_OnExtensionLoad) {
   // Create a fake entry in the preferences.
-  RememberFakeFileSystem(
-      profile_, kExtensionId, kFileSystemId, kDisplayName, true /* writable */);
+  RememberFakeFileSystem(profile_,
+                         kExtensionId,
+                         kFileSystemId,
+                         kDisplayName,
+                         true /* writable */,
+                         true /* supports_notify_tag */);
 
   // Create a new service instance in order to load remembered file systems
   // from preferences.
   scoped_ptr<Service> new_service(
       new Service(profile_, extension_registry_.get()));
   LoggingObserver observer;
   new_service->AddObserver(&observer);
 
   new_service->SetFileSystemFactoryForTesting(
       base::Bind(&FakeProvidedFileSystem::Create));
 
   EXPECT_EQ(0u, observer.mounts.size());
 
   // Directly call the observer's method.
   new_service->OnExtensionLoaded(profile_, extension_.get());
 
   ASSERT_EQ(1u, observer.mounts.size());
   EXPECT_EQ(base::File::FILE_OK, observer.mounts[0].error());
 
   EXPECT_EQ(kExtensionId, observer.mounts[0].file_system_info().extension_id());
   EXPECT_EQ(kFileSystemId,
             observer.mounts[0].file_system_info().file_system_id());
   EXPECT_TRUE(observer.mounts[0].file_system_info().writable());
+  EXPECT_TRUE(observer.mounts[0].file_system_info().supports_notify_tag());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
       new_service->GetProvidedFileSystemInfoList();
   ASSERT_EQ(1u, file_system_info_list.size());
 
   new_service->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnMount) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
-  EXPECT_TRUE(service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kDisplayName, true /* writable */));
+  EXPECT_TRUE(service_->MountFileSystem(kExtensionId,
+                                        kFileSystemId,
+                                        kDisplayName,
+                                        true /* writable */,
+                                        true /* supports_notify_tag */));
   ASSERT_EQ(1u, observer.mounts.size());
 
   TestingPrefServiceSyncable* const pref_service =
       profile_->GetTestingPrefService();
   ASSERT_TRUE(pref_service);
 
   const base::DictionaryValue* const extensions =
       pref_service->GetDictionary(prefs::kFileSystemProviderMounted);
   ASSERT_TRUE(extensions);
 
@@ skipping 16 matching lines @@
   std::string display_name;
   EXPECT_TRUE(file_system->GetStringWithoutPathExpansion(kPrefKeyDisplayName,
                                                          &display_name));
   EXPECT_EQ(kDisplayName, display_name);
 
   bool writable = false;
   EXPECT_TRUE(
       file_system->GetBooleanWithoutPathExpansion(kPrefKeyWritable, &writable));
   EXPECT_TRUE(writable);
 
+  bool supports_notify_tag = false;
+  EXPECT_TRUE(file_system->GetBooleanWithoutPathExpansion(
+      kPrefKeySupportsNotifyTag, &supports_notify_tag));
+  EXPECT_TRUE(supports_notify_tag);
+
   service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnUnmountOnShutdown) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
   TestingPrefServiceSyncable* const pref_service =
       profile_->GetTestingPrefService();
   ASSERT_TRUE(pref_service);
 
   {
-    EXPECT_TRUE(service_->MountFileSystem(
-        kExtensionId, kFileSystemId, kDisplayName, false /* writable */));
+    EXPECT_TRUE(service_->MountFileSystem(kExtensionId,
+                                          kFileSystemId,
+                                          kDisplayName,
+                                          false /* writable */,
+                                          false /* supports_notify_tag */));
     ASSERT_EQ(1u, observer.mounts.size());
 
     const base::DictionaryValue* extensions =
         pref_service->GetDictionary(prefs::kFileSystemProviderMounted);
     ASSERT_TRUE(extensions);
 
     const base::DictionaryValue* file_systems = NULL;
     ASSERT_TRUE(extensions->GetDictionaryWithoutPathExpansion(kExtensionId,
                                                               &file_systems));
     EXPECT_EQ(1u, file_systems->size());
@@ skipping 18 matching lines @@
 
 TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnUnmountByUser) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
   TestingPrefServiceSyncable* const pref_service =
       profile_->GetTestingPrefService();
   ASSERT_TRUE(pref_service);
 
   {
-    EXPECT_TRUE(service_->MountFileSystem(
-        kExtensionId, kFileSystemId, kDisplayName, false /* writable */));
+    EXPECT_TRUE(service_->MountFileSystem(kExtensionId,
+                                          kFileSystemId,
+                                          kDisplayName,
+                                          false /* writable */,
+                                          false /* supports_notify_tag */));
     ASSERT_EQ(1u, observer.mounts.size());
 
     const base::DictionaryValue* extensions =
         pref_service->GetDictionary(prefs::kFileSystemProviderMounted);
     ASSERT_TRUE(extensions);
 
     const base::DictionaryValue* file_systems = NULL;
     ASSERT_TRUE(extensions->GetDictionaryWithoutPathExpansion(kExtensionId,
                                                               &file_systems));
     EXPECT_EQ(1u, file_systems->size());
@@ skipping 10 matching lines @@
     const base::DictionaryValue* file_systems = NULL;
     EXPECT_FALSE(extensions->GetDictionaryWithoutPathExpansion(kExtensionId,
                                                                &file_systems));
   }
 
   service_->RemoveObserver(&observer);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos