Home | History | Annotate | Download | only in first_run 
      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/upgrade_util.h"
      6 
      7 #include <windows.h>
      8 #include <psapi.h>
      9 #include <shellapi.h>
     10 
     11 #include <algorithm>
     12 #include <string>
     13 
     14 #include "base/base_paths.h"
     15 #include "base/command_line.h"
     16 #include "base/environment.h"
     17 #include "base/file_util.h"
     18 #include "base/files/file_path.h"
     19 #include "base/logging.h"
     20 #include "base/path_service.h"
     21 #include "base/process/launch.h"
     22 #include "base/process/process_handle.h"
     23 #include "base/strings/string_number_conversions.h"
     24 #include "base/strings/string_util.h"
     25 #include "base/strings/stringprintf.h"
     26 #include "base/win/metro.h"
     27 #include "base/win/registry.h"
     28 #include "base/win/scoped_comptr.h"
     29 #include "base/win/windows_version.h"
     30 #include "chrome/browser/first_run/upgrade_util_win.h"
     31 #include "chrome/browser/shell_integration.h"
     32 #include "chrome/common/chrome_constants.h"
     33 #include "chrome/common/chrome_switches.h"
     34 #include "chrome/installer/util/browser_distribution.h"
     35 #include "chrome/installer/util/google_update_constants.h"
     36 #include "chrome/installer/util/install_util.h"
     37 #include "chrome/installer/util/shell_util.h"
     38 #include "chrome/installer/util/util_constants.h"
     39 #include "google_update/google_update_idl.h"
     40 
     41 namespace {
     42 
     43 bool GetNewerChromeFile(base::FilePath* path) {
     44   if (!PathService::Get(base::DIR_EXE, path))
     45     return false;
     46   *path = path->Append(installer::kChromeNewExe);
     47   return true;
     48 }
     49 
     50 bool InvokeGoogleUpdateForRename() {
     51   base::win::ScopedComPtr<IProcessLauncher> ipl;
     52   if (!FAILED(ipl.CreateInstance(__uuidof(ProcessLauncherClass)))) {
     53     ULONG_PTR phandle = NULL;
     54     DWORD id = GetCurrentProcessId();
     55     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
     56     if (!FAILED(ipl->LaunchCmdElevated(dist->GetAppGuid().c_str(),
     57                                        google_update::kRegRenameCmdField,
     58                                        id,
     59                                        &phandle))) {
     60       HANDLE handle = HANDLE(phandle);
     61       WaitForSingleObject(handle, INFINITE);
     62       DWORD exit_code;
     63       ::GetExitCodeProcess(handle, &exit_code);
     64       ::CloseHandle(handle);
     65       if (exit_code == installer::RENAME_SUCCESSFUL)
     66         return true;
     67     }
     68   }
     69   return false;
     70 }
     71 
     72 base::FilePath GetMetroRelauncherPath(const base::FilePath& chrome_exe,
     73                                       const std::string& version_str) {
     74   base::FilePath path(chrome_exe.DirName());
     75 
     76   // The relauncher is ordinarily in the version directory.  When running in a
     77   // build tree however (where CHROME_VERSION is not set in the environment)
     78   // look for it in Chrome's directory.
     79   if (!version_str.empty())
     80     path = path.AppendASCII(version_str);
     81 
     82   return path.Append(installer::kDelegateExecuteExe);
     83 }
     84 
     85 }  // namespace
     86 
     87 namespace upgrade_util {
     88 
     89 const char kRelaunchModeMetro[] = "relaunch.mode.metro";
     90 const char kRelaunchModeDesktop[] = "relaunch.mode.desktop";
     91 const char kRelaunchModeDefault[] = "relaunch.mode.default";
     92 
     93 // TODO(shrikant): Have a map/array to quickly map enum to strings.
     94 std::string RelaunchModeEnumToString(const RelaunchMode relaunch_mode) {
     95   if (relaunch_mode == RELAUNCH_MODE_METRO)
     96     return kRelaunchModeMetro;
     97 
     98   if (relaunch_mode == RELAUNCH_MODE_DESKTOP)
     99     return kRelaunchModeDesktop;
    100 
    101   // For the purpose of code flow, even in case of wrong value we will
    102   // return default re-launch mode.
    103   return kRelaunchModeDefault;
    104 }
    105 
    106 RelaunchMode RelaunchModeStringToEnum(const std::string& relaunch_mode) {
    107   if (relaunch_mode == kRelaunchModeMetro)
    108     return RELAUNCH_MODE_METRO;
    109 
    110   if (relaunch_mode == kRelaunchModeDesktop)
    111     return RELAUNCH_MODE_DESKTOP;
    112 
    113   return RELAUNCH_MODE_DEFAULT;
    114 }
    115 
    116 bool RelaunchChromeHelper(const CommandLine& command_line,
    117                           const RelaunchMode& relaunch_mode) {
    118   scoped_ptr<base::Environment> env(base::Environment::Create());
    119   std::string version_str;
    120 
    121   // Get the version variable and remove it from the environment.
    122   if (env->GetVar(chrome::kChromeVersionEnvVar, &version_str))
    123     env->UnSetVar(chrome::kChromeVersionEnvVar);
    124   else
    125     version_str.clear();
    126 
    127   base::FilePath chrome_exe;
    128   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
    129     NOTREACHED();
    130     return false;
    131   }
    132 
    133   // Explicitly make sure to relaunch chrome.exe rather than old_chrome.exe.
    134   // This can happen when old_chrome.exe is launched by a user.
    135   CommandLine chrome_exe_command_line = command_line;
    136   chrome_exe_command_line.SetProgram(
    137       chrome_exe.DirName().Append(installer::kChromeExe));
    138 
    139   if (base::win::GetVersion() < base::win::VERSION_WIN8)
    140     return base::LaunchProcess(chrome_exe_command_line,
    141                                base::LaunchOptions(), NULL);
    142 
    143   // On Windows 8 we always use the delegate_execute for re-launching chrome.
    144   //
    145   // Pass this Chrome's Start Menu shortcut path to the relauncher so it can re-
    146   // activate chrome via ShellExecute which will wait until we exit. Since
    147   // ShellExecute does not support handle passing to the child process we create
    148   // a uniquely named mutex that we aquire and never release. So when we exit,
    149   // Windows marks our mutex as abandoned and the wait is satisfied. The format
    150   // of the named mutex is important. See DelegateExecuteOperation for more
    151   // details.
    152   base::string16 mutex_name =
    153       base::StringPrintf(L"chrome.relaunch.%d", ::GetCurrentProcessId());
    154   HANDLE mutex = ::CreateMutexW(NULL, TRUE, mutex_name.c_str());
    155   // The |mutex| handle needs to be leaked. See comment above.
    156   if (!mutex) {
    157     NOTREACHED();
    158     return false;
    159   }
    160   if (::GetLastError() == ERROR_ALREADY_EXISTS) {
    161     NOTREACHED() << "Relaunch mutex already exists";
    162     return false;
    163   }
    164 
    165   CommandLine relaunch_cmd(CommandLine::NO_PROGRAM);
    166   relaunch_cmd.AppendSwitchPath(switches::kRelaunchShortcut,
    167       ShellIntegration::GetStartMenuShortcut(chrome_exe));
    168   relaunch_cmd.AppendSwitchNative(switches::kWaitForMutex, mutex_name);
    169 
    170   if (relaunch_mode != RELAUNCH_MODE_DEFAULT) {
    171     relaunch_cmd.AppendSwitch(relaunch_mode == RELAUNCH_MODE_METRO?
    172         switches::kForceImmersive : switches::kForceDesktop);
    173   }
    174 
    175   base::string16 params(relaunch_cmd.GetCommandLineString());
    176   base::string16 path(GetMetroRelauncherPath(chrome_exe, version_str).value());
    177 
    178   SHELLEXECUTEINFO sei = { sizeof(sei) };
    179   sei.fMask = SEE_MASK_FLAG_LOG_USAGE | SEE_MASK_NOCLOSEPROCESS;
    180   sei.nShow = SW_SHOWNORMAL;
    181   sei.lpFile = path.c_str();
    182   sei.lpParameters = params.c_str();
    183 
    184   if (!::ShellExecuteExW(&sei)) {
    185     NOTREACHED() << "ShellExecute failed with " << GetLastError();
    186     return false;
    187   }
    188   DWORD pid = ::GetProcessId(sei.hProcess);
    189   CloseHandle(sei.hProcess);
    190   if (!pid)
    191     return false;
    192   // The next call appears to be needed if we are relaunching from desktop into
    193   // metro mode. The observed effect if not done is that chrome starts in metro
    194   // mode but it is not given focus and it gets killed by windows after a few
    195   // seconds.
    196   ::AllowSetForegroundWindow(pid);
    197   return true;
    198 }
    199 
    200 bool RelaunchChromeBrowser(const CommandLine& command_line) {
    201   return RelaunchChromeHelper(command_line, RELAUNCH_MODE_DEFAULT);
    202 }
    203 
    204 bool RelaunchChromeWithMode(const CommandLine& command_line,
    205                             const RelaunchMode& relaunch_mode) {
    206   return RelaunchChromeHelper(command_line, relaunch_mode);
    207 }
    208 
    209 bool IsUpdatePendingRestart() {
    210   base::FilePath new_chrome_exe;
    211   if (!GetNewerChromeFile(&new_chrome_exe))
    212     return false;
    213   return base::PathExists(new_chrome_exe);
    214 }
    215 
    216 bool SwapNewChromeExeIfPresent() {
    217   base::FilePath new_chrome_exe;
    218   if (!GetNewerChromeFile(&new_chrome_exe))
    219     return false;
    220   if (!base::PathExists(new_chrome_exe))
    221     return false;
    222   base::FilePath cur_chrome_exe;
    223   if (!PathService::Get(base::FILE_EXE, &cur_chrome_exe))
    224     return false;
    225 
    226   // Open up the registry key containing current version and rename information.
    227   bool user_install =
    228       InstallUtil::IsPerUserInstall(cur_chrome_exe.value().c_str());
    229   HKEY reg_root = user_install ? HKEY_CURRENT_USER : HKEY_LOCAL_MACHINE;
    230   BrowserDistribution *dist = BrowserDistribution::GetDistribution();
    231   base::win::RegKey key;
    232   if (key.Open(reg_root, dist->GetVersionKey().c_str(),
    233                KEY_QUERY_VALUE) == ERROR_SUCCESS) {
    234     // First try to rename exe by launching rename command ourselves.
    235     std::wstring rename_cmd;
    236     if (key.ReadValue(google_update::kRegRenameCmdField,
    237                       &rename_cmd) == ERROR_SUCCESS) {
    238       base::win::ScopedHandle handle;
    239       base::LaunchOptions options;
    240       options.wait = true;
    241       options.start_hidden = true;
    242       if (base::LaunchProcess(rename_cmd, options, &handle)) {
    243         DWORD exit_code;
    244         ::GetExitCodeProcess(handle, &exit_code);
    245         if (exit_code == installer::RENAME_SUCCESSFUL)
    246           return true;
    247       }
    248     }
    249   }
    250 
    251   // Rename didn't work so try to rename by calling Google Update
    252   return InvokeGoogleUpdateForRename();
    253 }
    254 
    255 bool IsRunningOldChrome() {
    256   // This figures out the actual file name that the section containing the
    257   // mapped exe refers to. This is used instead of GetModuleFileName because the
    258   // .exe may have been renamed out from under us while we've been running which
    259   // GetModuleFileName won't notice.
    260   wchar_t mapped_file_name[MAX_PATH * 2] = {};
    261 
    262   if (!::GetMappedFileName(::GetCurrentProcess(),
    263                            reinterpret_cast<void*>(::GetModuleHandle(NULL)),
    264                            mapped_file_name,
    265                            arraysize(mapped_file_name))) {
    266     return false;
    267   }
    268 
    269   base::FilePath file_name(base::FilePath(mapped_file_name).BaseName());
    270   return base::FilePath::CompareEqualIgnoreCase(file_name.value(),
    271                                                 installer::kChromeOldExe);
    272 }
    273 
    274 bool DoUpgradeTasks(const CommandLine& command_line) {
    275   // The DelegateExecute verb handler finalizes pending in-use updates for
    276   // metro mode launches, as Chrome cannot be gracefully relaunched when
    277   // running in this mode.
    278   if (base::win::IsMetroProcess())
    279     return false;
    280   if (!SwapNewChromeExeIfPresent() && !IsRunningOldChrome())
    281     return false;
    282   // At this point the chrome.exe has been swapped with the new one.
    283   if (!RelaunchChromeBrowser(command_line)) {
    284     // The re-launch fails. Feel free to panic now.
    285     NOTREACHED();
    286   }
    287   return true;
    288 }
    289 
    290 }  // namespace upgrade_util
    291