Enable EULA dialog to be shown from metro Chrome.

chrome/browser/first_run/first_run_win.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/first_run/first_run.h"
 
+#include <shellapi.h>
 #include <shlobj.h>
 #include <windows.h>
 
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/stringprintf.h"
 #include "base/utf_string_conversions.h"
+#include "base/win/metro.h"
 #include "base/win/object_watcher.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/extensions/updater/extension_updater.h"
 #include "chrome/browser/first_run/first_run_import_observer.h"
 #include "chrome/browser/first_run/first_run_internal.h"
 #include "chrome/browser/importer/importer_host.h"
 #include "chrome/browser/importer/importer_list.h"
 #include "chrome/browser/importer/importer_progress_dialog.h"
@@ skipping 17 matching lines @@
 #include "content/public/browser/notification_service.h"
 #include "content/public/browser/user_metrics.h"
 #include "google_update/google_update_idl.h"
 #include "grit/chromium_strings.h"
 #include "grit/generated_resources.h"
 #include "grit/locale_settings.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/base/layout.h"
 #include "ui/base/ui_base_switches.h"
+#include "ui/base/win/shell.h"
 
 namespace {
 
-const char kEULASentinelFile[] = "EULA Accepted";
-
 // Helper class that performs delayed first-run tasks that need more of the
 // chrome infrastructure to be up and running before they can be attempted.
 class FirstRunDelayedTasks : public content::NotificationObserver {
  public:
   enum Tasks {
     NO_TASK,
     INSTALL_EXTENSIONS
   };
 
   explicit FirstRunDelayedTasks(Tasks task) {
@@ skipping 67 matching lines @@
 }
 
 void PlatformSetup(Profile* profile) {
   CreateChromeDesktopShortcut();
 
   // Windows 7 has deprecated the quick launch bar.
   if (base::win::GetVersion() < base::win::VERSION_WIN7)
     CreateChromeQuickLaunchShortcut();
 }
 
-// Launches the setup exe with the given parameter/value on the command-line,
-// waits for its termination, returns its exit code in |*ret_code|, and
-// returns true if the exit code is valid.
-bool LaunchSetupWithParam(const std::string& param,
-                          const FilePath::StringType& value,
-                          int* ret_code) {
-  FilePath exe_path;
-  if (!PathService::Get(base::DIR_MODULE, &exe_path))
+// Launches the setup exe with the given parameter/value on the command-line.
+// For non-metro Windows, it waits for its termination, returns its exit code
+// in |*ret_code|, and returns true if the exit code is valid.
+// For metro Windows, it launches setup via ShellExecuteEx and returns in order
+// to bounce the user back to the desktop, then returns immediately.
+bool LaunchSetupForEula(const FilePath::StringType& value, int* ret_code) {
+  FilePath exe_dir;
+  if (!PathService::Get(base::DIR_MODULE, &exe_dir))
     return false;
-  exe_path = exe_path.Append(installer::kInstallerDir);
-  exe_path = exe_path.Append(installer::kSetupExe);
+  exe_dir = exe_dir.Append(installer::kInstallerDir);
+  FilePath exe_path = exe_dir.Append(installer::kSetupExe);
   base::ProcessHandle ph;
-  CommandLine cl(exe_path);
-  cl.AppendSwitchNative(param, value);
+
+  CommandLine cl(CommandLine::NO_PROGRAM);
+  cl.AppendSwitchNative(installer::switches::kShowEula, value);
 
   CommandLine* browser_command_line = CommandLine::ForCurrentProcess();
   if (browser_command_line->HasSwitch(switches::kChromeFrame)) {
     cl.AppendSwitch(switches::kChromeFrame);
   }
 
-  // TODO(evan): should this use options.wait = true?
-  if (!base::LaunchProcess(cl, base::LaunchOptions(), &ph))
+  if (base::win::IsMetroProcess()) {
+    cl.AppendSwitch(installer::switches::kShowEulaForMetro);
+
+    // This obscure use of the 'log usage' mask for windows 8 is documented
+    // here http://goo.gl/HBOe9. It causes the desktop process to receive

[grt (UTC plus 2), 2012/09/20 15:58:31]

please link to the current version of the MS doc rather than to some guy's
posting of an old one: http://go.microsoft.com/fwlink/?LinkID=243079

[robertshield, 2012/09/21 01:24:43]

Done.

+    // focus. Pass SEE_MASK_FLAG_NO_UI to avoid hangs if an error occurs since
+    // the UI can't be shown from a metro process.
+    ui::win::OpenAnyViaShell(exe_path.value(),
+                             exe_dir.value(),
+                             cl.GetCommandLineString(),
+                             SEE_MASK_FLAG_LOG_USAGE | SEE_MASK_FLAG_NO_UI);
     return false;
-  DWORD wr = ::WaitForSingleObject(ph, INFINITE);
-  if (wr != WAIT_OBJECT_0)
-    return false;
-  return (TRUE == ::GetExitCodeProcess(ph, reinterpret_cast<DWORD*>(ret_code)));
+  } else {
+    base::LaunchOptions launch_options;
+    launch_options.wait = true;
+    CommandLine setup_path(exe_path);
+    setup_path.AppendArguments(cl, false);
+
+    if (!base::LaunchProcess(setup_path, launch_options, &ph))
+      return false;
+    return (
+        TRUE == ::GetExitCodeProcess(ph, reinterpret_cast<DWORD*>(ret_code)));

[grt (UTC plus 2), 2012/09/20 15:58:31]

1. please COMPILE_ASSERT(sizeof(*ret_code) == sizeof(DWORD),
this_cast_is_unsafe_bang_bang_bang);
2. ::GetExitCodeProcess(...) isn't documented as returning TRUE/FALSE, but
rather zero/non-zero.  please change this to just return ::GetExitCodeProcess()
so that C++'s standard bool conversion does the right thing.

[robertshield, 2012/09/21 01:24:43]

Done.

+  }
 }
 
 // Populates |path| with the path to |file| in the sentinel directory. This is
 // the application directory for user-level installs, and the default user data
 // dir for system-level installs. Returns false on error.
 bool GetSentinelFilePath(const char* file, FilePath* path) {
   FilePath exe_path;
   if (!PathService::Get(base::DIR_EXE, &exe_path))
     return false;
   if (InstallUtil::IsPerUserInstall(exe_path.value().c_str()))
     *path = exe_path;
   else if (!PathService::Get(chrome::DIR_USER_DATA, path))
     return false;
 
   *path = path->AppendASCII(file);
   return true;
 }
 
 bool GetEULASentinelFilePath(FilePath* path) {
-  return GetSentinelFilePath(kEULASentinelFile, path);
+  return GetSentinelFilePath(installer::kEULASentinelFile, path);
 }
 
 // Returns true if the EULA is required but has not been accepted by this user.
 // The EULA is considered having been accepted if the user has gotten past
 // first run in the "other" environment (desktop or metro).
 bool IsEULANotAccepted(installer::MasterPreferences* install_prefs) {
   bool value = false;
   if (install_prefs->GetBool(installer::master_preferences::kRequireEula,
           &value) && value) {
     FilePath eula_sentinel;
@@ skipping 23 matching lines @@
 
 // Creates the sentinel indicating that the EULA was required and has been
 // accepted.
 bool CreateEULASentinel() {
   FilePath eula_sentinel;
   if (!GetEULASentinelFilePath(&eula_sentinel))
     return false;
   return file_util::WriteFile(eula_sentinel, "", 0) != -1;
 }
 
-void ShowPostInstallEULAIfNeeded(installer::MasterPreferences* install_prefs) {
+// Shows the EULA dialog if required. Returns true if the EULA is accepted,
+// returns false if the EULA has not been accepted, in which case the browser
+// should exit.
+bool ShowPostInstallEULAIfNeeded(installer::MasterPreferences* install_prefs) {
   if (IsEULANotAccepted(install_prefs)) {
     // Show the post-installation EULA. This is done by setup.exe and the
     // result determines if we continue or not. We wait here until the user
     // dismisses the dialog.
 
     // The actual eula text is in a resource in chrome. We extract it to
     // a text file so setup.exe can use it as an inner frame.
     FilePath inner_html;
     if (WriteEULAtoTempFile(&inner_html)) {
       int retcode = 0;
-      if (!LaunchSetupWithParam(installer::switches::kShowEula,
-                                inner_html.value(), &retcode) ||
+      if (!LaunchSetupForEula(inner_html.value(), &retcode) ||
           (retcode != installer::EULA_ACCEPTED &&
            retcode != installer::EULA_ACCEPTED_OPT_IN)) {
-        LOG(WARNING) << "EULA rejected. Fast exit.";
-        ::ExitProcess(1);
+        LOG(WARNING) << "EULA flow requires fast exit.";
+        return false;
       }
       CreateEULASentinel();
+
       if (retcode == installer::EULA_ACCEPTED) {
         VLOG(1) << "EULA : no collection";
         GoogleUpdateSettings::SetCollectStatsConsent(false);
       } else if (retcode == installer::EULA_ACCEPTED_OPT_IN) {
         VLOG(1) << "EULA : collection consent";
         GoogleUpdateSettings::SetCollectStatsConsent(true);
       }
     }
   }
+  return true;
 }
 
 // Installs a task to do an extensions update check once the extensions system
 // is running.
 void DoDelayedInstallExtensions() {
   new FirstRunDelayedTasks(FirstRunDelayedTasks::INSTALL_EXTENSIONS);
 }
 
 void DoDelayedInstallExtensionsIfNeeded(
     installer::MasterPreferences* install_prefs) {
@@ skipping 308 matching lines @@
 }
 
 FilePath MasterPrefsPath() {
   // The standard location of the master prefs is next to the chrome binary.
   FilePath master_prefs;
   if (!PathService::Get(base::DIR_EXE, &master_prefs))
     return FilePath();
   return master_prefs.AppendASCII(installer::kDefaultMasterPrefs);
 }
 
-bool ProcessMasterPreferences(const FilePath& user_data_dir,
-                              MasterPrefs* out_prefs) {
+ProcessMasterPreferencesResult ProcessMasterPreferences(
+    const FilePath& user_data_dir,
+    MasterPrefs* out_prefs) {
   DCHECK(!user_data_dir.empty());
 
   FilePath master_prefs_path;
   scoped_ptr<installer::MasterPreferences>
       install_prefs(internal::LoadMasterPrefs(&master_prefs_path));
   if (!install_prefs.get())
-    return true;
+    return SHOW_FIRST_RUN;
 
   out_prefs->new_tabs = install_prefs->GetFirstRunTabs();
 
   internal::SetRLZPref(out_prefs, install_prefs.get());
-  ShowPostInstallEULAIfNeeded(install_prefs.get());
+
+  if (!ShowPostInstallEULAIfNeeded(install_prefs.get()))
+    return EULA_EXIT_NOW;
 
   if (!internal::CopyPrefFile(user_data_dir, master_prefs_path))
-    return true;
+    return SHOW_FIRST_RUN;
 
   DoDelayedInstallExtensionsIfNeeded(install_prefs.get());
 
   internal::SetupMasterPrefsFromInstallPrefs(out_prefs,
       install_prefs.get());
 
   // TODO(mirandac): Refactor skip-first-run-ui process into regular first run
   // import process.  http://crbug.com/49647
   // Note we are skipping all other master preferences if skip-first-run-ui
   // is *not* specified. (That is, we continue only if skipping first run ui.)
   if (!internal::SkipFirstRunUI(install_prefs.get()))
-    return true;
+    return SHOW_FIRST_RUN;
 
   // We need to be able to create the first run sentinel or else we cannot
   // proceed because ImportSettings will launch the importer process which
   // would end up here if the sentinel is not present.
   if (!CreateSentinel())
-    return false;
+    return SKIP_FIRST_RUN;
 
   internal::SetShowWelcomePagePrefIfNeeded(install_prefs.get());
   internal::SetImportPreferencesAndLaunchImport(out_prefs, install_prefs.get());
   internal::SetDefaultBrowser(install_prefs.get());
 
-  return false;
+  return SKIP_FIRST_RUN;
 }
 
 }  // namespace first_run