Replace FileManagerUtil class with namespace file_manager_util.

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/bind.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/path_service.h"
@@ skipping 20 matching lines @@
 
 #if defined(OS_CHROMEOS)
 #include "chrome/browser/chromeos/media/media_player.h"
 #endif
 
 using content::BrowserThread;
 
 #define FILEBROWSER_DOMAIN "hhaomjibdihmijegdhdafkllkbggdgoj"
 const char kFileBrowserDomain[] = FILEBROWSER_DOMAIN;
 
+namespace file_manager_util {
 namespace {
 
 #define FILEBROWSER_URL(PATH) \
     ("chrome-extension://" FILEBROWSER_DOMAIN "/" PATH)
 // This is the "well known" url for the file manager extension from
 // browser/resources/file_manager.  In the future we may provide a way to swap
 // out this file manager for an aftermarket part, but not yet.
 const char kFileBrowserExtensionUrl[] = FILEBROWSER_URL("");
 const char kBaseFileBrowserUrl[] = FILEBROWSER_URL("main.html");
 const char kMediaPlayerUrl[] = FILEBROWSER_URL("mediaplayer.html");
@@ skipping 77 matching lines @@
                       const char** array,
                       size_t array_size) {
   for (size_t i = 0; i < array_size; i++) {
     if (base::strcasecmp(ext, array[i]) == 0) {
       return i;
     }
   }
   return 0;
 }
 
+// Convert numeric dialog type to a string.
+std::string 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";
+      break;
+
+    case SelectFileDialog::SELECT_SAVEAS_FILE:
+      type_str = "saveas-file";
+      break;
+
+    case SelectFileDialog::SELECT_OPEN_FILE:
+      type_str = "open-file";
+      break;
+
+    case SelectFileDialog::SELECT_OPEN_MULTI_FILE:
+      type_str = "open-multi-file";
+      break;
+
+    default:
+      NOTREACHED();
+  }
+
+  return type_str;
+}
+
 }  // namespace
 
-// static
-GURL FileManagerUtil::GetFileBrowserExtensionUrl() {
+GURL GetFileBrowserExtensionUrl() {
   return GURL(kFileBrowserExtensionUrl);
 }
 
-// static
-GURL FileManagerUtil::GetFileBrowserUrl() {
+GURL GetFileBrowserUrl() {
   return GURL(kBaseFileBrowserUrl);
 }
 
-// static
-GURL FileManagerUtil::GetMediaPlayerUrl() {
+GURL GetMediaPlayerUrl() {
   return GURL(kMediaPlayerUrl);
 }
 
-// static
-GURL FileManagerUtil::GetMediaPlayerPlaylistUrl() {
+GURL GetMediaPlayerPlaylistUrl() {
   return GURL(kMediaPlayerPlaylistUrl);
 }
 
-// static
-bool FileManagerUtil::ConvertFileToFileSystemUrl(
+bool ConvertFileToFileSystemUrl(
     Profile* profile, const FilePath& full_file_path, const GURL& origin_url,
     GURL* url) {
   FilePath virtual_path;
   if (!ConvertFileToRelativeFileSystemPath(profile, full_file_path,
                                            &virtual_path)) {
     return false;
   }
 
   GURL base_url = fileapi::GetFileSystemRootURI(origin_url,
       fileapi::kFileSystemTypeExternal);
   *url = GURL(base_url.spec() + virtual_path.value());
   return true;
 }
 
-// static
-bool FileManagerUtil::ConvertFileToRelativeFileSystemPath(
+bool ConvertFileToRelativeFileSystemPath(
     Profile* profile, const FilePath& full_file_path, FilePath* virtual_path) {
   fileapi::FileSystemPathManager* path_manager =
       profile->GetFileSystemContext()->path_manager();
   fileapi::ExternalFileSystemMountPointProvider* provider =
       path_manager->external_provider();
   if (!provider)
     return false;
 
   // Find if this file path is managed by the external provider.
   if (!provider->GetVirtualPath(full_file_path, virtual_path))
     return false;
 
   return true;
 }
 
-// static
-GURL FileManagerUtil::GetFileBrowserUrlWithParams(
+GURL 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) {
   DictionaryValue arg_value;
   arg_value.SetString("type", GetDialogTypeAsString(type));
   arg_value.SetString("title", title);
   arg_value.SetString("defaultPath", default_virtual_path.value());
@@ skipping 22 matching lines @@
       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() +
+  std::string url = GetFileBrowserUrl().spec() +
                     '?' + net::EscapeUrlEncodedData(json_args, false);
   return GURL(url);
 }
 
-// static
-void FileManagerUtil::ViewFolder(const FilePath& dir) {
+void ViewFolder(const FilePath& dir) {
   Browser* browser = BrowserList::GetLastActive();
   if (!browser)
     return;
 
   FilePath virtual_path;
-  if (!FileManagerUtil::ConvertFileToRelativeFileSystemPath(browser->profile(),
-                                                            dir,
-                                                            &virtual_path)) {
+  if (!ConvertFileToRelativeFileSystemPath(browser->profile(), dir,
+                                           &virtual_path)) {
     return;
   }
 
   std::string url = chrome::kChromeUIFileManagerURL;
   url += "#/" + net::EscapeUrlEncodedData(virtual_path.value(), false);
 
   UserMetrics::RecordAction(UserMetricsAction("ShowFileBrowserFullTab"));
   browser->ShowSingletonTabRespectRef(GURL(url));
 }
 
-// static
-void FileManagerUtil::ViewItem(const FilePath& full_path, bool enqueue) {
+void ViewItem(const FilePath& full_path, bool enqueue) {
   if (!BrowserThread::CurrentlyOn(BrowserThread::UI)) {
     bool result = BrowserThread::PostTask(
         BrowserThread::UI, FROM_HERE,
-        base::Bind(&FileManagerUtil::ViewItem, full_path, enqueue));
+        base::Bind(&ViewItem, full_path, enqueue));
     DCHECK(result);
     return;
   }
 
   // There is nothing we can do if the browser is not present.
   Browser* browser = BrowserList::GetLastActive();
   if (!browser)
     return;
 
   std::string ext = full_path.Extension();
@@ skipping 36 matching lines @@
 
   browser::ShowErrorBox(
       browser->window()->GetNativeHandle(),
       l10n_util::GetStringFUTF16(
           IDS_FILEBROWSER_ERROR_VIEWING_FILE_TITLE,
           UTF8ToUTF16(full_path.BaseName().value())),
       l10n_util::GetStringUTF16(
           IDS_FILEBROWSER_ERROR_VIEWING_FILE));
 }
 
-// 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;
+}  // namespace file_manager_util
 
-    case SelectFileDialog::SELECT_FOLDER:
-      type_str = "folder";
-      break;
-
-    case SelectFileDialog::SELECT_SAVEAS_FILE:
-      type_str = "saveas-file";
-      break;
-
-    case SelectFileDialog::SELECT_OPEN_FILE:
-      type_str = "open-file";
-      break;
-
-    case SelectFileDialog::SELECT_OPEN_MULTI_FILE:
-      type_str = "open-multi-file";
-      break;
-
-    default:
-      NOTREACHED();
-  }
-
-  return type_str;
-}