[fsp] Rename file_system_name to display_name for consistency.

chrome/browser/chromeos/file_system_provider/mount_path_util_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/mount_path_util.h"
 
 #include <string>
 
 #include "base/files/file.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 15 matching lines @@
 #include "webkit/browser/fileapi/isolated_context.h"
 
 namespace chromeos {
 namespace file_system_provider {
 namespace util {
 
 namespace {
 
 const char kExtensionId[] = "mbflcebpggnecokmikipoihdbecnjfoj";
 const char kFileSystemId[] = "File/System/Id";
-const char kFileSystemName[] = "Camera Pictures";
+const char kDisplayName[] = "Camera Pictures";
 
 // Creates a FileSystemURL for tests.
 fileapi::FileSystemURL CreateFileSystemURL(
     Profile* profile,
     const ProvidedFileSystemInfo& file_system_info,
     const base::FilePath& file_path) {
   const std::string origin =
       std::string("chrome-extension://") + file_system_info.extension_id();
   const base::FilePath mount_path = file_system_info.mount_path();
   const fileapi::ExternalMountPoints* const mount_points =
@@ skipping 73 matching lines @@
       base::FilePath::FromUTF8Unsafe("provided/hello-world/test.txt")));
   EXPECT_FALSE(IsFileSystemProviderLocalPath(
       base::FilePath::FromUTF8Unsafe("/provided")));
   EXPECT_FALSE(
       IsFileSystemProviderLocalPath(base::FilePath::FromUTF8Unsafe("/")));
   EXPECT_FALSE(IsFileSystemProviderLocalPath(base::FilePath()));
 }
 
 TEST_F(FileSystemProviderMountPathUtilTest, Parser) {
   const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kFileSystemName);
+      kExtensionId, kFileSystemId, kDisplayName);
   ASSERT_TRUE(result);
   const ProvidedFileSystemInfo file_system_info =
       file_system_provider_service_->GetProvidedFileSystem(kExtensionId,
                                                            kFileSystemId)
           ->GetFileSystemInfo();
 
   const base::FilePath kFilePath =
       base::FilePath::FromUTF8Unsafe("/hello/world.txt");
   const fileapi::FileSystemURL url =
       CreateFileSystemURL(profile_, file_system_info, kFilePath);
   EXPECT_TRUE(url.is_valid());
 
   FileSystemURLParser parser(url);
   EXPECT_TRUE(parser.Parse());
 
   ProvidedFileSystemInterface* file_system = parser.file_system();
   ASSERT_TRUE(file_system);
   EXPECT_EQ(kFileSystemId, file_system->GetFileSystemInfo().file_system_id());
   EXPECT_EQ(kFilePath.AsUTF8Unsafe(), parser.file_path().AsUTF8Unsafe());
 }
 
 TEST_F(FileSystemProviderMountPathUtilTest, Parser_RootPath) {
   const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kFileSystemName);
+      kExtensionId, kFileSystemId, kDisplayName);
   ASSERT_TRUE(result);
   const ProvidedFileSystemInfo file_system_info =
       file_system_provider_service_->GetProvidedFileSystem(kExtensionId,
                                                            kFileSystemId)
           ->GetFileSystemInfo();
 
   const base::FilePath kFilePath = base::FilePath::FromUTF8Unsafe("/");
   const fileapi::FileSystemURL url =
       CreateFileSystemURL(profile_, file_system_info, kFilePath);
   EXPECT_TRUE(url.is_valid());
 
   FileSystemURLParser parser(url);
   EXPECT_TRUE(parser.Parse());
 
   ProvidedFileSystemInterface* file_system = parser.file_system();
   ASSERT_TRUE(file_system);
   EXPECT_EQ(kFileSystemId, file_system->GetFileSystemInfo().file_system_id());
   EXPECT_EQ(kFilePath.AsUTF8Unsafe(), parser.file_path().AsUTF8Unsafe());
 }
 
 TEST_F(FileSystemProviderMountPathUtilTest, Parser_WrongUrl) {
   const ProvidedFileSystemInfo file_system_info(
       kExtensionId,
       kFileSystemId,
-      kFileSystemName,
+      kDisplayName,
       GetMountPath(profile_, kExtensionId, kFileSystemId));
 
   const base::FilePath kFilePath = base::FilePath::FromUTF8Unsafe("/hello");
   const fileapi::FileSystemURL url =
       CreateFileSystemURL(profile_, file_system_info, kFilePath);
   // It is impossible to create a cracked URL for a mount point which doesn't
   // exist, therefore is will always be invalid, and empty.
   EXPECT_FALSE(url.is_valid());
 
   FileSystemURLParser parser(url);
   EXPECT_FALSE(parser.Parse());
 }
 
 TEST_F(FileSystemProviderMountPathUtilTest, Parser_IsolatedURL) {
   const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kFileSystemName);
+      kExtensionId, kFileSystemId, kDisplayName);
   ASSERT_TRUE(result);
   const ProvidedFileSystemInfo file_system_info =
       file_system_provider_service_->GetProvidedFileSystem(kExtensionId,
                                                            kFileSystemId)
           ->GetFileSystemInfo();
 
   const base::FilePath kFilePath =
       base::FilePath::FromUTF8Unsafe("/hello/world.txt");
   const fileapi::FileSystemURL url =
       CreateFileSystemURL(profile_, file_system_info, kFilePath);
@@ skipping 25 matching lines @@
   EXPECT_TRUE(parser.Parse());
 
   ProvidedFileSystemInterface* file_system = parser.file_system();
   ASSERT_TRUE(file_system);
   EXPECT_EQ(kFileSystemId, file_system->GetFileSystemInfo().file_system_id());
   EXPECT_EQ(kFilePath.AsUTF8Unsafe(), parser.file_path().AsUTF8Unsafe());
 }
 
 TEST_F(FileSystemProviderMountPathUtilTest, LocalPathParser) {
   const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kFileSystemName);
+      kExtensionId, kFileSystemId, kDisplayName);
   ASSERT_TRUE(result);
   const ProvidedFileSystemInfo file_system_info =
       file_system_provider_service_->GetProvidedFileSystem(kExtensionId,
                                                            kFileSystemId)
           ->GetFileSystemInfo();
 
   const base::FilePath kFilePath =
       base::FilePath::FromUTF8Unsafe("/hello/world.txt");
   const base::FilePath kLocalFilePath = file_system_info.mount_path().Append(
       base::FilePath(kFilePath.value().substr(1)));
 
   LOG(ERROR) << kLocalFilePath.value();
   LocalPathParser parser(profile_, kLocalFilePath);
   EXPECT_TRUE(parser.Parse());
 
   ProvidedFileSystemInterface* file_system = parser.file_system();
   ASSERT_TRUE(file_system);
   EXPECT_EQ(kFileSystemId, file_system->GetFileSystemInfo().file_system_id());
   EXPECT_EQ(kFilePath.AsUTF8Unsafe(), parser.file_path().AsUTF8Unsafe());
 }
 
 TEST_F(FileSystemProviderMountPathUtilTest, LocalPathParser_RootPath) {
   const bool result = file_system_provider_service_->MountFileSystem(
-      kExtensionId, kFileSystemId, kFileSystemName);
+      kExtensionId, kFileSystemId, kDisplayName);
   ASSERT_TRUE(result);
   const ProvidedFileSystemInfo file_system_info =
       file_system_provider_service_->GetProvidedFileSystem(kExtensionId,
                                                            kFileSystemId)
           ->GetFileSystemInfo();
 
   const base::FilePath kFilePath = base::FilePath::FromUTF8Unsafe("/");
   const base::FilePath kLocalFilePath = file_system_info.mount_path();
 
   LocalPathParser parser(profile_, kLocalFilePath);
@@ skipping 23 matching lines @@
     const base::FilePath kFilePath =
         base::FilePath::FromUTF8Unsafe("provided/hello/world");
     LocalPathParser parser(profile_, kFilePath);
     EXPECT_FALSE(parser.Parse());
   }
 }
 
 }  // namespace util
 }  // namespace file_system_provider
 }  // namespace chromeos