Wire the eula and the dialog display code...

chrome/installer/setup/main.cc

 // Copyright (c) 2006-2008 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 <string>
 #include <windows.h>
 #include <msi.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/path_service.h"
 #include "base/registry.h"
 #include "base/string_util.h"
 #include "base/win_util.h"
 #include "chrome/installer/setup/setup.h"
 #include "chrome/installer/setup/setup_constants.h"
 #include "chrome/installer/setup/uninstall.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/delete_tree_work_item.h"
 #include "chrome/installer/util/helper.h"
 #include "chrome/installer/util/html_dialog.h"
 #include "chrome/installer/util/install_util.h"
+#include "chrome/installer/util/l10n_string_util.h"
 #include "chrome/installer/util/logging_installer.h"
 #include "chrome/installer/util/lzma_util.h"
 #include "chrome/installer/util/google_update_constants.h"
 #include "chrome/installer/util/master_preferences.h"
 #include "chrome/installer/util/shell_util.h"
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item.h"
 #include "third_party/bspatch/mbspatch.h"
 
 #include "installer_util_strings.h"
@@ skipping 183 matching lines @@
 
   if (cmd_line.HasSwitch(installer_util::switches::kInstallerData)) {
     std::wstring prefs_path = cmd_line.GetSwitchValue(
         installer_util::switches::kInstallerData);
     preferences = installer_util::ParseDistributionPreferences(prefs_path);
     if ((preferences & installer_util::MASTER_PROFILE_NOT_FOUND) == 0) {
       options |= installer_util::MASTER_PROFILE_PRESENT;
       if ((preferences & installer_util::MASTER_PROFILE_ERROR) == 0)
         options |= installer_util::MASTER_PROFILE_VALID;
     }
+    // While there is a --show-eula command line flag, we don't process
+    // it in this function because it requires special handling.
+    if (preferences & installer_util::MASTER_PROFILE_REQUIRE_EULA)
+      options |= installer_util::MASTER_PROFILE_REQUIRE_EULA;

[huanr, 2009/01/27 06:19:16]

There are two sets of constants, MasterPrefResult defined in master_preference.h
used for preferences, and InstallOption defined in util_constants.h used for
options. It is better to add an installer_util::REQUIRE_EULA in util_cosntants.h
and change the code to:

if (preferences & installer_util::MASTER_PROFILE_REQUIRE_EULA)
  options |= installer_util::REQUIRE_EULA;

This way we don't have potential risk of collision if a new setting is added.

   }
 
   if (preferences & installer_util::MASTER_PROFILE_CREATE_ALL_SHORTCUTS ||
       cmd_line.HasSwitch(installer_util::switches::kCreateAllShortcuts))
     options |= installer_util::CREATE_ALL_SHORTCUTS;
 
   if (preferences & installer_util::MASTER_PROFILE_DO_NOT_LAUNCH_CHROME ||
       cmd_line.HasSwitch(installer_util::switches::kDoNotLaunchChrome))
     options |= installer_util::DO_NOT_LAUNCH_CHROME;
 
   if (preferences & installer_util::MASTER_PROFILE_MAKE_CHROME_DEFAULT ||
       cmd_line.HasSwitch(installer_util::switches::kMakeChromeDefault))
     options |= installer_util::MAKE_CHROME_DEFAULT;
 
   if (preferences & installer_util::MASTER_PROFILE_SYSTEM_LEVEL ||
       cmd_line.HasSwitch(installer_util::switches::kSystemLevel))
     options |= installer_util::SYSTEM_LEVEL;
 
   if (preferences & installer_util::MASTER_PROFILE_VERBOSE_LOGGING ||
       cmd_line.HasSwitch(installer_util::switches::kVerboseLogging))
     options |= installer_util::VERBOSE_LOGGING;
-
+  
   return options;
 }
 
 // Copy master preference file if provided to installer to the same path
 // of chrome.exe so Chrome first run can find it.
 // This function will be called only when Chrome is launched the first time.
 void CopyPreferenceFileForFirstRun(int options, const CommandLine& cmd_line) {
   if (options & installer_util::MASTER_PROFILE_VALID) {
     std::wstring prefs_source_path = cmd_line.GetSwitchValue(
         installer_util::switches::kInstallerData);
@@ skipping 171 matching lines @@
     return installer_util::CHROME_NOT_INSTALLED;
   }
 
   bool remove_all = !cmd_line.HasSwitch(
       installer_util::switches::kDoNotRemoveSharedItems);
   bool force = cmd_line.HasSwitch(installer_util::switches::kForceUninstall);
   return installer_setup::UninstallChrome(cmd_line.program(), system_install,
                                           *version, remove_all, force);
 }
 
-// This function is temporary and meant to live while we get our eula dialogs
-// looking sharp. If the cmd line has --eula-test=path then the eula dialog
-// will be shown and no matter what the selection is the installer will exit.
-bool HandleEULADialog(const CommandLine& cmdline) {
-  std:: wstring eula_path(cmdline.GetSwitchValue(L"eula-test"));
-  if (eula_path.empty())
-    return true;
+bool ShowEULADialog() {
+  LOG(INFO) << "About to show EULA";
+  std::wstring eula_path = installer_util::GetLocalizedEulaResource();
+  if (eula_path.empty()) {
+    LOG(ERROR) << "No EULA path available";
+    return false;
+  }
   installer::EulaHTMLDialog dlg(eula_path);
-  dlg.ShowModal();
-  return false;
+  if (!dlg.ShowModal()) {
+    LOG(ERROR) << "EULA rejected or EULA failure";
+    return false;
+  }
+  return true;
 }
 
 }  // namespace
 
 int WINAPI wWinMain(HINSTANCE instance, HINSTANCE prev_instance,
                     wchar_t* command_line, int show_command) {
   // The exit manager is in charge of calling the dtors of singletons.
   base::AtExitManager exit_manager;
   CommandLine::Init(0, NULL);
   const CommandLine& parsed_command_line = *CommandLine::ForCurrentProcess();
   installer::InitInstallerLogging(parsed_command_line);
   int options = GetInstallOptions(parsed_command_line);
   if (options & installer_util::VERBOSE_LOGGING)
     logging::SetMinLogLevel(logging::LOG_INFO);
 
   bool system_install = (options & installer_util::SYSTEM_LEVEL) != 0;
   LOG(INFO) << "system install is " << system_install;
 
-  if (!HandleEULADialog(parsed_command_line))
-    return 0;
-
   // Check to make sure current system is WinXP or later. If not, log
   // error message and get out.
   if (!InstallUtil::IsOSSupported()) {
     LOG(ERROR) << "Chrome only supports Windows XP or later.";
     InstallUtil::WriteInstallerResult(system_install,
                                       installer_util::OS_NOT_SUPPORTED,
                                       IDS_INSTALL_OS_NOT_SUPPORTED_BASE, NULL);
     return installer_util::OS_NOT_SUPPORTED;
   }
 
   // Initialize COM for use later.
   if (CoInitializeEx(NULL, COINIT_APARTMENTTHREADED) != S_OK) {
     LOG(ERROR) << "COM initialization failed.";
     InstallUtil::WriteInstallerResult(system_install,
                                       installer_util::OS_ERROR,
                                       IDS_INSTALL_OS_ERROR_BASE, NULL);
     return installer_util::OS_ERROR;
   }
 
+  // Check if we need to show the EULA. There are two cases:
+  // 1- If it is passed as a command line (--show-eula), then the dialog is
+  //    shown and regardless of the outcome setup exits here.
+  // 2- If it is found in the installerdata file then the eula is shown
+  //    and the installation proceeds if the user acepts.
+  if (parsed_command_line.HasSwitch(installer_util::switches::kShowEula)) {
+    return (ShowEULADialog() ?
+        installer_util::EULA_ACCEPTED : installer_util::EULA_REJECTED);
+  } else if (installer_util::MASTER_PROFILE_REQUIRE_EULA & options) {

[huanr, 2009/01/27 06:19:16]

Same change here.

+    if (!ShowEULADialog())
+      return installer_util::EULA_REJECTED;
+  }
+
   // If --register-chrome-browser option is specified, register all
   // Chrome protocol/file associations as well as register it as a valid
   // browser for StarMenu->Internet shortcut. This option should only
   // be used when setup.exe is launched with admin rights. We do not
   // make any user specific changes in this option.
   if (parsed_command_line.HasSwitch(
       installer_util::switches::kRegisterChromeBrowser)) {
     std::wstring chrome_exe(parsed_command_line.GetSwitchValue(
         installer_util::switches::kRegisterChromeBrowser));
     return ShellUtil::AddChromeToSetAccessDefaults(chrome_exe, true);
@@ skipping 58 matching lines @@
 
     install_status = InstallChrome(parsed_command_line,
                                    installed_version.get(),
                                    options);
   }
 
   CoUninitialize();
   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
   return dist->GetInstallReturnCode(install_status);
 }