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"
 #include "apps/switches.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/command_line.h"
 #include "base/compiler_specific.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/lazy_instance.h"
 #include "base/logging.h"
 #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/stringprintf.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/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"
@@ skipping 56 matching lines @@
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service.h"
 #include "chrome/browser/printing/cloud_print/cloud_print_proxy_service_factory.h"
 #include "chrome/browser/printing/print_dialog_cloud.h"
 #endif
 
 using content::BrowserThread;
 using content::ChildProcessSecurityPolicy;
 
 namespace {
 
+// The URL to the webstore page for a specific app.
+const char kWebstoreUrlFormat[] =

[tapted, 2014/07/24 07:52:50]

I don't think this constant belongs here..

[jackhou1, 2014/07/25 01:47:33]

Kept this part in install_chrome_app.

+    "https://chrome.google.com/webstore/detail/%s";
+
 // Keeps track on which profiles have been launched.
 class ProfileLaunchObserver : public content::NotificationObserver {
  public:
   ProfileLaunchObserver()
       : profile_to_activate_(NULL),
         activated_profile_(false) {
     registrar_.Add(this, chrome::NOTIFICATION_PROFILE_DESTROYED,
                    content::NotificationService::AllSources());
     registrar_.Add(this, chrome::NOTIFICATION_BROWSER_WINDOW_READY,
                    content::NotificationService::AllSources());
@@ skipping 124 matching lines @@
 // The file is overwritten if it exists. This function should only be called in
 // the blocking pool.
 void DumpBrowserHistograms(const base::FilePath& output_file) {
   base::ThreadRestrictions::AssertIOAllowed();
 
   std::string output_string(base::StatisticsRecorder::ToJSON(std::string()));
   base::WriteFile(output_file, output_string.data(),
                   static_cast<int>(output_string.size()));
 }
 
+GURL GetAppInstallUrl(const std::string& app_id) {
+  return GURL(base::StringPrintf(kWebstoreUrlFormat, app_id.c_str()));
+}
+
 }  // namespace
 
 StartupBrowserCreator::StartupBrowserCreator()
     : is_default_browser_dialog_suppressed_(false),
       show_main_browser_window_(true) {
 }
 
 StartupBrowserCreator::~StartupBrowserCreator() {}
 
 // static
@@ skipping 36 matching lines @@
   // Note: This check should have been done in ProcessCmdLineImpl()
   // before calling this function. However chromeos/login/login_utils.cc
   // calls this function directly (see comments there) so it has to be checked
   // again.
   const bool silent_launch = command_line.HasSwitch(switches::kSilentLaunch);
 
   if (!silent_launch) {
     StartupBrowserCreatorImpl lwp(cur_dir, command_line, this, is_first_run);
     const std::vector<GURL> urls_to_launch =
         GetURLsFromCommandLine(command_line, cur_dir, profile);
+
     chrome::HostDesktopType host_desktop_type =
         chrome::HOST_DESKTOP_TYPE_NATIVE;
 
 #if defined(USE_ASH) && !defined(OS_CHROMEOS)
     // We want to maintain only one type of instance for now, either ASH
     // or desktop.
     // TODO(shrikant): Remove this code once we decide on running both desktop
     // and ASH instances side by side.
     if (ash::Shell::HasInstance())
       host_desktop_type = chrome::HOST_DESKTOP_TYPE_ASH;
@@ skipping 186 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;
+  if (command_line.HasSwitch(switches::kInstallChromeApp)) {
+    extensions::StartupHelper helper;
+    helper.InstallChromeApp(command_line, last_used_profile);
+    extra_urls_to_launch.push_back(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);
 }