Add a data source field for volumes.

chrome/browser/chromeos/file_system_provider/registry.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 "base/files/file_path.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/stl_util.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.h"
 #include "chrome/browser/chromeos/file_system_provider/provided_file_system_info.h"
 #include "chrome/browser/chromeos/file_system_provider/service_factory.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
 #include "storage/browser/fileapi/external_mount_points.h"
 
 namespace chromeos {
 namespace file_system_provider {
 
 const char kPrefKeyFileSystemId[] = "file-system-id";
 const char kPrefKeyDisplayName[] = "display-name";
 const char kPrefKeyWritable[] = "writable";
+const char kPrefKeySource[] = "source";
 const char kPrefKeySupportsNotifyTag[] = "supports-notify-tag";
 const char kPrefKeyWatchers[] = "watchers";
 const char kPrefKeyWatcherEntryPath[] = "entry-path";
 const char kPrefKeyWatcherRecursive[] = "recursive";
 const char kPrefKeyWatcherLastTag[] = "last-tag";
 const char kPrefKeyWatcherPersistentOrigins[] = "persistent-origins";
 const char kPrefKeyOpenedFilesLimit[] = "opened-files-limit";
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(
       prefs::kFileSystemProviderMounted,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
+std::string SourceToString(Source source) {
+  switch (source) {
+    case SOURCE_UNKNOWN:
+      return "unknown";
+    case SOURCE_FILE:
+      return "file";
+    case SOURCE_DEVICE:
+      return "device";
+    case SOURCE_NETWORK:
+      return "network";
+  }
+  NOTREACHED();
+  return std::string();
+}
+
+bool StringToSource(const std::string& source, Source* result) {
+  if (source.compare("unknown") == 0) {
+    *result = SOURCE_UNKNOWN;
+    return true;
+  }
+  if (source.compare("file") == 0) {
+    *result = SOURCE_FILE;
+    return true;
+  }
+  if (source.compare("device") == 0) {
+    *result = SOURCE_DEVICE;
+    return true;
+  }
+  if (source.compare("network") == 0) {
+    *result = SOURCE_NETWORK;
+    return true;
+  }
+  return false;
+}
+
 Registry::Registry(Profile* profile) : profile_(profile) {
 }
 
 Registry::~Registry() {
 }
 
 void Registry::RememberFileSystem(
     const ProvidedFileSystemInfo& file_system_info,
     const Watchers& watchers) {
   base::DictionaryValue* const file_system = new base::DictionaryValue();
   file_system->SetStringWithoutPathExpansion(kPrefKeyFileSystemId,
                                              file_system_info.file_system_id());
   file_system->SetStringWithoutPathExpansion(kPrefKeyDisplayName,
                                              file_system_info.display_name());
   file_system->SetBooleanWithoutPathExpansion(kPrefKeyWritable,
                                               file_system_info.writable());
+  file_system->SetStringWithoutPathExpansion(
+      kPrefKeySource, SourceToString(file_system_info.source()));
   file_system->SetBooleanWithoutPathExpansion(
       kPrefKeySupportsNotifyTag, file_system_info.supports_notify_tag());
   file_system->SetIntegerWithoutPathExpansion(
       kPrefKeyOpenedFilesLimit, file_system_info.opened_files_limit());
 
   base::DictionaryValue* const watchers_value = new base::DictionaryValue();
   file_system->SetWithoutPathExpansion(kPrefKeyWatchers, watchers_value);
 
   for (const auto& it : watchers) {
     base::DictionaryValue* const watcher = new base::DictionaryValue();
@@ skipping 77 matching lines @@
     const base::DictionaryValue* file_system = NULL;
     file_systems_per_extension->GetWithoutPathExpansion(it.key(),
                                                         &file_system_value);
     DCHECK(file_system_value);
 
     std::string file_system_id;
     std::string display_name;
     bool writable = false;
     bool supports_notify_tag = false;
     int opened_files_limit = 0;
+    std::string source_as_string;
+    Source source = SOURCE_UNKNOWN;
 
     // TODO(mtomasz): Move opened files limit to the mandatory list above in
     // M42.
     if ((!file_system_value->GetAsDictionary(&file_system) ||
          !file_system->GetStringWithoutPathExpansion(kPrefKeyFileSystemId,
                                                      &file_system_id) ||
          !file_system->GetStringWithoutPathExpansion(kPrefKeyDisplayName,
                                                      &display_name) ||
          !file_system->GetBooleanWithoutPathExpansion(kPrefKeyWritable,
                                                       &writable) ||
          !file_system->GetBooleanWithoutPathExpansion(kPrefKeySupportsNotifyTag,
                                                       &supports_notify_tag) ||
          file_system_id.empty() || display_name.empty()) ||
+        // Optional fields.
         (file_system->GetIntegerWithoutPathExpansion(kPrefKeyOpenedFilesLimit,
                                                      &opened_files_limit) &&
-         opened_files_limit < 0)) {
+         (file_system->GetStringWithoutPathExpansion(kPrefKeySource,
+                                                     &source_as_string) &&
+          !StringToSource(source_as_string, &source)))) {
       LOG(ERROR)
           << "Malformed provided file system information in preferences.";
       continue;
     }
 
     MountOptions options;
     options.file_system_id = file_system_id;
     options.display_name = display_name;
     options.writable = writable;
+    options.source = source;
     options.supports_notify_tag = supports_notify_tag;
     options.opened_files_limit = opened_files_limit;
 
     RestoredFileSystem restored_file_system;
     restored_file_system.extension_id = extension_id;
     restored_file_system.options = options;
 
     // Restore watchers. It's optional, since this field is new.
     const base::DictionaryValue* watchers = NULL;
     if (file_system->GetDictionaryWithoutPathExpansion(kPrefKeyWatchers,
@@ skipping 80 matching lines @@
     LOG(ERROR) << "Broken preferences detected while updating a tag.";
     return;
   }
 
   watcher_value->SetStringWithoutPathExpansion(kPrefKeyWatcherLastTag,
                                                watcher.last_tag);
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos