first_run_internal_win.cc revision 0529e5d033099cbfc42635f6f6183833b09dff6e
1// Copyright (c) 2012 The Chromium Authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#include "chrome/browser/first_run/first_run_internal.h" 6 7#include <windows.h> 8#include <shellapi.h> 9 10#include "base/base_paths.h" 11#include "base/callback.h" 12#include "base/command_line.h" 13#include "base/file_util.h" 14#include "base/files/file_path.h" 15#include "base/path_service.h" 16#include "base/process/kill.h" 17#include "base/process/launch.h" 18#include "base/process/process.h" 19#include "base/threading/sequenced_worker_pool.h" 20#include "base/time/time.h" 21#include "base/win/metro.h" 22#include "chrome/common/chrome_constants.h" 23#include "chrome/common/chrome_paths.h" 24#include "chrome/common/chrome_switches.h" 25#include "chrome/installer/util/google_update_settings.h" 26#include "chrome/installer/util/install_util.h" 27#include "chrome/installer/util/master_preferences.h" 28#include "chrome/installer/util/master_preferences_constants.h" 29#include "chrome/installer/util/util_constants.h" 30#include "content/public/browser/browser_thread.h" 31#include "grit/locale_settings.h" 32#include "ui/base/l10n/l10n_util.h" 33#include "ui/base/win/shell.h" 34 35namespace { 36 37// Launches the setup exe with the given parameter/value on the command-line. 38// For non-metro Windows, it waits for its termination, returns its exit code 39// in |*ret_code|, and returns true if the exit code is valid. 40// For metro Windows, it launches setup via ShellExecuteEx and returns in order 41// to bounce the user back to the desktop, then returns immediately. 42bool LaunchSetupForEula(const base::FilePath::StringType& value, 43 int* ret_code) { 44 base::FilePath exe_dir; 45 if (!PathService::Get(base::DIR_MODULE, &exe_dir)) 46 return false; 47 exe_dir = exe_dir.Append(installer::kInstallerDir); 48 base::FilePath exe_path = exe_dir.Append(installer::kSetupExe); 49 base::ProcessHandle ph; 50 51 CommandLine cl(CommandLine::NO_PROGRAM); 52 cl.AppendSwitchNative(installer::switches::kShowEula, value); 53 54 if (base::win::IsMetroProcess()) { 55 cl.AppendSwitch(installer::switches::kShowEulaForMetro); 56 57 // This obscure use of the 'log usage' mask for windows 8 is documented here 58 // http://go.microsoft.com/fwlink/?LinkID=243079. It causes the desktop 59 // process to receive focus. Pass SEE_MASK_FLAG_NO_UI to avoid hangs if an 60 // error occurs since the UI can't be shown from a metro process. 61 ui::win::OpenAnyViaShell(exe_path.value(), 62 exe_dir.value(), 63 cl.GetCommandLineString(), 64 SEE_MASK_FLAG_LOG_USAGE | SEE_MASK_FLAG_NO_UI); 65 return false; 66 } else { 67 CommandLine setup_path(exe_path); 68 setup_path.AppendArguments(cl, false); 69 70 int exit_code = 0; 71 if (!base::LaunchProcess(setup_path, base::LaunchOptions(), &ph) || 72 !base::WaitForExitCode(ph, &exit_code)) { 73 return false; 74 } 75 76 *ret_code = exit_code; 77 return true; 78 } 79} 80 81// Returns true if the EULA is required but has not been accepted by this user. 82// The EULA is considered having been accepted if the user has gotten past 83// first run in the "other" environment (desktop or metro). 84bool IsEULANotAccepted(installer::MasterPreferences* install_prefs) { 85 bool value = false; 86 if (install_prefs->GetBool(installer::master_preferences::kRequireEula, 87 &value) && value) { 88 base::FilePath eula_sentinel; 89 // Be conservative and show the EULA if the path to the sentinel can't be 90 // determined. 91 if (!InstallUtil::GetEULASentinelFilePath(&eula_sentinel) || 92 !base::PathExists(eula_sentinel)) { 93 return true; 94 } 95 } 96 return false; 97} 98 99// Writes the EULA to a temporary file, returned in |*eula_path|, and returns 100// true if successful. 101bool WriteEULAtoTempFile(base::FilePath* eula_path) { 102 std::string terms = l10n_util::GetStringUTF8(IDS_TERMS_HTML); 103 return (!terms.empty() && 104 base::CreateTemporaryFile(eula_path) && 105 base::WriteFile(*eula_path, terms.data(), terms.size()) != -1); 106} 107 108// Creates the sentinel indicating that the EULA was required and has been 109// accepted. 110bool CreateEULASentinel() { 111 base::FilePath eula_sentinel; 112 return InstallUtil::GetEULASentinelFilePath(&eula_sentinel) && 113 base::CreateDirectory(eula_sentinel.DirName()) && 114 base::WriteFile(eula_sentinel, "", 0) != -1; 115} 116 117} // namespace 118 119namespace first_run { 120namespace internal { 121 122void DoPostImportPlatformSpecificTasks(Profile* /* profile */) { 123 // Trigger the Active Setup command for system-level Chromes to finish 124 // configuring this user's install (e.g. per-user shortcuts). 125 // Delay the task slightly to give Chrome launch I/O priority while also 126 // making sure shortcuts are created promptly to avoid annoying the user by 127 // re-creating shortcuts he previously deleted. 128 static const int64 kTiggerActiveSetupDelaySeconds = 5; 129 base::FilePath chrome_exe; 130 if (!PathService::Get(base::FILE_EXE, &chrome_exe)) { 131 NOTREACHED(); 132 } else if (!InstallUtil::IsPerUserInstall(chrome_exe.value().c_str())) { 133 content::BrowserThread::GetBlockingPool()->PostDelayedTask( 134 FROM_HERE, 135 base::Bind(&InstallUtil::TriggerActiveSetupCommand), 136 base::TimeDelta::FromSeconds(kTiggerActiveSetupDelaySeconds)); 137 } 138} 139 140bool IsFirstRunSentinelPresent() { 141 base::FilePath sentinel; 142 if (!GetFirstRunSentinelFilePath(&sentinel) || base::PathExists(sentinel)) 143 return true; 144 145 // Copy any legacy first run sentinel file for Windows user-level installs 146 // from the application directory to the user data directory. 147 base::FilePath exe_path; 148 if (PathService::Get(base::DIR_EXE, &exe_path) && 149 InstallUtil::IsPerUserInstall(exe_path.value().c_str())) { 150 base::FilePath legacy_sentinel = exe_path.Append(chrome::kFirstRunSentinel); 151 if (base::PathExists(legacy_sentinel)) { 152 // Copy the file instead of moving it to avoid breaking developer builds 153 // where the sentinel is dropped beside chrome.exe by a build action. 154 bool migrated = base::CopyFile(legacy_sentinel, sentinel); 155 DPCHECK(migrated); 156 // The sentinel is present regardless of whether or not it was migrated. 157 return true; 158 } 159 } 160 161 return false; 162} 163 164bool ShowPostInstallEULAIfNeeded(installer::MasterPreferences* install_prefs) { 165 if (IsEULANotAccepted(install_prefs)) { 166 // Show the post-installation EULA. This is done by setup.exe and the 167 // result determines if we continue or not. We wait here until the user 168 // dismisses the dialog. 169 170 // The actual eula text is in a resource in chrome. We extract it to 171 // a text file so setup.exe can use it as an inner frame. 172 base::FilePath inner_html; 173 if (WriteEULAtoTempFile(&inner_html)) { 174 int retcode = 0; 175 if (!LaunchSetupForEula(inner_html.value(), &retcode) || 176 (retcode != installer::EULA_ACCEPTED && 177 retcode != installer::EULA_ACCEPTED_OPT_IN)) { 178 LOG(WARNING) << "EULA flow requires fast exit."; 179 return false; 180 } 181 CreateEULASentinel(); 182 183 if (retcode == installer::EULA_ACCEPTED) { 184 VLOG(1) << "EULA : no collection"; 185 GoogleUpdateSettings::SetCollectStatsConsent(false); 186 } else if (retcode == installer::EULA_ACCEPTED_OPT_IN) { 187 VLOG(1) << "EULA : collection consent"; 188 GoogleUpdateSettings::SetCollectStatsConsent(true); 189 } 190 } 191 } 192 return true; 193} 194 195base::FilePath MasterPrefsPath() { 196 // The standard location of the master prefs is next to the chrome binary. 197 base::FilePath master_prefs; 198 if (!PathService::Get(base::DIR_EXE, &master_prefs)) 199 return base::FilePath(); 200 return master_prefs.AppendASCII(installer::kDefaultMasterPrefs); 201} 202 203} // namespace internal 204} // namespace first_run 205