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/shell_integration.h" 6 7 #include <windows.h> 8 #include <shlwapi.h> 9 #include <shobjidl.h> 10 #include <propkey.h> // Needs to come after shobjidl.h. 11 12 #include "base/bind.h" 13 #include "base/command_line.h" 14 #include "base/files/file_enumerator.h" 15 #include "base/files/file_util.h" 16 #include "base/message_loop/message_loop.h" 17 #include "base/path_service.h" 18 #include "base/strings/string_number_conversions.h" 19 #include "base/strings/string_util.h" 20 #include "base/strings/stringprintf.h" 21 #include "base/strings/utf_string_conversions.h" 22 #include "base/win/registry.h" 23 #include "base/win/scoped_comptr.h" 24 #include "base/win/scoped_propvariant.h" 25 #include "base/win/shortcut.h" 26 #include "base/win/windows_version.h" 27 #include "chrome/browser/policy/policy_path_parser.h" 28 #include "chrome/browser/web_applications/web_app.h" 29 #include "chrome/common/chrome_constants.h" 30 #include "chrome/common/chrome_paths_internal.h" 31 #include "chrome/common/chrome_switches.h" 32 #include "chrome/installer/setup/setup_util.h" 33 #include "chrome/installer/util/browser_distribution.h" 34 #include "chrome/installer/util/create_reg_key_work_item.h" 35 #include "chrome/installer/util/install_util.h" 36 #include "chrome/installer/util/set_reg_value_work_item.h" 37 #include "chrome/installer/util/shell_util.h" 38 #include "chrome/installer/util/util_constants.h" 39 #include "chrome/installer/util/work_item.h" 40 #include "chrome/installer/util/work_item_list.h" 41 #include "content/public/browser/browser_thread.h" 42 43 using content::BrowserThread; 44 45 namespace { 46 47 const wchar_t kAppListAppNameSuffix[] = L"AppList"; 48 49 // Helper function for ShellIntegration::GetAppId to generates profile id 50 // from profile path. "profile_id" is composed of sanitized basenames of 51 // user data dir and profile dir joined by a ".". 52 base::string16 GetProfileIdFromPath(const base::FilePath& profile_path) { 53 // Return empty string if profile_path is empty 54 if (profile_path.empty()) 55 return base::string16(); 56 57 base::FilePath default_user_data_dir; 58 // Return empty string if profile_path is in default user data 59 // dir and is the default profile. 60 if (chrome::GetDefaultUserDataDirectory(&default_user_data_dir) && 61 profile_path.DirName() == default_user_data_dir && 62 profile_path.BaseName().value() == 63 base::ASCIIToUTF16(chrome::kInitialProfile)) { 64 return base::string16(); 65 } 66 67 // Get joined basenames of user data dir and profile. 68 base::string16 basenames = profile_path.DirName().BaseName().value() + 69 L"." + profile_path.BaseName().value(); 70 71 base::string16 profile_id; 72 profile_id.reserve(basenames.size()); 73 74 // Generate profile_id from sanitized basenames. 75 for (size_t i = 0; i < basenames.length(); ++i) { 76 if (IsAsciiAlpha(basenames[i]) || 77 IsAsciiDigit(basenames[i]) || 78 basenames[i] == L'.') 79 profile_id += basenames[i]; 80 } 81 82 return profile_id; 83 } 84 85 base::string16 GetAppListAppName() { 86 BrowserDistribution* dist = BrowserDistribution::GetDistribution(); 87 base::string16 app_name(dist->GetBaseAppId()); 88 app_name.append(kAppListAppNameSuffix); 89 return app_name; 90 } 91 92 // Gets expected app id for given Chrome (based on |command_line| and 93 // |is_per_user_install|). 94 base::string16 GetExpectedAppId(const CommandLine& command_line, 95 bool is_per_user_install) { 96 base::FilePath user_data_dir; 97 if (command_line.HasSwitch(switches::kUserDataDir)) 98 user_data_dir = command_line.GetSwitchValuePath(switches::kUserDataDir); 99 else 100 chrome::GetDefaultUserDataDirectory(&user_data_dir); 101 // Adjust with any policy that overrides any other way to set the path. 102 policy::path_parser::CheckUserDataDirPolicy(&user_data_dir); 103 DCHECK(!user_data_dir.empty()); 104 105 base::FilePath profile_subdir; 106 if (command_line.HasSwitch(switches::kProfileDirectory)) { 107 profile_subdir = 108 command_line.GetSwitchValuePath(switches::kProfileDirectory); 109 } else { 110 profile_subdir = 111 base::FilePath(base::ASCIIToUTF16(chrome::kInitialProfile)); 112 } 113 DCHECK(!profile_subdir.empty()); 114 115 base::FilePath profile_path = user_data_dir.Append(profile_subdir); 116 base::string16 app_name; 117 if (command_line.HasSwitch(switches::kApp)) { 118 app_name = base::UTF8ToUTF16(web_app::GenerateApplicationNameFromURL( 119 GURL(command_line.GetSwitchValueASCII(switches::kApp)))); 120 } else if (command_line.HasSwitch(switches::kAppId)) { 121 app_name = base::UTF8ToUTF16( 122 web_app::GenerateApplicationNameFromExtensionId( 123 command_line.GetSwitchValueASCII(switches::kAppId))); 124 } else if (command_line.HasSwitch(switches::kShowAppList)) { 125 app_name = GetAppListAppName(); 126 } else { 127 BrowserDistribution* dist = BrowserDistribution::GetDistribution(); 128 app_name = ShellUtil::GetBrowserModelId(dist, is_per_user_install); 129 } 130 DCHECK(!app_name.empty()); 131 132 return ShellIntegration::GetAppModelIdForProfile(app_name, profile_path); 133 } 134 135 void MigrateChromiumShortcutsCallback() { 136 // This should run on the file thread. 137 DCHECK(BrowserThread::CurrentlyOn(BrowserThread::FILE)); 138 139 // Get full path of chrome. 140 base::FilePath chrome_exe; 141 if (!PathService::Get(base::FILE_EXE, &chrome_exe)) 142 return; 143 144 // Locations to check for shortcuts migration. 145 static const struct { 146 int location_id; 147 const wchar_t* sub_dir; 148 } kLocations[] = { 149 { 150 base::DIR_TASKBAR_PINS, 151 NULL 152 }, { 153 base::DIR_USER_DESKTOP, 154 NULL 155 }, { 156 base::DIR_START_MENU, 157 NULL 158 }, { 159 base::DIR_APP_DATA, 160 L"Microsoft\\Internet Explorer\\Quick Launch\\User Pinned\\StartMenu" 161 } 162 }; 163 164 for (int i = 0; i < arraysize(kLocations); ++i) { 165 base::FilePath path; 166 if (!PathService::Get(kLocations[i].location_id, &path)) { 167 NOTREACHED(); 168 continue; 169 } 170 171 if (kLocations[i].sub_dir) 172 path = path.Append(kLocations[i].sub_dir); 173 174 bool check_dual_mode = (kLocations[i].location_id == base::DIR_START_MENU); 175 ShellIntegration::MigrateShortcutsInPathInternal(chrome_exe, path, 176 check_dual_mode); 177 } 178 } 179 180 // Windows 8 introduced a new protocol->executable binding system which cannot 181 // be retrieved in the HKCR registry subkey method implemented below. We call 182 // AssocQueryString with the new Win8-only flag ASSOCF_IS_PROTOCOL instead. 183 base::string16 GetAppForProtocolUsingAssocQuery(const GURL& url) { 184 base::string16 url_scheme = base::ASCIIToWide(url.scheme()); 185 // Don't attempt to query protocol association on an empty string. 186 if (url_scheme.empty()) 187 return base::string16(); 188 189 // Query AssocQueryString for a human-readable description of the program 190 // that will be invoked given the provided URL spec. This is used only to 191 // populate the external protocol dialog box the user sees when invoking 192 // an unknown external protocol. 193 wchar_t out_buffer[1024]; 194 DWORD buffer_size = arraysize(out_buffer); 195 HRESULT hr = AssocQueryString(ASSOCF_IS_PROTOCOL, 196 ASSOCSTR_FRIENDLYAPPNAME, 197 url_scheme.c_str(), 198 NULL, 199 out_buffer, 200 &buffer_size); 201 if (FAILED(hr)) { 202 DLOG(WARNING) << "AssocQueryString failed!"; 203 return base::string16(); 204 } 205 return base::string16(out_buffer); 206 } 207 208 base::string16 GetAppForProtocolUsingRegistry(const GURL& url) { 209 base::string16 url_spec = base::ASCIIToWide(url.possibly_invalid_spec()); 210 const base::string16 cmd_key_path = 211 base::ASCIIToWide(url.scheme() + "\\shell\\open\\command"); 212 base::win::RegKey cmd_key(HKEY_CLASSES_ROOT, 213 cmd_key_path.c_str(), 214 KEY_READ); 215 size_t split_offset = url_spec.find(L':'); 216 if (split_offset == base::string16::npos) 217 return base::string16(); 218 const base::string16 parameters = url_spec.substr(split_offset + 1, 219 url_spec.length() - 1); 220 base::string16 application_to_launch; 221 if (cmd_key.ReadValue(NULL, &application_to_launch) == ERROR_SUCCESS) { 222 ReplaceSubstringsAfterOffset(&application_to_launch, 223 0, 224 L"%1", 225 parameters); 226 return application_to_launch; 227 } 228 return base::string16(); 229 } 230 231 232 ShellIntegration::DefaultWebClientState 233 GetDefaultWebClientStateFromShellUtilDefaultState( 234 ShellUtil::DefaultState default_state) { 235 switch (default_state) { 236 case ShellUtil::NOT_DEFAULT: 237 return ShellIntegration::NOT_DEFAULT; 238 case ShellUtil::IS_DEFAULT: 239 return ShellIntegration::IS_DEFAULT; 240 default: 241 DCHECK_EQ(ShellUtil::UNKNOWN_DEFAULT, default_state); 242 return ShellIntegration::UNKNOWN_DEFAULT; 243 } 244 } 245 246 } // namespace 247 248 ShellIntegration::DefaultWebClientSetPermission 249 ShellIntegration::CanSetAsDefaultBrowser() { 250 BrowserDistribution* distribution = BrowserDistribution::GetDistribution(); 251 if (distribution->GetDefaultBrowserControlPolicy() != 252 BrowserDistribution::DEFAULT_BROWSER_FULL_CONTROL) 253 return SET_DEFAULT_NOT_ALLOWED; 254 255 if (ShellUtil::CanMakeChromeDefaultUnattended()) 256 return SET_DEFAULT_UNATTENDED; 257 else 258 return SET_DEFAULT_INTERACTIVE; 259 } 260 261 bool ShellIntegration::SetAsDefaultBrowser() { 262 base::FilePath chrome_exe; 263 if (!PathService::Get(base::FILE_EXE, &chrome_exe)) { 264 LOG(ERROR) << "Error getting app exe path"; 265 return false; 266 } 267 268 // From UI currently we only allow setting default browser for current user. 269 BrowserDistribution* dist = BrowserDistribution::GetDistribution(); 270 if (!ShellUtil::MakeChromeDefault(dist, ShellUtil::CURRENT_USER, 271 chrome_exe.value(), true)) { 272 LOG(ERROR) << "Chrome could not be set as default browser."; 273 return false; 274 } 275 276 VLOG(1) << "Chrome registered as default browser."; 277 return true; 278 } 279 280 bool ShellIntegration::SetAsDefaultProtocolClient(const std::string& protocol) { 281 if (protocol.empty()) 282 return false; 283 284 base::FilePath chrome_exe; 285 if (!PathService::Get(base::FILE_EXE, &chrome_exe)) { 286 LOG(ERROR) << "Error getting app exe path"; 287 return false; 288 } 289 290 base::string16 wprotocol(base::UTF8ToUTF16(protocol)); 291 BrowserDistribution* dist = BrowserDistribution::GetDistribution(); 292 if (!ShellUtil::MakeChromeDefaultProtocolClient(dist, chrome_exe.value(), 293 wprotocol)) { 294 LOG(ERROR) << "Chrome could not be set as default handler for " 295 << protocol << "."; 296 return false; 297 } 298 299 VLOG(1) << "Chrome registered as default handler for " << protocol << "."; 300 return true; 301 } 302 303 bool ShellIntegration::SetAsDefaultBrowserInteractive() { 304 base::FilePath chrome_exe; 305 if (!PathService::Get(base::FILE_EXE, &chrome_exe)) { 306 NOTREACHED() << "Error getting app exe path"; 307 return false; 308 } 309 310 BrowserDistribution* dist = BrowserDistribution::GetDistribution(); 311 if (!ShellUtil::ShowMakeChromeDefaultSystemUI(dist, chrome_exe.value())) { 312 LOG(ERROR) << "Failed to launch the set-default-browser Windows UI."; 313 return false; 314 } 315 316 VLOG(1) << "Set-default-browser Windows UI completed."; 317 return true; 318 } 319 320 bool ShellIntegration::SetAsDefaultProtocolClientInteractive( 321 const std::string& protocol) { 322 base::FilePath chrome_exe; 323 if (!PathService::Get(base::FILE_EXE, &chrome_exe)) { 324 NOTREACHED() << "Error getting app exe path"; 325 return false; 326 } 327 328 BrowserDistribution* dist = BrowserDistribution::GetDistribution(); 329 base::string16 wprotocol(base::UTF8ToUTF16(protocol)); 330 if (!ShellUtil::ShowMakeChromeDefaultProtocolClientSystemUI( 331 dist, chrome_exe.value(), wprotocol)) { 332 LOG(ERROR) << "Failed to launch the set-default-client Windows UI."; 333 return false; 334 } 335 336 VLOG(1) << "Set-default-client Windows UI completed."; 337 return true; 338 } 339 340 ShellIntegration::DefaultWebClientState ShellIntegration::GetDefaultBrowser() { 341 return GetDefaultWebClientStateFromShellUtilDefaultState( 342 ShellUtil::GetChromeDefaultState()); 343 } 344 345 ShellIntegration::DefaultWebClientState 346 ShellIntegration::IsDefaultProtocolClient(const std::string& protocol) { 347 return GetDefaultWebClientStateFromShellUtilDefaultState( 348 ShellUtil::GetChromeDefaultProtocolClientState( 349 base::UTF8ToUTF16(protocol))); 350 } 351 352 base::string16 ShellIntegration::GetApplicationNameForProtocol( 353 const GURL& url) { 354 // Windows 8 or above requires a new protocol association query. 355 if (base::win::GetVersion() >= base::win::VERSION_WIN8) 356 return GetAppForProtocolUsingAssocQuery(url); 357 else 358 return GetAppForProtocolUsingRegistry(url); 359 } 360 361 // There is no reliable way to say which browser is default on a machine (each 362 // browser can have some of the protocols/shortcuts). So we look for only HTTP 363 // protocol handler. Even this handler is located at different places in 364 // registry on XP and Vista: 365 // - HKCR\http\shell\open\command (XP) 366 // - HKCU\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\ 367 // http\UserChoice (Vista) 368 // This method checks if Firefox is defualt browser by checking these 369 // locations and returns true if Firefox traces are found there. In case of 370 // error (or if Firefox is not found)it returns the default value which 371 // is false. 372 bool ShellIntegration::IsFirefoxDefaultBrowser() { 373 bool ff_default = false; 374 if (base::win::GetVersion() >= base::win::VERSION_VISTA) { 375 base::string16 app_cmd; 376 base::win::RegKey key(HKEY_CURRENT_USER, 377 ShellUtil::kRegVistaUrlPrefs, KEY_READ); 378 if (key.Valid() && (key.ReadValue(L"Progid", &app_cmd) == ERROR_SUCCESS) && 379 app_cmd == L"FirefoxURL") 380 ff_default = true; 381 } else { 382 base::string16 key_path(L"http"); 383 key_path.append(ShellUtil::kRegShellOpen); 384 base::win::RegKey key(HKEY_CLASSES_ROOT, key_path.c_str(), KEY_READ); 385 base::string16 app_cmd; 386 if (key.Valid() && (key.ReadValue(L"", &app_cmd) == ERROR_SUCCESS) && 387 base::string16::npos != 388 base::StringToLowerASCII(app_cmd).find(L"firefox")) 389 ff_default = true; 390 } 391 return ff_default; 392 } 393 394 base::string16 ShellIntegration::GetAppModelIdForProfile( 395 const base::string16& app_name, 396 const base::FilePath& profile_path) { 397 std::vector<base::string16> components; 398 components.push_back(app_name); 399 const base::string16 profile_id(GetProfileIdFromPath(profile_path)); 400 if (!profile_id.empty()) 401 components.push_back(profile_id); 402 return ShellUtil::BuildAppModelId(components); 403 } 404 405 base::string16 ShellIntegration::GetChromiumModelIdForProfile( 406 const base::FilePath& profile_path) { 407 BrowserDistribution* dist = BrowserDistribution::GetDistribution(); 408 base::FilePath chrome_exe; 409 if (!PathService::Get(base::FILE_EXE, &chrome_exe)) { 410 NOTREACHED(); 411 return dist->GetBaseAppId(); 412 } 413 return GetAppModelIdForProfile( 414 ShellUtil::GetBrowserModelId( 415 dist, InstallUtil::IsPerUserInstall(chrome_exe.value().c_str())), 416 profile_path); 417 } 418 419 base::string16 ShellIntegration::GetAppListAppModelIdForProfile( 420 const base::FilePath& profile_path) { 421 return ShellIntegration::GetAppModelIdForProfile( 422 GetAppListAppName(), profile_path); 423 } 424 425 void ShellIntegration::MigrateChromiumShortcuts() { 426 if (base::win::GetVersion() < base::win::VERSION_WIN7) 427 return; 428 429 // This needs to happen eventually (e.g. so that the appid is fixed and the 430 // run-time Chrome icon is merged with the taskbar shortcut), but this is not 431 // urgent and shouldn't delay Chrome startup. 432 static const int64 kMigrateChromiumShortcutsDelaySeconds = 15; 433 BrowserThread::PostDelayedTask( 434 BrowserThread::FILE, FROM_HERE, 435 base::Bind(&MigrateChromiumShortcutsCallback), 436 base::TimeDelta::FromSeconds(kMigrateChromiumShortcutsDelaySeconds)); 437 } 438 439 int ShellIntegration::MigrateShortcutsInPathInternal( 440 const base::FilePath& chrome_exe, 441 const base::FilePath& path, 442 bool check_dual_mode) { 443 DCHECK(base::win::GetVersion() >= base::win::VERSION_WIN7); 444 445 // Enumerate all pinned shortcuts in the given path directly. 446 base::FileEnumerator shortcuts_enum( 447 path, false, // not recursive 448 base::FileEnumerator::FILES, FILE_PATH_LITERAL("*.lnk")); 449 450 bool is_per_user_install = 451 InstallUtil::IsPerUserInstall(chrome_exe.value().c_str()); 452 453 int shortcuts_migrated = 0; 454 base::FilePath target_path; 455 base::string16 arguments; 456 base::win::ScopedPropVariant propvariant; 457 for (base::FilePath shortcut = shortcuts_enum.Next(); !shortcut.empty(); 458 shortcut = shortcuts_enum.Next()) { 459 // TODO(gab): Use ProgramCompare instead of comparing FilePaths below once 460 // it is fixed to work with FilePaths with spaces. 461 if (!base::win::ResolveShortcut(shortcut, &target_path, &arguments) || 462 chrome_exe != target_path) { 463 continue; 464 } 465 CommandLine command_line(CommandLine::FromString(base::StringPrintf( 466 L"\"%ls\" %ls", target_path.value().c_str(), arguments.c_str()))); 467 468 // Get the expected AppId for this Chrome shortcut. 469 base::string16 expected_app_id( 470 GetExpectedAppId(command_line, is_per_user_install)); 471 if (expected_app_id.empty()) 472 continue; 473 474 // Load the shortcut. 475 base::win::ScopedComPtr<IShellLink> shell_link; 476 base::win::ScopedComPtr<IPersistFile> persist_file; 477 if (FAILED(shell_link.CreateInstance(CLSID_ShellLink, NULL, 478 CLSCTX_INPROC_SERVER)) || 479 FAILED(persist_file.QueryFrom(shell_link)) || 480 FAILED(persist_file->Load(shortcut.value().c_str(), STGM_READ))) { 481 DLOG(WARNING) << "Failed loading shortcut at " << shortcut.value(); 482 continue; 483 } 484 485 // Any properties that need to be updated on the shortcut will be stored in 486 // |updated_properties|. 487 base::win::ShortcutProperties updated_properties; 488 489 // Validate the existing app id for the shortcut. 490 base::win::ScopedComPtr<IPropertyStore> property_store; 491 propvariant.Reset(); 492 if (FAILED(property_store.QueryFrom(shell_link)) || 493 property_store->GetValue(PKEY_AppUserModel_ID, 494 propvariant.Receive()) != S_OK) { 495 // When in doubt, prefer not updating the shortcut. 496 NOTREACHED(); 497 continue; 498 } else { 499 switch (propvariant.get().vt) { 500 case VT_EMPTY: 501 // If there is no app_id set, set our app_id if one is expected. 502 if (!expected_app_id.empty()) 503 updated_properties.set_app_id(expected_app_id); 504 break; 505 case VT_LPWSTR: 506 if (expected_app_id != base::string16(propvariant.get().pwszVal)) 507 updated_properties.set_app_id(expected_app_id); 508 break; 509 default: 510 NOTREACHED(); 511 continue; 512 } 513 } 514 515 // Only set dual mode if the expected app id is the default app id. 516 BrowserDistribution* dist = BrowserDistribution::GetDistribution(); 517 base::string16 default_chromium_model_id( 518 ShellUtil::GetBrowserModelId(dist, is_per_user_install)); 519 if (check_dual_mode && expected_app_id == default_chromium_model_id) { 520 propvariant.Reset(); 521 if (property_store->GetValue(PKEY_AppUserModel_IsDualMode, 522 propvariant.Receive()) != S_OK) { 523 // When in doubt, prefer to not update the shortcut. 524 NOTREACHED(); 525 continue; 526 } else { 527 switch (propvariant.get().vt) { 528 case VT_EMPTY: 529 // If dual_mode is not set at all, make sure it gets set to true. 530 updated_properties.set_dual_mode(true); 531 break; 532 case VT_BOOL: 533 // If it is set to false, make sure it gets set to true as well. 534 if (!propvariant.get().boolVal) 535 updated_properties.set_dual_mode(true); 536 break; 537 default: 538 NOTREACHED(); 539 continue; 540 } 541 } 542 } 543 544 persist_file.Release(); 545 shell_link.Release(); 546 547 // Update the shortcut if some of its properties need to be updated. 548 if (updated_properties.options && 549 base::win::CreateOrUpdateShortcutLink( 550 shortcut, updated_properties, 551 base::win::SHORTCUT_UPDATE_EXISTING)) { 552 ++shortcuts_migrated; 553 } 554 } 555 return shortcuts_migrated; 556 } 557 558 base::FilePath ShellIntegration::GetStartMenuShortcut( 559 const base::FilePath& chrome_exe) { 560 static const int kFolderIds[] = { 561 base::DIR_COMMON_START_MENU, 562 base::DIR_START_MENU, 563 }; 564 BrowserDistribution* dist = BrowserDistribution::GetDistribution(); 565 base::string16 shortcut_name( 566 dist->GetShortcutName(BrowserDistribution::SHORTCUT_CHROME)); 567 base::FilePath shortcut; 568 569 // Check both the common and the per-user Start Menu folders for system-level 570 // installs. 571 size_t folder = 572 InstallUtil::IsPerUserInstall(chrome_exe.value().c_str()) ? 1 : 0; 573 for (; folder < arraysize(kFolderIds); ++folder) { 574 if (!PathService::Get(kFolderIds[folder], &shortcut)) { 575 NOTREACHED(); 576 continue; 577 } 578 579 shortcut = shortcut.Append(shortcut_name).Append(shortcut_name + 580 installer::kLnkExt); 581 if (base::PathExists(shortcut)) 582 return shortcut; 583 } 584 585 return base::FilePath(); 586 } 587