[fsp] Remember mounted file systems as soon as possible.

chrome/browser/chromeos/file_system_provider/service_unittest.cc

Index: chrome/browser/chromeos/file_system_provider/service_unittest.cc
diff --git a/chrome/browser/chromeos/file_system_provider/service_unittest.cc b/chrome/browser/chromeos/file_system_provider/service_unittest.cc
index c6673d92d703c0d121885abc027ec45971323712..81fc945aba678cbddd3248eff233fcaa3f96a9ef 100644
--- a/chrome/browser/chromeos/file_system_provider/service_unittest.cc
+++ b/chrome/browser/chromeos/file_system_provider/service_unittest.cc
@@ -31,7 +31,7 @@ namespace file_system_provider {
 namespace {
 
 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
-const char kFileSystemId[] = "camera/pictures/id !@#$%^&*()_+";
+const char kFileSystemId[] = "camera/pictures/id .!@#$%^&*()_+";

[hashimoto, 2014/07/02 08:59:37]

What is the point of this change?

[mtomasz, 2014/07/03 05:24:07]

File system IDs are used as keys in preferences. This dot ensures, that we
correctly save preferences. Note, that Value::Set(kFileSystemId, ...) would
expand the key, which is unexpected. SetWithoutPathExpansion has to be used.

[hashimoto, 2014/07/04 06:38:41]

Then "." here has a special role unlike other random symbols.
Please add a comment about it.

[mtomasz, 2014/07/04 07:50:42]

Done.

 const char kFileSystemName[] = "Camera Pictures";
 
 // Utility observer, logging events from file_system_provider::Service.
@@ -98,11 +98,11 @@ void RememberFakeFileSystem(TestingProfile* profile,
   ASSERT_TRUE(pref_service);
 
   base::DictionaryValue extensions;
-  base::ListValue* file_systems = new base::ListValue();
+  base::DictionaryValue* file_systems = new base::DictionaryValue();
   base::DictionaryValue* file_system = new base::DictionaryValue();
   file_system->SetString(kPrefKeyFileSystemId, kFileSystemId);
   file_system->SetString(kPrefKeyFileSystemName, kFileSystemName);
-  file_systems->Append(file_system);
+  file_systems->SetWithoutPathExpansion(kFileSystemId, file_system);
   extensions.Set(kExtensionId, file_systems);
 
   pref_service->Set(prefs::kFileSystemProviderMounted, extensions);
@@ -122,9 +122,8 @@ class FileSystemProviderServiceTest : public testing::Test {
     user_manager_enabler_.reset(new ScopedUserManagerEnabler(user_manager_));
     extension_registry_.reset(
         new extensions::ExtensionRegistry(profile_.get()));
-    file_system_provider_service_.reset(
-        new Service(profile_.get(), extension_registry_.get()));
-    file_system_provider_service_->SetFileSystemFactoryForTesting(
+    service_.reset(new Service(profile_.get(), extension_registry_.get()));
+    service_->SetFileSystemFactoryForTesting(
         base::Bind(&FakeProvidedFileSystem::Create));
     extension_ = createFakeExtension(kExtensionId);
   }
@@ -134,16 +133,16 @@ class FileSystemProviderServiceTest : public testing::Test {
   FakeUserManager* user_manager_;
   scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_;
   scoped_ptr<extensions::ExtensionRegistry> extension_registry_;
-  scoped_ptr<Service> file_system_provider_service_;
+  scoped_ptr<Service> service_;
   scoped_refptr<extensions::Extension> extension_;
 };
 
 TEST_F(FileSystemProviderServiceTest, MountFileSystem) {
   LoggingObserver observer;
-  file_system_provider_service_->AddObserver(&observer);
+  service_->AddObserver(&observer);
 
-  const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kFileSystemName);
+  const bool result =
+      service_->MountFileSystem(kExtensionId, kFileSystemId, kFileSystemName);
   EXPECT_TRUE(result);
 
   ASSERT_EQ(1u, observer.mounts.size());
@@ -160,22 +159,22 @@ TEST_F(FileSystemProviderServiceTest, MountFileSystem) {
   ASSERT_EQ(0u, observer.unmounts.size());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
-      file_system_provider_service_->GetProvidedFileSystemInfoList();
+      service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(1u, file_system_info_list.size());
 
-  file_system_provider_service_->RemoveObserver(&observer);
+  service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, MountFileSystem_UniqueIds) {
   LoggingObserver observer;
-  file_system_provider_service_->AddObserver(&observer);
+  service_->AddObserver(&observer);
 
-  const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kFileSystemName);
+  const bool result =
+      service_->MountFileSystem(kExtensionId, kFileSystemId, kFileSystemName);
   EXPECT_TRUE(result);
 
-  const bool second_result = file_system_provider_service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kFileSystemName);
+  const bool second_result =
+      service_->MountFileSystem(kExtensionId, kFileSystemId, kFileSystemName);
   EXPECT_FALSE(second_result);
 
   ASSERT_EQ(2u, observer.mounts.size());
@@ -183,29 +182,29 @@ TEST_F(FileSystemProviderServiceTest, MountFileSystem_UniqueIds) {
   EXPECT_EQ(base::File::FILE_ERROR_EXISTS, observer.mounts[1].error());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
-      file_system_provider_service_->GetProvidedFileSystemInfoList();
+      service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(1u, file_system_info_list.size());
 
-  file_system_provider_service_->RemoveObserver(&observer);
+  service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, MountFileSystem_StressTest) {
   LoggingObserver observer;
-  file_system_provider_service_->AddObserver(&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);
-    const bool result = file_system_provider_service_->MountFileSystem(
+    const bool result = service_->MountFileSystem(
         kExtensionId, file_system_id, kFileSystemName);
     EXPECT_TRUE(result);
   }
   ASSERT_EQ(kMaxFileSystems, observer.mounts.size());
 
   // The next file system is out of limit, and registering it should fail.
-  const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kFileSystemName);
+  const bool result =
+      service_->MountFileSystem(kExtensionId, kFileSystemId, kFileSystemName);
   EXPECT_FALSE(result);
 
   ASSERT_EQ(kMaxFileSystems + 1, observer.mounts.size());
@@ -213,23 +212,23 @@ TEST_F(FileSystemProviderServiceTest, MountFileSystem_StressTest) {
             observer.mounts[kMaxFileSystems].error());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
-      file_system_provider_service_->GetProvidedFileSystemInfoList();
+      service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(kMaxFileSystems, file_system_info_list.size());
 
-  file_system_provider_service_->RemoveObserver(&observer);
+  service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, UnmountFileSystem) {
   LoggingObserver observer;
-  file_system_provider_service_->AddObserver(&observer);
+  service_->AddObserver(&observer);
 
-  const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kFileSystemName);
+  const bool result =
+      service_->MountFileSystem(kExtensionId, kFileSystemId, kFileSystemName);
   EXPECT_TRUE(result);
   ASSERT_EQ(1u, observer.mounts.size());
 
-  const bool unmount_result = file_system_provider_service_->UnmountFileSystem(
-      kExtensionId, kFileSystemId);
+  const bool unmount_result = service_->UnmountFileSystem(
+      kExtensionId, kFileSystemId, Service::UNMOUNT_MODE_USER);
   EXPECT_TRUE(unmount_result);
   ASSERT_EQ(1u, observer.unmounts.size());
   EXPECT_EQ(base::File::FILE_OK, observer.unmounts[0].error());
@@ -240,23 +239,23 @@ TEST_F(FileSystemProviderServiceTest, UnmountFileSystem) {
             observer.unmounts[0].file_system_info().file_system_id());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
-      file_system_provider_service_->GetProvidedFileSystemInfoList();
+      service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(0u, file_system_info_list.size());
 
-  file_system_provider_service_->RemoveObserver(&observer);
+  service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, UnmountFileSystem_OnExtensionUnload) {
   LoggingObserver observer;
-  file_system_provider_service_->AddObserver(&observer);
+  service_->AddObserver(&observer);
 
-  const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kFileSystemName);
+  const bool result =
+      service_->MountFileSystem(kExtensionId, kFileSystemId, kFileSystemName);
   EXPECT_TRUE(result);
   ASSERT_EQ(1u, observer.mounts.size());
 
   // Directly call the observer's method.
-  file_system_provider_service_->OnExtensionUnloaded(
+  service_->OnExtensionUnloaded(
       profile_.get(),
       extension_.get(),
       extensions::UnloadedExtensionInfo::REASON_DISABLE);
@@ -270,144 +269,188 @@ TEST_F(FileSystemProviderServiceTest, UnmountFileSystem_OnExtensionUnload) {
             observer.unmounts[0].file_system_info().file_system_id());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
-      file_system_provider_service_->GetProvidedFileSystemInfoList();
+      service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(0u, file_system_info_list.size());
 
-  file_system_provider_service_->RemoveObserver(&observer);
+  service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, UnmountFileSystem_WrongExtensionId) {
   LoggingObserver observer;
-  file_system_provider_service_->AddObserver(&observer);
+  service_->AddObserver(&observer);
 
   const std::string kWrongExtensionId = "helloworldhelloworldhelloworldhe";
 
-  const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kFileSystemName);
+  const bool result =
+      service_->MountFileSystem(kExtensionId, kFileSystemId, kFileSystemName);
   EXPECT_TRUE(result);
   ASSERT_EQ(1u, observer.mounts.size());
-  ASSERT_EQ(
-      1u,
-      file_system_provider_service_->GetProvidedFileSystemInfoList().size());
+  ASSERT_EQ(1u, service_->GetProvidedFileSystemInfoList().size());
 
-  const bool unmount_result = file_system_provider_service_->UnmountFileSystem(
-      kWrongExtensionId, kFileSystemId);
+  const bool unmount_result = service_->UnmountFileSystem(
+      kWrongExtensionId, kFileSystemId, Service::UNMOUNT_MODE_USER);
   EXPECT_FALSE(unmount_result);
   ASSERT_EQ(1u, observer.unmounts.size());
   EXPECT_EQ(base::File::FILE_ERROR_NOT_FOUND, observer.unmounts[0].error());
-  ASSERT_EQ(
-      1u,
-      file_system_provider_service_->GetProvidedFileSystemInfoList().size());
+  ASSERT_EQ(1u, service_->GetProvidedFileSystemInfoList().size());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
-      file_system_provider_service_->GetProvidedFileSystemInfoList();
+      service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(1u, file_system_info_list.size());
 
-  file_system_provider_service_->RemoveObserver(&observer);
+  service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, RestoreFileSystem_OnExtensionLoad) {
-  LoggingObserver observer;
-  file_system_provider_service_->AddObserver(&observer);
-
   // Create a fake entry in the preferences.
   RememberFakeFileSystem(
       profile_.get(), kExtensionId, kFileSystemId, kFileSystemName);
 
-  EXPECT_EQ(0u, observer.mounts.size());
-
-  // Directly call the observer's method.
-  file_system_provider_service_->OnExtensionLoaded(profile_.get(),
-                                                   extension_.get());
+  {

[hashimoto, 2014/07/02 08:59:37]

Why do we need a scope here?

[mtomasz, 2014/07/03 05:24:07]

Not needed. Done.

+    scoped_ptr<Service> service(

[hashimoto, 2014/07/02 08:59:37]

Why can't you call reset() against |service_| here?

[mtomasz, 2014/07/03 05:24:07]

Sure I can, but is it better? The new instance is needed only in this scope, so
is there a reason to save it as a member?

[hashimoto, 2014/07/04 06:38:41]

Having |service| and |service_| in the same scope looks ambiguous.
Please remove this variable or rename it to a more distinguishable name.

[mtomasz, 2014/07/04 07:50:42]

Done.

[hashimoto, 2014/07/07 11:07:46]

|file_system_provider_service| does not tell how it's different from |service_|.
Please use a more meaningful name like |new_service| or |service_after_reboot|.

[mtomasz, 2014/07/08 01:52:08]

Done.

+        new Service(profile_.get(), extension_registry_.get()));

[hashimoto, 2014/07/02 08:59:37]

Please add a comment to describe that you want to load the saved file system by
creating a new Service.

[mtomasz, 2014/07/03 05:24:07]

Done.

+    LoggingObserver observer;
+    service->AddObserver(&observer);
 
-  ASSERT_EQ(1u, observer.mounts.size());
-  EXPECT_EQ(base::File::FILE_OK, observer.mounts[0].error());
+    service->SetFileSystemFactoryForTesting(
+        base::Bind(&FakeProvidedFileSystem::Create));
 
-  EXPECT_EQ(kExtensionId, observer.mounts[0].file_system_info().extension_id());
-  EXPECT_EQ(kFileSystemId,
-            observer.mounts[0].file_system_info().file_system_id());
+    EXPECT_EQ(0u, observer.mounts.size());
 
-  std::vector<ProvidedFileSystemInfo> file_system_info_list =
-      file_system_provider_service_->GetProvidedFileSystemInfoList();
-  ASSERT_EQ(1u, file_system_info_list.size());
+    // Directly call the observer's method.
+    service->OnExtensionLoaded(profile_.get(), extension_.get());
 
-  file_system_provider_service_->RemoveObserver(&observer);
-}
+    ASSERT_EQ(1u, observer.mounts.size());
+    EXPECT_EQ(base::File::FILE_OK, observer.mounts[0].error());
 
-TEST_F(FileSystemProviderServiceTest, ForgetFileSystem_OnExtensionUnload) {
-  LoggingObserver observer;
-  file_system_provider_service_->AddObserver(&observer);
+    EXPECT_EQ(kExtensionId,
+              observer.mounts[0].file_system_info().extension_id());
+    EXPECT_EQ(kFileSystemId,
+              observer.mounts[0].file_system_info().file_system_id());
 
-  // Create a fake entry in the preferences.
-  RememberFakeFileSystem(
-      profile_.get(), kExtensionId, kFileSystemId, kFileSystemName);
+    std::vector<ProvidedFileSystemInfo> file_system_info_list =
+        service->GetProvidedFileSystemInfoList();
+    ASSERT_EQ(1u, file_system_info_list.size());
 
-  // Directly call the observer's methods.
-  file_system_provider_service_->OnExtensionLoaded(profile_.get(),
-                                                   extension_.get());
+    service->RemoveObserver(&observer);
+  }
+}
 
-  file_system_provider_service_->OnExtensionUnloaded(
-      profile_.get(),
-      extension_.get(),
-      extensions::UnloadedExtensionInfo::REASON_DISABLE);
+TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnMount) {
+  LoggingObserver observer;
+  service_->AddObserver(&observer);
 
+  const bool result =
+      service_->MountFileSystem(kExtensionId, kFileSystemId, kFileSystemName);
+  EXPECT_TRUE(result);
   ASSERT_EQ(1u, observer.mounts.size());
-  EXPECT_EQ(base::File::FILE_OK, observer.mounts[0].error());
-  ASSERT_EQ(1u, observer.unmounts.size());
-  EXPECT_EQ(base::File::FILE_OK, observer.unmounts[0].error());
 
-  TestingPrefServiceSyncable* pref_service = profile_->GetTestingPrefService();
+  TestingPrefServiceSyncable* const pref_service =
+      profile_->GetTestingPrefService();
   ASSERT_TRUE(pref_service);
 
-  const base::DictionaryValue* extensions =
+  const base::DictionaryValue* const extensions =
       pref_service->GetDictionary(prefs::kFileSystemProviderMounted);
   ASSERT_TRUE(extensions);
 
-  const base::ListValue* file_systems;
-  EXPECT_FALSE(extensions->GetList(kExtensionId, &file_systems));
+  const base::DictionaryValue* file_systems;
+  ASSERT_TRUE(extensions->GetDictionary(kExtensionId, &file_systems));
+  ASSERT_EQ(1u, file_systems->size());
+
+  const base::Value* file_system_value = NULL;
+  const base::DictionaryValue* file_system = NULL;
+  ASSERT_TRUE(
+      file_systems->GetWithoutPathExpansion(kFileSystemId, &file_system_value));
+  ASSERT_TRUE(file_system_value->GetAsDictionary(&file_system));
+
+  std::string file_system_id;
+  file_system->GetString(kPrefKeyFileSystemId, &file_system_id);
+  EXPECT_EQ(kFileSystemId, file_system_id);
+
+  std::string file_system_name;
+  file_system->GetString(kPrefKeyFileSystemName, &file_system_name);
+  EXPECT_EQ(kFileSystemName, file_system_name);
 
-  file_system_provider_service_->RemoveObserver(&observer);
+  service_->RemoveObserver(&observer);
 }
 
-TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnShutdown) {
-  {
-    scoped_ptr<Service> service(
-        new Service(profile_.get(), extension_registry_.get()));
-    service->SetFileSystemFactoryForTesting(
-        base::Bind(&FakeProvidedFileSystem::Create));
+TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnUnmountByUser) {

[hashimoto, 2014/07/02 08:59:38]

What is the relationship between these two new test cases and the removed test
cases, "ForgetFileSystem_OnExtensionUnload" and "RememberFileSystem_OnShutdown"?

[mtomasz, 2014/07/03 05:24:07]

ForgetFileSystem_OnExtensionUnload -> RememberFileSystem_OnUnmountByUser
RememberFileSystem_OnShutdown -> RememberFileSystem_OnUnmountOnShutdown

[hashimoto, 2014/07/04 06:38:41]

Why did you change the order?
Even if you need to do that, could you do that in a separate change?
It's hard to review all of file_system_provider_service_ renaming, pref
structure change and test case reordering at the same time.

[mtomasz, 2014/07/04 07:50:42]

I flipped the order, but the diff doesn't look much better.

+  LoggingObserver observer;
+  service_->AddObserver(&observer);
 
-    LoggingObserver observer;
-    service->AddObserver(&observer);
+  TestingPrefServiceSyncable* const pref_service =
+      profile_->GetTestingPrefService();
+  ASSERT_TRUE(pref_service);
 
-    const bool result =
-        service->MountFileSystem(kExtensionId, kFileSystemId, kFileSystemName);
-    EXPECT_TRUE(result);
+  {
+    const bool mount_result =
+        service_->MountFileSystem(kExtensionId, kFileSystemId, kFileSystemName);
+    EXPECT_TRUE(mount_result);
     ASSERT_EQ(1u, observer.mounts.size());
 
-    service->RemoveObserver(&observer);
+    const base::DictionaryValue* extensions =
+        pref_service->GetDictionary(prefs::kFileSystemProviderMounted);
+    ASSERT_TRUE(extensions);
+
+    const base::DictionaryValue* file_systems;
+    ASSERT_TRUE(extensions->GetDictionary(kExtensionId, &file_systems));
+    EXPECT_EQ(1u, file_systems->size());
+  }
+
+  {
+    const bool unmount_result = service_->UnmountFileSystem(
+        kExtensionId, kFileSystemId, Service::UNMOUNT_MODE_USER);
+    EXPECT_TRUE(unmount_result);
+
+    const base::DictionaryValue* const extensions =
+        pref_service->GetDictionary(prefs::kFileSystemProviderMounted);
+    ASSERT_TRUE(extensions);
+
+    const base::DictionaryValue* file_systems;
+    EXPECT_FALSE(extensions->GetDictionary(kExtensionId, &file_systems));
   }
 
-  TestingPrefServiceSyncable* pref_service = profile_->GetTestingPrefService();
+  service_->RemoveObserver(&observer);
+}
+
+TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnUnmountOnShutdown) {
+  LoggingObserver observer;
+  service_->AddObserver(&observer);
+
+  TestingPrefServiceSyncable* const pref_service =
+      profile_->GetTestingPrefService();
   ASSERT_TRUE(pref_service);
 
-  const base::DictionaryValue* extensions =
-      pref_service->GetDictionary(prefs::kFileSystemProviderMounted);
-  ASSERT_TRUE(extensions);
+  {
+    const bool mount_result =
+        service_->MountFileSystem(kExtensionId, kFileSystemId, kFileSystemName);
+    EXPECT_TRUE(mount_result);
+    ASSERT_EQ(1u, observer.mounts.size());
 
-  const base::ListValue* file_systems;
-  ASSERT_TRUE(extensions->GetList(kExtensionId, &file_systems));
-  ASSERT_EQ(1u, file_systems->GetSize());
+    const base::DictionaryValue* extensions =
+        pref_service->GetDictionary(prefs::kFileSystemProviderMounted);
+    ASSERT_TRUE(extensions);
 
-  const base::DictionaryValue* file_system = NULL;
-  ASSERT_TRUE(file_systems->GetDictionary(0, &file_system));
+    const base::DictionaryValue* file_systems;
+    ASSERT_TRUE(extensions->GetDictionary(kExtensionId, &file_systems));
+    EXPECT_EQ(1u, file_systems->size());
+  }
 
-  std::string file_system_id;
-  file_system->GetString(kPrefKeyFileSystemId, &file_system_id);
-  EXPECT_EQ(kFileSystemId, file_system_id);
+  {
+    const bool unmount_result = service_->UnmountFileSystem(
+        kExtensionId, kFileSystemId, Service::UNMOUNT_MODE_SHUTDOWN);
+    EXPECT_TRUE(unmount_result);
 
-  std::string file_system_name;
-  file_system->GetString(kPrefKeyFileSystemName, &file_system_name);
-  EXPECT_EQ(kFileSystemName, file_system_name);
+    const base::DictionaryValue* const extensions =
+        pref_service->GetDictionary(prefs::kFileSystemProviderMounted);
+    ASSERT_TRUE(extensions);
+
+    const base::DictionaryValue* file_systems;
+    ASSERT_TRUE(extensions->GetDictionary(kExtensionId, &file_systems));
+    EXPECT_EQ(1u, file_systems->size());
+  }
+
+  service_->RemoveObserver(&observer);
 }
 
 }  // namespace file_system_provider