| // Copyright 2012 The Chromium Authors |
| // 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/upgrade_util_win.h" |
| |
| #include <objbase.h> |
| |
| #include <windows.h> |
| |
| #include <psapi.h> |
| #include <shellapi.h> |
| #include <wrl/client.h> |
| |
| #include <algorithm> |
| #include <ios> |
| #include <string> |
| |
| #include "base/base_paths.h" |
| #include "base/check.h" |
| #include "base/command_line.h" |
| #include "base/files/file_path.h" |
| #include "base/files/file_util.h" |
| #include "base/functional/bind.h" |
| #include "base/logging.h" |
| #include "base/memory/ref_counted.h" |
| #include "base/memory/scoped_refptr.h" |
| #include "base/metrics/histogram_functions.h" |
| #include "base/path_service.h" |
| #include "base/process/launch.h" |
| #include "base/process/process_handle.h" |
| #include "base/strings/string_number_conversions.h" |
| #include "base/strings/string_util.h" |
| #include "base/synchronization/waitable_event.h" |
| #include "base/system/sys_info.h" |
| #include "base/task/sequenced_task_runner.h" |
| #include "base/task/task_traits.h" |
| #include "base/task/thread_pool.h" |
| #include "base/threading/platform_thread.h" |
| #include "base/time/time.h" |
| #include "base/timer/elapsed_timer.h" |
| #include "base/trace_event/trace_event.h" |
| #include "base/values.h" |
| #include "base/win/registry.h" |
| #include "base/win/scoped_bstr.h" |
| #include "base/win/scoped_variant.h" |
| #include "base/win/windows_version.h" |
| #include "build/branding_buildflags.h" |
| #include "chrome/browser/browser_process.h" |
| #include "chrome/browser/chrome_process_singleton.h" |
| #include "chrome/browser/first_run/upgrade_util.h" |
| #include "chrome/browser/shell_integration.h" |
| #include "chrome/browser/win/browser_util.h" |
| #include "chrome/common/chrome_switches.h" |
| #include "chrome/common/pref_names.h" |
| #include "chrome/install_static/install_util.h" |
| #include "chrome/installer/util/app_command.h" |
| #include "chrome/installer/util/per_install_values.h" |
| #include "chrome/installer/util/util_constants.h" |
| #include "components/prefs/pref_service.h" |
| #include "third_party/abseil-cpp/absl/cleanup/cleanup.h" |
| #include "ui/base/ui_base_switches.h" |
| |
| #if BUILDFLAG(GOOGLE_CHROME_BRANDING) |
| #include "chrome/updater/app/server/win/updater_legacy_idl.h" |
| #endif |
| |
| namespace { |
| |
| bool GetNewerChromeFile(base::FilePath* path) { |
| if (!base::PathService::Get(base::DIR_EXE, path)) |
| return false; |
| *path = path->Append(installer::kChromeNewExe); |
| return true; |
| } |
| |
| #if BUILDFLAG(GOOGLE_CHROME_BRANDING) |
| // Holds the result of the IPC to CoCreate `GoogleUpdate3Web`. |
| struct CreateGoogleUpdate3WebResult |
| : public base::RefCountedThreadSafe<CreateGoogleUpdate3WebResult> { |
| Microsoft::WRL::ComPtr<IStream> stream; |
| base::WaitableEvent completion_event; |
| |
| private: |
| friend class base::RefCountedThreadSafe<CreateGoogleUpdate3WebResult>; |
| ~CreateGoogleUpdate3WebResult() = default; |
| }; |
| |
| // CoCreates the `GoogleUpdate3Web` class, and if successful, marshals the |
| // resulting interface into `result->stream`. Signals `result->completion_event` |
| // on successful or failed completion. |
| void CreateAndMarshalGoogleUpdate3Web( |
| scoped_refptr<CreateGoogleUpdate3WebResult> result) { |
| const absl::Cleanup signal_completion_event = [&result] { |
| result->completion_event.Signal(); |
| }; |
| |
| Microsoft::WRL::ComPtr<IUnknown> unknown; |
| { |
| TRACE_EVENT0("startup", "InvokeGoogleUpdateForRename CoCreateInstance"); |
| const HRESULT hr = |
| ::CoCreateInstance(__uuidof(GoogleUpdate3WebSystemClass), nullptr, |
| CLSCTX_ALL, IID_PPV_ARGS(&unknown)); |
| if (FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", "InvokeGoogleUpdateForRename CoCreateInstance failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "CoCreate GoogleUpdate3WebSystemClass failed; hr = " |
| << std::hex << hr; |
| return; |
| } |
| } |
| const HRESULT hr = ::CoMarshalInterThreadInterfaceInStream( |
| __uuidof(IUnknown), unknown.Get(), &result->stream); |
| if (FAILED(hr)) { |
| TRACE_EVENT_INSTANT1("startup", |
| "InvokeGoogleUpdateForRename " |
| "CoMarshalInterThreadInterfaceInStream failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "CoMarshalInterThreadInterfaceInStream " |
| "GoogleUpdate3WebSystemClass failed; hr = " |
| << std::hex << hr; |
| } |
| } |
| |
| // CoCreates the Google Update `GoogleUpdate3WebSystemClass` in a `ThreadPool` |
| // thread with a timeout, if the `ThreadPool` is operational. The starting value |
| // for the timeout is 15 seconds. If the CoCreate times out, the timeout is |
| // increased by 15 seconds at each failed attempt and persisted for the next |
| // attempt. |
| // |
| // If the `ThreadPool` is not operational, the CoCreate is done |
| // without a timeout. |
| Microsoft::WRL::ComPtr<IUnknown> CreateGoogleUpdate3Web() { |
| constexpr int kDefaultTimeoutIncrementSeconds = 15; |
| constexpr base::TimeDelta kMaxTimeAfterSystemStartup = base::Seconds(150); |
| |
| auto result = base::MakeRefCounted<CreateGoogleUpdate3WebResult>(); |
| if (base::ThreadPool::CreateCOMSTATaskRunner( |
| {base::MayBlock(), base::TaskPriority::USER_BLOCKING}) |
| ->PostTask( |
| FROM_HERE, |
| base::BindOnce(&CreateAndMarshalGoogleUpdate3Web, result))) { |
| installer::PerInstallValue creation_timeout( |
| L"ProcessLauncherCreationTimeout"); |
| const base::TimeDelta timeout = base::Seconds( |
| creation_timeout.Get() |
| .value_or(base::Value(kDefaultTimeoutIncrementSeconds)) |
| .GetIfInt() |
| .value_or(kDefaultTimeoutIncrementSeconds)); |
| const base::ElapsedTimer timer; |
| const bool is_at_startup = |
| base::SysInfo::Uptime() <= kMaxTimeAfterSystemStartup; |
| if (!result->completion_event.TimedWait(timeout)) { |
| base::UmaHistogramMediumTimes( |
| is_at_startup |
| ? "Startup.CreateProcessLauncher2.TimedWaitFailedAtStartup" |
| : "Startup.CreateProcessLauncher2.TimedWaitFailed", |
| timer.Elapsed()); |
| creation_timeout.Set(base::Value(static_cast<int>(timeout.InSeconds()) + |
| kDefaultTimeoutIncrementSeconds)); |
| TRACE_EVENT_INSTANT0( |
| "startup", "InvokeGoogleUpdateForRename CoCreateInstance timed out", |
| TRACE_EVENT_SCOPE_THREAD); |
| LOG(ERROR) << "CoCreate GoogleUpdate3WebSystemClass timed out"; |
| return {}; |
| } |
| |
| if (!result->stream) { |
| return {}; |
| } |
| base::UmaHistogramMediumTimes( |
| is_at_startup |
| ? "Startup.CreateProcessLauncher2.TimedWaitSucceededAtStartup" |
| : "Startup.CreateProcessLauncher2.TimedWaitSucceeded", |
| timer.Elapsed()); |
| |
| Microsoft::WRL::ComPtr<IUnknown> unknown; |
| const HRESULT hr = |
| ::CoUnmarshalInterface(result->stream.Get(), __uuidof(IUnknown), |
| IID_PPV_ARGS_Helper(&unknown)); |
| if (FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", "InvokeGoogleUpdateForRename CoUnmarshalInterface failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) |
| << "CoUnmarshalInterface GoogleUpdate3WebSystemClass failed; hr = " |
| << std::hex << hr; |
| return {}; |
| } |
| |
| return unknown; |
| } |
| |
| // The task could not be posted to the task runner, so CoCreate without a |
| // timeout. This could happen in shutdown, where the `ThreadPool` is not |
| // operational. |
| { |
| TRACE_EVENT0("startup", "InvokeGoogleUpdateForRename CoCreateInstance"); |
| Microsoft::WRL::ComPtr<IUnknown> unknown; |
| const HRESULT hr = |
| ::CoCreateInstance(__uuidof(GoogleUpdate3WebSystemClass), nullptr, |
| CLSCTX_ALL, IID_PPV_ARGS(&unknown)); |
| if (FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", "InvokeGoogleUpdateForRename CoCreateInstance failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "CoCreate GoogleUpdate3WebSystemClass failed; hr = " |
| << std::hex << hr; |
| return {}; |
| } |
| |
| return unknown; |
| } |
| } |
| #endif // BUILDFLAG(GOOGLE_CHROME_BRANDING) |
| |
| bool InvokeGoogleUpdateForRename() { |
| #if BUILDFLAG(GOOGLE_CHROME_BRANDING) |
| // This has been identified as very slow on some startups. Detailed trace |
| // events below try to shine a light on each steps. crbug.com/1252004 |
| TRACE_EVENT0("startup", "upgrade_util::InvokeGoogleUpdateForRename"); |
| |
| Microsoft::WRL::ComPtr<IUnknown> unknown = CreateGoogleUpdate3Web(); |
| if (!unknown) { |
| return false; |
| } |
| |
| // Chrome queries for the SxS IIDs first, with a fallback to the legacy IID, |
| // to make sure that marshaling loads the proxy/stub from the correct (HKLM) |
| // hive. |
| Microsoft::WRL::ComPtr<IGoogleUpdate3Web> update3web; |
| if (HRESULT hr = unknown.CopyTo(__uuidof(IGoogleUpdate3WebSystem), |
| IID_PPV_ARGS_Helper(&update3web)); |
| FAILED(hr)) { |
| hr = unknown.As(&update3web); |
| if (FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", "InvokeGoogleUpdateForRename QI IGoogleUpdate3Web failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "QI IGoogleUpdate3Web failed; hr = " << std::hex << hr; |
| return false; |
| } |
| } |
| |
| Microsoft::WRL::ComPtr<IAppBundleWeb> bundle; |
| { |
| Microsoft::WRL::ComPtr<IDispatch> dispatch; |
| if (HRESULT hr = update3web->createAppBundleWeb(&dispatch); FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", "InvokeGoogleUpdateForRename createAppBundleWeb failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "createAppBundleWeb failed; hr = " << std::hex << hr; |
| return false; |
| } |
| |
| if (HRESULT hr = dispatch.CopyTo(__uuidof(IAppBundleWebSystem), |
| IID_PPV_ARGS_Helper(&bundle)); |
| FAILED(hr)) { |
| hr = dispatch.As(&bundle); |
| if (FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", "InvokeGoogleUpdateForRename QI IAppBundleWeb failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "QI IAppBundleWeb failed; hr = " << std::hex << hr; |
| return false; |
| } |
| } |
| } |
| |
| if (HRESULT hr = bundle->initialize(); FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", "InvokeGoogleUpdateForRename bundle->initialize failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "bundle->initialize failed; hr = " << std::hex << hr; |
| return false; |
| } |
| |
| if (HRESULT hr = bundle->createInstalledApp( |
| base::win::ScopedBstr(install_static::GetAppGuid()).Get()); |
| FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", |
| "InvokeGoogleUpdateForRename bundle->createInstalledApp failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "bundle->createInstalledApp failed; hr = " << std::hex << hr; |
| return false; |
| } |
| |
| Microsoft::WRL::ComPtr<IAppWeb> app; |
| { |
| Microsoft::WRL::ComPtr<IDispatch> app_dispatch; |
| if (HRESULT hr = bundle->get_appWeb(0, &app_dispatch); FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", "InvokeGoogleUpdateForRename bundle->get_appWeb failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "bundle->get_appWeb failed; hr = " << std::hex << hr; |
| return false; |
| } |
| |
| if (HRESULT hr = app_dispatch.CopyTo(__uuidof(IAppWebSystem), |
| IID_PPV_ARGS_Helper(&app)); |
| FAILED(hr)) { |
| hr = app_dispatch.As(&app); |
| if (FAILED(hr)) { |
| TRACE_EVENT_INSTANT1("startup", |
| "InvokeGoogleUpdateForRename QI IAppWeb failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "QI IAppWeb failed; hr = " << std::hex << hr; |
| return false; |
| } |
| } |
| } |
| |
| Microsoft::WRL::ComPtr<IAppCommandWeb> app_command_web; |
| { |
| Microsoft::WRL::ComPtr<IDispatch> command_dispatch; |
| if (HRESULT hr = app->get_command( |
| base::win::ScopedBstr(installer::kCmdRenameChromeExe).Get(), |
| &command_dispatch); |
| FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", "InvokeGoogleUpdateForRename app->get_command failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "app->get_command failed; hr = " << std::hex << hr; |
| return false; |
| } |
| |
| if (HRESULT hr = |
| command_dispatch.CopyTo(__uuidof(IAppCommandWebSystem), |
| IID_PPV_ARGS_Helper(&app_command_web)); |
| FAILED(hr)) { |
| hr = command_dispatch.As(&app_command_web); |
| if (FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", "InvokeGoogleUpdateForRename QI IAppCommandWeb failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "QI IAppCommandWeb failed; hr = " << std::hex << hr; |
| return false; |
| } |
| } |
| } |
| |
| { |
| TRACE_EVENT0("startup", "InvokeGoogleUpdateForRename execute"); |
| if (HRESULT hr = |
| app_command_web->execute(base::win::ScopedVariant::kEmptyVariant, |
| base::win::ScopedVariant::kEmptyVariant, |
| base::win::ScopedVariant::kEmptyVariant, |
| base::win::ScopedVariant::kEmptyVariant, |
| base::win::ScopedVariant::kEmptyVariant, |
| base::win::ScopedVariant::kEmptyVariant, |
| base::win::ScopedVariant::kEmptyVariant, |
| base::win::ScopedVariant::kEmptyVariant, |
| base::win::ScopedVariant::kEmptyVariant); |
| FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", |
| "InvokeGoogleUpdateForRename app_command_web->execute failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "app_command_web->execute failed; hr = " << std::hex << hr; |
| return false; |
| } |
| |
| UINT status = 0; |
| for (const auto deadline = base::TimeTicks::Now() + base::Seconds(60); |
| base::TimeTicks::Now() < deadline; |
| base::PlatformThread::Sleep(base::Seconds(1))) { |
| if (HRESULT hr = app_command_web->get_status(&status); FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", |
| "InvokeGoogleUpdateForRename app_command_web->get_status failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "app_command_web->get_status failed; hr = " << std::hex |
| << hr; |
| return false; |
| } |
| if (status == COMMAND_STATUS_COMPLETE) { |
| break; |
| } |
| } |
| if (status != COMMAND_STATUS_COMPLETE) { |
| TRACE_EVENT_INSTANT1( |
| "startup", "InvokeGoogleUpdateForRename !COMMAND_STATUS_COMPLETE", |
| TRACE_EVENT_SCOPE_THREAD, "status", status); |
| LOG(ERROR) << "AppCommand timed out with status code " << status; |
| return false; |
| } |
| } |
| |
| DWORD exit_code = 0; |
| if (HRESULT hr = app_command_web->get_exitCode(&exit_code); FAILED(hr)) { |
| TRACE_EVENT_INSTANT1( |
| "startup", |
| "InvokeGoogleUpdateForRename app_command_web->get_exitCode failed", |
| TRACE_EVENT_SCOPE_THREAD, "hr", hr); |
| LOG(ERROR) << "app_command_web->get_exitCode failed; hr = " << std::hex |
| << hr; |
| return false; |
| } |
| |
| if (exit_code != installer::RENAME_SUCCESSFUL) { |
| TRACE_EVENT_INSTANT1("startup", |
| "InvokeGoogleUpdateForRename !RENAME_SUCCESSFUL", |
| TRACE_EVENT_SCOPE_THREAD, "exit_code", exit_code); |
| LOG(ERROR) << "Rename process failed with exit code " << exit_code; |
| return false; |
| } |
| |
| TRACE_EVENT_INSTANT0("startup", |
| "InvokeGoogleUpdateForRename RENAME_SUCCESSFUL", |
| TRACE_EVENT_SCOPE_THREAD); |
| |
| return true; |
| #else // BUILDFLAG(GOOGLE_CHROME_BRANDING) |
| return false; |
| #endif // BUILDFLAG(GOOGLE_CHROME_BRANDING) |
| } |
| |
| } // namespace |
| |
| namespace upgrade_util { |
| |
| bool RelaunchChromeBrowserImpl(const base::CommandLine& command_line) { |
| TRACE_EVENT0("startup", "upgrade_util::RelaunchChromeBrowserImpl"); |
| |
| base::FilePath chrome_exe; |
| if (!base::PathService::Get(base::FILE_EXE, &chrome_exe)) { |
| NOTREACHED(); |
| } |
| |
| // Explicitly make sure to relaunch chrome.exe rather than old_chrome.exe. |
| // This can happen when old_chrome.exe is launched by a user. |
| base::CommandLine chrome_exe_command_line = command_line; |
| chrome_exe_command_line.SetProgram( |
| chrome_exe.DirName().Append(installer::kChromeExe)); |
| |
| // Set the working directory to the exe's directory. This avoids a handle to |
| // the version directory being kept open in the relaunched child process. |
| base::LaunchOptions launch_options; |
| launch_options.current_directory = chrome_exe.DirName(); |
| // Give the new process the right to bring its windows to the foreground. |
| launch_options.grant_foreground_privilege = true; |
| return base::LaunchProcess(chrome_exe_command_line, launch_options).IsValid(); |
| } |
| |
| bool IsUpdatePendingRestart() { |
| TRACE_EVENT0("startup", "upgrade_util::IsUpdatePendingRestart"); |
| base::FilePath new_chrome_exe; |
| if (!GetNewerChromeFile(&new_chrome_exe)) |
| return false; |
| return base::PathExists(new_chrome_exe); |
| } |
| |
| bool SwapNewChromeExeIfPresent() { |
| if (!IsUpdatePendingRestart()) |
| return false; |
| |
| TRACE_EVENT0("startup", "upgrade_util::SwapNewChromeExeIfPresent"); |
| |
| // Renaming the chrome executable requires the process singleton to avoid |
| // any race condition. |
| CHECK(ChromeProcessSingleton::IsSingletonInstance()); |
| |
| // If this is a system-level install, ask Google Update to launch an elevated |
| // process to rename Chrome executables. |
| if (install_static::IsSystemInstall()) |
| return InvokeGoogleUpdateForRename(); |
| |
| // If this is a user-level install, directly launch a process to rename Chrome |
| // executables. Obtain the command to launch the process from the registry. |
| installer::AppCommand rename_cmd(installer::kCmdRenameChromeExe, {}); |
| if (!rename_cmd.Initialize(HKEY_CURRENT_USER)) |
| return false; |
| |
| base::LaunchOptions options; |
| options.wait = true; |
| options.start_hidden = true; |
| ::SetLastError(ERROR_SUCCESS); |
| base::Process process = |
| base::LaunchProcess(rename_cmd.command_line(), options); |
| if (!process.IsValid()) { |
| PLOG(ERROR) << "Launch rename process failed"; |
| return false; |
| } |
| |
| DWORD exit_code; |
| if (!::GetExitCodeProcess(process.Handle(), &exit_code)) { |
| PLOG(ERROR) << "GetExitCodeProcess of rename process failed"; |
| return false; |
| } |
| |
| if (exit_code != installer::RENAME_SUCCESSFUL) { |
| LOG(ERROR) << "Rename process failed with exit code " << exit_code; |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool IsRunningOldChrome() { |
| TRACE_EVENT0("startup", "upgrade_util::IsRunningOldChrome"); |
| // This figures out the actual file name that the section containing the |
| // mapped exe refers to. This is used instead of GetModuleFileName because the |
| // .exe may have been renamed out from under us while we've been running which |
| // GetModuleFileName won't notice. |
| wchar_t mapped_file_name[MAX_PATH * 2] = {}; |
| |
| if (!::GetMappedFileName(::GetCurrentProcess(), |
| reinterpret_cast<void*>(::GetModuleHandle(NULL)), |
| mapped_file_name, std::size(mapped_file_name))) { |
| return false; |
| } |
| |
| base::FilePath file_name(base::FilePath(mapped_file_name).BaseName()); |
| return base::FilePath::CompareEqualIgnoreCase(file_name.value(), |
| installer::kChromeOldExe); |
| } |
| |
| bool DoUpgradeTasks(const base::CommandLine& command_line) { |
| TRACE_EVENT0("startup", "upgrade_util::DoUpgradeTasks"); |
| // If there is no other instance already running then check if there is a |
| // pending update and complete it by performing the swap and then relaunch. |
| |
| // Upgrade tasks require the process singleton to avoid any race condition. |
| CHECK(ChromeProcessSingleton::IsSingletonInstance()); |
| |
| bool did_swap = false; |
| if (!browser_util::IsBrowserAlreadyRunning()) |
| did_swap = SwapNewChromeExeIfPresent(); |
| |
| // We don't need to relaunch if we didn't swap and we aren't running stale |
| // binaries. |
| if (!did_swap && !IsRunningOldChrome()) { |
| return false; |
| } |
| |
| // At this point the chrome.exe has been swapped with the new one. |
| if (!RelaunchChromeBrowser(command_line)) { |
| // The relaunch failed. Feel free to panic now. |
| DUMP_WILL_BE_NOTREACHED(); |
| } |
| return true; |
| } |
| |
| } // namespace upgrade_util |
