Make --install-chrome-app use extensions::WebstoreInstallWithPrompt.

chrome/browser/ui/startup/startup_browser_creator.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/ui/startup/startup_browser_creator.h"
 
 #include <algorithm>   // For max().
 #include <set>
 
 #include "apps/app_load_service.h"
@@ skipping 10 matching lines @@
 #include "base/memory/scoped_ptr.h"
 #include "base/metrics/histogram.h"
 #include "base/metrics/statistics_recorder.h"
 #include "base/path_service.h"
 #include "base/prefs/pref_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_restrictions.h"
 #include "chrome/browser/app_mode/app_mode_utils.h"
+#include "chrome/browser/apps/install_chrome_app.h"
 #include "chrome/browser/auto_launch_trial.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/chrome_notification_types.h"
 #include "chrome/browser/custom_handlers/protocol_handler_registry.h"
 #include "chrome/browser/extensions/startup_helper.h"
 #include "chrome/browser/extensions/unpacked_installer.h"
 #include "chrome/browser/first_run/first_run.h"
 #include "chrome/browser/notifications/desktop_notification_service.h"
 #include "chrome/browser/prefs/incognito_mode_prefs.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
@@ skipping 459 matching lines @@
   }
 
   if (command_line.HasSwitch(switches::kInstallFromWebstore)) {
     extensions::StartupHelper helper;
     helper.InstallFromWebstore(command_line, last_used_profile);
     // Nothing more needs to be done, so return false to stop launching and
     // quit.
     return false;
   }
 
+  std::vector<GURL> extra_urls_to_launch;

[tapted, 2014/07/25 03:49:12]

URLs are already added in StartupBrowserCreator::LaunchBrowser() - I don't think
they should be added here too. (StartupBrowserCreator::ProcessCmdLineImpl() is
already crazy huge - we should try not to add more logic, but something like

if (extensions::StartupHelper::HandleCommandLine(..))
  return false;

that does all of kInstallFromWebstore, kValidateCrx,
kLimitedInstallFromWebstore, and kInstallChromeApp might be a nice cleanup. But
that doesn't help with the URLs thing - see next comment)

[jackhou1, 2014/07/28 02:58:15]

I open up the webstore page because WebstoreStartupInstaller will cancel
installation if it's a paid app. In that case, we want to present the webstore
page which asks the user to sign in. We might change this, e.g. to only show the
webstore if the user did not have Chrome installed (this is a first run).

+  if (command_line.HasSwitch(switches::kInstallChromeApp)) {
+    extensions::StartupHelper helper;
+    helper.InstallChromeApp(command_line, last_used_profile);
+    extra_urls_to_launch.push_back(install_chrome_app::GetAppInstallUrl(
+        command_line.GetSwitchValueASCII(switches::kInstallChromeApp)));
+  }
+
   if (command_line.HasSwitch(switches::kValidateCrx)) {
     if (!process_startup) {
       LOG(ERROR) << "chrome is already running; you must close all running "
                  << "instances before running with the --"
                  << switches::kValidateCrx << " flag";
       return false;
     }
     extensions::StartupHelper helper;
     std::string message;
     std::string error;
@@ skipping 82 matching lines @@
     // background page of apps. Tracked at http://crbug.com/175381
     if (chrome::GetTotalBrowserCountForProfile(last_used_profile) != 0)
       return true;
   }
 
   chrome::startup::IsProcessStartup is_process_startup = process_startup ?
       chrome::startup::IS_PROCESS_STARTUP :
       chrome::startup::IS_NOT_PROCESS_STARTUP;
   chrome::startup::IsFirstRun is_first_run = first_run::IsChromeFirstRun() ?
       chrome::startup::IS_FIRST_RUN : chrome::startup::IS_NOT_FIRST_RUN;
+  CommandLine command_line_with_extra_urls(command_line);
+  for (std::vector<GURL>::const_iterator it = extra_urls_to_launch.begin();
+       it != extra_urls_to_launch.end();
+       ++it) {
+    if (it->is_valid())
+      command_line_with_extra_urls.AppendArg(it->spec());
+  }
   // |last_opened_profiles| will be empty in the following circumstances:
   // - This is the first launch. |last_used_profile| is the initial profile.
   // - The user exited the browser by closing all windows for all
   // profiles. |last_used_profile| is the profile which owned the last open
   // window.
   // - Only incognito windows were open when the browser exited.
   // |last_used_profile| is the last used incognito profile. Restoring it will
   // create a browser window for the corresponding original profile.
   if (last_opened_profiles.empty()) {
     // If the last used profile is locked or was a guest, show the user manager.
     if (switches::IsNewProfileManagement()) {
       ProfileInfoCache& profile_info =
           g_browser_process->profile_manager()->GetProfileInfoCache();
       size_t profile_index = profile_info.GetIndexOfProfileWithPath(
           last_used_profile->GetPath());
       bool signin_required = profile_index != std::string::npos &&
           profile_info.ProfileIsSigninRequiredAtIndex(profile_index);
       if (signin_required || last_used_profile->IsGuestSession()) {
         chrome::ShowUserManager(base::FilePath());
         return true;
       }
     }
-    if (!browser_creator->LaunchBrowser(command_line, last_used_profile,
+    if (!browser_creator->LaunchBrowser(command_line_with_extra_urls,
+                                        last_used_profile,
                                         cur_dir, is_process_startup,
                                         is_first_run, return_code)) {
       return false;
     }
   } else {
     // Launch the last used profile with the full command line, and the other
     // opened profiles without the URLs to launch.
     CommandLine command_line_without_urls(command_line.GetProgram());
     const CommandLine::SwitchMap& switches = command_line.GetSwitches();
     for (CommandLine::SwitchMap::const_iterator switch_it = switches.begin();
@@ skipping 13 matching lines @@
           startup_pref.type == SessionStartupPref::DEFAULT &&
           !HasPendingUncleanExit(*it))
         continue;
 
       // Don't re-open a browser window for the guest profile.
       if (switches::IsNewProfileManagement() &&
           (*it)->IsGuestSession())
         continue;
 
       if (!browser_creator->LaunchBrowser((*it == last_used_profile) ?
-          command_line : command_line_without_urls, *it, cur_dir,
-          is_process_startup, is_first_run, return_code))
+          command_line_with_extra_urls : command_line_without_urls, *it,
+          cur_dir, is_process_startup, is_first_run, return_code))
         return false;
       // We've launched at least one browser.
       is_process_startup = chrome::startup::IS_NOT_PROCESS_STARTUP;
     }
     // This must be done after all profiles have been launched so the observer
     // knows about all profiles to wait for before activating this one.
 
     // If the last used profile was the guest one, we didn't open it so
     // we don't need to activate it either.
     if (!switches::IsNewProfileManagement() &&
@@ skipping 55 matching lines @@
   }
 
   if (command_line.HasSwitch(switches::kProfileDirectory)) {
     return user_data_dir.Append(
         command_line.GetSwitchValuePath(switches::kProfileDirectory));
   }
 
   return g_browser_process->profile_manager()->GetLastUsedProfileDir(
       user_data_dir);
 }