[cros] Remove file manager code for WebIntents file tasks.

chrome/browser/chromeos/extensions/file_handler_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_handler_util.h"
 
 #include "base/bind.h"
 #include "base/file_util.h"
 #include "base/i18n/case_conversion.h"
 #include "base/json/json_writer.h"
@@ skipping 37 matching lines @@
 using content::ChildProcessSecurityPolicy;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::Extension;
 using fileapi::FileSystemURL;
 
 namespace file_handler_util {
 
 const char kTaskFile[] = "file";
 const char kTaskDrive[] = "drive";
-const char kTaskWebIntent[] = "web-intent";
 const char kTaskApp[] = "app";
 
 namespace {
 
 // Legacy Drive task extension prefix, used by CrackTaskID.
 const char kDriveTaskExtensionPrefix[] = "drive-app:";
 const size_t kDriveTaskExtensionPrefixLength =
     arraysize(kDriveTaskExtensionPrefix) - 1;
 
 typedef std::set<const FileBrowserHandler*> FileBrowserHandlerSet;
@@ skipping 194 matching lines @@
 
 int GetReadOnlyPermissions() {
   return kReadOnlyFilePermissions;
 }
 
 std::string MakeTaskID(const std::string& extension_id,
                        const std::string& task_type,
                        const std::string& action_id) {
   DCHECK(task_type == kTaskFile ||
          task_type == kTaskDrive ||
-         task_type == kTaskWebIntent ||
          task_type == kTaskApp);
   return base::StringPrintf("%s|%s|%s",
                             extension_id.c_str(),
                             task_type.c_str(),
                             action_id.c_str());
 }
 
 // Breaks down task_id that is used between getFileTasks() and executeTask() on
 // its building blocks. task_id field the following structure:
 //     <extension-id>|<task-type>|<task-action-id>
@@ skipping 30 matching lines @@
   if (count != 3)
     return false;
 
   if (extension_id)
     *extension_id = result[0];
 
   if (task_type) {
     *task_type = result[1];
     DCHECK(*task_type == kTaskFile ||
            *task_type == kTaskDrive ||
-           *task_type == kTaskWebIntent ||
            *task_type == kTaskApp);
   }
 
   if (action_id)
     *action_id = result[2];
 
   return true;
 }
 
 // Find a specific handler in the handler list.
@@ skipping 200 matching lines @@
   void SetupHandlerHostFileAccessPermissions(
       const FileDefinitionList& file_list,
       const Extension* extension,
       int handler_pid);
 
   int32 tab_id_;
   const std::string action_id_;
   FileTaskFinishedCallback done_;
 };
 
-class WebIntentTaskExecutor : public FileTaskExecutor {
- public:
-  // FileTaskExecutor overrides.
-  virtual bool ExecuteAndNotify(const std::vector<FileSystemURL>& file_urls,
-                                const FileTaskFinishedCallback& done) OVERRIDE;
-
- private:
-  // FileTaskExecutor is the only class allowed to create one.
-  friend class FileTaskExecutor;
-
-  WebIntentTaskExecutor(Profile* profile,
-                        const GURL& source_url,
-                        const std::string& file_browser_id,
-                        const std::string& extension_id,
-                        const std::string& action_id);
-  virtual ~WebIntentTaskExecutor();
-
-  const std::string extension_id_;
-  const std::string action_id_;
-};
-
 class AppTaskExecutor : public FileTaskExecutor {
  public:
   // FileTaskExecutor overrides.
   virtual bool ExecuteAndNotify(const std::vector<FileSystemURL>& file_urls,
                                 const FileTaskFinishedCallback& done) OVERRIDE;
 
  private:
   // FileTaskExecutor is the only class allowed to create one.
   friend class FileTaskExecutor;
 
@@ skipping 22 matching lines @@
                                      file_browser_id,
                                      tab_id,
                                      extension_id,
                                      action_id);
 
   if (task_type == kTaskDrive)
     return new drive::DriveTaskExecutor(profile,
                                         extension_id,  // really app_id
                                         action_id);
 
-  if (task_type == kTaskWebIntent)
-    return new WebIntentTaskExecutor(profile,
-                                     source_url,
-                                     file_browser_id,
-                                     extension_id,
-                                     action_id);
-
   if (task_type == kTaskApp)
     return new AppTaskExecutor(profile,
                                source_url,
                                file_browser_id,
                                extension_id,
                                action_id);
 
   NOTREACHED();
   return NULL;
 }
@@ skipping 380 matching lines @@
   for (FileDefinitionList::const_iterator iter = file_list.begin();
        iter != file_list.end();
        ++iter) {
     content::ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
         handler_pid,
         iter->absolute_path,
         GetAccessPermissionsForFileBrowserHandler(extension, action_id_));
   }
 }
 
-WebIntentTaskExecutor::WebIntentTaskExecutor(
-    Profile* profile,
-    const GURL& source_url,
-    const std::string& file_browser_id,
-    const std::string& extension_id,
-    const std::string& action_id)
-    : FileTaskExecutor(profile, source_url, file_browser_id, extension_id),
-      action_id_(action_id) {
-}
-
-WebIntentTaskExecutor::~WebIntentTaskExecutor() {}
-
-bool WebIntentTaskExecutor::ExecuteAndNotify(
-    const std::vector<FileSystemURL>& file_urls,
-    const FileTaskFinishedCallback& done) {
-  if (!FileBrowserHasAccessPermissionForFiles(file_urls))
-    return false;
-
-  for (size_t i = 0; i != file_urls.size(); ++i) {
-    extensions::LaunchPlatformAppWithPath(profile(), GetExtension(),
-                                          file_urls[i].path());
-  }
-
-  if (!done.is_null())
-    done.Run(true);
-
-  return true;
-}
-
 AppTaskExecutor::AppTaskExecutor(
     Profile* profile,
     const GURL& source_url,
     const std::string& file_browser_id,
     const std::string& extension_id,
     const std::string& action_id)
     : FileTaskExecutor(profile, source_url, file_browser_id,  extension_id),
       action_id_(action_id) {
 }
 
 AppTaskExecutor::~AppTaskExecutor() {}
 
 bool AppTaskExecutor::ExecuteAndNotify(
     const std::vector<FileSystemURL>& file_urls,
     const FileTaskFinishedCallback& done) {
   if (!FileBrowserHasAccessPermissionForFiles(file_urls))
     return false;
 
   for (size_t i = 0; i != file_urls.size(); ++i) {
     extensions::LaunchPlatformAppWithFileHandler(profile(), GetExtension(),
         action_id_, file_urls[i].path());
   }
 
   if (!done.is_null())
     done.Run(true);
   return true;
 }
 
 } // namespace file_handler_util