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/installer/setup/install.h" 6 7 #include <windows.h> 8 #include <shlobj.h> 9 #include <time.h> 10 11 #include <string> 12 13 #include "base/command_line.h" 14 #include "base/file_util.h" 15 #include "base/files/file_path.h" 16 #include "base/logging.h" 17 #include "base/memory/scoped_ptr.h" 18 #include "base/path_service.h" 19 #include "base/process/launch.h" 20 #include "base/strings/string_util.h" 21 #include "base/strings/stringprintf.h" 22 #include "base/strings/utf_string_conversions.h" 23 #include "base/win/shortcut.h" 24 #include "base/win/windows_version.h" 25 #include "chrome/common/chrome_constants.h" 26 #include "chrome/common/chrome_switches.h" 27 #include "chrome/installer/launcher_support/chrome_launcher_support.h" 28 #include "chrome/installer/setup/install_worker.h" 29 #include "chrome/installer/setup/setup_constants.h" 30 #include "chrome/installer/util/auto_launch_util.h" 31 #include "chrome/installer/util/browser_distribution.h" 32 #include "chrome/installer/util/create_reg_key_work_item.h" 33 #include "chrome/installer/util/delete_after_reboot_helper.h" 34 #include "chrome/installer/util/google_update_constants.h" 35 #include "chrome/installer/util/helper.h" 36 #include "chrome/installer/util/install_util.h" 37 #include "chrome/installer/util/master_preferences.h" 38 #include "chrome/installer/util/master_preferences_constants.h" 39 #include "chrome/installer/util/set_reg_value_work_item.h" 40 #include "chrome/installer/util/shell_util.h" 41 #include "chrome/installer/util/util_constants.h" 42 #include "chrome/installer/util/work_item_list.h" 43 44 // Build-time generated include file. 45 #include "registered_dlls.h" // NOLINT 46 47 using installer::InstallerState; 48 using installer::InstallationState; 49 using installer::Product; 50 51 namespace { 52 53 void LogShortcutOperation(ShellUtil::ShortcutLocation location, 54 BrowserDistribution* dist, 55 const ShellUtil::ShortcutProperties& properties, 56 ShellUtil::ShortcutOperation operation, 57 bool failed) { 58 // ShellUtil::SHELL_SHORTCUT_UPDATE_EXISTING should not be used at install and 59 // thus this method does not handle logging a message for it. 60 DCHECK(operation != ShellUtil::SHELL_SHORTCUT_UPDATE_EXISTING); 61 std::string message; 62 if (failed) 63 message.append("Failed: "); 64 message.append( 65 (operation == ShellUtil::SHELL_SHORTCUT_CREATE_ALWAYS || 66 operation == ShellUtil::SHELL_SHORTCUT_CREATE_IF_NO_SYSTEM_LEVEL) ? 67 "Creating " : "Overwriting "); 68 if (failed && operation == ShellUtil::SHELL_SHORTCUT_REPLACE_EXISTING) 69 message.append("(maybe the shortcut doesn't exist?) "); 70 message.append((properties.level == ShellUtil::CURRENT_USER) ? "per-user " : 71 "all-users "); 72 switch (location) { 73 case ShellUtil::SHORTCUT_LOCATION_DESKTOP: 74 message.append("Desktop "); 75 break; 76 case ShellUtil::SHORTCUT_LOCATION_QUICK_LAUNCH: 77 message.append("Quick Launch "); 78 break; 79 case ShellUtil::SHORTCUT_LOCATION_START_MENU: 80 message.append("Start menu "); 81 break; 82 default: 83 NOTREACHED(); 84 } 85 86 message.push_back('"'); 87 if (properties.has_shortcut_name()) 88 message.append(UTF16ToUTF8(properties.shortcut_name)); 89 else 90 message.append(UTF16ToUTF8(dist->GetAppShortCutName())); 91 message.push_back('"'); 92 93 message.append(" shortcut to "); 94 message.append(UTF16ToUTF8(properties.target.value())); 95 if (properties.has_arguments()) 96 message.append(UTF16ToUTF8(properties.arguments)); 97 98 if (properties.pin_to_taskbar && 99 base::win::GetVersion() >= base::win::VERSION_WIN7) { 100 message.append(" and pinning to the taskbar."); 101 } else { 102 message.push_back('.'); 103 } 104 105 if (failed) 106 LOG(WARNING) << message; 107 else 108 VLOG(1) << message; 109 } 110 111 void ExecuteAndLogShortcutOperation( 112 ShellUtil::ShortcutLocation location, 113 BrowserDistribution* dist, 114 const ShellUtil::ShortcutProperties& properties, 115 ShellUtil::ShortcutOperation operation) { 116 LogShortcutOperation(location, dist, properties, operation, false); 117 if (!ShellUtil::CreateOrUpdateShortcut(location, dist, properties, 118 operation)) { 119 LogShortcutOperation(location, dist, properties, operation, true); 120 } 121 } 122 123 void AddChromeToMediaPlayerList() { 124 string16 reg_path(installer::kMediaPlayerRegPath); 125 // registry paths can also be appended like file system path 126 reg_path.push_back(base::FilePath::kSeparators[0]); 127 reg_path.append(installer::kChromeExe); 128 VLOG(1) << "Adding Chrome to Media player list at " << reg_path; 129 scoped_ptr<WorkItem> work_item(WorkItem::CreateCreateRegKeyWorkItem( 130 HKEY_LOCAL_MACHINE, reg_path)); 131 132 // if the operation fails we log the error but still continue 133 if (!work_item.get()->Do()) 134 LOG(ERROR) << "Could not add Chrome to media player inclusion list."; 135 } 136 137 // Copy master_preferences file provided to installer, in the same folder 138 // as chrome.exe so Chrome first run can find it. This function will be called 139 // only on the first install of Chrome. 140 void CopyPreferenceFileForFirstRun(const InstallerState& installer_state, 141 const base::FilePath& prefs_source_path) { 142 base::FilePath prefs_dest_path(installer_state.target_path().AppendASCII( 143 installer::kDefaultMasterPrefs)); 144 if (!base::CopyFile(prefs_source_path, prefs_dest_path)) { 145 VLOG(1) << "Failed to copy master preferences from:" 146 << prefs_source_path.value() << " gle: " << ::GetLastError(); 147 } 148 } 149 150 // This function installs a new version of Chrome to the specified location. 151 // 152 // setup_path: Path to the executable (setup.exe) as it will be copied 153 // to Chrome install folder after install is complete 154 // archive_path: Path to the archive (chrome.7z) as it will be copied 155 // to Chrome install folder after install is complete 156 // src_path: the path that contains a complete and unpacked Chrome package 157 // to be installed. 158 // temp_path: the path of working directory used during installation. This path 159 // does not need to exist. 160 // new_version: new Chrome version that needs to be installed 161 // current_version: returns the current active version (if any) 162 // 163 // This function makes best effort to do installation in a transactional 164 // manner. If failed it tries to rollback all changes on the file system 165 // and registry. For example, if package exists before calling the 166 // function, it rolls back all new file and directory changes under 167 // package. If package does not exist before calling the function 168 // (typical new install), the function creates package during install 169 // and removes the whole directory during rollback. 170 installer::InstallStatus InstallNewVersion( 171 const InstallationState& original_state, 172 const InstallerState& installer_state, 173 const base::FilePath& setup_path, 174 const base::FilePath& archive_path, 175 const base::FilePath& src_path, 176 const base::FilePath& temp_path, 177 const Version& new_version, 178 scoped_ptr<Version>* current_version) { 179 DCHECK(current_version); 180 181 installer_state.UpdateStage(installer::BUILDING); 182 183 current_version->reset(installer_state.GetCurrentVersion(original_state)); 184 scoped_ptr<WorkItemList> install_list(WorkItem::CreateWorkItemList()); 185 186 AddInstallWorkItems(original_state, 187 installer_state, 188 setup_path, 189 archive_path, 190 src_path, 191 temp_path, 192 current_version->get(), 193 new_version, 194 install_list.get()); 195 196 base::FilePath new_chrome_exe( 197 installer_state.target_path().Append(installer::kChromeNewExe)); 198 199 installer_state.UpdateStage(installer::EXECUTING); 200 201 if (!install_list->Do()) { 202 installer_state.UpdateStage(installer::ROLLINGBACK); 203 installer::InstallStatus result = 204 base::PathExists(new_chrome_exe) && current_version->get() && 205 new_version.Equals(*current_version->get()) ? 206 installer::SAME_VERSION_REPAIR_FAILED : 207 installer::INSTALL_FAILED; 208 LOG(ERROR) << "Install failed, rolling back... result: " << result; 209 install_list->Rollback(); 210 LOG(ERROR) << "Rollback complete. "; 211 return result; 212 } 213 214 installer_state.UpdateStage(installer::REFRESHING_POLICY); 215 216 installer::RefreshElevationPolicy(); 217 218 if (!current_version->get()) { 219 VLOG(1) << "First install of version " << new_version.GetString(); 220 return installer::FIRST_INSTALL_SUCCESS; 221 } 222 223 if (new_version.Equals(**current_version)) { 224 VLOG(1) << "Install repaired of version " << new_version.GetString(); 225 return installer::INSTALL_REPAIRED; 226 } 227 228 if (new_version.CompareTo(**current_version) > 0) { 229 if (base::PathExists(new_chrome_exe)) { 230 VLOG(1) << "Version updated to " << new_version.GetString() 231 << " while running " << (*current_version)->GetString(); 232 return installer::IN_USE_UPDATED; 233 } 234 VLOG(1) << "Version updated to " << new_version.GetString(); 235 return installer::NEW_VERSION_UPDATED; 236 } 237 238 LOG(ERROR) << "Not sure how we got here while updating" 239 << ", new version: " << new_version.GetString() 240 << ", old version: " << (*current_version)->GetString(); 241 242 return installer::INSTALL_FAILED; 243 } 244 245 // Deletes the old "Uninstall Google Chrome" shortcut in the Start menu and, if 246 // this is a system-level install, also deletes the old Default user Quick 247 // Launch shortcut. Both of these were created prior to Chrome 24; in Chrome 24, 248 // the uninstall shortcut was removed and the Default user Quick Launch shortcut 249 // was replaced by per-user shortcuts created via Active Setup. 250 void CleanupLegacyShortcuts(const InstallerState& installer_state, 251 BrowserDistribution* dist, 252 const base::FilePath& chrome_exe) { 253 ShellUtil::ShellChange shortcut_level = installer_state.system_install() ? 254 ShellUtil::SYSTEM_LEVEL : ShellUtil::CURRENT_USER; 255 base::FilePath uninstall_shortcut_path; 256 ShellUtil::GetShortcutPath(ShellUtil::SHORTCUT_LOCATION_START_MENU, dist, 257 shortcut_level, &uninstall_shortcut_path); 258 uninstall_shortcut_path = uninstall_shortcut_path.Append( 259 dist->GetUninstallLinkName() + installer::kLnkExt); 260 base::DeleteFile(uninstall_shortcut_path, false); 261 262 if (installer_state.system_install()) { 263 ShellUtil::RemoveShortcuts( 264 ShellUtil::SHORTCUT_LOCATION_QUICK_LAUNCH, dist, 265 ShellUtil::SYSTEM_LEVEL, chrome_exe); 266 } 267 } 268 269 // Returns the appropriate shortcut operations for App Launcher, 270 // based on state of installation and master_preferences. 271 installer::InstallShortcutOperation GetAppLauncherShortcutOperation( 272 const InstallationState& original_state, 273 const InstallerState& installer_state) { 274 const installer::ProductState* original_app_host_state = 275 original_state.GetProductState(installer_state.system_install(), 276 BrowserDistribution::CHROME_APP_HOST); 277 bool app_launcher_exists = original_app_host_state && 278 original_app_host_state->uninstall_command() 279 .HasSwitch(installer::switches::kChromeAppLauncher); 280 if (!app_launcher_exists) 281 return installer::INSTALL_SHORTCUT_CREATE_ALL; 282 283 return installer::INSTALL_SHORTCUT_REPLACE_EXISTING; 284 } 285 286 } // end namespace 287 288 namespace installer { 289 290 void EscapeXmlAttributeValueInSingleQuotes(string16* att_value) { 291 ReplaceChars(*att_value, L"&", L"&", att_value); 292 ReplaceChars(*att_value, L"'", L"'", att_value); 293 ReplaceChars(*att_value, L"<", L"<", att_value); 294 } 295 296 bool CreateVisualElementsManifest(const base::FilePath& src_path, 297 const Version& version) { 298 // Construct the relative path to the versioned VisualElements directory. 299 string16 elements_dir(ASCIIToUTF16(version.GetString())); 300 elements_dir.push_back(base::FilePath::kSeparators[0]); 301 elements_dir.append(installer::kVisualElements); 302 303 // Some distributions of Chromium may not include visual elements. Only 304 // proceed if this distribution does. 305 if (!base::PathExists(src_path.Append(elements_dir))) { 306 VLOG(1) << "No visual elements found, not writing " 307 << installer::kVisualElementsManifest << " to " << src_path.value(); 308 return true; 309 } else { 310 // A printf_p-style format string for generating the visual elements 311 // manifest. Required arguments, in order, are: 312 // - Localized display name for the product. 313 // - Relative path to the VisualElements directory. 314 static const char kManifestTemplate[] = 315 "<Application>\r\n" 316 " <VisualElements\r\n" 317 " DisplayName='%1$ls'\r\n" 318 " Logo='%2$ls\\Logo.png'\r\n" 319 " SmallLogo='%2$ls\\SmallLogo.png'\r\n" 320 " ForegroundText='light'\r\n" 321 " BackgroundColor='#323232'>\r\n" 322 " <DefaultTile ShowName='allLogos'/>\r\n" 323 " <SplashScreen Image='%2$ls\\splash-620x300.png'/>\r\n" 324 " </VisualElements>\r\n" 325 "</Application>"; 326 327 const string16 manifest_template(ASCIIToUTF16(kManifestTemplate)); 328 329 BrowserDistribution* dist = BrowserDistribution::GetSpecificDistribution( 330 BrowserDistribution::CHROME_BROWSER); 331 // TODO(grt): http://crbug.com/75152 Write a reference to a localized 332 // resource for |display_name|. 333 string16 display_name(dist->GetAppShortCutName()); 334 EscapeXmlAttributeValueInSingleQuotes(&display_name); 335 336 // Fill the manifest with the desired values. 337 string16 manifest16(base::StringPrintf(manifest_template.c_str(), 338 display_name.c_str(), 339 elements_dir.c_str())); 340 341 // Write the manifest to |src_path|. 342 const std::string manifest(UTF16ToUTF8(manifest16)); 343 if (file_util::WriteFile( 344 src_path.Append(installer::kVisualElementsManifest), 345 manifest.c_str(), manifest.size())) { 346 VLOG(1) << "Successfully wrote " << installer::kVisualElementsManifest 347 << " to " << src_path.value(); 348 return true; 349 } else { 350 PLOG(ERROR) << "Error writing " << installer::kVisualElementsManifest 351 << " to " << src_path.value(); 352 return false; 353 } 354 } 355 } 356 357 void CreateOrUpdateShortcuts( 358 const base::FilePath& target, 359 const Product& product, 360 const MasterPreferences& prefs, 361 InstallShortcutLevel install_level, 362 InstallShortcutOperation install_operation) { 363 bool do_not_create_any_shortcuts = false; 364 prefs.GetBool(master_preferences::kDoNotCreateAnyShortcuts, 365 &do_not_create_any_shortcuts); 366 if (do_not_create_any_shortcuts) 367 return; 368 369 // Extract shortcut preferences from |prefs|. 370 bool do_not_create_desktop_shortcut = false; 371 bool do_not_create_quick_launch_shortcut = false; 372 bool do_not_create_taskbar_shortcut = false; 373 bool alternate_desktop_shortcut = false; 374 prefs.GetBool(master_preferences::kDoNotCreateDesktopShortcut, 375 &do_not_create_desktop_shortcut); 376 prefs.GetBool(master_preferences::kDoNotCreateQuickLaunchShortcut, 377 &do_not_create_quick_launch_shortcut); 378 prefs.GetBool(master_preferences::kDoNotCreateTaskbarShortcut, 379 &do_not_create_taskbar_shortcut); 380 prefs.GetBool(master_preferences::kAltShortcutText, 381 &alternate_desktop_shortcut); 382 383 BrowserDistribution* dist = product.distribution(); 384 385 // The default operation on update is to overwrite shortcuts with the 386 // currently desired properties, but do so only for shortcuts that still 387 // exist. 388 ShellUtil::ShortcutOperation shortcut_operation; 389 switch (install_operation) { 390 case INSTALL_SHORTCUT_CREATE_ALL: 391 shortcut_operation = ShellUtil::SHELL_SHORTCUT_CREATE_ALWAYS; 392 break; 393 case INSTALL_SHORTCUT_CREATE_EACH_IF_NO_SYSTEM_LEVEL: 394 shortcut_operation = ShellUtil::SHELL_SHORTCUT_CREATE_IF_NO_SYSTEM_LEVEL; 395 break; 396 default: 397 DCHECK(install_operation == INSTALL_SHORTCUT_REPLACE_EXISTING); 398 shortcut_operation = ShellUtil::SHELL_SHORTCUT_REPLACE_EXISTING; 399 break; 400 } 401 402 // Shortcuts are always installed per-user unless specified. 403 ShellUtil::ShellChange shortcut_level = (install_level == ALL_USERS ? 404 ShellUtil::SYSTEM_LEVEL : ShellUtil::CURRENT_USER); 405 406 // |base_properties|: The basic properties to set on every shortcut installed 407 // (to be refined on a per-shortcut basis). 408 ShellUtil::ShortcutProperties base_properties(shortcut_level); 409 product.AddDefaultShortcutProperties(target, &base_properties); 410 411 if (!do_not_create_desktop_shortcut || 412 shortcut_operation == ShellUtil::SHELL_SHORTCUT_REPLACE_EXISTING) { 413 ShellUtil::ShortcutProperties desktop_properties(base_properties); 414 if (alternate_desktop_shortcut) 415 desktop_properties.set_shortcut_name(dist->GetAlternateApplicationName()); 416 ExecuteAndLogShortcutOperation( 417 ShellUtil::SHORTCUT_LOCATION_DESKTOP, dist, desktop_properties, 418 shortcut_operation); 419 420 // On update there is no harm in always trying to update the alternate 421 // Desktop shortcut. 422 if (!alternate_desktop_shortcut && 423 shortcut_operation == ShellUtil::SHELL_SHORTCUT_REPLACE_EXISTING) { 424 desktop_properties.set_shortcut_name(dist->GetAlternateApplicationName()); 425 ExecuteAndLogShortcutOperation( 426 ShellUtil::SHORTCUT_LOCATION_DESKTOP, dist, desktop_properties, 427 shortcut_operation); 428 } 429 } 430 431 if (!do_not_create_quick_launch_shortcut || 432 shortcut_operation == ShellUtil::SHELL_SHORTCUT_REPLACE_EXISTING) { 433 // There is no such thing as an all-users Quick Launch shortcut, always 434 // install the per-user shortcut. 435 ShellUtil::ShortcutProperties quick_launch_properties(base_properties); 436 quick_launch_properties.level = ShellUtil::CURRENT_USER; 437 ExecuteAndLogShortcutOperation( 438 ShellUtil::SHORTCUT_LOCATION_QUICK_LAUNCH, dist, 439 quick_launch_properties, shortcut_operation); 440 } 441 442 ShellUtil::ShortcutProperties start_menu_properties(base_properties); 443 // IMPORTANT: Only the default (no arguments and default browserappid) browser 444 // shortcut in the Start menu (Start screen on Win8+) should be made dual 445 // mode. 446 start_menu_properties.set_dual_mode(true); 447 if (!do_not_create_taskbar_shortcut && 448 (shortcut_operation == ShellUtil::SHELL_SHORTCUT_CREATE_ALWAYS || 449 shortcut_operation == 450 ShellUtil::SHELL_SHORTCUT_CREATE_IF_NO_SYSTEM_LEVEL)) { 451 start_menu_properties.set_pin_to_taskbar(true); 452 } 453 ExecuteAndLogShortcutOperation(ShellUtil::SHORTCUT_LOCATION_START_MENU, 454 dist, start_menu_properties, 455 shortcut_operation); 456 } 457 458 void RegisterChromeOnMachine(const InstallerState& installer_state, 459 const Product& product, 460 bool make_chrome_default) { 461 DCHECK(product.is_chrome()); 462 463 // Try to add Chrome to Media Player shim inclusion list. We don't do any 464 // error checking here because this operation will fail if user doesn't 465 // have admin rights and we want to ignore the error. 466 AddChromeToMediaPlayerList(); 467 468 // Make Chrome the default browser if desired when possible. Otherwise, only 469 // register it with Windows. 470 BrowserDistribution* dist = product.distribution(); 471 const string16 chrome_exe( 472 installer_state.target_path().Append(installer::kChromeExe).value()); 473 VLOG(1) << "Registering Chrome as browser: " << chrome_exe; 474 if (make_chrome_default && ShellUtil::CanMakeChromeDefaultUnattended()) { 475 int level = ShellUtil::CURRENT_USER; 476 if (installer_state.system_install()) 477 level = level | ShellUtil::SYSTEM_LEVEL; 478 ShellUtil::MakeChromeDefault(dist, level, chrome_exe, true); 479 } else { 480 ShellUtil::RegisterChromeBrowser(dist, chrome_exe, string16(), false); 481 } 482 } 483 484 InstallStatus InstallOrUpdateProduct( 485 const InstallationState& original_state, 486 const InstallerState& installer_state, 487 const base::FilePath& setup_path, 488 const base::FilePath& archive_path, 489 const base::FilePath& install_temp_path, 490 const base::FilePath& src_path, 491 const base::FilePath& prefs_path, 492 const MasterPreferences& prefs, 493 const Version& new_version) { 494 // TODO(robertshield): Removing the pending on-reboot moves should be done 495 // elsewhere. 496 // TODO(erikwright): Understand why this is Chrome Frame only and whether 497 // it also applies to App Host. Shouldn't it apply to any multi-install too? 498 const Products& products = installer_state.products(); 499 DCHECK(products.size()); 500 if (installer_state.FindProduct(BrowserDistribution::CHROME_FRAME)) { 501 // Make sure that we don't end up deleting installed files on next reboot. 502 if (!RemoveFromMovesPendingReboot( 503 installer_state.target_path().value().c_str())) { 504 LOG(ERROR) << "Error accessing pending moves value."; 505 } 506 } 507 508 // Create VisualElementManifest.xml in |src_path| (if required) so that it 509 // looks as if it had been extracted from the archive when calling 510 // InstallNewVersion() below. 511 installer_state.UpdateStage(installer::CREATING_VISUAL_MANIFEST); 512 CreateVisualElementsManifest(src_path, new_version); 513 514 scoped_ptr<Version> existing_version; 515 InstallStatus result = InstallNewVersion(original_state, installer_state, 516 setup_path, archive_path, src_path, install_temp_path, new_version, 517 &existing_version); 518 519 // TODO(robertshield): Everything below this line should instead be captured 520 // by WorkItems. 521 if (!InstallUtil::GetInstallReturnCode(result)) { 522 installer_state.UpdateStage(installer::UPDATING_CHANNELS); 523 524 // Update the modifiers on the channel values for the product(s) being 525 // installed and for the binaries in case of multi-install. 526 installer_state.UpdateChannels(); 527 528 installer_state.UpdateStage(installer::COPYING_PREFERENCES_FILE); 529 530 if (result == FIRST_INSTALL_SUCCESS && !prefs_path.empty()) 531 CopyPreferenceFileForFirstRun(installer_state, prefs_path); 532 533 installer_state.UpdateStage(installer::CREATING_SHORTCUTS); 534 535 const Product* app_launcher_product = 536 installer_state.FindProduct(BrowserDistribution::CHROME_APP_HOST); 537 // Creates shortcuts for App Launcher. 538 if (app_launcher_product) { 539 // TODO(huangs): Remove this check once we have system-level App Host. 540 DCHECK(!installer_state.system_install()); 541 const base::FilePath app_host_exe( 542 installer_state.target_path().Append(kChromeAppHostExe)); 543 InstallShortcutOperation app_launcher_shortcut_operation = 544 GetAppLauncherShortcutOperation(original_state, installer_state); 545 546 // Always install per-user shortcuts for App Launcher. 547 CreateOrUpdateShortcuts(app_host_exe, *app_launcher_product, prefs, 548 CURRENT_USER, app_launcher_shortcut_operation); 549 } 550 551 const Product* chrome_product = 552 installer_state.FindProduct(BrowserDistribution::CHROME_BROWSER); 553 // Creates shortcuts for Chrome. 554 if (chrome_product) { 555 BrowserDistribution* chrome_dist = chrome_product->distribution(); 556 const base::FilePath chrome_exe( 557 installer_state.target_path().Append(kChromeExe)); 558 CleanupLegacyShortcuts(installer_state, chrome_dist, chrome_exe); 559 560 // Install per-user shortcuts on user-level installs and all-users 561 // shortcuts on system-level installs. Note that Active Setup will take 562 // care of installing missing per-user shortcuts on system-level install 563 // (i.e., quick launch, taskbar pin, and possibly deleted all-users 564 // shortcuts). 565 InstallShortcutLevel install_level = installer_state.system_install() ? 566 ALL_USERS : CURRENT_USER; 567 568 InstallShortcutOperation install_operation = 569 INSTALL_SHORTCUT_REPLACE_EXISTING; 570 if (result == installer::FIRST_INSTALL_SUCCESS || 571 result == installer::INSTALL_REPAIRED || 572 !original_state.GetProductState(installer_state.system_install(), 573 chrome_dist->GetType())) { 574 // Always create the shortcuts on a new install, a repair install, and 575 // when the Chrome product is being added to the current install. 576 install_operation = INSTALL_SHORTCUT_CREATE_ALL; 577 } 578 579 CreateOrUpdateShortcuts(chrome_exe, *chrome_product, prefs, install_level, 580 install_operation); 581 } 582 583 if (chrome_product) { 584 // Register Chrome and, if requested, make Chrome the default browser. 585 installer_state.UpdateStage(installer::REGISTERING_CHROME); 586 587 bool make_chrome_default = false; 588 prefs.GetBool(master_preferences::kMakeChromeDefault, 589 &make_chrome_default); 590 591 // If this is not the user's first Chrome install, but they have chosen 592 // Chrome to become their default browser on the download page, we must 593 // force it here because the master_preferences file will not get copied 594 // into the build. 595 bool force_chrome_default_for_user = false; 596 if (result == NEW_VERSION_UPDATED || 597 result == INSTALL_REPAIRED) { 598 prefs.GetBool(master_preferences::kMakeChromeDefaultForUser, 599 &force_chrome_default_for_user); 600 } 601 602 RegisterChromeOnMachine(installer_state, *chrome_product, 603 make_chrome_default || force_chrome_default_for_user); 604 605 // Configure auto-launch. 606 if (result == FIRST_INSTALL_SUCCESS) { 607 installer_state.UpdateStage(installer::CONFIGURE_AUTO_LAUNCH); 608 609 // Add auto-launch key if specified in master_preferences. 610 bool auto_launch_chrome = false; 611 prefs.GetBool( 612 installer::master_preferences::kAutoLaunchChrome, 613 &auto_launch_chrome); 614 if (auto_launch_chrome) { 615 auto_launch_util::EnableForegroundStartAtLogin( 616 ASCIIToUTF16(chrome::kInitialProfile), 617 installer_state.target_path()); 618 } 619 } 620 } 621 622 installer_state.UpdateStage(installer::REMOVING_OLD_VERSIONS); 623 624 installer_state.RemoveOldVersionDirectories( 625 new_version, 626 existing_version.get(), 627 install_temp_path); 628 } 629 630 return result; 631 } 632 633 void HandleOsUpgradeForBrowser(const InstallerState& installer_state, 634 const Product& chrome) { 635 DCHECK(chrome.is_chrome()); 636 // Upon upgrading to Windows 8, we need to fix Chrome shortcuts and register 637 // Chrome, so that Metro Chrome would work if Chrome is the default browser. 638 if (base::win::GetVersion() >= base::win::VERSION_WIN8) { 639 VLOG(1) << "Updating and registering shortcuts."; 640 // Read master_preferences copied beside chrome.exe at install. 641 MasterPreferences prefs( 642 installer_state.target_path().AppendASCII(kDefaultMasterPrefs)); 643 644 // Unfortunately, if this is a system-level install, we can't update the 645 // shortcuts of each individual user (this only matters if this is an OS 646 // upgrade from XP/Vista to Win7+ as some properties are only set on 647 // shortcuts as of Win7). 648 // At least attempt to update potentially existing all-users shortcuts. 649 InstallShortcutLevel level = installer_state.system_install() ? 650 ALL_USERS : CURRENT_USER; 651 base::FilePath chrome_exe(installer_state.target_path().Append(kChromeExe)); 652 CreateOrUpdateShortcuts( 653 chrome_exe, chrome, prefs, level, INSTALL_SHORTCUT_REPLACE_EXISTING); 654 RegisterChromeOnMachine(installer_state, chrome, false); 655 } 656 } 657 658 // NOTE: Should the work done here, on Active Setup, change: kActiveSetupVersion 659 // in install_worker.cc needs to be increased for Active Setup to invoke this 660 // again for all users of this install. 661 void HandleActiveSetupForBrowser(const base::FilePath& installation_root, 662 const Product& chrome, 663 bool force) { 664 DCHECK(chrome.is_chrome()); 665 // Only create shortcuts on Active Setup if the first run sentinel is not 666 // present for this user (as some shortcuts used to be installed on first 667 // run and this could otherwise re-install shortcuts for users that have 668 // already deleted them in the past). 669 base::FilePath first_run_sentinel; 670 InstallUtil::GetSentinelFilePath( 671 chrome::kFirstRunSentinel, chrome.distribution(), &first_run_sentinel); 672 // Decide whether to create the shortcuts or simply replace existing 673 // shortcuts; if the decision is to create them, only shortcuts whose matching 674 // all-users shortcut isn't present on the system will be created. 675 InstallShortcutOperation install_operation = 676 (!force && base::PathExists(first_run_sentinel) ? 677 INSTALL_SHORTCUT_REPLACE_EXISTING : 678 INSTALL_SHORTCUT_CREATE_EACH_IF_NO_SYSTEM_LEVEL); 679 680 // Read master_preferences copied beside chrome.exe at install. 681 MasterPreferences prefs(installation_root.AppendASCII(kDefaultMasterPrefs)); 682 base::FilePath chrome_exe(installation_root.Append(kChromeExe)); 683 CreateOrUpdateShortcuts( 684 chrome_exe, chrome, prefs, CURRENT_USER, install_operation); 685 } 686 687 bool InstallFromWebstore(const std::string& app_code) { 688 base::FilePath app_host_path(chrome_launcher_support::GetAnyAppHostPath()); 689 if (app_host_path.empty()) 690 return false; 691 692 CommandLine cmd(app_host_path); 693 cmd.AppendSwitchASCII(::switches::kInstallFromWebstore, app_code); 694 VLOG(1) << "App install command: " << cmd.GetCommandLineString(); 695 return base::LaunchProcess(cmd, base::LaunchOptions(), NULL); 696 } 697 698 } // namespace installer 699
