chrome/installer/util/install_util.cc

   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 // See the corresponding header file for description of the functions in this
   6 // file.
   7
   8 #include "chrome/installer/util/install_util.h"
   9
  10 #include <shellapi.h>
  11 #include <shlobj.h>
  12 #include <shlwapi.h>
  13
  14 #include <algorithm>
  15
  16 #include "base/command_line.h"
  17 #include "base/file_util.h"
  18 #include "base/logging.h"
  19 #include "base/memory/scoped_ptr.h"
  20 #include "base/path_service.h"
  21 #include "base/process/launch.h"
  22 #include "base/strings/string_util.h"
  23 #include "base/sys_info.h"
  24 #include "base/values.h"
  25 #include "base/version.h"
  26 #include "base/win/metro.h"
  27 #include "base/win/registry.h"
  28 #include "base/win/windows_version.h"
  29 #include "chrome/installer/util/browser_distribution.h"
  30 #include "chrome/installer/util/google_update_constants.h"
  31 #include "chrome/installer/util/helper.h"
  32 #include "chrome/installer/util/installation_state.h"
  33 #include "chrome/installer/util/l10n_string_util.h"
  34 #include "chrome/installer/util/util_constants.h"
  35 #include "chrome/installer/util/work_item_list.h"
  36
  37 using base::win::RegKey;
  38 using installer::ProductState;
  39
  40 namespace {
  41
  42 const wchar_t kStageBinaryPatching[] = L"binary_patching";
  43 const wchar_t kStageBuilding[] = L"building";
  44 const wchar_t kStageConfiguringAutoLaunch[] = L"configuring_auto_launch";
  45 const wchar_t kStageCopyingPreferencesFile[] = L"copying_prefs";
  46 const wchar_t kStageCreatingShortcuts[] = L"creating_shortcuts";
  47 const wchar_t kStageEnsemblePatching[] = L"ensemble_patching";
  48 const wchar_t kStageExecuting[] = L"executing";
  49 const wchar_t kStageFinishing[] = L"finishing";
  50 const wchar_t kStagePreconditions[] = L"preconditions";
  51 const wchar_t kStageRefreshingPolicy[] = L"refreshing_policy";
  52 const wchar_t kStageRegisteringChrome[] = L"registering_chrome";
  53 const wchar_t kStageRemovingOldVersions[] = L"removing_old_ver";
  54 const wchar_t kStageRollingback[] = L"rollingback";
  55 const wchar_t kStageUncompressing[] = L"uncompressing";
  56 const wchar_t kStageUnpacking[] = L"unpacking";
  57 const wchar_t kStageUpdatingChannels[] = L"updating_channels";
  58 const wchar_t kStageCreatingVisualManifest[] = L"creating_visual_manifest";
  59 const wchar_t kStageDeferringToHigherVersion[] = L"deferring_to_higher_version";
  60
  61 const wchar_t* const kStages[] = {
  62   NULL,
  63   kStagePreconditions,
  64   kStageUncompressing,
  65   kStageEnsemblePatching,
  66   kStageBinaryPatching,
  67   kStageUnpacking,
  68   kStageBuilding,
  69   kStageExecuting,
  70   kStageRollingback,
  71   kStageRefreshingPolicy,
  72   kStageUpdatingChannels,
  73   kStageCopyingPreferencesFile,
  74   kStageCreatingShortcuts,
  75   kStageRegisteringChrome,
  76   kStageRemovingOldVersions,
  77   kStageFinishing,
  78   kStageConfiguringAutoLaunch,
  79   kStageCreatingVisualManifest,
  80   kStageDeferringToHigherVersion,
  81 };
  82
  83 COMPILE_ASSERT(installer::NUM_STAGES == arraysize(kStages),
  84                kStages_disagrees_with_Stage_comma_they_must_match_bang);
  85
  86 // Creates a zero-sized non-decorated foreground window that doesn't appear
  87 // in the taskbar. This is used as a parent window for calls to ShellExecuteEx
  88 // in order for the UAC dialog to appear in the foreground and for focus
  89 // to be returned to this process once the UAC task is dismissed. Returns
  90 // NULL on failure, a handle to the UAC window on success.
  91 HWND CreateUACForegroundWindow() {
  92   HWND foreground_window = ::CreateWindowEx(WS_EX_TOOLWINDOW,
  93                                             L"STATIC",
  94                                             NULL,
  95                                             WS_POPUP | WS_VISIBLE,
  96                                             0, 0, 0, 0,
  97                                             NULL, NULL,
  98                                             ::GetModuleHandle(NULL),
  99                                             NULL);
 100   if (foreground_window) {
 101     HMONITOR monitor = ::MonitorFromWindow(foreground_window,
 102                                            MONITOR_DEFAULTTONEAREST);
 103     if (monitor) {
 104       MONITORINFO mi = {0};
 105       mi.cbSize = sizeof(mi);
 106       ::GetMonitorInfo(monitor, &mi);
 107       RECT screen_rect = mi.rcWork;
 108       int x_offset = (screen_rect.right - screen_rect.left) / 2;
 109       int y_offset = (screen_rect.bottom - screen_rect.top) / 2;
 110       ::MoveWindow(foreground_window,
 111                    screen_rect.left + x_offset,
 112                    screen_rect.top + y_offset,
 113                    0, 0, FALSE);
 114     } else {
 115       NOTREACHED() << "Unable to get default monitor";
 116     }
 117     ::SetForegroundWindow(foreground_window);
 118   }
 119   return foreground_window;
 120 }
 121
 122 }  // namespace
 123
 124 string16 InstallUtil::GetActiveSetupPath(BrowserDistribution* dist) {
 125   static const wchar_t kInstalledComponentsPath[] =
 126       L"Software\\Microsoft\\Active Setup\\Installed Components\\";
 127   return kInstalledComponentsPath + dist->GetActiveSetupGuid();
 128 }
 129
 130 void InstallUtil::TriggerActiveSetupCommand() {
 131   string16 active_setup_reg(
 132       GetActiveSetupPath(BrowserDistribution::GetDistribution()));
 133   base::win::RegKey active_setup_key(
 134       HKEY_LOCAL_MACHINE, active_setup_reg.c_str(), KEY_QUERY_VALUE);
 135   string16 cmd_str;
 136   LONG read_status = active_setup_key.ReadValue(L"StubPath", &cmd_str);
 137   if (read_status != ERROR_SUCCESS) {
 138     LOG(ERROR) << active_setup_reg << ", " << read_status;
 139     // This should never fail if Chrome is registered at system-level, but if it
 140     // does there is not much else to be done.
 141     return;
 142   }
 143
 144   CommandLine cmd(CommandLine::FromString(cmd_str));
 145   // Force creation of shortcuts as the First Run beacon might land between now
 146   // and the time setup.exe checks for it.
 147   cmd.AppendSwitch(installer::switches::kForceConfigureUserSettings);
 148
 149   base::LaunchOptions launch_options;
 150   if (base::win::IsMetroProcess())
 151     launch_options.force_breakaway_from_job_ = true;
 152   if (!base::LaunchProcess(cmd.GetCommandLineString(), launch_options, NULL))
 153     PLOG(ERROR) << cmd.GetCommandLineString();
 154 }
 155
 156 bool InstallUtil::ExecuteExeAsAdmin(const CommandLine& cmd, DWORD* exit_code) {
 157   base::FilePath::StringType program(cmd.GetProgram().value());
 158   DCHECK(!program.empty());
 159   DCHECK_NE(program[0], L'\"');
 160
 161   CommandLine::StringType params(cmd.GetCommandLineString());
 162   if (params[0] == '"') {
 163     DCHECK_EQ('"', params[program.length() + 1]);
 164     DCHECK_EQ(program, params.substr(1, program.length()));
 165     params = params.substr(program.length() + 2);
 166   } else {
 167     DCHECK_EQ(program, params.substr(0, program.length()));
 168     params = params.substr(program.length());
 169   }
 170
 171   TrimWhitespace(params, TRIM_ALL, &params);
 172
 173   HWND uac_foreground_window = CreateUACForegroundWindow();
 174
 175   SHELLEXECUTEINFO info = {0};
 176   info.cbSize = sizeof(SHELLEXECUTEINFO);
 177   info.fMask = SEE_MASK_NOCLOSEPROCESS;
 178   info.hwnd = uac_foreground_window;
 179   info.lpVerb = L"runas";
 180   info.lpFile = program.c_str();
 181   info.lpParameters = params.c_str();
 182   info.nShow = SW_SHOW;
 183
 184   bool success = false;
 185   if (::ShellExecuteEx(&info) == TRUE) {
 186     ::WaitForSingleObject(info.hProcess, INFINITE);
 187     DWORD ret_val = 0;
 188     if (::GetExitCodeProcess(info.hProcess, &ret_val)) {
 189       success = true;
 190       if (exit_code)
 191         *exit_code = ret_val;
 192     }
 193   }
 194
 195   if (uac_foreground_window) {
 196     DestroyWindow(uac_foreground_window);
 197   }
 198
 199   return success;
 200 }
 201
 202 CommandLine InstallUtil::GetChromeUninstallCmd(
 203     bool system_install, BrowserDistribution::Type distribution_type) {
 204   ProductState state;
 205   if (state.Initialize(system_install, distribution_type)) {
 206     return state.uninstall_command();
 207   }
 208   return CommandLine(CommandLine::NO_PROGRAM);
 209 }
 210
 211 void InstallUtil::GetChromeVersion(BrowserDistribution* dist,
 212                                    bool system_install,
 213                                    Version* version) {
 214   DCHECK(dist);
 215   RegKey key;
 216   HKEY reg_root = (system_install) ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 217   LONG result = key.Open(reg_root, dist->GetVersionKey().c_str(),
 218                          KEY_QUERY_VALUE);
 219
 220   string16 version_str;
 221   if (result == ERROR_SUCCESS)
 222     result = key.ReadValue(google_update::kRegVersionField, &version_str);
 223
 224   *version = Version();
 225   if (result == ERROR_SUCCESS && !version_str.empty()) {
 226     VLOG(1) << "Existing " << dist->GetAppShortCutName() << " version found "
 227             << version_str;
 228     *version = Version(WideToASCII(version_str));
 229   } else {
 230     DCHECK_EQ(ERROR_FILE_NOT_FOUND, result);
 231     VLOG(1) << "No existing " << dist->GetAppShortCutName()
 232             << " install found.";
 233   }
 234 }
 235
 236 void InstallUtil::GetCriticalUpdateVersion(BrowserDistribution* dist,
 237                                            bool system_install,
 238                                            Version* version) {
 239   DCHECK(dist);
 240   RegKey key;
 241   HKEY reg_root = (system_install) ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 242   LONG result =
 243       key.Open(reg_root, dist->GetVersionKey().c_str(), KEY_QUERY_VALUE);
 244
 245   string16 version_str;
 246   if (result == ERROR_SUCCESS)
 247     result = key.ReadValue(google_update::kRegCriticalVersionField,
 248                            &version_str);
 249
 250   *version = Version();
 251   if (result == ERROR_SUCCESS && !version_str.empty()) {
 252     VLOG(1) << "Critical Update version for " << dist->GetAppShortCutName()
 253             << " found " << version_str;
 254     *version = Version(WideToASCII(version_str));
 255   } else {
 256     DCHECK_EQ(ERROR_FILE_NOT_FOUND, result);
 257     VLOG(1) << "No existing " << dist->GetAppShortCutName()
 258             << " install found.";
 259   }
 260 }
 261
 262 bool InstallUtil::IsOSSupported() {
 263   // We do not support Win2K or older, or XP without service pack 2.
 264   VLOG(1) << base::SysInfo::OperatingSystemName() << ' '
 265           << base::SysInfo::OperatingSystemVersion();
 266   base::win::Version version = base::win::GetVersion();
 267   return (version > base::win::VERSION_XP) ||
 268       ((version == base::win::VERSION_XP) &&
 269        (base::win::OSInfo::GetInstance()->service_pack().major >= 2));
 270 }
 271
 272 void InstallUtil::AddInstallerResultItems(bool system_install,
 273                                           const string16& state_key,
 274                                           installer::InstallStatus status,
 275                                           int string_resource_id,
 276                                           const string16* const launch_cmd,
 277                                           WorkItemList* install_list) {
 278   DCHECK(install_list);
 279   const HKEY root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 280   DWORD installer_result = (GetInstallReturnCode(status) == 0) ? 0 : 1;
 281   install_list->AddCreateRegKeyWorkItem(root, state_key);
 282   install_list->AddSetRegValueWorkItem(root, state_key,
 283                                        installer::kInstallerResult,
 284                                        installer_result, true);
 285   install_list->AddSetRegValueWorkItem(root, state_key,
 286                                        installer::kInstallerError,
 287                                        static_cast<DWORD>(status), true);
 288   if (string_resource_id != 0) {
 289     string16 msg = installer::GetLocalizedString(string_resource_id);
 290     install_list->AddSetRegValueWorkItem(root, state_key,
 291         installer::kInstallerResultUIString, msg, true);
 292   }
 293   if (launch_cmd != NULL && !launch_cmd->empty()) {
 294     install_list->AddSetRegValueWorkItem(root, state_key,
 295         installer::kInstallerSuccessLaunchCmdLine, *launch_cmd, true);
 296   }
 297 }
 298
 299 void InstallUtil::UpdateInstallerStage(bool system_install,
 300                                        const string16& state_key_path,
 301                                        installer::InstallerStage stage) {
 302   DCHECK_LE(static_cast<installer::InstallerStage>(0), stage);
 303   DCHECK_GT(installer::NUM_STAGES, stage);
 304   const HKEY root = system_install ? HKEY_LOCAL_MACHINE : HKEY_CURRENT_USER;
 305   RegKey state_key;
 306   LONG result = state_key.Open(root, state_key_path.c_str(),
 307                                KEY_QUERY_VALUE | KEY_SET_VALUE);
 308   if (result == ERROR_SUCCESS) {
 309     if (stage == installer::NO_STAGE) {
 310       result = state_key.DeleteValue(installer::kInstallerExtraCode1);
 311       LOG_IF(ERROR, result != ERROR_SUCCESS && result != ERROR_FILE_NOT_FOUND)
 312           << "Failed deleting installer stage from " << state_key_path
 313           << "; result: " << result;
 314     } else {
 315       const DWORD extra_code_1 = static_cast<DWORD>(stage);
 316       result = state_key.WriteValue(installer::kInstallerExtraCode1,
 317                                     extra_code_1);
 318       LOG_IF(ERROR, result != ERROR_SUCCESS)
 319           << "Failed writing installer stage to " << state_key_path
 320           << "; result: " << result;
 321     }
 322     // TODO(grt): Remove code below here once we're convinced that our use of
 323     // Google Update's new InstallerExtraCode1 value is good.
 324     installer::ChannelInfo channel_info;
 325     // This will return false if the "ap" value isn't present, which is fine.
 326     channel_info.Initialize(state_key);
 327     if (channel_info.SetStage(kStages[stage]) &&
 328         !channel_info.Write(&state_key)) {
 329       LOG(ERROR) << "Failed writing installer stage to " << state_key_path;
 330     }
 331   } else {
 332     LOG(ERROR) << "Failed opening " << state_key_path
 333                << " to update installer stage; result: " << result;
 334   }
 335 }
 336
 337 bool InstallUtil::IsPerUserInstall(const wchar_t* const exe_path) {
 338   wchar_t program_files_path[MAX_PATH] = {0};
 339   if (SUCCEEDED(SHGetFolderPath(NULL, CSIDL_PROGRAM_FILES, NULL,
 340                                 SHGFP_TYPE_CURRENT, program_files_path))) {
 341     return !StartsWith(exe_path, program_files_path, false);
 342   } else {
 343     NOTREACHED();
 344   }
 345   return true;
 346 }
 347
 348 bool InstallUtil::IsMultiInstall(BrowserDistribution* dist,
 349                                  bool system_install) {
 350   DCHECK(dist);
 351   ProductState state;
 352   return state.Initialize(system_install, dist->GetType()) &&
 353          state.is_multi_install();
 354 }
 355
 356 bool CheckIsChromeSxSProcess() {
 357   CommandLine* command_line = CommandLine::ForCurrentProcess();
 358   CHECK(command_line);
 359
 360   if (command_line->HasSwitch(installer::switches::kChromeSxS))
 361     return true;
 362
 363   // Also return true if we are running from Chrome SxS installed path.
 364   base::FilePath exe_dir;
 365   PathService::Get(base::DIR_EXE, &exe_dir);
 366   string16 chrome_sxs_dir(installer::kGoogleChromeInstallSubDir2);
 367   chrome_sxs_dir.append(installer::kSxSSuffix);
 368   return base::FilePath::CompareEqualIgnoreCase(
 369           exe_dir.BaseName().value(), installer::kInstallBinaryDir) &&
 370       base::FilePath::CompareEqualIgnoreCase(
 371           exe_dir.DirName().BaseName().value(), chrome_sxs_dir);
 372 }
 373
 374 bool InstallUtil::IsChromeSxSProcess() {
 375   static bool sxs = CheckIsChromeSxSProcess();
 376   return sxs;
 377 }
 378
 379 bool InstallUtil::GetSentinelFilePath(const base::FilePath::CharType* file,
 380                                       BrowserDistribution* dist,
 381                                       base::FilePath* path) {
 382   base::FilePath exe_path;
 383   if (!PathService::Get(base::DIR_EXE, &exe_path))
 384     return false;
 385
 386   if (IsPerUserInstall(exe_path.value().c_str())) {
 387     const base::FilePath maybe_product_dir(exe_path.DirName().DirName());
 388     if (base::PathExists(exe_path.Append(installer::kChromeExe))) {
 389       // DIR_EXE is most likely Chrome's directory in which case |exe_path| is
 390       // the user-level sentinel path.
 391       *path = exe_path;
 392     } else if (base::PathExists(
 393                    maybe_product_dir.Append(installer::kChromeExe))) {
 394       // DIR_EXE can also be the Installer directory if this is called from a
 395       // setup.exe running from Application\<version>\Installer (see
 396       // InstallerState::GetInstallerDirectory) in which case Chrome's directory
 397       // is two levels up.
 398       *path = maybe_product_dir;
 399     } else {
 400       NOTREACHED();
 401       return false;
 402     }
 403   } else {
 404     std::vector<base::FilePath> user_data_dir_paths;
 405     installer::GetChromeUserDataPaths(dist, &user_data_dir_paths);
 406
 407     if (!user_data_dir_paths.empty())
 408       *path = user_data_dir_paths[0];
 409     else
 410       return false;
 411   }
 412
 413   *path = path->Append(file);
 414   return true;
 415 }
 416
 417 // This method tries to delete a registry key and logs an error message
 418 // in case of failure. It returns true if deletion is successful (or the key did
 419 // not exist), otherwise false.
 420 bool InstallUtil::DeleteRegistryKey(HKEY root_key,
 421                                     const string16& key_path) {
 422   VLOG(1) << "Deleting registry key " << key_path;
 423   LONG result = ::SHDeleteKey(root_key, key_path.c_str());
 424   if (result != ERROR_SUCCESS && result != ERROR_FILE_NOT_FOUND) {
 425     LOG(ERROR) << "Failed to delete registry key: " << key_path
 426                << " error: " << result;
 427     return false;
 428   }
 429   return true;
 430 }
 431
 432 // This method tries to delete a registry value and logs an error message
 433 // in case of failure. It returns true if deletion is successful (or the key did
 434 // not exist), otherwise false.
 435 bool InstallUtil::DeleteRegistryValue(HKEY reg_root,
 436                                       const string16& key_path,
 437                                       const string16& value_name) {
 438   RegKey key;
 439   LONG result = key.Open(reg_root, key_path.c_str(), KEY_SET_VALUE);
 440   if (result == ERROR_SUCCESS)
 441     result = key.DeleteValue(value_name.c_str());
 442   if (result != ERROR_SUCCESS && result != ERROR_FILE_NOT_FOUND) {
 443     LOG(ERROR) << "Failed to delete registry value: " << value_name
 444                << " error: " << result;
 445     return false;
 446   }
 447   return true;
 448 }
 449
 450 // static
 451 InstallUtil::ConditionalDeleteResult InstallUtil::DeleteRegistryKeyIf(
 452     HKEY root_key,
 453     const string16& key_to_delete_path,
 454     const string16& key_to_test_path,
 455     const wchar_t* value_name,
 456     const RegistryValuePredicate& predicate) {
 457   DCHECK(root_key);
 458   ConditionalDeleteResult delete_result = NOT_FOUND;
 459   RegKey key;
 460   string16 actual_value;
 461   if (key.Open(root_key, key_to_test_path.c_str(),
 462                KEY_QUERY_VALUE) == ERROR_SUCCESS &&
 463       key.ReadValue(value_name, &actual_value) == ERROR_SUCCESS &&
 464       predicate.Evaluate(actual_value)) {
 465     key.Close();
 466     delete_result = DeleteRegistryKey(root_key, key_to_delete_path)
 467         ? DELETED : DELETE_FAILED;
 468   }
 469   return delete_result;
 470 }
 471
 472 // static
 473 InstallUtil::ConditionalDeleteResult InstallUtil::DeleteRegistryValueIf(
 474     HKEY root_key,
 475     const wchar_t* key_path,
 476     const wchar_t* value_name,
 477     const RegistryValuePredicate& predicate) {
 478   DCHECK(root_key);
 479   DCHECK(key_path);
 480   ConditionalDeleteResult delete_result = NOT_FOUND;
 481   RegKey key;
 482   string16 actual_value;
 483   if (key.Open(root_key, key_path,
 484                KEY_QUERY_VALUE | KEY_SET_VALUE) == ERROR_SUCCESS &&
 485       key.ReadValue(value_name, &actual_value) == ERROR_SUCCESS &&
 486       predicate.Evaluate(actual_value)) {
 487     LONG result = key.DeleteValue(value_name);
 488     if (result != ERROR_SUCCESS) {
 489       LOG(ERROR) << "Failed to delete registry value: "
 490                  << (value_name ? value_name : L"(Default)")
 491                  << " error: " << result;
 492       delete_result = DELETE_FAILED;
 493     }
 494     delete_result = DELETED;
 495   }
 496   return delete_result;
 497 }
 498
 499 bool InstallUtil::ValueEquals::Evaluate(const string16& value) const {
 500   return value == value_to_match_;
 501 }
 502
 503 // static
 504 int InstallUtil::GetInstallReturnCode(installer::InstallStatus status) {
 505   switch (status) {
 506     case installer::FIRST_INSTALL_SUCCESS:
 507     case installer::INSTALL_REPAIRED:
 508     case installer::NEW_VERSION_UPDATED:
 509     case installer::IN_USE_UPDATED:
 510       return 0;
 511     default:
 512       return status;
 513   }
 514 }
 515
 516 // static
 517 void InstallUtil::MakeUninstallCommand(const string16& program,
 518                                        const string16& arguments,
 519                                        CommandLine* command_line) {
 520   *command_line = CommandLine::FromString(L"\"" + program + L"\" " + arguments);
 521 }
 522
 523 // static
 524 string16 InstallUtil::GetCurrentDate() {
 525   static const wchar_t kDateFormat[] = L"yyyyMMdd";
 526   wchar_t date_str[arraysize(kDateFormat)] = {0};
 527   int len = GetDateFormatW(LOCALE_INVARIANT, 0, NULL, kDateFormat,
 528                            date_str, arraysize(date_str));
 529   if (len) {
 530     --len;  // Subtract terminating \0.
 531   } else {
 532     PLOG(DFATAL) << "GetDateFormat";
 533   }
 534
 535   return string16(date_str, len);
 536 }
 537
 538 // Open |path| with minimal access to obtain information about it, returning
 539 // true and populating |handle| on success.
 540 // static
 541 bool InstallUtil::ProgramCompare::OpenForInfo(const base::FilePath& path,
 542                                               base::win::ScopedHandle* handle) {
 543   DCHECK(handle);
 544   handle->Set(base::CreatePlatformFile(path, base::PLATFORM_FILE_OPEN, NULL,
 545                                        NULL));
 546   return handle->IsValid();
 547 }
 548
 549 // Populate |info| for |handle|, returning true on success.
 550 // static
 551 bool InstallUtil::ProgramCompare::GetInfo(const base::win::ScopedHandle& handle,
 552                                           BY_HANDLE_FILE_INFORMATION* info) {
 553   DCHECK(handle.IsValid());
 554   return GetFileInformationByHandle(
 555       const_cast<base::win::ScopedHandle&>(handle), info) != 0;
 556 }
 557
 558 InstallUtil::ProgramCompare::ProgramCompare(const base::FilePath& path_to_match)
 559     : path_to_match_(path_to_match),
 560       file_handle_(base::kInvalidPlatformFileValue),
 561       file_info_() {
 562   DCHECK(!path_to_match_.empty());
 563   if (!OpenForInfo(path_to_match_, &file_handle_)) {
 564     PLOG(WARNING) << "Failed opening " << path_to_match_.value()
 565                   << "; falling back to path string comparisons.";
 566   } else if (!GetInfo(file_handle_, &file_info_)) {
 567     PLOG(WARNING) << "Failed getting information for "
 568                   << path_to_match_.value()
 569                   << "; falling back to path string comparisons.";
 570     file_handle_.Close();
 571   }
 572 }
 573
 574 InstallUtil::ProgramCompare::~ProgramCompare() {
 575 }
 576
 577 bool InstallUtil::ProgramCompare::Evaluate(const string16& value) const {
 578   // Suss out the exe portion of the value, which is expected to be a command
 579   // line kinda (or exactly) like:
 580   // "c:\foo\bar\chrome.exe" -- "%1"
 581   base::FilePath program(CommandLine::FromString(value).GetProgram());
 582   if (program.empty()) {
 583     LOG(WARNING) << "Failed to parse an executable name from command line: \""
 584                  << value << "\"";
 585     return false;
 586   }
 587
 588   return EvaluatePath(program);
 589 }
 590
 591 bool InstallUtil::ProgramCompare::EvaluatePath(
 592     const base::FilePath& path) const {
 593   // Try the simple thing first: do the paths happen to match?
 594   if (base::FilePath::CompareEqualIgnoreCase(path_to_match_.value(),
 595                                              path.value()))
 596     return true;
 597
 598   // If the paths don't match and we couldn't open the expected file, we've done
 599   // our best.
 600   if (!file_handle_.IsValid())
 601     return false;
 602
 603   // Open the program and see if it references the expected file.
 604   base::win::ScopedHandle handle;
 605   BY_HANDLE_FILE_INFORMATION info = {};
 606
 607   return (OpenForInfo(path, &handle) &&
 608           GetInfo(handle, &info) &&
 609           info.dwVolumeSerialNumber == file_info_.dwVolumeSerialNumber &&
 610           info.nFileIndexHigh == file_info_.nFileIndexHigh &&
 611           info.nFileIndexLow == file_info_.nFileIndexLow);
 612 }