file_manager: Split the open with browser stuff into a set of separate files

chrome/browser/chromeos/extensions/file_manager/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/file_manager_util.h"
 
 #include "base/bind.h"
-#include "base/command_line.h"
 #include "base/logging.h"
-#include "base/metrics/histogram.h"
-#include "base/path_service.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
-#include "base/threading/sequenced_worker_pool.h"
-#include "chrome/browser/chromeos/drive/drive.pb.h"
-#include "chrome/browser/chromeos/drive/drive_integration_service.h"
-#include "chrome/browser/chromeos/drive/file_system.h"
-#include "chrome/browser/chromeos/drive/file_system_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager/app_id.h"
 #include "chrome/browser/chromeos/extensions/file_manager/file_browser_handlers.h"
 #include "chrome/browser/chromeos/extensions/file_manager/file_tasks.h"
 #include "chrome/browser/chromeos/extensions/file_manager/fileapi_util.h"
 #include "chrome/browser/chromeos/extensions/file_manager/url_util.h"
 #include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
-#include "chrome/browser/extensions/crx_installer.h"
-#include "chrome/browser/extensions/extension_install_prompt.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/google_apis/task_util.h"
-#include "chrome/browser/plugins/plugin_prefs.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_tabstrip.h"
 #include "chrome/browser/ui/browser_window.h"
 #include "chrome/browser/ui/extensions/application_launch.h"
 #include "chrome/browser/ui/simple_message_box.h"
-#include "chrome/common/chrome_paths.h"
-#include "chrome/common/chrome_switches.h"
 #include "chrome/common/extensions/api/file_browser_handlers/file_browser_handler.h"
-#include "chrome/common/url_constants.h"
-#include "chromeos/chromeos_switches.h"
 #include "content/public/browser/browser_thread.h"
-#include "content/public/browser/plugin_service.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/user_metrics.h"
-#include "content/public/common/pepper_plugin_info.h"
-#include "content/public/common/webplugininfo.h"
 #include "grit/generated_resources.h"
-#include "net/base/escape.h"
 #include "net/base/mime_util.h"
-#include "net/base/net_util.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "webkit/browser/fileapi/file_system_backend.h"
 #include "webkit/browser/fileapi/file_system_context.h"
 #include "webkit/browser/fileapi/file_system_operation_runner.h"
 #include "webkit/browser/fileapi/file_system_url.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
-using content::PluginService;
 using content::UserMetricsAction;
 using extensions::Extension;
 using extensions::app_file_handler_util::FindFileHandlersForFiles;
 using extensions::app_file_handler_util::PathAndMimeTypeSet;
 using fileapi::FileSystemURL;
 
 namespace file_manager {
 namespace util {
 namespace {
 
-const base::FilePath::CharType kCRXExtension[] = FILE_PATH_LITERAL(".crx");
-const base::FilePath::CharType kPdfExtension[] = FILE_PATH_LITERAL(".pdf");
-const base::FilePath::CharType kSwfExtension[] = FILE_PATH_LITERAL(".swf");
-
-// List of file extensions viewable in the browser.
-const base::FilePath::CharType* kFileExtensionsViewableInBrowser[] = {
-#if defined(GOOGLE_CHROME_BUILD)
-  FILE_PATH_LITERAL(".pdf"),
-  FILE_PATH_LITERAL(".swf"),
-#endif
-  FILE_PATH_LITERAL(".bmp"),
-  FILE_PATH_LITERAL(".jpg"),
-  FILE_PATH_LITERAL(".jpeg"),
-  FILE_PATH_LITERAL(".png"),
-  FILE_PATH_LITERAL(".webp"),
-  FILE_PATH_LITERAL(".gif"),
-  FILE_PATH_LITERAL(".txt"),
-  FILE_PATH_LITERAL(".html"),
-  FILE_PATH_LITERAL(".htm"),
-  FILE_PATH_LITERAL(".mhtml"),
-  FILE_PATH_LITERAL(".mht"),
-  FILE_PATH_LITERAL(".svg"),
-};
-
-// Returns true if |file_path| is viewable in the browser (ex. HTML file).
-bool IsViewableInBrowser(const base::FilePath& file_path) {
-  for (size_t i = 0; i < arraysize(kFileExtensionsViewableInBrowser); i++) {
-    if (file_path.MatchesExtension(kFileExtensionsViewableInBrowser[i]))
-      return true;
-  }
-  return false;
-}
-
-bool IsPepperPluginEnabled(Profile* profile,
-                           const base::FilePath& plugin_path) {
-  content::PepperPluginInfo* pepper_info =
-      PluginService::GetInstance()->GetRegisteredPpapiPluginInfo(plugin_path);
-  if (!pepper_info)
-    return false;
-
-  scoped_refptr<PluginPrefs> plugin_prefs = PluginPrefs::GetForProfile(profile);
-  if (!plugin_prefs.get())
-    return false;
-
-  return plugin_prefs->IsPluginEnabled(pepper_info->ToWebPluginInfo());
-}
-
-bool IsPdfPluginEnabled(Profile* profile) {
-  base::FilePath plugin_path;
-  PathService::Get(chrome::FILE_PDF_PLUGIN, &plugin_path);
-  return IsPepperPluginEnabled(profile, plugin_path);
-}
-
-bool IsFlashPluginEnabled(Profile* profile) {
-  base::FilePath plugin_path(
-      CommandLine::ForCurrentProcess()->GetSwitchValueNative(
-          switches::kPpapiFlashPath));
-  if (plugin_path.empty())
-    PathService::Get(chrome::FILE_PEPPER_FLASH_PLUGIN, &plugin_path);
-  return IsPepperPluginEnabled(profile, plugin_path);
-}
-
-void OpenNewTab(Profile* profile, const GURL& url) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-  Browser* browser = chrome::FindOrCreateTabbedBrowser(
-      profile ? profile : ProfileManager::GetDefaultProfileOrOffTheRecord(),
-      chrome::HOST_DESKTOP_TYPE_ASH);
-  chrome::AddSelectedTabWithURL(browser, url, content::PAGE_TRANSITION_LINK);
-  // If the current browser is not tabbed then the new tab will be created
-  // in a different browser. Make sure it is visible.
-  browser->window()->Show();
-}
-
 // Shows a warning message box saying that the file could not be opened.
 void ShowWarningMessageBox(Profile* profile, const base::FilePath& file_path) {
   // TODO: if FindOrCreateTabbedBrowser creates a new browser the returned
   // browser is leaked.
   Browser* browser =
       chrome::FindOrCreateTabbedBrowser(profile,
                                         chrome::HOST_DESKTOP_TYPE_ASH);
   chrome::ShowMessageBox(
       browser->window()->GetNativeWindow(),
       l10n_util::GetStringFUTF16(
           IDS_FILE_BROWSER_ERROR_VIEWING_FILE_TITLE,
           UTF8ToUTF16(file_path.BaseName().value())),
       l10n_util::GetStringUTF16(IDS_FILE_BROWSER_ERROR_VIEWING_FILE),
       chrome::MESSAGE_BOX_TYPE_WARNING);
 }
 
-void InstallCRX(Browser* browser, const base::FilePath& file_path) {
-  ExtensionService* service =
-      extensions::ExtensionSystem::Get(browser->profile())->extension_service();
-  CHECK(service);
-
-  scoped_refptr<extensions::CrxInstaller> installer(
-      extensions::CrxInstaller::Create(
-          service,
-          scoped_ptr<ExtensionInstallPrompt>(new ExtensionInstallPrompt(
-              browser->profile(), NULL, NULL))));
-  installer->set_error_on_unsupported_requirements(true);
-  installer->set_is_gallery_install(false);
-  installer->set_allow_silent_install(false);
-  installer->InstallCrx(file_path);
-}
-
-// Called when a crx file on Drive was downloaded.
-void OnCRXDownloadCallback(Browser* browser,
-                           drive::FileError error,
-                           const base::FilePath& file,
-                           scoped_ptr<drive::ResourceEntry> entry) {
-  if (error != drive::FILE_ERROR_OK)
-    return;
-  InstallCRX(browser, file);
-}
-
 // Grants file system access to the file manager.
 bool GrantFileSystemAccessToFileBrowser(Profile* profile) {
   // The file manager always runs in the site for its extension id, so that
   // is the site for which file access permissions should be granted.
   GURL site = extensions::ExtensionSystem::Get(profile)->extension_service()->
       GetSiteForExtensionId(kFileManagerAppId);
   fileapi::ExternalFileSystemBackend* backend =
       BrowserContext::GetStoragePartitionForSite(profile, site)->
           GetFileSystemContext()->external_backend();
   if (!backend)
@@ skipping 174 matching lines @@
         handler->id());
   if (handler_task_id != default_task_id &&
       !file_browser_handlers::IsFallbackFileBrowserHandler(handler) &&
       OpenFileWithFileHandler(
           profile, file_path, url, mime_type, default_task_id)) {
     return true;
   }
   return OpenFileWithFileBrowserHandler(profile, file_path, *handler, url);
 }
 
-// Reads the alternate URL from a GDoc file. When it fails, returns a file URL
-// for |file_path| as fallback.
-// Note that an alternate url is a URL to open a hosted document.
-GURL ReadUrlFromGDocOnBlockingPool(const base::FilePath& file_path) {
-  GURL url = drive::util::ReadUrlFromGDocFile(file_path);
-  if (url.is_empty())
-    url = net::FilePathToFileURL(file_path);
-  return url;
-}
-
 // Used to implement OpenItem().
 void ContinueOpenItem(Profile* profile,
                       const base::FilePath& file_path,
                       base::PlatformFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error == base::PLATFORM_FILE_OK) {
     // A directory exists at |file_path|. Open it with the file manager.
     OpenFileManagerWithInternalActionId(file_path, "open");
   } else {
@@ skipping 93 matching lines @@
 
   CheckIfDirectoryExists(file_system_context, url,
                          base::Bind(&ContinueOpenItem, profile, file_path));
 }
 
 void ShowItemInFolder(const base::FilePath& file_path) {
   // This action changes the selection so we do not reuse existing tabs.
   OpenFileManagerWithInternalActionId(file_path, "select");
 }
 
-bool OpenFileWithBrowser(Browser* browser, const base::FilePath& file_path) {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  Profile* profile = browser->profile();
-  // For things supported natively by the browser, we should open it
-  // in a tab.
-  if (IsViewableInBrowser(file_path) ||
-      ShouldBeOpenedWithPlugin(profile, file_path.Extension())) {
-    GURL page_url = net::FilePathToFileURL(file_path);
-    // Override drive resource to point to internal handler instead of file URL.
-    if (drive::util::IsUnderDriveMountPoint(file_path)) {
-      page_url = drive::util::FilePathToDriveURL(
-          drive::util::ExtractDrivePath(file_path));
-    }
-    OpenNewTab(profile, page_url);
-    return true;
-  }
-
-  if (drive::util::HasGDocFileExtension(file_path)) {
-    if (drive::util::IsUnderDriveMountPoint(file_path)) {
-      // The file is on Google Docs. Open with drive URL.
-      GURL url = drive::util::FilePathToDriveURL(
-          drive::util::ExtractDrivePath(file_path));
-      OpenNewTab(profile, url);
-    } else {
-      // The file is local (downloaded from an attachment or otherwise copied).
-      // Parse the file to extract the Docs url and open this url.
-      base::PostTaskAndReplyWithResult(
-          BrowserThread::GetBlockingPool(),
-          FROM_HERE,
-          base::Bind(&ReadUrlFromGDocOnBlockingPool, file_path),
-          base::Bind(&OpenNewTab, static_cast<Profile*>(NULL)));
-    }
-    return true;
-  }
-
-  if (file_path.MatchesExtension(kCRXExtension)) {
-    if (drive::util::IsUnderDriveMountPoint(file_path)) {
-      drive::DriveIntegrationService* integration_service =
-          drive::DriveIntegrationServiceFactory::GetForProfile(profile);
-      if (!integration_service)
-        return false;
-      integration_service->file_system()->GetFileByPath(
-          drive::util::ExtractDrivePath(file_path),
-          base::Bind(&OnCRXDownloadCallback, browser));
-    } else {
-      InstallCRX(browser, file_path);
-    }
-    return true;
-  }
-
-  // Failed to open the file of unknown type.
-  LOG(WARNING) << "Unknown file type: " << file_path.value();
-  return false;
-}
-
-// If a bundled plugin is enabled, we should open pdf/swf files in a tab.
-bool ShouldBeOpenedWithPlugin(
-    Profile* profile,
-    const base::FilePath::StringType& file_extension) {
-  const base::FilePath file_path =
-      base::FilePath::FromUTF8Unsafe("dummy").AddExtension(file_extension);
-  if (file_path.MatchesExtension(kPdfExtension))
-    return IsPdfPluginEnabled(profile);
-  if (file_path.MatchesExtension(kSwfExtension))
-    return IsFlashPluginEnabled(profile);
-  return false;
-}
-
 std::string GetMimeTypeForPath(const base::FilePath& file_path) {
   const base::FilePath::StringType file_extension =
       StringToLowerASCII(file_path.Extension());
 
   // TODO(thorogood): Rearchitect this call so it can run on the File thread;
   // GetMimeTypeFromFile requires this on Linux. Right now, we use
   // Chrome-level knowledge only.
   std::string mime_type;
   if (file_extension.empty() ||
       !net::GetWellKnownMimeTypeFromExtension(file_extension.substr(1),
                                               &mime_type)) {
     // If the file doesn't have an extension or its mime-type cannot be
     // determined, then indicate that it has the empty mime-type. This will
     // only be matched if the Web Intents accepts "*" or "*/*".
     return "";
   } else {
     return mime_type;
   }
 }
 
 }  // namespace util
 }  // namespace file_manager