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"
@@ skipping 35 matching lines @@
   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.
+// 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()) {
+    if (file_path_.empty()) {
       LaunchWithNoLaunchData();
       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 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) &&
           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::kFileSystemTypeIsolated, file_path, &registered_name);
+        fileapi::kFileSystemTypeIsolated, 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);
   }
 
   // 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 that is being
 // passed in a a blob.
 // 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 PlatformAppBlobIntentLauncher
     : public base::RefCountedThreadSafe<PlatformAppBlobIntentLauncher> {
@@ skipping 66 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAppBlobIntentLauncher);
 };
 
 }  // namespace
 
 void LaunchPlatformApp(Profile* profile,
                        const Extension* extension,
                        const CommandLine* command_line,
                        const FilePath& current_directory) {
+  // Optionally resolve the file_path from the first command-line argument.

[benwells, 2012/08/30 08:09:03]

I really like these refactorings as the role of the PlatformAppPathLauncher
seems really clean: it launches apps with paths.

Let's keep it nice and clean by making it not handle the simple case of
launching with no data. That can just become a function in the anonymous
namespace used by LaunchPlatformApp if there is no command line data, or by the
PlatformAppPathLauncher if there is some problem.

Also, creating a function GetAbsolutePathFromCommandLine  would make this really
nice, it can then be something like:

if (GetAbsolutePathFromCommandLine(command_line, cur_dir, &path) {
  LaunchPlatformAppWIthPath(...)
  return;
}

LaunchPlatformAppWithNoData(...)

[thorogood, 2012/08/31 01:27:32]

These are great suggestions! The code feels much neater now. 
The only thing I'm hesitant about is that we still have the method
"LaunchPlatformApp", when we could instead call it
"LaunchPlatformAppWithCommandLine". However perhaps it's not required...

+  FilePath file_path;
+  if (command_line && command_line->GetArgs().size()) {
+    file_path = FilePath(command_line->GetArgs()[0]);
+
+    // 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();
+      file_path = FilePath();
+    } else {
+      file_path = absolute_path;
+    }
+  }
+  LaunchPlatformAppWithPath(profile, extension, file_path);
+}
+
+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) {
   if (web_intent_data.data_type == webkit_glue::WebIntentData::BLOB) {
     scoped_refptr<PlatformAppBlobIntentLauncher> launcher =
         new PlatformAppBlobIntentLauncher(profile, extension, web_intent_data);
     launcher->Launch();
     return;
   }
 
   extensions::AppEventRouter::DispatchOnLaunchedEventWithWebIntent(
       profile, extension, web_intent_data);
 }
 
 }  // namespace extensions