Keeping the current directory in URL.

chrome/browser/extensions/file_manager_util.cc

 // Copyright (c) 2011 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/file_manager_util.h"
 
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "chrome/browser/chromeos/media/media_player.h"
 #include "chrome/browser/platform_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_list.h"
+#include "chrome/common/url_constants.h"
 #include "content/browser/browser_thread.h"
 #include "content/browser/user_metrics.h"
 #include "grit/generated_resources.h"
 #include "net/base/escape.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_mount_point_provider.h"
 #include "webkit/fileapi/file_system_util.h"
 
 #define FILEBROWSER_URL(PATH) \
@@ skipping 118 matching lines @@
 }
 
 // static
 GURL FileManagerUtil::GetFileBrowserUrlWithParams(
     SelectFileDialog::Type type,
     const string16& title,
     const FilePath& default_virtual_path,
     const SelectFileDialog::FileTypeInfo* file_types,
     int file_type_index,
     const FilePath::StringType& default_extension) {
-  std::string json = GetArgumentsJson(type, title, default_virtual_path,
-                                      file_types, file_type_index,
-                                      default_extension);
-  return GURL(FileManagerUtil::GetFileBrowserUrl().spec() + "?" +
-              EscapeUrlEncodedData(json, false));
+  DictionaryValue arg_value;

[Vladislav Kaznacheev, 2011/08/05 13:01:36]

Any special reason to inline the helper function? It actually looked pretty
reasonable.

[SeRya, 2011/08/05 13:45:42]

This function is not used anywhere else anymore and does work what hardly make
sense in any other context. Equal list of parameters (quite long by the way) is
another sign that it should not exist.

+  arg_value.SetString("type", GetDialogTypeAsString(type));
+  arg_value.SetString("title", title);
+  arg_value.SetString("defaultPath", default_virtual_path.value());
+  arg_value.SetString("defaultExtension", default_extension);
+
+  if (file_types) {
+    ListValue* types_list = new ListValue();
+    for (size_t i = 0; i < file_types->extensions.size(); ++i) {
+      ListValue* extensions_list = new ListValue();
+      for (size_t j = 0; j < file_types->extensions[i].size(); ++j) {
+        extensions_list->Set(
+            i, Value::CreateStringValue(file_types->extensions[i][j]));
+      }
+
+      DictionaryValue* dict = new DictionaryValue();
+      dict->Set("extensions", extensions_list);
+
+      if (i < file_types->extension_description_overrides.size()) {
+        string16 desc = file_types->extension_description_overrides[i];
+        dict->SetString("description", desc);
+      }
+
+      dict->SetBoolean("selected",
+                       (static_cast<size_t>(file_type_index) == i));
+
+      types_list->Set(i, dict);
+    }
+    arg_value.Set("typeList", types_list);
+  }
+
+  std::string json_args;
+  base::JSONWriter::Write(&arg_value, false, &json_args);
+
+  // kChromeUIFileManagerURL could not be used since query parameters are not
+  // supported for it.
+  std::string url = FileManagerUtil::GetFileBrowserUrl().spec() +
+                    '?' + EscapeUrlEncodedData(json_args, false);
+  return GURL(url);
 
 }
 
 // static
 void FileManagerUtil::ShowFullTabUrl(Profile*,
-                                     const FilePath& default_path) {
-  std::string json = GetArgumentsJson(SelectFileDialog::SELECT_NONE, string16(),
-      default_path, NULL, 0, FilePath::StringType());
-  GURL url(std::string(kBaseFileBrowserUrl) + "?" +
-           EscapeUrlEncodedData(json, false));
+                                     const FilePath& dir) {
   Browser* browser = BrowserList::GetLastActive();
   if (!browser)
     return;
 
+  FilePath virtual_path;
+  if (!FileManagerUtil::ConvertFileToRelativeFileSystemPath(browser->profile(),
+                                                            dir,
+                                                            &virtual_path)) {
+    return;
+  }
+
+  std::string url = chrome::kChromeUIFileManagerURL;
+  url += '#' + EscapeUrlEncodedData(virtual_path.value(), false);
+
   UserMetrics::RecordAction(UserMetricsAction("ShowFileBrowserFullTab"));
   browser->ShowSingletonTab(GURL(url));
 }
 
 void FileManagerUtil::ViewItem(const FilePath& full_path, bool enqueue) {
   std::string ext = full_path.Extension();
   // For things supported natively by the browser, we should open it
   // in a tab.
   if (IsSupportedBrowserExtension(ext.data())) {
     std::string path;
@@ skipping 36 matching lines @@
       NewRunnableFunction(
           &platform_util::SimpleErrorBox,
           static_cast<gfx::NativeWindow>(NULL),
           l10n_util::GetStringUTF16(IDS_FILEBROWSER_ERROR_TITLE),
           l10n_util::GetStringFUTF16(IDS_FILEBROWSER_ERROR_UNKNOWN_FILE_TYPE,
                                      UTF8ToUTF16(full_path.BaseName().value()))
           ));
 }
 
 // static
-std::string FileManagerUtil::GetArgumentsJson(
-    SelectFileDialog::Type type,
-    const string16& title,
-    const FilePath& default_virtual_path,
-    const SelectFileDialog::FileTypeInfo* file_types,
-    int file_type_index,
-    const FilePath::StringType& default_extension) {
-  DictionaryValue arg_value;
-  arg_value.SetString("type", GetDialogTypeAsString(type));
-  arg_value.SetString("title", title);
-  // TODO(zelidrag): Convert local system path into virtual path for File API.
-  arg_value.SetString("defaultPath", default_virtual_path.value());
-  arg_value.SetString("defaultExtension", default_extension);
-
-
-  if (file_types) {
-    ListValue* types_list = new ListValue();
-    for (size_t i = 0; i < file_types->extensions.size(); ++i) {
-      ListValue* extensions_list = new ListValue();
-      for (size_t j = 0; j < file_types->extensions[i].size(); ++j) {
-        extensions_list->Set(
-            i, Value::CreateStringValue(file_types->extensions[i][j]));
-      }
-
-      DictionaryValue* dict = new DictionaryValue();
-      dict->Set("extensions", extensions_list);
-
-      if (i < file_types->extension_description_overrides.size()) {
-        string16 desc = file_types->extension_description_overrides[i];
-        dict->SetString("description", desc);
-      }
-
-      dict->SetBoolean("selected",
-                       (static_cast<size_t>(file_type_index) == i));
-
-      types_list->Set(i, dict);
-    }
-    arg_value.Set("typeList", types_list);
-  }
-
-  std::string rv;
-  base::JSONWriter::Write(&arg_value, false, &rv);
-
-  return rv;
-}
-
-// static
 std::string FileManagerUtil::GetDialogTypeAsString(
     SelectFileDialog::Type dialog_type) {
   std::string type_str;
   switch (dialog_type) {
     case SelectFileDialog::SELECT_NONE:
       type_str = "full-page";
       break;
 
     case SelectFileDialog::SELECT_FOLDER:
       type_str = "folder";
@@ skipping 10 matching lines @@
     case SelectFileDialog::SELECT_OPEN_MULTI_FILE:
       type_str = "open-multi-file";
       break;
 
     default:
       NOTREACHED();
   }
 
   return type_str;
 }