Add a data source field for volumes.

chrome/browser/chromeos/file_system_provider/registry_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/registry.h"
 
 #include <string>
 #include <vector>
 
 #include "base/files/file_path.h"
@@ skipping 11 matching lines @@
 namespace chromeos {
 namespace file_system_provider {
 namespace {
 
 const char kTemporaryOrigin[] =
     "chrome-extension://abcabcabcabcabcabcabcabcabcabcabcabca/";
 const char kPersistentOrigin[] =
     "chrome-extension://efgefgefgefgefgefgefgefgefgefgefgefge/";
 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
 const char kDisplayName[] = "Camera Pictures";
+const Source kSource = SOURCE_NETWORK;
 
 // The dot in the file system ID is there in order to check that saving to
 // preferences works correctly. File System ID is used as a key in
 // a base::DictionaryValue, so it has to be stored without path expansion.
 const char kFileSystemId[] = "camera/pictures/id .!@#$%^&*()_+";
 
 const int kOpenedFilesLimit = 5;
 
 // Stores a provided file system information in preferences together with a
 // fake watcher.
 void RememberFakeFileSystem(TestingProfile* profile,
                             const std::string& extension_id,
                             const std::string& file_system_id,
                             const std::string& display_name,
                             bool writable,
+                            Source source,
                             bool supports_notify_tag,
                             int opened_files_limit,
                             const Watcher& watcher) {
   // Warning. Updating this code means that backward compatibility may be
   // broken, what is unexpected and should be avoided.
   TestingPrefServiceSyncable* const pref_service =
       profile->GetTestingPrefService();
   ASSERT_TRUE(pref_service);
 
   base::DictionaryValue extensions;
   base::DictionaryValue* const file_systems = new base::DictionaryValue();
   base::DictionaryValue* const file_system = new base::DictionaryValue();
   file_system->SetStringWithoutPathExpansion(kPrefKeyFileSystemId,
                                              kFileSystemId);
   file_system->SetStringWithoutPathExpansion(kPrefKeyDisplayName, kDisplayName);
   file_system->SetBooleanWithoutPathExpansion(kPrefKeyWritable, writable);
+  file_system->SetStringWithoutPathExpansion(kPrefKeySource,
+                                             SourceToString(source));
   file_system->SetBooleanWithoutPathExpansion(kPrefKeySupportsNotifyTag,
                                               supports_notify_tag);
   file_system->SetIntegerWithoutPathExpansion(kPrefKeyOpenedFilesLimit,
                                               opened_files_limit);
   file_systems->SetWithoutPathExpansion(kFileSystemId, file_system);
   extensions.SetWithoutPathExpansion(kExtensionId, file_systems);
 
   // Remember watchers.
   base::DictionaryValue* const watchers = new base::DictionaryValue();
   file_system->SetWithoutPathExpansion(kPrefKeyWatchers, watchers);
@@ skipping 44 matching lines @@
   content::TestBrowserThreadBundle thread_bundle_;
   scoped_ptr<TestingProfileManager> profile_manager_;
   TestingProfile* profile_;
   scoped_ptr<RegistryInterface> registry_;
   Watcher fake_watcher_;
 };
 
 TEST_F(FileSystemProviderRegistryTest, RestoreFileSystems) {
   // Create a fake entry in the preferences.
   RememberFakeFileSystem(profile_, kExtensionId, kFileSystemId, kDisplayName,
-                         true /* writable */, true /* supports_notify_tag */,
-                         kOpenedFilesLimit, fake_watcher_);
+                         true /* writable */, kSource,
+                         true /* supports_notify_tag */, kOpenedFilesLimit,
+                         fake_watcher_);
 
   scoped_ptr<RegistryInterface::RestoredFileSystems> restored_file_systems =
       registry_->RestoreFileSystems(kExtensionId);
 
   ASSERT_EQ(1u, restored_file_systems->size());
   const RegistryInterface::RestoredFileSystem& restored_file_system =
       restored_file_systems->at(0);
   EXPECT_EQ(kExtensionId, restored_file_system.extension_id);
   EXPECT_EQ(kFileSystemId, restored_file_system.options.file_system_id);
   EXPECT_EQ(kDisplayName, restored_file_system.options.display_name);
   EXPECT_TRUE(restored_file_system.options.writable);
+  EXPECT_EQ(kSource, restored_file_system.options.source);
   EXPECT_TRUE(restored_file_system.options.supports_notify_tag);
   EXPECT_EQ(kOpenedFilesLimit, restored_file_system.options.opened_files_limit);
 
   ASSERT_EQ(1u, restored_file_system.watchers.size());
   const auto& restored_watcher_it = restored_file_system.watchers.find(
       WatcherKey(fake_watcher_.entry_path, fake_watcher_.recursive));
   ASSERT_NE(restored_file_system.watchers.end(), restored_watcher_it);
 
   EXPECT_EQ(fake_watcher_.entry_path, restored_watcher_it->second.entry_path);
   EXPECT_EQ(fake_watcher_.recursive, restored_watcher_it->second.recursive);
   EXPECT_EQ(fake_watcher_.last_tag, restored_watcher_it->second.last_tag);
 }
 
 TEST_F(FileSystemProviderRegistryTest, RememberFileSystem) {
   MountOptions options(kFileSystemId, kDisplayName);
   options.writable = true;
+  options.source = kSource;
   options.supports_notify_tag = true;
   options.opened_files_limit = kOpenedFilesLimit;
 
   ProvidedFileSystemInfo file_system_info(
       kExtensionId, options, base::FilePath(FILE_PATH_LITERAL("/a/b/c")));
 
   Watchers watchers;
   watchers[WatcherKey(fake_watcher_.entry_path, fake_watcher_.recursive)] =
       fake_watcher_;
 
@@ skipping 26 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);
 
+  std::string source_as_string;
+  EXPECT_TRUE(file_system->GetStringWithoutPathExpansion(kPrefKeySource,
+                                                         &source_as_string));
+  EXPECT_EQ("network", source_as_string);
+
   bool supports_notify_tag = false;
   EXPECT_TRUE(file_system->GetBooleanWithoutPathExpansion(
       kPrefKeySupportsNotifyTag, &supports_notify_tag));
   EXPECT_TRUE(supports_notify_tag);
 
   int opened_files_limit = 0;
   EXPECT_TRUE(file_system->GetIntegerWithoutPathExpansion(
       kPrefKeyOpenedFilesLimit, &opened_files_limit));
   EXPECT_EQ(kOpenedFilesLimit, opened_files_limit);
 
@@ skipping 29 matching lines @@
   EXPECT_TRUE(persistent_origins->GetString(0, &persistent_origin));
   const auto& fake_subscriber_it =
       fake_watcher_.subscribers.find(GURL(persistent_origin));
   ASSERT_NE(fake_watcher_.subscribers.end(), fake_subscriber_it);
   EXPECT_TRUE(fake_subscriber_it->second.persistent);
 }
 
 TEST_F(FileSystemProviderRegistryTest, ForgetFileSystem) {
   // Create a fake file systems in the preferences.
   RememberFakeFileSystem(profile_, kExtensionId, kFileSystemId, kDisplayName,
-                         true /* writable */, true /* supports_notify_tag */,
-                         kOpenedFilesLimit, fake_watcher_);
+                         true /* writable */, kSource,
+                         true /* supports_notify_tag */, kOpenedFilesLimit,
+                         fake_watcher_);
 
   registry_->ForgetFileSystem(kExtensionId, kFileSystemId);
 
   TestingPrefServiceSyncable* const pref_service =
       profile_->GetTestingPrefService();
   ASSERT_TRUE(pref_service);
 
   const base::DictionaryValue* const extensions =
       pref_service->GetDictionary(prefs::kFileSystemProviderMounted);
   ASSERT_TRUE(extensions);
@@ skipping 46 matching lines @@
   const base::DictionaryValue* watcher = NULL;
   ASSERT_TRUE(watchers_value->GetDictionaryWithoutPathExpansion(
       fake_watcher_.entry_path.value(), &watcher));
 
   std::string last_tag;
   EXPECT_TRUE(watcher->GetStringWithoutPathExpansion(kPrefKeyWatcherLastTag,
                                                      &last_tag));
   EXPECT_EQ(fake_watcher_.last_tag, last_tag);
 }
 
+TEST_F(FileSystemProviderRegistryTest, SourceToString) {
+  {
+    Source result = SOURCE_UNKNOWN;
+    EXPECT_TRUE(StringToSource(SourceToString(SOURCE_FILE), &result));
+    EXPECT_EQ(SOURCE_FILE, result);
+  }
+  {
+    Source result = SOURCE_UNKNOWN;
+    EXPECT_TRUE(StringToSource(SourceToString(SOURCE_DEVICE), &result));
+    EXPECT_EQ(SOURCE_DEVICE, result);
+  }
+  {
+    Source result = SOURCE_UNKNOWN;
+    EXPECT_TRUE(StringToSource(SourceToString(SOURCE_NETWORK), &result));
+    EXPECT_EQ(SOURCE_NETWORK, result);
+  }
+  {
+    Source result = SOURCE_FILE;
+    EXPECT_TRUE(StringToSource(SourceToString(SOURCE_UNKNOWN), &result));
+    EXPECT_EQ(SOURCE_UNKNOWN, result);
+  }
+}
+
 }  // namespace file_system_provider
 }  // namespace chromeos