Allow platform apps to respond to 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/app_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/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 "content/public/browser/web_intents_dispatcher.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;
 using extensions::Extension;
 using extensions::ExtensionSystem;
@@ skipping 193 matching lines @@
 // 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> {
  public:
   PlatformAppBlobIntentLauncher(Profile* profile,
-                                const Extension* extension,
-                                const webkit_glue::WebIntentData& data)
+      const Extension* extension,
+      content::WebIntentsDispatcher* intents_dispatcher)
       : profile_(profile),
         extension_(extension),
-        data_(data) {}
+        intents_dispatcher_(intents_dispatcher) {}
 
   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 =
@@ skipping 26 matching lines @@
     }
 
     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);
+    webkit_glue::WebIntentData data = intents_dispatcher_->GetIntent();
+    if (!policy->CanReadFile(renderer_id, data.blob_file))
+      policy->GrantReadFile(renderer_id, data.blob_file);
 
     extensions::AppEventRouter::DispatchOnLaunchedEventWithWebIntent(
-        profile_, extension_, data_);
+        profile_, extension_, intents_dispatcher_);
   }
 
   // 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_;
+  // The dispatcher so that platform apps can respond to this intent.
+  content::WebIntentsDispatcher* intents_dispatcher_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAppBlobIntentLauncher);
 };
 
 }  // namespace
 
 namespace extensions {
 
 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) {
+    content::WebIntentsDispatcher* intents_dispatcher) {
+  webkit_glue::WebIntentData web_intent_data = intents_dispatcher->GetIntent();
   if (web_intent_data.data_type == webkit_glue::WebIntentData::BLOB) {
     scoped_refptr<PlatformAppBlobIntentLauncher> launcher =
-        new PlatformAppBlobIntentLauncher(profile, extension, web_intent_data);
+        new PlatformAppBlobIntentLauncher(profile, extension,
+                                          intents_dispatcher);
     launcher->Launch();
     return;
   }
 
   extensions::AppEventRouter::DispatchOnLaunchedEventWithWebIntent(
-      profile, extension, web_intent_data);
+      profile, extension, intents_dispatcher);
 }
 
 }  // namespace extensions