file_manager: Rename and document some functions in file_manager_util.cc

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 "ash/shell.h"
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/json/json_writer.h"
 #include "base/logging.h"
@@ skipping 233 matching lines @@
       GetSiteForExtensionId(kFileBrowserDomain);
   fileapi::ExternalFileSystemBackend* backend =
       BrowserContext::GetStoragePartitionForSite(profile, site)->
           GetFileSystemContext()->external_backend();
   if (!backend)
     return false;
   backend->GrantFullAccessToExtension(GetFileBrowserUrl().host());
   return true;
 }
 
-// Executes handler specified with |task| for |url|.
-void ExecuteHandler(Profile* profile,
-                    const file_tasks::TaskDescriptor& task,
-                    const GURL& url) {
+// Opens the file specified by |url| with |task|.
+void OpenFileWithTask(Profile* profile,
+                      const file_tasks::TaskDescriptor& task,
+                      const GURL& url) {
   // If File Browser has not been open yet then it did not request access
   // to the file system. Do it now.
   if (!GrantFileSystemAccessToFileBrowser(profile))
     return;
 
   fileapi::FileSystemContext* file_system_context =
       fileapi_util::GetFileSystemContextForExtensionId(
           profile, kFileBrowserDomain);
 
   // We are executing the task on behalf of File Browser extension.
   const GURL source_url = GetFileBrowserUrl();
   std::vector<FileSystemURL> urls;
   urls.push_back(file_system_context->CrackURL(url));
 
   file_tasks::ExecuteFileTask(
       profile,
       source_url,
       kFileBrowserDomain,
       0, // no tab id
       task,
       urls,
       file_tasks::FileTaskFinishedCallback());
 }
 
-void OpenFileBrowserImpl(const base::FilePath& path,
-                         const std::string& action_id) {
+// Opens the file specified with |path|. Used to implement internal handlers
+// of special action IDs such as "auto-open", "open", and "select".
+void OpenFileWithInternalActionId(const base::FilePath& path,
+                                  const std::string& action_id) {
+  DCHECK(action_id == "auto-open" ||
+         action_id == "open" ||
+         action_id == "select");
+
   content::RecordAction(UserMetricsAction("ShowFileBrowserFullTab"));
   Profile* profile = ProfileManager::GetDefaultProfileOrOffTheRecord();
 
   GURL url;
   if (!ConvertFileToFileSystemUrl(profile, path, kFileBrowserDomain, &url))
     return;
 
   file_tasks::TaskDescriptor task(kFileBrowserDomain,
                                   file_tasks::kFileBrowserHandlerTaskType,
                                   action_id);
-  ExecuteHandler(profile, task, url);
+  OpenFileWithTask(profile, task, url);
 }
 
 Browser* GetBrowserForUrl(GURL target_url) {
   for (chrome::BrowserIterator it; !it.done(); it.Next()) {
     Browser* browser = *it;
     TabStripModel* tab_strip = browser->tab_strip_model();
     for (int idx = 0; idx < tab_strip->count(); idx++) {
       content::WebContents* web_contents = tab_strip->GetWebContentsAt(idx);
       const GURL& url = web_contents->GetLastCommittedURL();
       if (url == target_url)
         return browser;
     }
   }
   return NULL;
 }
 
-bool ExecuteDefaultAppHandler(Profile* profile,
+// Opens the file specified by |path| and |url| with a file handler,
+// preferably the default handler for the type of the file.  Returns false if
+// no file handler is found.
+bool OpenFileWithFileHandler(Profile* profile,
                               const base::FilePath& path,
                               const GURL& url,
                               const std::string& mime_type,
                               const std::string& default_task_id) {
   ExtensionService* service = profile->GetExtensionService();
   if (!service)
     return false;
 
   PathAndMimeTypeSet files;
   files.insert(std::make_pair(path, mime_type));
@@ skipping 24 matching lines @@
          i != file_handlers.end(); ++i) {
       const extensions::FileHandlerInfo* handler = *i;
       std::string task_id = file_tasks::MakeTaskID(
           extension->id(),
           file_tasks::kFileHandlerTaskType,
           handler->id);
       if (task_id == default_task_id) {
         file_tasks::TaskDescriptor task(extension->id(),
                                         file_tasks::kFileHandlerTaskType,
                                         handler->id);
-        ExecuteHandler(profile, task, url);
+        OpenFileWithTask(profile, task, url);
         return true;
 
       } else if (!first_handler) {
         first_handler = handler;
         extension_for_first_handler = extension;
       }
     }
   }
   if (first_handler) {
     file_tasks::TaskDescriptor task(extension_for_first_handler->id(),
                                     file_tasks::kFileHandlerTaskType,
                                     first_handler->id);
-    ExecuteHandler(profile, task, url);
+    OpenFileWithTask(profile, task, url);
     return true;
   }
   return false;
 }
 
-bool ExecuteExtensionHandler(Profile* profile,
-                             const base::FilePath& path,
-                             const FileBrowserHandler& handler,
-                             const GURL& url) {
+// Returns true if |action_id| indicates that the file currently being
+// handled should be opened with the browser (i.e. should be opened with
+// OpenFileWithBrowser()).
+bool ShouldBeOpenedWithBrowser(const std::string& action_id) {
+  return (action_id == "view-pdf" ||
+          action_id == "view-swf" ||
+          action_id == "view-in-browser" ||
+          action_id == "install-crx" ||
+          action_id == "open-hosted-generic" ||
+          action_id == "open-hosted-gdoc" ||
+          action_id == "open-hosted-gsheet" ||
+          action_id == "open-hosted-gslides");
+}
+
+// Opens the file specified by |path| and |url| with the file browser handler
+// specified by |handler|. Returns false if failed to open the file.
+bool OpenFileWithFileBrowserHandler(Profile* profile,
+                                    const base::FilePath& path,
+                                    const FileBrowserHandler& handler,
+                                    const GURL& url) {
   std::string extension_id = handler.extension_id();
   std::string action_id = handler.id();
   Browser* browser = chrome::FindLastActiveWithProfile(profile,
       chrome::HOST_DESKTOP_TYPE_ASH);
 
   // If there is no browsers for the profile, bail out. Return true so warning
   // about file type not being supported is not displayed.
   if (!browser)
     return true;
 
-  if (extension_id == kFileBrowserDomain) {
-    if (action_id == kFileBrowserGalleryTaskId ||
-        action_id == kFileBrowserMountArchiveTaskId ||
-        action_id == kFileBrowserPlayTaskId ||
-        action_id == kFileBrowserWatchTaskId) {
-      file_tasks::TaskDescriptor task(extension_id,
-                                      file_tasks::kFileBrowserHandlerTaskType,
-                                      action_id);
-      ExecuteHandler(profile, task, url);
-      return true;
-    }
-    return ExecuteBuiltinHandler(browser, path);
+  // Some action IDs of the file manager's file browser handlers require the
+  // file to be directly opened with the browser.
+  if (extension_id == kFileBrowserDomain &&
+      ShouldBeOpenedWithBrowser(action_id)) {
+    return OpenFileWithBrowser(browser, path);
   }
 
   file_tasks::TaskDescriptor task(extension_id,
                                   file_tasks::kFileBrowserHandlerTaskType,
                                   action_id);
-  ExecuteHandler(profile, task, url);
+  OpenFileWithTask(profile, task, url);
   return true;
 }
 
-bool ExecuteDefaultHandler(Profile* profile, const base::FilePath& path) {
+// Opens the file specified by |path| with a handler (either of file browser
+// handler or file handler, preferably the default handler for the type of
+// the file), or opens the file with the browser. Returns false if failed to
+// open the file.
+bool OpenFileWithHandlerOrBrowser(Profile* profile,
+                                  const base::FilePath& path) {
   GURL url;
   if (!ConvertFileToFileSystemUrl(profile, path, kFileBrowserDomain, &url))
     return false;
 
   std::string mime_type = GetMimeTypeForPath(path);
   std::string default_task_id = file_tasks::GetDefaultTaskIdFromPrefs(
       profile, mime_type, path.Extension());
 
   // We choose the file handler from the following in decreasing priority or
   // fail if none support the file type:
-  // 1. default extension
-  // 2. default app
+  // 1. default file browser handler
+  // 2. default file handler
   // 3. a fallback handler (e.g. opening in the browser)
-  // 4. non-default app
-  // 5. non-default extension
+  // 4. non-default file handler
+  // 5. non-default file browser handler
   // Note that there can be at most one of default extension and default app.
   const FileBrowserHandler* handler =
       file_browser_handlers::FindFileBrowserHandlerForURLAndPath(
           profile, url, path);
   if (!handler) {
-    return ExecuteDefaultAppHandler(
+    return OpenFileWithFileHandler(
         profile, path, url, mime_type, default_task_id);
   }
 
   std::string handler_task_id = file_tasks::MakeTaskID(
         handler->extension_id(),
         file_tasks::kFileBrowserHandlerTaskType,
         handler->id());
   if (handler_task_id != default_task_id &&
       !file_browser_handlers::IsFallbackFileBrowserHandler(handler) &&
-      ExecuteDefaultAppHandler(
+      OpenFileWithFileHandler(
           profile, path, url, mime_type, default_task_id)) {
     return true;
   }
-  return ExecuteExtensionHandler(profile, path, *handler, url);
+  return OpenFileWithFileBrowserHandler(profile, 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 ViewItem().
 void ContinueViewItem(Profile* profile,
                       const base::FilePath& path,
                       base::PlatformFileError error) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   if (error == base::PLATFORM_FILE_OK) {
-    // A directory exists at |path|. Open it with FileBrowser.
-    OpenFileBrowserImpl(path, "open");
+    // A directory exists at |path|. Open it with the file manager.
+    OpenFileWithInternalActionId(path, "open");
   } else {
-    if (!ExecuteDefaultHandler(profile, path))
+    // |path| should be a file. Open it with a handler or the browser.
+    if (!OpenFileWithHandlerOrBrowser(profile, path))
       ShowWarningMessageBox(profile, path);
   }
 }
 
 // Used to implement CheckIfDirectoryExists().
 void CheckIfDirectoryExistsOnIOThread(
     scoped_refptr<fileapi::FileSystemContext> file_system_context,
     const GURL& url,
     const fileapi::FileSystemOperationRunner::StatusCallback& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
@@ skipping 183 matching lines @@
       break;
 
     default:
       NOTREACHED();
   }
 
   return title;
 }
 
 void ViewRemovableDrive(const base::FilePath& path) {
-  OpenFileBrowserImpl(path, "auto-open");
+  OpenFileWithInternalActionId(path, "auto-open");
 }
 
 void OpenActionChoiceDialog(const base::FilePath& path, bool advanced_mode) {
   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();
 
@@ skipping 49 matching lines @@
   scoped_refptr<fileapi::FileSystemContext> file_system_context =
       fileapi_util::GetFileSystemContextForExtensionId(
           profile, kFileBrowserDomain);
 
   CheckIfDirectoryExists(file_system_context, url,
                          base::Bind(&ContinueViewItem, profile, path));
 }
 
 void ShowFileInFolder(const base::FilePath& path) {
   // This action changes the selection so we do not reuse existing tabs.
-  OpenFileBrowserImpl(path, "select");
+  OpenFileWithInternalActionId(path, "select");
 }
 
-bool ExecuteBuiltinHandler(Browser* browser, const base::FilePath& path) {
+bool OpenFileWithBrowser(Browser* browser, const base::FilePath& path) {
   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()) ||
       ShouldBeOpenedWithPlugin(profile, file_extension.data())) {
     GURL page_url = net::FilePathToFileURL(path);
     // Override drive resource to point to internal handler instead of file URL.
@@ skipping 67 matching lines @@
     // 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