Prettify Mac names, rewrite getDisplayPath API call to focus on $HOME

chrome/browser/extensions/api/file_system/file_system_api.cc

 // Copyright (c) 2012 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/extensions/api/file_system/file_system_api.h"
 
 #include "base/bind.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
@@ skipping 11 matching lines @@
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/web_contents.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/file_system_util.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/dialogs/select_file_dialog.h"
 
+#if defined(OS_MACOSX)
+#include "base/mac/foundation_util.h"
+#endif
+
 using fileapi::IsolatedContext;
 
 const char kInvalidParameters[] = "Invalid parameters";
 const char kSecurityError[] = "Security error";
 const char kInvalidCallingPage[] = "Invalid calling page";
 const char kUserCancelled[] = "User cancelled";
 const char kWritableFileError[] = "Invalid file for writing";
 const char kRequiresFileSystemWriteError[] =
     "Operation requires fileSystemWrite permission";
 const char kUnknownChooseFileType[] = "Unknown type";
 
 const char kOpenFileOption[] = "openFile";
 const char kOpenWritableFileOption[] ="openWritableFile";
 const char kSaveFileOption[] = "saveFile";
 
 namespace file_system = extensions::api::file_system;
 namespace ChooseFile = file_system::ChooseFile;
 
 namespace {
 
-struct RewritePair {
-  int path_key;
-  const char* output;
-};
+// Get the user's (optional) home directory via PathService.
+FilePath GetHome() {
+  int home_key = 0;
+#if defined(OS_WIN)
+  home_key = base::DIR_PROFILE;
+#elif defined(OS_POSIX)
+  home_key = base::DIR_HOME;
+#endif
+  FilePath home_path;
+  if (home_key && PathService::Get(home_key, &home_path)) {
+    return home_path;
+  }
+  return FilePath();
+}
 
-const RewritePair g_rewrite_pairs[] = {
-#if defined(OS_WIN)
-  {base::DIR_PROFILE, "~"},
-#elif defined(OS_POSIX)
-  {base::DIR_HOME, "~"},
+// Prettifies |source_path|. If the path is inside the user's home directory,
+// then replace the home directory component with "~".
+FilePath PrettifyPath(const FilePath& source_path) {
+  DCHECK(source_path.IsAbsolute());
+  FilePath home_path = GetHome();
+
+#if defined(OS_MACOSX)
+  // Break down the incoming path into components, and grab the display name
+  // for every component. This will match app bundles, ".localized" folders,
+  // and localized subfolders of the user's home directory.
+  std::vector<FilePath::StringType> components;
+  source_path.GetComponents(&components);
+  FilePath display_path = FilePath(components[0]);
+  FilePath actual_path = display_path;
+  for (std::vector<FilePath::StringType>::iterator i = components.begin() + 1;
+       i != components.end(); ++i) {
+    actual_path = actual_path.Append(*i);
+    if (actual_path == home_path) {
+      display_path = FilePath("~");
+      home_path = FilePath();
+      continue;
+    }
+    std::string display_basename =
+        base::mac::GetDisplayNameForPath(actual_path);
+    display_path = display_path.Append(display_basename);
+  }
+  DCHECK(actual_path == source_path);
+  return display_path;
+#else
+  // If found, replace the leading home directory with "~".
+  FilePath display_path("~");
+  if (!home_path.empty() && home_path.AppendRelativePath(source_path, &output))
+    return display_path;
+  return source_path;
 #endif
-};
-
-FilePath PrettifyPath(const FilePath& file_path) {
-#if defined(OS_WIN) || defined(OS_POSIX)
-  for (size_t i = 0; i < arraysize(g_rewrite_pairs); ++i) {
-    FilePath candidate_path;
-    if (!PathService::Get(g_rewrite_pairs[i].path_key, &candidate_path))
-      continue;  // We don't DCHECK this value, as Get will return false even
-                 // if the path_key gives a blank string as a result.
-
-    FilePath output = FilePath::FromUTF8Unsafe(g_rewrite_pairs[i].output);
-    if (candidate_path.AppendRelativePath(file_path, &output)) {
-      // The output path must not be absolute, as it might collide with the
-      // real filesystem.
-      DCHECK(!output.IsAbsolute());
-      return output;
-    }
-  }
-#endif
-
-  return file_path;
 }
 
 bool g_skip_picker_for_test = false;
 FilePath* g_path_to_be_picked_for_test;
 
 bool GetFilePathOfFileEntry(const std::string& filesystem_name,
                             const std::string& filesystem_path,
                             const content::RenderViewHost* render_view_host,
                             FilePath* file_path,
                             std::string* error) {
@@ skipping 459 matching lines @@
 
   if (entry_type == WRITABLE && !HasFileSystemWritePermission()) {
     error_ = kRequiresFileSystemWriteError;
     return false;
   }
 
   return ShowPicker(suggested_name, file_type_info, picker_type, entry_type);
 }
 
 }  // namespace extensions