Chrome OS "open with" picker allowing Web Intents

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"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/chromeos/extensions/file_manager_util.h"
 #include "chrome/browser/chromeos/gdata/drive_file_system_util.h"
 #include "chrome/browser/chromeos/gdata/drive_task_executor.h"
 #include "chrome/browser/extensions/event_router.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/extensions/lazy_background_task_queue.h"
+#include "chrome/browser/extensions/platform_app_launcher.h"
 #include "chrome/browser/prefs/scoped_user_pref_update.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/common/extensions/file_browser_handler.h"
 #include "chrome/common/pref_names.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/child_process_security_policy.h"
 #include "content/public/browser/render_process_host.h"
 #include "content/public/browser/site_instance.h"
 #include "content/public/browser/storage_partition.h"
 #include "content/public/browser/web_contents.h"
 #include "net/base/escape.h"
 #include "webkit/chromeos/fileapi/cros_mount_point_provider.h"
 #include "webkit/fileapi/file_system_context.h"
 #include "webkit/fileapi/file_system_url.h"
 #include "webkit/fileapi/file_system_util.h"
+#include "webkit/fileapi/isolated_context.h"
 
 using content::BrowserContext;
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 using content::SiteInstance;
 using content::WebContents;
 using extensions::Extension;
 
 namespace file_handler_util {
 
-// The prefix used to differentiate drive extensions from Chrome extensions.
-const char FileTaskExecutor::kDriveTaskExtensionPrefix[] = "drive-app:";
-const size_t FileTaskExecutor::kDriveTaskExtensionPrefixLength =
-    arraysize(FileTaskExecutor::kDriveTaskExtensionPrefix) - 1;
-
 namespace {
 typedef std::set<const FileBrowserHandler*> FileBrowserHandlerSet;
 
 const int kReadWriteFilePermissions = base::PLATFORM_FILE_OPEN |
                                       base::PLATFORM_FILE_CREATE |
                                       base::PLATFORM_FILE_OPEN_ALWAYS |
                                       base::PLATFORM_FILE_CREATE_ALWAYS |
                                       base::PLATFORM_FILE_OPEN_TRUNCATED |
                                       base::PLATFORM_FILE_READ |
                                       base::PLATFORM_FILE_WRITE |
@@ skipping 39 matching lines @@
   for (Extension::FileBrowserHandlerList::const_iterator action_iter =
            extension->file_browser_handlers()->begin();
        action_iter != extension->file_browser_handlers()->end();
        ++action_iter) {
     if (action_iter->get()->id() == action_id)
       return action_iter->get();
   }
   return NULL;
 }
 
-unsigned int GetAccessPermissionsForHandler(const Extension* extension,
-                                            const std::string& action_id) {
+unsigned int GetAccessPermissionsForFileBrowserHandler(
+    const Extension* extension,
+    const std::string& action_id) {
   const FileBrowserHandler* action =
       FindFileBrowserHandler(extension, action_id);
   if (!action)
     return 0;
   unsigned int result = 0;
   if (action->CanRead())
     result |= kReadOnlyFilePermissions;
   if (action->CanWrite())
     result |= kReadWriteFilePermissions;
   // TODO(tbarzic): We don't handle Create yet.
   return result;
 }
 
-
 std::string EscapedUtf8ToLower(const std::string& str) {
   string16 utf16 = UTF8ToUTF16(
       net::UnescapeURLComponent(str, net::UnescapeRule::NORMAL));
   return net::EscapeUrlEncodedData(
       UTF16ToUTF8(base::i18n::ToLower(utf16)),
       false /* do not replace space with plus */);
 }
 
 bool GetFileBrowserHandlers(Profile* profile,
                             const GURL& selected_file_url,
@@ skipping 23 matching lines @@
       const FileBrowserHandler* action = action_iter->get();
       if (!action->MatchesURL(lowercase_url))
         continue;
 
       results->insert(action_iter->get());
     }
   }
   return true;
 }
 
+// Legacy Drive task extension prefix, used by CrackTaskID.
+const char kDriveTaskExtensionPrefix[] = "drive-app:";
+const size_t kDriveTaskExtensionPrefixLength =

[tbarzic, 2012/09/19 15:45:13]

nit:
I'd expect these to be at the beginning of the namespace

[thorogood, 2012/09/20 00:48:17]

Done.

+    arraysize(kDriveTaskExtensionPrefix) - 1;
+
 }  // namespace
 
 void UpdateDefaultTask(Profile* profile,
                        const std::string& task_id,
                        const std::set<std::string>& suffixes,
                        const std::set<std::string>& mime_types) {
   if (!profile || !profile->GetPrefs())
     return;
 
   if (!mime_types.empty()) {
@@ skipping 54 matching lines @@
 
 int GetReadWritePermissions() {
   return kReadWriteFilePermissions;
 }
 
 int GetReadOnlyPermissions() {
   return kReadOnlyFilePermissions;
 }
 
 std::string MakeTaskID(const std::string& extension_id,
+                       const std::string& task_type,
                        const std::string& action_id) {
-  return base::StringPrintf("%s|%s", extension_id.c_str(), action_id.c_str());
-}
-
-std::string MakeDriveTaskID(const std::string& app_id,
-                            const std::string& action_id) {
-  return MakeTaskID(FileTaskExecutor::kDriveTaskExtensionPrefix + app_id,
-                    action_id);
-}
-
-bool CrackDriveTaskID(const std::string& task_id,
-                      std::string* app_id,
-                      std::string* action_id) {
-  std::string app_id_tmp;
-  std::string action_id_tmp;
-  if (!CrackTaskID(task_id, &app_id_tmp, &action_id_tmp))
-    return false;
-  if (StartsWithASCII(app_id_tmp,
-                      FileTaskExecutor::kDriveTaskExtensionPrefix,
-                      false)) {
-    // Strip off the prefix from the extension ID so we convert it to an app id.
-    if (app_id) {
-      *app_id = app_id_tmp.substr(
-          FileTaskExecutor::kDriveTaskExtensionPrefixLength);
-    }
-    if (action_id)
-      *action_id = action_id_tmp;
-    return true;
-  }
-  return false;
+  DCHECK(task_type == kTaskFile ||
+         task_type == kTaskDrive ||
+         task_type == kTaskWebIntent);
+  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-action-id>
+//     <extension-id>|<task-type>|<task-action-id>
 bool CrackTaskID(const std::string& task_id,
                  std::string* extension_id,
+                 std::string* task_type,
                  std::string* action_id) {
   std::vector<std::string> result;
   int count = Tokenize(task_id, std::string("|"), &result);
-  if (count != 2)
+
+  // Parse historic task_id parameters that only contain two parts. Drive tasks
+  // are identified by a prefix "drive-app:" on the extension ID.
+  if (count == 2) {
+    if (StartsWithASCII(result[0], kDriveTaskExtensionPrefix, true)) {
+      if (task_type)
+        *task_type = kTaskDrive;
+
+      if (extension_id)
+        *extension_id = result[0].substr(kDriveTaskExtensionPrefixLength);
+    } else {
+      if (task_type)
+        *task_type = kTaskFile;
+
+      if (extension_id)
+        *extension_id = result[0];
+    }
+
+    if (action_id)
+      *action_id = result[1];
+
+    return true;
+  }
+
+  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);
+  }
+
   if (action_id)
-    *action_id = result[1];
+    *action_id = result[2];
+
   return true;
 }
 
 // Find a specific handler in the handler list.
 FileBrowserHandlerSet::iterator FindHandler(
     FileBrowserHandlerSet* handler_set,
     const std::string& extension_id,
     const std::string& id) {
   FileBrowserHandlerSet::iterator iter = handler_set->begin();
   while (iter != handler_set->end() &&
          !((*iter)->extension_id() == extension_id &&
            (*iter)->id() == id)) {
     iter++;
   }
   return iter;
 }
 
+// Given the list of selected files, returns array of file action tasks
+// that are shared between them.
 void FindDefaultTasks(Profile* profile,
                       const std::vector<GURL>& files_list,
                       const FileBrowserHandlerSet& common_tasks,
                       FileBrowserHandlerSet* default_tasks) {
   DCHECK(default_tasks);
   default_tasks->clear();
 
   std::set<std::string> default_ids;
   for (std::vector<GURL>::const_iterator it = files_list.begin();
        it != files_list.end(); ++it) {
     // Get the default task for this file based only on the extension (since
     // we don't have MIME types here), and add it to the set of default tasks.
     fileapi::FileSystemURL filesystem_url(*it);
     if (filesystem_url.is_valid() &&
         (filesystem_url.type() == fileapi::kFileSystemTypeDrive ||
          filesystem_url.type() == fileapi::kFileSystemTypeNativeMedia ||
          filesystem_url.type() == fileapi::kFileSystemTypeNativeLocal)) {
       std::string task_id = file_handler_util::GetDefaultTaskIdFromPrefs(
           profile, "", filesystem_url.virtual_path().Extension());
       if (!task_id.empty())
         default_ids.insert(task_id);
     }
   }
 
   // Convert the default task IDs collected above to one of the handler pointers
   // from common_tasks.
   for (FileBrowserHandlerSet::const_iterator task_iter = common_tasks.begin();
        task_iter != common_tasks.end(); ++task_iter) {
-    std::string task_id = MakeTaskID((*task_iter)->extension_id(),
+    std::string task_id = MakeTaskID((*task_iter)->extension_id(), kTaskFile,
                                      (*task_iter)->id());
     for (std::set<std::string>::iterator default_iter = default_ids.begin();
          default_iter != default_ids.end(); ++default_iter) {
       if (task_id == *default_iter) {
         default_tasks->insert(*task_iter);
         break;
       }
     }
   }
 }
@@ skipping 134 matching lines @@
                                         const GURL& file_system_root,
                                         const FileDefinitionList& file_list,
                                         int handler_pid_in,
                                         extensions::ExtensionHost* host);
 
   // Populates |handler_host_permissions| with file path-permissions pairs that
   // will be given to the handler extension host process.
   void InitHandlerHostFileAccessPermissions(
       const FileDefinitionList& file_list,
       const extensions::Extension* handler_extension,
-      const std::string& action_id,
       const base::Closure& callback);
 
   // Invoked upon completion of InitHandlerHostFileAccessPermissions initiated
   // by ExecuteFileActionsOnUIThread.
   void OnInitAccessForExecuteFileActionsOnUIThread(
       const std::string& file_system_name,
       const GURL& file_system_root,
       const FileDefinitionList& file_list,
       int handler_pid);
 
   // Registers file permissions from |handler_host_permissions_| with
   // ChildProcessSecurityPolicy for process with id |handler_pid|.
   void SetupHandlerHostFileAccessPermissions(int handler_pid);
 
-  // Helper function to get the extension pointer.
-  const extensions::Extension* GetExtension();
-
   const GURL source_url_;
-  const std::string extension_id_;
   const std::string action_id_;
   FileTaskFinishedCallback done_;
 
   // (File path, permission for file path) pairs for the handler.
   std::vector<std::pair<FilePath, int> > handler_host_permissions_;
 };
 
+class WebIntentTaskExecutor : public FileTaskExecutor {
+ public:
+  // FileTaskExecutor overrides.
+  virtual bool ExecuteAndNotify(const std::vector<GURL>& 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& extension_id,
+                        const std::string& action_id);
+  virtual ~WebIntentTaskExecutor();
+
+  bool ExecuteForURL(const GURL& file_url);
+
+  const GURL source_url_;
+  const std::string extension_id_;
+  const std::string action_id_;
+};
+
 // static
 FileTaskExecutor* FileTaskExecutor::Create(Profile* profile,
                                            const GURL source_url,
                                            const std::string& extension_id,
+                                           const std::string& task_type,
                                            const std::string& action_id) {
-  // Check out the extension ID and see if this is a drive task,
-  // and instantiate drive-specific executor if so.
-  if (StartsWithASCII(extension_id,
-                      FileTaskExecutor::kDriveTaskExtensionPrefix,
-                      false)) {
-    return new gdata::DriveTaskExecutor(profile,
-                                        extension_id, // really app_id
-                                        action_id);
-  } else {
+  if (task_type == kTaskFile)
     return new ExtensionTaskExecutor(profile,
                                      source_url,
                                      extension_id,
                                      action_id);
-  }
+
+  if (task_type == kTaskDrive)
+    return new gdata::DriveTaskExecutor(profile,
+                                        extension_id,  // really app_id
+                                        action_id);
+
+  if (task_type == kTaskWebIntent)
+    return new WebIntentTaskExecutor(profile,
+                                     source_url,
+                                     extension_id,
+                                     action_id);
+
+  NOTREACHED();
+  return NULL;
 }
 
-FileTaskExecutor::FileTaskExecutor(Profile* profile) : profile_(profile) {
+FileTaskExecutor::FileTaskExecutor(
+    Profile* profile,
+    const std::string& extension_id)
+  : profile_(profile),
+    extension_id_(extension_id) {
 }
 
 FileTaskExecutor::~FileTaskExecutor() {
 }
 
 bool FileTaskExecutor::Execute(const std::vector<GURL>& file_urls) {
   return ExecuteAndNotify(file_urls, FileTaskFinishedCallback());
 }
 
 Browser* FileTaskExecutor::GetBrowser() const {
   return browser::FindOrCreateTabbedBrowser(
       profile_ ? profile_ : ProfileManager::GetDefaultProfileOrOffTheRecord());
 }
 
+const Extension* FileTaskExecutor::GetExtension() {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+
+  ExtensionService* service = profile()->GetExtensionService();
+  return service ? service->GetExtensionById(extension_id_, false) :
+                   NULL;
+}
+
 ExtensionTaskExecutor::FileDefinition::FileDefinition() : is_directory(false) {
 }
 
 ExtensionTaskExecutor::FileDefinition::~FileDefinition() {
 }
 
 class ExtensionTaskExecutor::ExecuteTasksFileSystemCallbackDispatcher {
  public:
   static fileapi::FileSystemContext::OpenFileSystemCallback CreateCallback(
       ExtensionTaskExecutor* executor,
@@ skipping 149 matching lines @@
   std::string action_id_;
   std::vector<GURL> origin_file_urls_;
   DISALLOW_COPY_AND_ASSIGN(ExecuteTasksFileSystemCallbackDispatcher);
 };
 
 ExtensionTaskExecutor::ExtensionTaskExecutor(
     Profile* profile,
     const GURL source_url,
     const std::string& extension_id,
     const std::string& action_id)
-  : FileTaskExecutor(profile),
+  : FileTaskExecutor(profile, extension_id),
     source_url_(source_url),
-    extension_id_(extension_id),
     action_id_(action_id) {
 }
 
 ExtensionTaskExecutor::~ExtensionTaskExecutor() {}
 
 bool ExtensionTaskExecutor::ExecuteAndNotify(
     const std::vector<GURL>& file_urls,
     const FileTaskFinishedCallback& done) {
-  ExtensionService* service = profile()->GetExtensionService();
-  if (!service)
-    return false;
-
-  scoped_refptr<const Extension> handler =
-      service->GetExtensionById(extension_id_, false);
+  scoped_refptr<const Extension> handler = GetExtension();
 
   if (!handler.get())
     return false;
 
   int handler_pid = ExtractProcessFromExtensionId(handler->id(), profile());
   if (handler_pid <= 0) {
     if (!handler->has_lazy_background_page())
       return false;
   }
 
@@ skipping 36 matching lines @@
           file_urls));
 }
 
 void ExtensionTaskExecutor::ExecuteDoneOnUIThread(bool success) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
   if (!done_.is_null())
     done_.Run(success);
   done_.Reset();
 }
 
-const Extension* ExtensionTaskExecutor::GetExtension() {
-  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-
-  ExtensionService* service = profile()->GetExtensionService();
-  return service ? service->GetExtensionById(extension_id_, false) :
-                   NULL;
-}
-
 void ExtensionTaskExecutor::ExecuteFileActionsOnUIThread(
     const std::string& file_system_name,
     const GURL& file_system_root,
     const FileDefinitionList& file_list,
     int handler_pid) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   const Extension* extension = GetExtension();
   if (!extension) {
     ExecuteDoneOnUIThread(false);
     return;
   }
 
   InitHandlerHostFileAccessPermissions(
       file_list,
       extension,
-      action_id_,
       base::Bind(
           &ExtensionTaskExecutor::OnInitAccessForExecuteFileActionsOnUIThread,
           this,
           file_system_name,
           file_system_root,
           file_list,
           handler_pid));
 }
 
 void ExtensionTaskExecutor::OnInitAccessForExecuteFileActionsOnUIThread(
@@ skipping 15 matching lines @@
   } else {
     // We have to wake the handler background page before we proceed.
     extensions::LazyBackgroundTaskQueue* queue =
         extensions::ExtensionSystem::Get(profile())->
         lazy_background_task_queue();
     if (!queue->ShouldEnqueueTask(profile(), extension)) {
       ExecuteDoneOnUIThread(false);
       return;
     }
     queue->AddPendingTask(
-        profile(), extension_id_,
+        profile(), extension_id(),
         base::Bind(&ExtensionTaskExecutor::SetupPermissionsAndDispatchEvent,
                    this, file_system_name, file_system_root, file_list,
                    handler_pid));
   }
 }
 
 void ExtensionTaskExecutor::SetupPermissionsAndDispatchEvent(
     const std::string& file_system_name,
     const GURL& file_system_root,
     const FileDefinitionList& file_list,
@@ skipping 38 matching lines @@
 
   // Get tab id.
   Browser* current_browser = GetBrowser();
   if (current_browser) {
     WebContents* contents = chrome::GetActiveWebContents(current_browser);
     if (contents)
       details->SetInteger("tab_id", ExtensionTabUtil::GetTabId(contents));
   }
 
   event_router->DispatchEventToExtension(
-      extension_id_, std::string("fileBrowserHandler.onExecute"),
+      extension_id(), std::string("fileBrowserHandler.onExecute"),
       event_args.Pass(), profile(), GURL());
   ExecuteDoneOnUIThread(true);
 }
 
 void ExtensionTaskExecutor::InitHandlerHostFileAccessPermissions(
     const FileDefinitionList& file_list,
     const Extension* handler_extension,
-    const std::string& action_id,
     const base::Closure& callback) {
   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
   scoped_ptr<std::vector<FilePath> > gdata_paths(new std::vector<FilePath>);
   for (FileDefinitionList::const_iterator iter = file_list.begin();
        iter != file_list.end();
        ++iter) {
     // Setup permission for file's absolute file.
-    handler_host_permissions_.push_back(std::make_pair(
-        iter->absolute_path,
-        GetAccessPermissionsForHandler(handler_extension, action_id)));
+    handler_host_permissions_.push_back(std::make_pair(iter->absolute_path,
+        GetAccessPermissionsForFileBrowserHandler(handler_extension,
+                                                  action_id_)));
 
     if (gdata::util::IsUnderDriveMountPoint(iter->absolute_path))
       gdata_paths->push_back(iter->virtual_path);
   }
 
   if (gdata_paths->empty()) {
     // Invoke callback if none of the files are on gdata mount point.
     callback.Run();
     return;
   }
@@ skipping 12 matching lines @@
     content::ChildProcessSecurityPolicy::GetInstance()->GrantPermissionsForFile(
         handler_pid,
         handler_host_permissions_[i].first,
         handler_host_permissions_[i].second);
   }
 
   // We don't need this anymore.
   handler_host_permissions_.clear();
 }
 
+WebIntentTaskExecutor::WebIntentTaskExecutor(
+    Profile* profile,
+    const GURL source_url,
+    const std::string& extension_id,
+    const std::string& action_id)
+  : FileTaskExecutor(profile, extension_id),

[tbarzic, 2012/09/19 15:45:13]

nit:
indent += 2 (from line 1014)

[thorogood, 2012/09/20 00:48:17]

Done here and on line 782.

+    source_url_(source_url),
+    action_id_(action_id) {
+}
+
+WebIntentTaskExecutor::~WebIntentTaskExecutor() {}
+
+bool WebIntentTaskExecutor::ExecuteAndNotify(
+    const std::vector<GURL>& file_urls,
+    const FileTaskFinishedCallback& done) {
+  bool success = true;
+
+  for (std::vector<GURL>::const_iterator i = file_urls.begin();
+       i != file_urls.end(); ++i) {
+    if (!ExecuteForURL(*i))
+      success = false;
+  }
+
+  if (!done.is_null())
+    done.Run(success);
+
+  return true;
+}
+
+bool WebIntentTaskExecutor::ExecuteForURL(const GURL& file_url) {
+  fileapi::FileSystemURL url(file_url);
+  if (!chromeos::CrosMountPointProvider::CanHandleURL(url))
+    return false;
+
+  scoped_refptr<fileapi::FileSystemContext> file_system_context =
+      BrowserContext::GetDefaultStoragePartition(profile())->
+      GetFileSystemContext();
+  fileapi::ExternalFileSystemMountPointProvider* external_provider =
+      file_system_context->external_provider();
+  if (!external_provider || !external_provider->IsAccessAllowed(url))
+    return false;
+
+  // Make sure this url really being used by the right caller extension.
+  if (source_url_.GetOrigin() != url.origin())
+    return false;
+
+  FilePath local_path = url.path();
+  extensions::LaunchPlatformAppWithPath(profile(), GetExtension(), local_path);
+  return true;
+}
+
 } // namespace file_handler_util