chromeos: Move functions in file_manager_util.cc to unnamed namespace

chrome/browser/chromeos/extensions/file_manager_util.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/chromeos/extensions/file_manager_util.h"
 
 #include "ash/shell.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/json/json_reader.h"
@@ skipping 245 matching lines @@
       page_url = GURL(entry_proto->file_specific_info().alternate_url());
     } else {
       NOTREACHED();
     }
     OpenNewTab(page_url, profile);
   } else {
     ShowWarningMessageBox(profile, file_path);
   }
 }
 
+void InstallCRX(Browser* browser, const FilePath& path) {
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(browser->profile())->extension_service();
+  CHECK(service);
+
+  content::WebContents* web_contents =
+      browser->tab_strip_model()->GetActiveWebContents();
+  scoped_refptr<extensions::CrxInstaller> installer(
+      extensions::CrxInstaller::Create(
+          service,
+          new ExtensionInstallPrompt(web_contents)));
+  installer->set_error_on_unsupported_requirements(true);
+  installer->set_is_gallery_install(false);
+  installer->set_allow_silent_install(false);
+  installer->InstallCrx(path);
+}
+
 // Called when a crx file on Drive was downloaded.
 void OnCRXDownloadCallback(Browser* browser,
                            drive::DriveFileError error,
                            const FilePath& file,
                            const std::string& unused_mime_type,
                            drive::DriveFileType file_type) {
   if (error != drive::DRIVE_FILE_OK || file_type != drive::REGULAR_FILE)
     return;
   InstallCRX(browser, file);
 }
 
-}  // namespace
-
-GURL GetFileBrowserExtensionUrl() {
-  return GURL(kFileBrowserExtensionUrl);
-}
-
-GURL GetFileBrowserUrl() {
-  return GURL(kBaseFileBrowserUrl);
-}
-
-GURL GetMediaPlayerUrl() {
-  return GURL(kMediaPlayerUrl);
-}
-
-GURL GetVideoPlayerUrl(const GURL& source_url) {
-  return GURL(kVideoPlayerUrl + std::string("?") + source_url.spec());
-}
-
-bool ConvertFileToFileSystemUrl(Profile* profile,
-                                const FilePath& full_file_path,
-                                const std::string& extension_id,
-                                GURL* url) {
-  GURL origin_url = Extension::GetBaseURLFromExtensionId(extension_id);
-  FilePath virtual_path;
-  if (!ConvertFileToRelativeFileSystemPath(profile, extension_id,
-           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;
-}
-
-bool ConvertFileToRelativeFileSystemPath(
-    Profile* profile,
-    const std::string& extension_id,
-    const FilePath& full_file_path,
-    FilePath* virtual_path) {
-  ExtensionService* service =
-      extensions::ExtensionSystem::Get(profile)->extension_service();
-  // May be NULL during unit_tests.
-  if (!service)
-    return false;
-
-  // File browser APIs are ment to be used only from extension context, so the
-  // extension's site is the one in whose file system context the virtual path
-  // should be found.
-  GURL site = service->GetSiteForExtensionId(extension_id);
-  fileapi::ExternalFileSystemMountPointProvider* provider =
-      BrowserContext::GetStoragePartitionForSite(profile, site)->
-          GetFileSystemContext()->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;
-}
-
-GURL GetFileBrowserUrlWithParams(
-    ui::SelectFileDialog::Type type,
-    const string16& title,
-    const FilePath& default_virtual_path,
-    const ui::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());
-  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->Append(
-            new base::StringValue(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);
-      }
-
-      // file_type_index is 1-based. 0 means no selection at all.
-      dict->SetBoolean("selected",
-                       (static_cast<size_t>(file_type_index) == (i + 1)));
-
-      types_list->Set(i, dict);
-    }
-    arg_value.Set("typeList", types_list);
-
-    arg_value.SetBoolean("includeAllFiles", file_types->include_all_files);
-  }
-
-  // Disable showing GDrive unless it's specifically supported.
-  arg_value.SetBoolean("disableGData",
-      !file_types || !file_types->support_gdata);
-
-  std::string json_args;
-  base::JSONWriter::Write(&arg_value, &json_args);
-
-  // kChromeUIFileManagerURL could not be used since query parameters are not
-  // supported for it.
-  std::string url = GetFileBrowserUrl().spec() +
-                    '?' + net::EscapeUrlEncodedData(json_args, false);
-  return GURL(url);
-}
-
-string16 GetTitleFromType(ui::SelectFileDialog::Type dialog_type) {
-  string16 title;
-  switch (dialog_type) {
-    case ui::SelectFileDialog::SELECT_NONE:
-      // Full page file manager doesn't need a title.
-      break;
-
-    case ui::SelectFileDialog::SELECT_FOLDER:
-      title = l10n_util::GetStringUTF16(
-          IDS_FILE_BROWSER_SELECT_FOLDER_TITLE);
-      break;
-
-    case ui::SelectFileDialog::SELECT_SAVEAS_FILE:
-      title = l10n_util::GetStringUTF16(
-          IDS_FILE_BROWSER_SELECT_SAVEAS_FILE_TITLE);
-      break;
-
-    case ui::SelectFileDialog::SELECT_OPEN_FILE:
-      title = l10n_util::GetStringUTF16(
-          IDS_FILE_BROWSER_SELECT_OPEN_FILE_TITLE);
-      break;
-
-    case ui::SelectFileDialog::SELECT_OPEN_MULTI_FILE:
-      title = l10n_util::GetStringUTF16(
-          IDS_FILE_BROWSER_SELECT_OPEN_MULTI_FILE_TITLE);
-      break;
-
-    default:
-      NOTREACHED();
-  }
-
-  return title;
-}
-
 enum TAB_REUSE_MODE {
   REUSE_ANY_FILE_MANAGER,
   REUSE_SAME_PATH,
   REUSE_NEVER
 };
 
 bool FileManageTabExists(const FilePath& path, TAB_REUSE_MODE mode) {
   if (mode == REUSE_NEVER)
     return false;
 
@@ skipping 119 matching lines @@
     for (int idx = 0; idx < tab_strip->count(); idx++) {
       content::WebContents* web_contents = tab_strip->GetWebContentsAt(idx);
       const GURL& url = web_contents->GetURL();
       if (url == target_url)
         return browser;
     }
   }
   return NULL;
 }
 
-void ViewRemovableDrive(const FilePath& path) {
-  OpenFileBrowser(path, REUSE_ANY_FILE_MANAGER, "auto-open");
-}
-
-void OpenActionChoiceDialog(const FilePath& path) {
-  const int kDialogWidth = 394;
-  // TODO(dgozman): remove 50, which is a title height once popup window
-  // will have no title.
-  const int kDialogHeight = 316 + 50;
-
-  Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
-
-  FilePath virtual_path;
-  if (!ConvertFileToRelativeFileSystemPath(profile, kFileBrowserDomain, path,
-                                           &virtual_path))
-    return;
-  std::string url = kActionChoiceUrl;
-  url += "#/" + net::EscapeUrlEncodedData(virtual_path.value(), false);
-  GURL dialog_url(url);
-
-  const gfx::Size screen = ash::Shell::GetScreen()->GetPrimaryDisplay().size();
-  const gfx::Rect bounds((screen.width() - kDialogWidth) / 2,
-                         (screen.height() - kDialogHeight) / 2,
-                         kDialogWidth,
-                         kDialogHeight);
-
-  Browser* browser = GetBrowserForUrl(dialog_url);
-
-  if (!browser) {
-    browser = new Browser(
-        Browser::CreateParams::CreateForApp(Browser::TYPE_POPUP,
-                                            "action_choice",
-                                            bounds,
-                                            profile));
-
-    chrome::AddSelectedTabWithURL(browser, dialog_url,
-                                  content::PAGE_TRANSITION_LINK);
-  }
-  browser->window()->Show();
-}
-
-void ShowFileInFolder(const FilePath& path) {
-  // This action changes the selection so we do not reuse existing tabs.
-  OpenFileBrowser(path, REUSE_NEVER, "select");
-}
-
-void ViewFolder(const FilePath& path) {
-  OpenFileBrowser(path, REUSE_SAME_PATH, "open");
-}
-
 bool ExecuteDefaultHandler(Profile* profile, const FilePath& path) {
   GURL url;
   if (!ConvertFileToFileSystemUrl(profile, path, kFileBrowserDomain, &url))
     return false;
 
   const FileBrowserHandler* handler;
   if (!file_handler_util::GetTaskForURL(profile, url, &handler))
     return false;
 
   std::string extension_id = handler->extension_id();
@@ skipping 29 matching lines @@
       OpenFileBrowser(path, REUSE_SAME_PATH, "");
       return true;
     }
     return ExecuteBuiltinHandler(browser, path, action_id);
   }
 
   ExecuteHandler(profile, extension_id, action_id, url);
   return true;
 }
 
-void ViewFile(const FilePath& path) {
-  Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
-  if (!ExecuteDefaultHandler(profile, path))
-    ShowWarningMessageBox(profile, path);
-}
-
 // Reads an entire file into a string. Fails is the file is 4K or longer.
 bool ReadSmallFileToString(const FilePath& path, std::string* contents) {
   FILE* file = file_util::OpenFile(path, "rb");
   if (!file) {
     return false;
   }
 
   char buf[1 << 12];  // 4K
   size_t len = fread(buf, 1, sizeof(buf), file);
   if (len > 0) {
@@ skipping 23 matching lines @@
       !root_value->GetAsDictionary(&dictionary_value) ||
       !dictionary_value->GetString("url", &edit_url_string)) {
     LOG(ERROR) << "Invalid JSON in " << file_path.value();
     return;
   }
 
   BrowserThread::PostTask(BrowserThread::UI, FROM_HERE,
       base::Bind(OpenNewTab, GURL(edit_url_string), (Profile*)NULL));
 }
 
+}  // namespace
+
+GURL GetFileBrowserExtensionUrl() {
+  return GURL(kFileBrowserExtensionUrl);
+}
+
+GURL GetFileBrowserUrl() {
+  return GURL(kBaseFileBrowserUrl);
+}
+
+GURL GetMediaPlayerUrl() {
+  return GURL(kMediaPlayerUrl);
+}
+
+GURL GetVideoPlayerUrl(const GURL& source_url) {
+  return GURL(kVideoPlayerUrl + std::string("?") + source_url.spec());
+}
+
+bool ConvertFileToFileSystemUrl(Profile* profile,
+                                const FilePath& full_file_path,
+                                const std::string& extension_id,
+                                GURL* url) {
+  GURL origin_url = Extension::GetBaseURLFromExtensionId(extension_id);
+  FilePath virtual_path;
+  if (!ConvertFileToRelativeFileSystemPath(profile, extension_id,
+           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;
+}
+
+bool ConvertFileToRelativeFileSystemPath(
+    Profile* profile,
+    const std::string& extension_id,
+    const FilePath& full_file_path,
+    FilePath* virtual_path) {
+  ExtensionService* service =
+      extensions::ExtensionSystem::Get(profile)->extension_service();
+  // May be NULL during unit_tests.
+  if (!service)
+    return false;
+
+  // File browser APIs are ment to be used only from extension context, so the
+  // extension's site is the one in whose file system context the virtual path
+  // should be found.
+  GURL site = service->GetSiteForExtensionId(extension_id);
+  fileapi::ExternalFileSystemMountPointProvider* provider =
+      BrowserContext::GetStoragePartitionForSite(profile, site)->
+          GetFileSystemContext()->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;
+}
+
+GURL GetFileBrowserUrlWithParams(
+    ui::SelectFileDialog::Type type,
+    const string16& title,
+    const FilePath& default_virtual_path,
+    const ui::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());
+  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->Append(
+            new base::StringValue(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);
+      }
+
+      // file_type_index is 1-based. 0 means no selection at all.
+      dict->SetBoolean("selected",
+                       (static_cast<size_t>(file_type_index) == (i + 1)));
+
+      types_list->Set(i, dict);
+    }
+    arg_value.Set("typeList", types_list);
+
+    arg_value.SetBoolean("includeAllFiles", file_types->include_all_files);
+  }
+
+  // Disable showing GDrive unless it's specifically supported.
+  arg_value.SetBoolean("disableGData",
+      !file_types || !file_types->support_gdata);
+
+  std::string json_args;
+  base::JSONWriter::Write(&arg_value, &json_args);
+
+  // kChromeUIFileManagerURL could not be used since query parameters are not
+  // supported for it.
+  std::string url = GetFileBrowserUrl().spec() +
+                    '?' + net::EscapeUrlEncodedData(json_args, false);
+  return GURL(url);
+}
+
+string16 GetTitleFromType(ui::SelectFileDialog::Type dialog_type) {
+  string16 title;
+  switch (dialog_type) {
+    case ui::SelectFileDialog::SELECT_NONE:
+      // Full page file manager doesn't need a title.
+      break;
+
+    case ui::SelectFileDialog::SELECT_FOLDER:
+      title = l10n_util::GetStringUTF16(
+          IDS_FILE_BROWSER_SELECT_FOLDER_TITLE);
+      break;
+
+    case ui::SelectFileDialog::SELECT_SAVEAS_FILE:
+      title = l10n_util::GetStringUTF16(
+          IDS_FILE_BROWSER_SELECT_SAVEAS_FILE_TITLE);
+      break;
+
+    case ui::SelectFileDialog::SELECT_OPEN_FILE:
+      title = l10n_util::GetStringUTF16(
+          IDS_FILE_BROWSER_SELECT_OPEN_FILE_TITLE);
+      break;
+
+    case ui::SelectFileDialog::SELECT_OPEN_MULTI_FILE:
+      title = l10n_util::GetStringUTF16(
+          IDS_FILE_BROWSER_SELECT_OPEN_MULTI_FILE_TITLE);
+      break;
+
+    default:
+      NOTREACHED();
+  }
+
+  return title;
+}
+
+void ViewRemovableDrive(const FilePath& path) {
+  OpenFileBrowser(path, REUSE_ANY_FILE_MANAGER, "auto-open");
+}
+
+void OpenActionChoiceDialog(const FilePath& path) {
+  const int kDialogWidth = 394;
+  // TODO(dgozman): remove 50, which is a title height once popup window
+  // will have no title.
+  const int kDialogHeight = 316 + 50;
+
+  Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
+
+  FilePath virtual_path;
+  if (!ConvertFileToRelativeFileSystemPath(profile, kFileBrowserDomain, path,
+                                           &virtual_path))
+    return;
+  std::string url = kActionChoiceUrl;
+  url += "#/" + net::EscapeUrlEncodedData(virtual_path.value(), false);
+  GURL dialog_url(url);
+
+  const gfx::Size screen = ash::Shell::GetScreen()->GetPrimaryDisplay().size();
+  const gfx::Rect bounds((screen.width() - kDialogWidth) / 2,
+                         (screen.height() - kDialogHeight) / 2,
+                         kDialogWidth,
+                         kDialogHeight);
+
+  Browser* browser = GetBrowserForUrl(dialog_url);
+
+  if (!browser) {
+    browser = new Browser(
+        Browser::CreateParams::CreateForApp(Browser::TYPE_POPUP,
+                                            "action_choice",
+                                            bounds,
+                                            profile));
+
+    chrome::AddSelectedTabWithURL(browser, dialog_url,
+                                  content::PAGE_TRANSITION_LINK);
+  }
+  browser->window()->Show();
+}
+
+void ViewFolder(const FilePath& path) {
+  OpenFileBrowser(path, REUSE_SAME_PATH, "open");
+}
+
+void ViewFile(const FilePath& path) {
+  Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
+  if (!ExecuteDefaultHandler(profile, path))
+    ShowWarningMessageBox(profile, path);
+}
+
+void ShowFileInFolder(const FilePath& path) {
+  // This action changes the selection so we do not reuse existing tabs.
+  OpenFileBrowser(path, REUSE_NEVER, "select");
+}
+
 bool ExecuteBuiltinHandler(Browser* browser, const FilePath& path,
     const std::string& internal_task_id) {
 
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   Profile* profile = browser->profile();
   std::string file_extension = path.Extension();
   // For things supported natively by the browser, we should open it
   // in a tab.
   if (IsSupportedBrowserExtension(file_extension.data()) ||
@@ skipping 91 matching lines @@
   // Unknown file type. Record UMA and show an error message.
   size_t extension_index = UMAExtensionIndex(file_extension.data(),
                                              kUMATrackingExtensions,
                                              arraysize(kUMATrackingExtensions));
   UMA_HISTOGRAM_ENUMERATION("FileBrowser.OpeningFileType",
                             extension_index,
                             arraysize(kUMATrackingExtensions) - 1);
   return false;
 }
 
-void InstallCRX(Browser* browser, const FilePath& path) {
-  ExtensionService* service =
-      extensions::ExtensionSystem::Get(browser->profile())->extension_service();
-  CHECK(service);
-
-  content::WebContents* web_contents =
-      browser->tab_strip_model()->GetActiveWebContents();
-  scoped_refptr<extensions::CrxInstaller> installer(
-      extensions::CrxInstaller::Create(
-          service,
-          new ExtensionInstallPrompt(web_contents)));
-  installer->set_error_on_unsupported_requirements(true);
-  installer->set_is_gallery_install(false);
-  installer->set_allow_silent_install(false);
-  installer->InstallCrx(path);
-}
-
 // If pdf plugin is enabled, we should open pdf files in a tab.
 bool ShouldBeOpenedWithPdfPlugin(Profile* profile, const char* file_extension) {
   if (base::strcasecmp(file_extension, kPdfExtension) != 0)
     return false;
 
   FilePath pdf_path;
   PathService::Get(chrome::FILE_PDF_PLUGIN, &pdf_path);
 
   content::PepperPluginInfo* pepper_info =
       PluginService::GetInstance()->GetRegisteredPpapiPluginInfo(pdf_path);
@@ skipping 15 matching lines @@
   for (google_apis::OperationProgressStatusList::const_iterator iter =
            list.begin();
        iter != list.end(); ++iter) {
     result_list->Append(
         ProgessStatusToDictionaryValue(profile, extension_id, *iter));
   }
   return result_list.release();
 }
 
 }  // namespace file_manager_util