[fsp] Store mounted file systems in preferences.

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 <string>
 #include <vector>
 
 #include "base/files/file.h"
 #include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/strings/string_number_conversions.h"
 #include "chrome/browser/chromeos/file_system_provider/fake_provided_file_system.h"
 #include "chrome/browser/chromeos/file_system_provider/mount_path_util.h"
 #include "chrome/browser/chromeos/file_system_provider/observer.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
 #include "chrome/browser/chromeos/file_system_provider/service.h"
 #include "chrome/browser/chromeos/login/users/fake_user_manager.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/testing_pref_service_syncable.h"
 #include "chrome/test/base/testing_profile.h"
+#include "components/user_prefs/user_prefs.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/common/extension.h"
 #include "extensions/common/manifest_constants.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webkit/browser/fileapi/external_mount_points.h"
 
 namespace chromeos {
 namespace file_system_provider {
 namespace {
@@ skipping 50 matching lines @@
   manifest.SetString(extensions::manifest_keys::kVersion, "1.0.0.0");
   manifest.SetString(extensions::manifest_keys::kName, "unused");
   return extensions::Extension::Create(base::FilePath(),
                                        extensions::Manifest::UNPACKED,
                                        manifest,
                                        extensions::Extension::NO_FLAGS,
                                        extension_id,
                                        &error);
 }
 
+// Stores a provided file system information in preferences.
+void rememberFakeFileSystem(TestingProfile* profile,

[hashimoto, 2014/05/26 08:35:38]

nit: "RememberFakeFileSystem"

[mtomasz, 2014/05/27 02:10:27]

Done.

+                            const std::string& extension_id,
+                            const std::string& file_system_id,
+                            const std::string& file_system_name) {
+  TestingPrefServiceSyncable* pref_service = profile->GetTestingPrefService();
+  ASSERT_TRUE(pref_service);
+
+  base::DictionaryValue extensions;
+  base::ListValue* file_systems = new base::ListValue();
+  base::DictionaryValue* file_system = new base::DictionaryValue();
+  file_system->SetString("file_system_id", kFileSystemId);
+  file_system->SetString("file_system_name", kFileSystemName);
+  file_systems->Append(file_system);
+  extensions.Set(kExtensionId, file_systems);
+
+  pref_service->Set(prefs::kFSPMountedFileSystems, extensions);
+}
+
 }  // namespace
 
 class FileSystemProviderServiceTest : public testing::Test {
  protected:
   FileSystemProviderServiceTest() {}
   virtual ~FileSystemProviderServiceTest() {}
 
   virtual void SetUp() OVERRIDE {
     profile_.reset(new TestingProfile);
     user_manager_ = new FakeUserManager();
@@ skipping 178 matching lines @@
       1u,
       file_system_provider_service_->GetProvidedFileSystemInfoList().size());
 
   std::vector<ProvidedFileSystemInfo> file_system_info_list =
       file_system_provider_service_->GetProvidedFileSystemInfoList();
   ASSERT_EQ(1u, file_system_info_list.size());
 
   file_system_provider_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());
+
+  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());
+
+  std::vector<ProvidedFileSystemInfo> file_system_info_list =
+      file_system_provider_service_->GetProvidedFileSystemInfoList();
+  ASSERT_EQ(1u, file_system_info_list.size());
+
+  file_system_provider_service_->RemoveObserver(&observer);
+}
+
+TEST_F(FileSystemProviderServiceTest, ForgetFileSystem_OnExtensionUnload) {
+  LoggingObserver observer;
+  file_system_provider_service_->AddObserver(&observer);
+
+  // Create a fake entry in the preferences.
+  rememberFakeFileSystem(
+      profile_.get(), kExtensionId, kFileSystemId, kFileSystemName);
+
+  // Directly call the observer's methods.
+  file_system_provider_service_->OnExtensionLoaded(profile_.get(),
+                                                   extension_.get());
+
+  file_system_provider_service_->OnExtensionUnloaded(
+      profile_.get(),
+      extension_.get(),
+      extensions::UnloadedExtensionInfo::REASON_DISABLE);
+
+  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();
+  ASSERT_TRUE(pref_service);
+
+  const base::DictionaryValue* extensions =
+      pref_service->GetDictionary(prefs::kFSPMountedFileSystems);
+  ASSERT_TRUE(extensions);
+
+  const base::ListValue* file_systems;
+  EXPECT_FALSE(extensions->GetList(kExtensionId, &file_systems));
+
+  file_system_provider_service_->RemoveObserver(&observer);
+}
+
+TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnShutdown) {
+  {
+    scoped_ptr<Service> service(
+        new Service(profile_.get(), extension_registry_.get()));
+
+    LoggingObserver observer;
+    service->AddObserver(&observer);
+
+    const bool result =
+        service->MountFileSystem(kExtensionId, kFileSystemId, kFileSystemName);
+    EXPECT_TRUE(result);
+    ASSERT_EQ(1u, observer.mounts.size());
+
+    service->RemoveObserver(&observer);
+  }
+
+  TestingPrefServiceSyncable* pref_service = profile_->GetTestingPrefService();
+  ASSERT_TRUE(pref_service);
+
+  const base::DictionaryValue* extensions =
+      pref_service->GetDictionary(prefs::kFSPMountedFileSystems);
+  ASSERT_TRUE(extensions);
+
+  const base::ListValue* file_systems;
+  ASSERT_TRUE(extensions->GetList(kExtensionId, &file_systems));
+  ASSERT_EQ(1u, file_systems->GetSize());
+
+  const base::DictionaryValue* file_system = NULL;
+  ASSERT_TRUE(file_systems->GetDictionary(0, &file_system));
+
+  std::string file_system_id;
+  file_system->GetString("file_system_id", &file_system_id);
+  EXPECT_EQ(kFileSystemId, file_system_id);
+
+  std::string file_system_name;
+  file_system->GetString("file_system_name", &file_system_name);
+  EXPECT_EQ(kFileSystemName, file_system_name);
+}
+
 }  // namespace file_system_provider
 }  // namespace chromeos