Add ARC++ specific fields to launch data for specific apps.

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>
 
 #include "base/command_line.h"
 #include "base/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/logging.h"
+#include "base/memory/ptr_util.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "chrome/browser/extensions/api/file_handlers/app_file_handler_util.h"
 #include "chrome/browser/extensions/api/file_handlers/directory_util.h"
 #include "chrome/browser/extensions/api/file_handlers/mime_util.h"
 #include "chrome/browser/extensions/api/file_system/file_system_api.h"
 #include "chrome/browser/profiles/profile.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/browser/render_process_host.h"
@@ skipping 16 matching lines @@
 #include "url/gurl.h"
 
 #if defined(OS_CHROMEOS)
 #include "components/user_manager/user_manager.h"
 #endif
 
 namespace app_runtime = extensions::api::app_runtime;
 
 using content::BrowserThread;
 using extensions::AppRuntimeEventRouter;
+using extensions::api::app_runtime::PlayStoreStatus;
 using extensions::app_file_handler_util::CreateFileEntry;
 using extensions::app_file_handler_util::FileHandlerCanHandleEntry;
 using extensions::app_file_handler_util::FileHandlerForId;
 using extensions::app_file_handler_util::FirstFileHandlerForEntry;
 using extensions::app_file_handler_util::HasFileSystemWritePermission;
 using extensions::app_file_handler_util::PrepareFilesForWritableApp;
 using extensions::EventRouter;
 using extensions::Extension;
 using extensions::ExtensionHost;
 using extensions::GrantedFileEntry;
@@ skipping 135 matching lines @@
   }
 
   void LaunchWithNoLaunchData() {
     // This method is required as an entry point on the UI thread.
     DCHECK_CURRENTLY_ON(BrowserThread::UI);
 
     const Extension* app = GetExtension();
     if (!app)
       return;
 
+    std::unique_ptr<app_runtime::LaunchData> launch_data =
+        base::MakeUnique<app_runtime::LaunchData>();
+    launch_data->action_data = std::move(action_data_);
+
     AppRuntimeEventRouter::DispatchOnLaunchedEvent(
-        profile_, app, launch_source_, std::move(action_data_));
+        profile_, app, launch_source_, std::move(launch_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 127 matching lines @@
   extensions::app_file_handler_util::MimeTypeCollector mime_type_collector_;
   extensions::app_file_handler_util::IsDirectoryCollector
       is_directory_collector_;
 
   DISALLOW_COPY_AND_ASSIGN(PlatformAppPathLauncher);
 };
 
 }  // namespace
 
 void LaunchPlatformAppWithCommandLine(Profile* profile,
-                                      const Extension* app,
+                                      const extensions::Extension* app,
                                       const base::CommandLine& command_line,
                                       const base::FilePath& current_directory,
-                                      extensions::AppLaunchSource source) {
+                                      extensions::AppLaunchSource source,
+                                      PlayStoreStatus play_store_status) {
   // An app with "kiosk_only" should not be installed and launched
   // outside of ChromeOS kiosk mode in the first place. This is a defensive
   // check in case this scenario does occur.
   if (extensions::KioskModeInfo::IsKioskOnly(app)) {
     bool in_kiosk_mode = false;
 #if defined(OS_CHROMEOS)
     user_manager::UserManager* user_manager = user_manager::UserManager::Get();
     in_kiosk_mode = user_manager && user_manager->IsLoggedInAsKioskApp();
 #endif
     if (!in_kiosk_mode) {
@@ skipping 10 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, app, source, std::unique_ptr<app_runtime::ActionData>());
+    std::unique_ptr<app_runtime::LaunchData> launch_data =
+        base::MakeUnique<app_runtime::LaunchData>();
+    if (play_store_status != PlayStoreStatus::PLAY_STORE_STATUS_UNKNOWN)
+      launch_data->play_store_status = play_store_status;
+    AppRuntimeEventRouter::DispatchOnLaunchedEvent(profile, app, source,
+                                                   std::move(launch_data));
     return;
   }
 
   base::FilePath file_path(command_line.GetArgs()[0]);
   scoped_refptr<PlatformAppPathLauncher> launcher =
       new PlatformAppPathLauncher(profile, app, file_path);
   launcher->LaunchWithRelativePath(current_directory);
 }
 
 void LaunchPlatformAppWithPath(Profile* profile,
@@ skipping 47 matching lines @@
   extensions::ExtensionPrefs* extension_prefs =
       extensions::ExtensionPrefs::Get(profile);
   bool had_windows = extension_prefs->IsActive(app->id());
   extension_prefs->SetIsActive(app->id(), false);
   bool listening_to_launch = event_router->ExtensionHasEventListener(
       app->id(), app_runtime::OnLaunched::kEventName);
 
   if (listening_to_launch && had_windows) {
     AppRuntimeEventRouter::DispatchOnLaunchedEvent(
         profile, app, extensions::SOURCE_RESTART,
-        std::unique_ptr<app_runtime::ActionData>());
+        std::unique_ptr<app_runtime::LaunchData>());
   }
 }
 
 void LaunchPlatformAppWithUrl(Profile* profile,
                               const Extension* app,
                               const std::string& handler_id,
                               const GURL& url,
                               const GURL& referrer_url) {
   AppRuntimeEventRouter::DispatchOnLaunchedEventWithUrl(
       profile, app, handler_id, url, referrer_url);
 }
 
 }  // namespace apps