[fsp] Store observed entries 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 "chrome/browser/chromeos/file_system_provider/service.h"
 
 #include <string>
 #include <vector>
 
 #include "base/files/file.h"
@@ skipping 65 matching lines @@
       const ProvidedFileSystemInfo& file_system_info,
       base::File::Error error) override {
     unmounts.push_back(Event(file_system_info, error));
   }
 
   std::vector<Event> mounts;
   std::vector<Event> unmounts;
 };
 
 // Creates a fake extension with the specified |extension_id|.
-scoped_refptr<extensions::Extension> createFakeExtension(
+scoped_refptr<extensions::Extension> CreateFakeExtension(
     const std::string& extension_id) {
   base::DictionaryValue manifest;
   std::string error;
   manifest.SetStringWithoutPathExpansion(extensions::manifest_keys::kVersion,
                                          "1.0.0.0");
   manifest.SetStringWithoutPathExpansion(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.
+// Stores a provided file system information in preferences together with a
+// fake observed entry.
 void RememberFakeFileSystem(TestingProfile* profile,
                             const std::string& extension_id,
                             const std::string& file_system_id,
                             const std::string& display_name,
                             bool writable,
-                            bool supports_notify_tag) {
+                            bool supports_notify_tag,
+                            const ObservedEntry& observed_entry) {
   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);
 
+  // Remember observed entries.
+  base::DictionaryValue* const observed_entries = new base::DictionaryValue();
+  file_system->SetWithoutPathExpansion(kPrefKeyObservedEntries,
+                                       observed_entries);
+  base::DictionaryValue* const observed_entry_value =
+      new base::DictionaryValue();
+  observed_entries->SetWithoutPathExpansion(observed_entry.entry_path.value(),
+                                            observed_entry_value);
+  observed_entry_value->SetStringWithoutPathExpansion(
+      kPrefKeyObservedEntryEntryPath, observed_entry.entry_path.value());
+  observed_entry_value->SetBooleanWithoutPathExpansion(
+      kPrefKeyObservedEntryRecursive, observed_entry.recursive);
+  observed_entry_value->SetStringWithoutPathExpansion(
+      kPrefKeyObservedEntryLastTag, observed_entry.last_tag);
+
   pref_service->Set(prefs::kFileSystemProviderMounted, extensions);
 }
 
 }  // namespace
 
 class FileSystemProviderServiceTest : public testing::Test {
  protected:
   FileSystemProviderServiceTest() : profile_(NULL) {}
 
   virtual ~FileSystemProviderServiceTest() {}
 
   virtual void SetUp() override {
     profile_manager_.reset(
         new TestingProfileManager(TestingBrowserProcess::GetGlobal()));
     ASSERT_TRUE(profile_manager_->SetUp());
     profile_ = profile_manager_->CreateTestingProfile("test-user@example.com");
     user_manager_ = new FakeUserManager();
     user_manager_->AddUser(profile_->GetProfileName());
     user_manager_enabler_.reset(new ScopedUserManagerEnabler(user_manager_));
     extension_registry_.reset(new extensions::ExtensionRegistry(profile_));
     service_.reset(new Service(profile_, extension_registry_.get()));
     service_->SetFileSystemFactoryForTesting(
         base::Bind(&FakeProvidedFileSystem::Create));
-    extension_ = createFakeExtension(kExtensionId);
+    extension_ = CreateFakeExtension(kExtensionId);
+    fake_observed_entry_.entry_path =
+        base::FilePath(FILE_PATH_LITERAL("/a/b/c"));
+    fake_observed_entry_.recursive = true;
+    fake_observed_entry_.last_tag = "hello-world";
   }
 
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<TestingProfileManager> profile_manager_;
   TestingProfile* profile_;
   FakeUserManager* user_manager_;
   scoped_ptr<ScopedUserManagerEnabler> user_manager_enabler_;
   scoped_ptr<extensions::ExtensionRegistry> extension_registry_;
   scoped_ptr<Service> service_;
   scoped_refptr<extensions::Extension> extension_;
+  ObservedEntry fake_observed_entry_;
 };
 
 TEST_F(FileSystemProviderServiceTest, MountFileSystem) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
   EXPECT_TRUE(service_->MountFileSystem(
       kExtensionId, MountOptions(kFileSystemId, kDisplayName)));
 
   ASSERT_EQ(1u, observer.mounts.size());
@@ skipping 164 matching lines @@
   service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, RestoreFileSystem_OnExtensionLoad) {
   // Create a fake entry in the preferences.
   RememberFakeFileSystem(profile_,
                          kExtensionId,
                          kFileSystemId,
                          kDisplayName,
                          true /* writable */,
-                         true /* supports_notify_tag */);
+                         true /* supports_notify_tag */,
+                         fake_observed_entry_);
 
   // 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());
 
+  ProvidedFileSystemInterface* const file_system =
+      new_service->GetProvidedFileSystem(kExtensionId, kFileSystemId);
+  ASSERT_TRUE(file_system);
+
+  const ObservedEntries* const observed_entries =
+      file_system->GetObservedEntries();
+  ASSERT_TRUE(observed_entries);
+  ASSERT_EQ(1u, observed_entries->size());
+
+  const ObservedEntries::const_iterator restored_observed_entry_it =
+      observed_entries->find(fake_observed_entry_.entry_path);
+  ASSERT_NE(observed_entries->end(), restored_observed_entry_it);
+
+  EXPECT_EQ(fake_observed_entry_.entry_path,
+            restored_observed_entry_it->second.entry_path);
+  EXPECT_EQ(fake_observed_entry_.recursive,
+            restored_observed_entry_it->second.recursive);
+  EXPECT_EQ(fake_observed_entry_.last_tag,
+            restored_observed_entry_it->second.last_tag);
+
   new_service->RemoveObserver(&observer);
 }
 
-TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnMount) {
-  LoggingObserver observer;
-  service_->AddObserver(&observer);
-
+TEST_F(FileSystemProviderServiceTest, RememberFileSystem) {
   MountOptions options(kFileSystemId, kDisplayName);
   options.writable = true;
   options.supports_notify_tag = true;
-  EXPECT_TRUE(service_->MountFileSystem(kExtensionId, options));
-  ASSERT_EQ(1u, observer.mounts.size());
+
+  ProvidedFileSystemInfo file_system_info(
+      kExtensionId, options, base::FilePath(FILE_PATH_LITERAL("/a/b/c")));
+
+  ObservedEntries observed_entries;
+  observed_entries[fake_observed_entry_.entry_path] = fake_observed_entry_;
+
+  service_->RememberFileSystem(file_system_info, observed_entries);
 
   TestingPrefServiceSyncable* const pref_service =
       profile_->GetTestingPrefService();
   ASSERT_TRUE(pref_service);
 
   const base::DictionaryValue* const extensions =
       pref_service->GetDictionary(prefs::kFileSystemProviderMounted);
   ASSERT_TRUE(extensions);
 
   const base::DictionaryValue* file_systems = NULL;
@@ skipping 20 matching lines @@
   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);
 
+  const base::DictionaryValue* observed_entries_value = NULL;
+  ASSERT_TRUE(file_system->GetDictionaryWithoutPathExpansion(
+      kPrefKeyObservedEntries, &observed_entries_value));
+
+  const base::DictionaryValue* observed_entry = NULL;
+  ASSERT_TRUE(observed_entries_value->GetDictionaryWithoutPathExpansion(
+      fake_observed_entry_.entry_path.value(), &observed_entry));
+
+  std::string entry_path;
+  EXPECT_TRUE(observed_entry->GetStringWithoutPathExpansion(
+      kPrefKeyObservedEntryEntryPath, &entry_path));
+  EXPECT_EQ(fake_observed_entry_.entry_path.value(), entry_path);
+
+  bool recursive = false;
+  EXPECT_TRUE(observed_entry->GetBooleanWithoutPathExpansion(
+      kPrefKeyObservedEntryRecursive, &recursive));
+  EXPECT_EQ(fake_observed_entry_.recursive, recursive);
+
+  std::string last_tag;
+  EXPECT_TRUE(observed_entry->GetStringWithoutPathExpansion(
+      kPrefKeyObservedEntryLastTag, &last_tag));
+  EXPECT_EQ(fake_observed_entry_.last_tag, last_tag);
+}
+
+TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnMount) {
+  LoggingObserver observer;
+  service_->AddObserver(&observer);
+
+  TestingPrefServiceSyncable* const pref_service =
+      profile_->GetTestingPrefService();
+  ASSERT_TRUE(pref_service);
+
+  EXPECT_TRUE(service_->MountFileSystem(
+      kExtensionId, MountOptions(kFileSystemId, kDisplayName)));
+  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());
+
   service_->RemoveObserver(&observer);
 }
 
 TEST_F(FileSystemProviderServiceTest, RememberFileSystem_OnUnmountOnShutdown) {
   LoggingObserver observer;
   service_->AddObserver(&observer);
 
   TestingPrefServiceSyncable* const pref_service =
       profile_->GetTestingPrefService();
   ASSERT_TRUE(pref_service);
@@ skipping 64 matching lines @@
     const base::DictionaryValue* file_systems = NULL;
     EXPECT_FALSE(extensions->GetDictionaryWithoutPathExpansion(kExtensionId,
                                                                &file_systems));
   }
 
   service_->RemoveObserver(&observer);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos