Deliver attach intent to packaged apps

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 207 matching lines @@
   // 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_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAppCommandLineLauncher);
 };
 
-// Class to handle launching of platform apps with WebIntent data that is being
-// passed in a a blob.
+// 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 PlatformAppBlobIntentLauncher
-    : public base::RefCountedThreadSafe<PlatformAppBlobIntentLauncher> {
+class PlatformAppWebIntentLauncher
+    : public base::RefCountedThreadSafe<PlatformAppWebIntentLauncher> {
  public:
-  PlatformAppBlobIntentLauncher(Profile* profile,
-                                const Extension* extension,
-                                const webkit_glue::WebIntentData& data)
+  PlatformAppWebIntentLauncher(Profile* profile,
+                               const Extension* extension,
+                               const webkit_glue::WebIntentData& data)
       : profile_(profile),
         extension_(extension),
         data_(data) {}
 
   void Launch() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
+    if (data_.data_type != webkit_glue::WebIntentData::BLOB &&
+        data_.data_type != webkit_glue::WebIntentData::FILESYSTEM) {
+      InternalLaunch();
+      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.
+    // Access needs to be granted to the file or filesystem 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
+    // he 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(
-              &PlatformAppBlobIntentLauncher::GrantAccessToFileAndLaunch,
+              &PlatformAppWebIntentLauncher::GrantAccessToFileAndLaunch,
               this));
       return;
     }
-
     ExtensionProcessManager* process_manager =
         ExtensionSystem::Get(profile_)->process_manager();
     extensions::ExtensionHost* host =
         process_manager->GetBackgroundHostForExtension(extension_->id());
     DCHECK(host);
     GrantAccessToFileAndLaunch(host);
   }
 
  private:
-  friend class base::RefCountedThreadSafe<PlatformAppBlobIntentLauncher>;
+  friend class base::RefCountedThreadSafe<PlatformAppWebIntentLauncher>;
 
-  virtual ~PlatformAppBlobIntentLauncher() {}
+  virtual ~PlatformAppWebIntentLauncher() {}
 
   void GrantAccessToFileAndLaunch(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, data_.blob_file))
-      policy->GrantReadFile(renderer_id, data_.blob_file);
+    if (data_.data_type == webkit_glue::WebIntentData::BLOB) {
+      // 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, data_.blob_file))
+        policy->GrantReadFile(renderer_id, data_.blob_file);
+    } else if (data_.data_type == webkit_glue::WebIntentData::FILESYSTEM) {
+      // Grant read filesystem and read directory permission to allow reading
+      // any part of the specified filesystem.
+      FilePath path;
+      const bool valid =
+          fileapi::IsolatedContext::GetInstance()->GetRegisteredPath(
+              data_.filesystem_id, &path);
+      DCHECK(valid);
+      if (!policy->CanReadFile(renderer_id, path))
+        policy->GrantReadFile(renderer_id, path);
+      policy->GrantReadFileSystem(renderer_id, data_.filesystem_id);
+    } else {
+      NOTREACHED();
+    }
+    InternalLaunch();
+  }
 
+  void InternalLaunch() {
     extensions::AppEventRouter::DispatchOnLaunchedEventWithWebIntent(
         profile_, extension_, data_);
   }
 
   // The profile the app should be run in.
   Profile* profile_;
   // The extension providing the app.
   const Extension* extension_;
   // The WebIntent data to be passed through to the app.
   const webkit_glue::WebIntentData data_;
 
-  DISALLOW_COPY_AND_ASSIGN(PlatformAppBlobIntentLauncher);
+  DISALLOW_COPY_AND_ASSIGN(PlatformAppWebIntentLauncher);
 };
 
 }  // namespace
 
 void LaunchPlatformApp(Profile* profile,
                        const Extension* extension,
                        const CommandLine* command_line,
                        const FilePath& current_directory) {
   // 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);
   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);
+  scoped_refptr<PlatformAppWebIntentLauncher> launcher =
+      new PlatformAppWebIntentLauncher(profile, extension, web_intent_data);
+  launcher->Launch();
 }
 
 }  // namespace extensions