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/files/file_path.h"
14#include "base/files/file_util.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/grit/locale_settings.h"
26#include "chrome/installer/util/google_update_settings.h"
27#include "chrome/installer/util/install_util.h"
28#include "chrome/installer/util/master_preferences.h"
29#include "chrome/installer/util/master_preferences_constants.h"
30#include "chrome/installer/util/util_constants.h"
31#include "content/public/browser/browser_thread.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