Enable EULA dialog to be shown from metro Chrome.

chrome/installer/setup/setup_main.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 <windows.h>
 #include <msi.h>
 #include <shellapi.h>
 #include <shlobj.h>
 
 #include "base/at_exit.h"
 #include "base/basictypes.h"
 #include "base/command_line.h"
 #include "base/file_util.h"
 #include "base/file_version_info.h"
 #include "base/path_service.h"
 #include "base/process_util.h"
 #include "base/scoped_temp_dir.h"
 #include "base/string16.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/win/registry.h"
+#include "base/win/scoped_comptr.h"
 #include "base/win/scoped_handle.h"
 #include "base/win/win_util.h"
 #include "base/win/windows_version.h"
 #include "breakpad/src/client/windows/handler/exception_handler.h"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/setup/chrome_frame_quick_enable.h"
 #include "chrome/installer/setup/chrome_frame_ready_mode.h"
 #include "chrome/installer/setup/install.h"
 #include "chrome/installer/setup/install_worker.h"
 #include "chrome/installer/setup/setup_constants.h"
@@ skipping 990 matching lines @@
     return installer::EULA_REJECTED;
   }
   if (installer::EulaHTMLDialog::ACCEPTED_OPT_IN == outcome) {
     VLOG(1) << "EULA accepted (opt-in)";
     return installer::EULA_ACCEPTED_OPT_IN;
   }
   VLOG(1) << "EULA accepted (no opt-in)";
   return installer::EULA_ACCEPTED;
 }
 
+// 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,
+                         BrowserDistribution* dist,
+                         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 {
+    std::vector<FilePath> user_data_dir_paths;
+    installer::GetChromeUserDataPaths(dist, &user_data_dir_paths);
+
+    if (!user_data_dir_paths.empty())
+      *path = user_data_dir_paths[0];
+    else
+      return false;
+  }
+
+  *path = path->AppendASCII(file);
+  return true;
+}
+
+// Creates the sentinel indicating that the EULA was required and has been
+// accepted.
+bool CreateEULASentinel(BrowserDistribution* dist) {
+  FilePath eula_sentinel;
+  if (!GetSentinelFilePath(installer::kEULASentinelFile, dist, &eula_sentinel))
+    return false;
+  return file_util::WriteFile(eula_sentinel, "", 0) != -1;
+}
+
+void ActivateMetroChrome() {
+  // Check to see if we're per-user or not. Need to do this since we may
+  // not have been invoked with --system-level even for a machine install.
+  wchar_t exe_path[MAX_PATH * 2] = {};
+  GetModuleFileName(NULL, exe_path, arraysize(exe_path));
+  bool is_per_user_install = InstallUtil::IsPerUserInstall(exe_path);
+
+  string16 app_model_id =
+      ShellUtil::GetBrowserModelId(BrowserDistribution::GetDistribution(),
+                                   is_per_user_install);
+
+  base::win::ScopedComPtr<IApplicationActivationManager> activator;
+  HRESULT hr = activator.CreateInstance(CLSID_ApplicationActivationManager);
+  if (SUCCEEDED(hr)) {
+    DWORD pid = 0;
+    hr = activator->ActivateApplication(
+        app_model_id.c_str(), L"open", AO_NONE, &pid);
+  }
+
+  LOG_IF(ERROR, FAILED(hr)) << "Tried and failed to launch Metro Chrome. "
+                            << "hr=" << hr;

[grt (UTC plus 2), 2012/09/21 01:35:42]

nit: << std::hex << hr so that the log message is more easily mapped to an
HRESULT in the headers (which, iirc, are ordinarily represented in hex).

[robertshield, 2012/09/21 13:12:59]

Done.

+}
+
 // This method processes any command line options that make setup.exe do
 // various tasks other than installation (renaming chrome.exe, showing eula
 // among others). This function returns true if any such command line option
 // has been found and processed (so setup.exe should exit at that point).
 bool HandleNonInstallCmdLineOptions(const InstallationState& original_state,
                                     const CommandLine& cmd_line,
                                     InstallerState* installer_state,
                                     int* exit_code) {
   bool handled = true;
   // TODO(tommi): Split these checks up into functions and use a data driven
@@ skipping 39 matching lines @@
           status, IDS_SETUP_PATCH_FAILED_BASE, NULL);
     }
     // We will be exiting normally, so clear the stage indicator.
     installer_state->UpdateStage(installer::NO_STAGE);
   } else if (cmd_line.HasSwitch(installer::switches::kShowEula)) {
     // Check if we need to show the EULA. If it is passed as a command line
     // then the dialog is shown and regardless of the outcome setup exits here.
     string16 inner_frame =
         cmd_line.GetSwitchValueNative(installer::switches::kShowEula);
     *exit_code = ShowEULADialog(inner_frame);
+
     if (installer::EULA_REJECTED != *exit_code) {
-      GoogleUpdateSettings::SetEULAConsent(
-          original_state, BrowserDistribution::GetDistribution(), true);
+      if (GoogleUpdateSettings::SetEULAConsent(
+              original_state, BrowserDistribution::GetDistribution(), true)) {
+        CreateEULASentinel(BrowserDistribution::GetDistribution());
+      }
+      // For a metro-originated launch, we now need to launch back into metro.
+      if (cmd_line.HasSwitch(installer::switches::kShowEulaForMetro))
+        ActivateMetroChrome();
     }
   } else if (cmd_line.HasSwitch(
       installer::switches::kConfigureUserSettings)) {
     DCHECK(installer_state->system_install());
     const Product* chrome_install =
         installer_state->FindProduct(BrowserDistribution::CHROME_BROWSER);
     DCHECK(chrome_install);
     // TODO(gab): Implement the new shortcut functionality here.
     LOG(ERROR) << "--configure-user-settings is not implemented.";
   } else if (cmd_line.HasSwitch(
@@ skipping 413 matching lines @@
   if (!(installer_state.is_msi() && is_uninstall))
     // Note that we allow the status installer::UNINSTALL_REQUIRES_REBOOT
     // to pass through, since this is only returned on uninstall which is
     // never invoked directly by Google Update.
     return_code = InstallUtil::GetInstallReturnCode(install_status);
 
   VLOG(1) << "Installation complete, returning: " << return_code;
 
   return return_code;
 }