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 213 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAppCommandLineLauncher);
 };
 
 // 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> {
+class PlatformAppGrantIntentLauncher
+    : public base::RefCountedThreadSafe<PlatformAppGrantIntentLauncher> {
  public:
-  PlatformAppBlobIntentLauncher(Profile* profile,
-                                const Extension* extension,
-                                const webkit_glue::WebIntentData& data)
+  PlatformAppGrantIntentLauncher(Profile* profile,
+                                 const Extension* extension,
+                                 const webkit_glue::WebIntentData& data)
       : profile_(profile),
         extension_(extension),
         data_(data) {}
 
   void Launch() {
     DCHECK(BrowserThread::CurrentlyOn(BrowserThread::UI));
 
     // 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(
-              &PlatformAppBlobIntentLauncher::GrantAccessToFileAndLaunch,
+              &PlatformAppGrantIntentLauncher::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<PlatformAppGrantIntentLauncher>;
 
-  virtual ~PlatformAppBlobIntentLauncher() {}
+  virtual ~PlatformAppGrantIntentLauncher() {}
 
   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.
+      policy->GrantReadFileSystem(renderer_id, data_.filesystem_id);
+// TODO(thorogood): We may need to revisit this.
+//      if (!policy->CanReadDirectory(renderer_id, data_.root_path))
+//        policy->GrantReadDirectory(renderer_id, data_.root_path);
+    } else {
+      NOTREACHED();
+    }
 
     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(PlatformAppGrantIntentLauncher);
 };
 
 }  // 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);
+  if (web_intent_data.data_type == webkit_glue::WebIntentData::BLOB ||
+      web_intent_data.data_type == webkit_glue::WebIntentData::FILESYSTEM) {
+    scoped_refptr<PlatformAppGrantIntentLauncher> launcher =
+        new PlatformAppGrantIntentLauncher(profile, extension, web_intent_data);
     launcher->Launch();
     return;
   }
 
   extensions::AppEventRouter::DispatchOnLaunchedEventWithWebIntent(
       profile, extension, web_intent_data);
 }
 
 }  // namespace extensions