Chrome OS "open with" picker allowing Web Intents

chrome/browser/extensions/platform_app_launcher.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/extensions/platform_app_launcher.h"
 
 #include "base/command_line.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "base/logging.h"
 #include "base/memory/ref_counted.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/app_runtime/app_runtime_api.h"
 #include "chrome/browser/extensions/extension_host.h"
 #include "chrome/browser/extensions/extension_process_manager.h"
 #include "chrome/browser/extensions/extension_system.h"
 #include "chrome/browser/extensions/lazy_background_task_queue.h"
+#include "chrome/browser/intents/web_intents_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/common/extensions/extension.h"
 #include "chrome/common/extensions/extension_messages.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 "net/base/mime_util.h"
 #include "net/base/net_util.h"
 #include "webkit/fileapi/file_system_types.h"
 #include "webkit/fileapi/isolated_context.h"
 #include "webkit/glue/web_intent_data.h"
 #include "webkit/glue/web_intent_service_data.h"
 
 using content::BrowserThread;
 
 namespace extensions {
 
 namespace {
 
-const char kViewIntent[] = "http://webintents.org/view";
-
 bool MakePathAbsolute(const FilePath& current_directory,
                       FilePath* file_path) {
   DCHECK(file_path);
   if (file_path->IsAbsolute())
     return true;
 
   if (current_directory.empty())
     return file_util::AbsolutePath(file_path);
 
   if (!current_directory.IsAbsolute())
     return false;
 
   *file_path = current_directory.Append(*file_path);
   return true;
 }
 
-// Class to handle launching of platform apps with command line information.
+bool GetAbsolutePathFromCommandLine(const CommandLine* command_line,
+                                    const FilePath& current_directory,
+                                    FilePath* path) {
+  if (!command_line || !command_line->GetArgs().size())
+    return false;
+
+  FilePath relative_path(command_line->GetArgs()[0]);
+  FilePath absolute_path(relative_path);
+  if (!MakePathAbsolute(current_directory, &absolute_path)) {
+    LOG(WARNING) << "Cannot make absolute path from " << relative_path.value();
+    return false;
+  }
+  *path = absolute_path;
+  return true;
+}
+
+// Helper method to launches the platform app |extension| with no data. This
+// should be called in the fallback case for the launchers above.
+void LaunchPlatformAppWithNoData(Profile* profile, const Extension* extension) {
+  DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+  extensions::AppEventRouter::DispatchOnLaunchedEvent(profile, extension);
+}
+
+// Class to handle launching of platform apps to open a specific path.
 // An instance of this class is created for each launch. The lifetime of these
 // instances is managed by reference counted pointers. As long as an instance
 // has outstanding tasks on a message queue it will be retained; once all
 // outstanding tasks are completed it will be deleted.
-class PlatformAppCommandLineLauncher
-    : public base::RefCountedThreadSafe<PlatformAppCommandLineLauncher> {
+class PlatformAppPathLauncher
+    : public base::RefCountedThreadSafe<PlatformAppPathLauncher> {
  public:
-  PlatformAppCommandLineLauncher(Profile* profile,
-                                 const Extension* extension,
-                                 const CommandLine* command_line,
-                                 const FilePath& current_directory)
+  PlatformAppPathLauncher(Profile* profile,
+                          const Extension* extension,
+                          const FilePath& file_path)
       : profile_(profile),
         extension_(extension),
-        command_line_(command_line),
-        current_directory_(current_directory) {}
+        file_path_(file_path) {}
 
   void Launch() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    if (!command_line_ || !command_line_->GetArgs().size()) {
-      LaunchWithNoLaunchData();
+    if (file_path_.empty()) {
+      LaunchPlatformAppWithNoData(profile_, extension_);
       return;
     }
 
-    FilePath file_path(command_line_->GetArgs()[0]);
+    DCHECK(file_path_.IsAbsolute());
     BrowserThread::PostTask(BrowserThread::FILE, FROM_HERE, base::Bind(
-            &PlatformAppCommandLineLauncher::GetMimeTypeAndLaunch,
-            this, file_path));
+            &PlatformAppPathLauncher::GetMimeTypeAndLaunch, this));
   }
 
  private:
-  friend class base::RefCountedThreadSafe<PlatformAppCommandLineLauncher>;
+  friend class base::RefCountedThreadSafe<PlatformAppPathLauncher>;
 
-  virtual ~PlatformAppCommandLineLauncher() {}
+  virtual ~PlatformAppPathLauncher() {}
 
-  void LaunchWithNoLaunchData() {
-    DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
-    extensions::AppEventRouter::DispatchOnLaunchedEvent(profile_, extension_);
-  }
-
-  void GetMimeTypeAndLaunch(const FilePath& file_path) {
+  void GetMimeTypeAndLaunch() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE));
 
-    // If we cannot construct an absolute path, launch with no launch data.
-    FilePath absolute_path(file_path);
-    if (!MakePathAbsolute(current_directory_, &absolute_path)) {
-      LOG(WARNING) << "Cannot make absolute path from " << file_path.value();
+    // If the file doesn't exist, or is a directory, launch with no launch data.
+    if (!file_util::PathExists(file_path_) ||
+        file_util::DirectoryExists(file_path_)) {
+      LOG(WARNING) << "No file exists with path " << file_path_.value();
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-              &PlatformAppCommandLineLauncher::LaunchWithNoLaunchData, this));
-      return;
-    }
-
-    // If the file doesn't exist, or is a directory, launch with no launch data.
-    if (!file_util::PathExists(absolute_path) ||
-        file_util::DirectoryExists(absolute_path)) {
-      LOG(WARNING) << "No file exists with path " << absolute_path.value();
-      BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-              &PlatformAppCommandLineLauncher::LaunchWithNoLaunchData, this));
+              &PlatformAppPathLauncher::LaunchWithNoLaunchData, this));
       return;
     }
 
     std::string mime_type;
     // If we cannot obtain the MIME type, launch with no launch data.
-    if (!net::GetMimeTypeFromFile(absolute_path, &mime_type)) {
+    if (!net::GetMimeTypeFromFile(file_path_, &mime_type)) {
       LOG(WARNING) << "Could not obtain MIME type for "
-                   << absolute_path.value();
+                   << file_path_.value();
       BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-              &PlatformAppCommandLineLauncher::LaunchWithNoLaunchData, this));
+              &PlatformAppPathLauncher::LaunchWithNoLaunchData, this));
       return;
     }
 
     BrowserThread::PostTask(BrowserThread::UI, FROM_HERE, base::Bind(
-            &PlatformAppCommandLineLauncher::LaunchWithMimeTypeAndPath,
-            this, absolute_path, mime_type));
+            &PlatformAppPathLauncher::LaunchWithMimeType, this, mime_type));
   }
 
-  void LaunchWithMimeTypeAndPath(const FilePath& file_path,
-                                 const std::string& mime_type) {
+  void LaunchWithNoLaunchData() {
+    // This method is required as an entry point on the UI thread.
+    LaunchPlatformAppWithNoData(profile_, extension_);
+  }
+
+  void LaunchWithMimeType(const std::string& mime_type) {
     // Find the intent service from the platform app for the file being opened.
     webkit_glue::WebIntentServiceData service;
     bool found_service = false;
 
     std::vector<webkit_glue::WebIntentServiceData> services =
         extension_->intents_services();
     for (size_t i = 0; i < services.size(); i++) {
       std::string service_type_ascii = UTF16ToASCII(services[i].type);
-      if (services[i].action == ASCIIToUTF16(kViewIntent) &&
+      if (services[i].action == ASCIIToUTF16(web_intents::action::kView) &&
           net::MatchesMimeType(service_type_ascii, mime_type)) {
         service = services[i];
         found_service = true;
         break;
       }
     }
 
     // If this app doesn't have an intent that supports the file, launch with
     // no launch data.
     if (!found_service) {
       LOG(WARNING) << "Extension does not provide a valid intent for "
-                   << file_path.value();
+                   << file_path_.value();
       LaunchWithNoLaunchData();
       return;
     }
 
     // Access needs to be granted to the file for the process associated with
     // the extension. To do this the ExtensionHost is needed. This might not be
     // available, or it might be in the process of being unloaded, in which case
     // the lazy background task queue is used to load the extension and then
     // call back to us.
     extensions::LazyBackgroundTaskQueue* queue =
         ExtensionSystem::Get(profile_)->lazy_background_task_queue();
     if (queue->ShouldEnqueueTask(profile_, extension_)) {
       queue->AddPendingTask(profile_, extension_->id(), base::Bind(
-              &PlatformAppCommandLineLauncher::GrantAccessToFileAndLaunch,
-              this, file_path, mime_type));
+              &PlatformAppPathLauncher::GrantAccessToFileAndLaunch,
+              this, mime_type));
       return;
     }
 
     ExtensionProcessManager* process_manager =
         ExtensionSystem::Get(profile_)->process_manager();
     extensions::ExtensionHost* host =
         process_manager->GetBackgroundHostForExtension(extension_->id());
     DCHECK(host);
-    GrantAccessToFileAndLaunch(file_path, mime_type, host);
+    GrantAccessToFileAndLaunch(mime_type, host);
   }
 
-  void GrantAccessToFileAndLaunch(const FilePath& file_path,
-                                  const std::string& mime_type,
+  void GrantAccessToFileAndLaunch(const std::string& mime_type,
                                   extensions::ExtensionHost* host) {
     // If there was an error loading the app page, |host| will be NULL.
     if (!host) {
       LOG(ERROR) << "Could not load app page for " << extension_->id();
       return;
     }
 
     content::ChildProcessSecurityPolicy* policy =
         content::ChildProcessSecurityPolicy::GetInstance();
     int renderer_id = host->render_process_host()->GetID();
 
     // Granting read file permission to allow reading file content.
     // If the renderer already has permission to read these paths, it is not
     // regranted, as this would overwrite any other permissions which the
     // renderer may already have.
-    if (!policy->CanReadFile(renderer_id, file_path))
-      policy->GrantReadFile(renderer_id, file_path);
+    if (!policy->CanReadFile(renderer_id, file_path_))
+      policy->GrantReadFile(renderer_id, file_path_);
 
     std::string registered_name;
     fileapi::IsolatedContext* isolated_context =
         fileapi::IsolatedContext::GetInstance();
     DCHECK(isolated_context);
     std::string filesystem_id = isolated_context->RegisterFileSystemForPath(
-        fileapi::kFileSystemTypeNativeLocal, file_path, &registered_name);
+        fileapi::kFileSystemTypeNativeLocal, file_path_, &registered_name);
     // Granting read file system permission as well to allow file-system
     // read operations.
     policy->GrantReadFileSystem(renderer_id, filesystem_id);
 
     extensions::AppEventRouter::DispatchOnLaunchedEventWithFileEntry(
-        profile_, extension_, ASCIIToUTF16(kViewIntent), filesystem_id,
-        registered_name);
+        profile_, extension_, ASCIIToUTF16(web_intents::action::kView),
+        filesystem_id, registered_name);
   }
 
   // The profile the app should be run in.
   Profile* profile_;
   // The extension providing the app.
   const Extension* extension_;
-  // The command line to be passed through to the app, or NULL.
-  const CommandLine* command_line_;
-  // If non-empty, this is used to expand relative paths.
-  const FilePath current_directory_;
+  // The path to be passed through to the app. This may be the empty path.
+  const FilePath file_path_;
 
-  DISALLOW_COPY_AND_ASSIGN(PlatformAppCommandLineLauncher);
+  DISALLOW_COPY_AND_ASSIGN(PlatformAppPathLauncher);
 };
 
 // Class to handle launching of platform apps with WebIntent data.
 // An instance of this class is created for each launch. The lifetime of these
 // instances is managed by reference counted pointers. As long as an instance
 // has outstanding tasks on a message queue it will be retained; once all
 // outstanding tasks are completed it will be deleted.
 class PlatformAppWebIntentLauncher
     : public base::RefCountedThreadSafe<PlatformAppWebIntentLauncher> {
  public:
@@ skipping 87 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAppWebIntentLauncher);
 };
 
 }  // namespace
 
 void LaunchPlatformApp(Profile* profile,
                        const Extension* extension,
                        const CommandLine* command_line,
                        const FilePath& current_directory) {
+  FilePath path;
+  if (GetAbsolutePathFromCommandLine(command_line, current_directory, &path))
+    LaunchPlatformAppWithPath(profile, extension, path);
+  else
+    LaunchPlatformAppWithNoData(profile, extension);

[benwells, 2012/08/31 05:40:15]

Nit: Use an early return here:

if (...) {
  Launch...
  return;
}

Launch...

[thorogood, 2012/09/01 03:02:11]

Done.

+}
+
+void LaunchPlatformAppWithPath(Profile* profile,
+                               const Extension* extension,
+                               const FilePath& file_path) {
   // launcher will be freed when nothing has a reference to it. The message
   // queue will retain a reference for any outstanding task, so when the
   // launcher has finished it will be freed.
-  scoped_refptr<PlatformAppCommandLineLauncher> launcher =
-      new PlatformAppCommandLineLauncher(profile, extension, command_line,
-                                         current_directory);
+  scoped_refptr<PlatformAppPathLauncher> launcher =
+      new PlatformAppPathLauncher(profile, extension, file_path);
   launcher->Launch();
 }
 
 void LaunchPlatformAppWithWebIntent(
     Profile* profile,
     const Extension* extension,
     const webkit_glue::WebIntentData& web_intent_data) {
   scoped_refptr<PlatformAppWebIntentLauncher> launcher =
       new PlatformAppWebIntentLauncher(profile, extension, web_intent_data);
   launcher->Launch();
 }
 
 }  // namespace extensions