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