[fsp] Rename file_system_name to display_name for consistency.

chrome/browser/chromeos/file_system_provider/service.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 "base/files/file_path.h"
 #include "base/prefs/pref_service.h"
 #include "base/prefs/scoped_user_pref_update.h"
 #include "base/stl_util.h"
@@ skipping 20 matching lines @@
 ProvidedFileSystemInterface* CreateProvidedFileSystem(
     Profile* profile,
     const ProvidedFileSystemInfo& file_system_info) {
   DCHECK(profile);
   return new ProvidedFileSystem(profile, file_system_info);
 }
 
 }  // namespace
 
 const char kPrefKeyFileSystemId[] = "file-system-id";
-const char kPrefKeyFileSystemName[] = "file-system-name";
+const char kPrefKeyDisplayName[] = "display-name";
 
 void RegisterProfilePrefs(user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterDictionaryPref(
       prefs::kFileSystemProviderMounted,
       user_prefs::PrefRegistrySyncable::UNSYNCABLE_PREF);
 }
 
 Service::Service(Profile* profile,
                  extensions::ExtensionRegistry* extension_registry)
     : profile_(profile),
@@ skipping 38 matching lines @@
 }
 
 void Service::SetFileSystemFactoryForTesting(
     const FileSystemFactoryCallback& factory_callback) {
   DCHECK(!factory_callback.is_null());
   file_system_factory_ = factory_callback;
 }
 
 bool Service::MountFileSystem(const std::string& extension_id,
                               const std::string& file_system_id,
-                              const std::string& file_system_name) {
+                              const std::string& display_name) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // If already exists a file system provided by the same extension with this
   // id, then abort.
   if (GetProvidedFileSystem(extension_id, file_system_id)) {
     FOR_EACH_OBSERVER(Observer,
                       observers_,
                       OnProvidedFileSystemMount(ProvidedFileSystemInfo(),
                                                 base::File::FILE_ERROR_EXISTS));
     return false;
@@ skipping 31 matching lines @@
     return false;
   }
 
   // Store the file system descriptor. Use the mount point name as the file
   // system provider file system id.
   // Examples:
   //   file_system_id = 41
   //   mount_point_name =  b33f1337-41-5aa5
   //   mount_path = /provided/b33f1337-41-5aa5
   ProvidedFileSystemInfo file_system_info(
-      extension_id, file_system_id, file_system_name, mount_path);
+      extension_id, file_system_id, display_name, mount_path);
 
   ProvidedFileSystemInterface* file_system =
       file_system_factory_.Run(profile_, file_system_info);
   DCHECK(file_system);
   file_system_map_[FileSystemKey(extension_id, file_system_id)] = file_system;
   mount_point_name_to_key_map_[mount_point_name] =
       FileSystemKey(extension_id, file_system_id);
 
   FOR_EACH_OBSERVER(
       Observer,
@@ skipping 161 matching lines @@
        it != file_system_info_list.end();
        ++it) {
     base::ListValue* file_systems = NULL;
     if (!extensions.GetList(it->extension_id(), &file_systems)) {
       file_systems = new base::ListValue();
       extensions.Set(it->extension_id(), file_systems);
     }
 
     base::DictionaryValue* file_system = new base::DictionaryValue();
     file_system->SetString(kPrefKeyFileSystemId, it->file_system_id());
-    file_system->SetString(kPrefKeyFileSystemName, it->file_system_name());
+    file_system->SetString(kPrefKeyDisplayName, it->display_name());
     file_systems->Append(file_system);
   }
 
   PrefService* pref_service = profile_->GetPrefs();
   DCHECK(pref_service);
   pref_service->Set(prefs::kFileSystemProviderMounted, extensions);
   pref_service->CommitPendingWrite();
 }
 
 void Service::ForgetFileSystems(const std::string& extension_id) {
@@ skipping 22 matching lines @@
 
   for (size_t i = 0; i < file_systems->GetSize(); ++i) {
     const base::DictionaryValue* file_system = NULL;
     file_systems->GetDictionary(i, &file_system);
     DCHECK(file_system);
 
     std::string file_system_id;
     file_system->GetString(kPrefKeyFileSystemId, &file_system_id);
     DCHECK(!file_system_id.empty());
 
-    std::string file_system_name;
-    file_system->GetString(kPrefKeyFileSystemName, &file_system_name);
-    DCHECK(!file_system_name.empty());
+    std::string display_name;
+    file_system->GetString(kPrefKeyDisplayName, &display_name);
+    DCHECK(!display_name.empty());
 
-    if (file_system_id.empty() || file_system_name.empty()) {
+    if (file_system_id.empty() || display_name.empty()) {
       LOG(ERROR)
           << "Malformed provided file system information in preferences.";
       continue;
     }
 
     const bool result =
-        MountFileSystem(extension_id, file_system_id, file_system_name);
+        MountFileSystem(extension_id, file_system_id, display_name);
     if (!result) {
       LOG(ERROR) << "Failed to restore a provided file system from "
                  << "preferences: " << extension_id << ", " << file_system_id
-                 << ", " << file_system_name << ".";
+                 << ", " << display_name << ".";
     }
   }
 }
 
 }  // namespace file_system_provider
 }  // namespace chromeos