Implement app launch changes for app runtime extension proposal.

apps/launcher.cc

 // Copyright 2013 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 "apps/launcher.h"
 
 #include <memory>
 #include <set>
 #include <utility>
 
@@ skipping 96 matching lines @@
                           const Extension* extension,
                           const base::FilePath& file_path)
       : profile_(profile),
         extension_id(extension->id()),
         mime_type_collector_(profile),
         is_directory_collector_(profile) {
     if (!file_path.empty())
       entry_paths_.push_back(file_path);
   }
 
+  void set_action_data(const extensions::ActionData& action_data) {
+    action_data_ = action_data;
+  }
+
+  void set_launch_source(extensions::AppLaunchSource launch_source) {
+    launch_source_ = launch_source;
+  }
+
   void Launch() {
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     const Extension* extension = GetExtension();
     if (!extension)
       return;
 
     if (entry_paths_.empty()) {
       LaunchWithNoLaunchData();
       return;
@@ skipping 62 matching lines @@
 
   void LaunchWithNoLaunchData() {
     // This method is required as an entry point on the UI thread.
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     const Extension* extension = GetExtension();
     if (!extension)
       return;
 
     AppRuntimeEventRouter::DispatchOnLaunchedEvent(
-        profile_, extension, extensions::SOURCE_FILE_HANDLER);
+        profile_, extension, launch_source_, action_data_);
   }
 
   void OnAreDirectoriesCollected(
       bool has_file_system_write_permission,
       std::unique_ptr<std::set<base::FilePath>> directory_paths) {
     if (has_file_system_write_permission) {
       std::set<base::FilePath>* const directory_paths_ptr =
           directory_paths.get();
       PrepareFilesForWritableApp(
           entry_paths_, profile_, *directory_paths_ptr,
@@ skipping 93 matching lines @@
     }
 
     std::vector<GrantedFileEntry> granted_entries;
     for (size_t i = 0; i < entry_paths_.size(); ++i) {
       granted_entries.push_back(CreateFileEntry(
           profile_, extension, host->render_process_host()->GetID(),
           entries_[i].path, entries_[i].is_directory));
     }
 
     AppRuntimeEventRouter::DispatchOnLaunchedEventWithFileEntries(
-        profile_, extension, handler_id_, entries_, granted_entries);
+        profile_, extension, launch_source_, handler_id_, entries_,
+        granted_entries, action_data_);
   }
 
   const Extension* GetExtension() const {
     return extensions::ExtensionRegistry::Get(profile_)->GetExtensionById(
         extension_id, extensions::ExtensionRegistry::EVERYTHING);
   }
 
   // The profile the app should be run in.
   Profile* profile_;
   // The id of the extension providing the app. A pointer to the extension is
   // not kept as the extension may be unloaded and deleted during the course of
   // the launch.
   const std::string extension_id;
+  extensions::AppLaunchSource launch_source_ = extensions::SOURCE_FILE_HANDLER;
+  base::Optional<extensions::ActionData> action_data_;

[Devlin, 2016/08/11 20:51:20]

Why an optional instead of a unique_ptr here?

[jdufault, 2016/08/12 18:56:54]

It conveyed intent more clearly. With the removal of the wrapper type, I've
moved to unique_ptr because of the DISALLOW_COPY_AND_ASSIGN.

   // A list of files and directories to be passed through to the app.
   std::vector<base::FilePath> entry_paths_;
   // A corresponding list with EntryInfo for every base::FilePath in
   // entry_paths_.
   std::vector<extensions::EntryInfo> entries_;
   // The ID of the file handler used to launch the app.
   std::string handler_id_;
   extensions::app_file_handler_util::MimeTypeCollector mime_type_collector_;
   extensions::app_file_handler_util::IsDirectoryCollector
       is_directory_collector_;
@@ skipping 31 matching lines @@
 #else
   base::CommandLine::StringType about_blank_url(url::kAboutBlankURL);
 #endif
   base::CommandLine::StringVector args = command_line.GetArgs();
   // Browser tests will add about:blank to the command line. This should
   // never be interpreted as a file to open, as doing so with an app that
   // has write access will result in a file 'about' being created, which
   // causes problems on the bots.
   if (args.empty() || (command_line.HasSwitch(switches::kTestType) &&
                        args[0] == about_blank_url)) {
-    AppRuntimeEventRouter::DispatchOnLaunchedEvent(profile, extension, source);
+    AppRuntimeEventRouter::DispatchOnLaunchedEvent(
+        profile, extension, source, base::Optional<extensions::ActionData>());
     return;
   }
 
   base::FilePath file_path(command_line.GetArgs()[0]);
   scoped_refptr<PlatformAppPathLauncher> launcher =
       new PlatformAppPathLauncher(profile, extension, file_path);
   launcher->LaunchWithRelativePath(current_directory);
 }
 
 void LaunchPlatformAppWithPath(Profile* profile,
                                const Extension* extension,
                                const base::FilePath& file_path) {
   scoped_refptr<PlatformAppPathLauncher> launcher =
       new PlatformAppPathLauncher(profile, extension, file_path);
   launcher->Launch();
 }
 
+void LaunchPlatformAppWithAction(Profile* profile,
+                                 const extensions::Extension* extension,
+                                 const extensions::ActionData& action_data,
+                                 const base::FilePath& file_path) {
+  scoped_refptr<PlatformAppPathLauncher> launcher =
+      new PlatformAppPathLauncher(profile, extension, file_path);
+  launcher->set_action_data(action_data);
+  launcher->set_launch_source(extensions::AppLaunchSource::SOURCE_UNTRACKED);
+  launcher->Launch();
+}
+
 void LaunchPlatformApp(Profile* profile,
                        const Extension* extension,
                        extensions::AppLaunchSource source) {
   LaunchPlatformAppWithCommandLine(
       profile,
       extension,
       base::CommandLine(base::CommandLine::NO_PROGRAM),
       base::FilePath(),
       source);
 }
@@ skipping 22 matching lines @@
   extensions::ExtensionPrefs* extension_prefs =
       extensions::ExtensionPrefs::Get(profile);
   bool had_windows = extension_prefs->IsActive(extension->id());
   extension_prefs->SetIsActive(extension->id(), false);
   bool listening_to_launch = event_router->
       ExtensionHasEventListener(extension->id(),
                                 app_runtime::OnLaunched::kEventName);
 
   if (listening_to_launch && had_windows) {
     AppRuntimeEventRouter::DispatchOnLaunchedEvent(
-        profile, extension, extensions::SOURCE_RESTART);
+        profile, extension, extensions::SOURCE_RESTART,
+        base::Optional<extensions::ActionData>());
   }
 }
 
 void LaunchPlatformAppWithUrl(Profile* profile,
                               const Extension* extension,
                               const std::string& handler_id,
                               const GURL& url,
                               const GURL& referrer_url) {
   AppRuntimeEventRouter::DispatchOnLaunchedEventWithUrl(
       profile, extension, handler_id, url, referrer_url);
 }
 
 }  // namespace apps