chrome/browser/shell_integration_win.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 #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 (base::IsAsciiAlpha(basenames[i]) ||
  77         base::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 base::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                            kLocations[i].location_id == base::DIR_TASKBAR_PINS;
 176     ShellIntegration::MigrateShortcutsInPathInternal(chrome_exe, path,
 177                                                      check_dual_mode);
 178   }
 179 }
 180
 181 // Windows 8 introduced a new protocol->executable binding system which cannot
 182 // be retrieved in the HKCR registry subkey method implemented below. We call
 183 // AssocQueryString with the new Win8-only flag ASSOCF_IS_PROTOCOL instead.
 184 base::string16 GetAppForProtocolUsingAssocQuery(const GURL& url) {
 185   base::string16 url_scheme = base::ASCIIToUTF16(url.scheme());
 186   // Don't attempt to query protocol association on an empty string.
 187   if (url_scheme.empty())
 188     return base::string16();
 189
 190   // Query AssocQueryString for a human-readable description of the program
 191   // that will be invoked given the provided URL spec. This is used only to
 192   // populate the external protocol dialog box the user sees when invoking
 193   // an unknown external protocol.
 194   wchar_t out_buffer[1024];
 195   DWORD buffer_size = arraysize(out_buffer);
 196   HRESULT hr = AssocQueryString(ASSOCF_IS_PROTOCOL,
 197                                 ASSOCSTR_FRIENDLYAPPNAME,
 198                                 url_scheme.c_str(),
 199                                 NULL,
 200                                 out_buffer,
 201                                 &buffer_size);
 202   if (FAILED(hr)) {
 203     DLOG(WARNING) << "AssocQueryString failed!";
 204     return base::string16();
 205   }
 206   return base::string16(out_buffer);
 207 }
 208
 209 base::string16 GetAppForProtocolUsingRegistry(const GURL& url) {
 210   const base::string16 cmd_key_path =
 211       base::ASCIIToUTF16(url.scheme() + "\\shell\\open\\command");
 212   base::win::RegKey cmd_key(HKEY_CLASSES_ROOT,
 213                             cmd_key_path.c_str(),
 214                             KEY_READ);
 215   base::string16 application_to_launch;
 216   if (cmd_key.ReadValue(NULL, &application_to_launch) == ERROR_SUCCESS) {
 217     const base::string16 url_spec =
 218         base::ASCIIToUTF16(url.possibly_invalid_spec());
 219     base::ReplaceSubstringsAfterOffset(&application_to_launch,
 220                                        0,
 221                                        L"%1",
 222                                        url_spec);
 223     return application_to_launch;
 224   }
 225   return base::string16();
 226 }
 227
 228
 229 ShellIntegration::DefaultWebClientState
 230     GetDefaultWebClientStateFromShellUtilDefaultState(
 231         ShellUtil::DefaultState default_state) {
 232   switch (default_state) {
 233     case ShellUtil::NOT_DEFAULT:
 234       return ShellIntegration::NOT_DEFAULT;
 235     case ShellUtil::IS_DEFAULT:
 236       return ShellIntegration::IS_DEFAULT;
 237     default:
 238       DCHECK_EQ(ShellUtil::UNKNOWN_DEFAULT, default_state);
 239       return ShellIntegration::UNKNOWN_DEFAULT;
 240   }
 241 }
 242
 243 }  // namespace
 244
 245 ShellIntegration::DefaultWebClientSetPermission
 246     ShellIntegration::CanSetAsDefaultBrowser() {
 247   BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
 248   if (distribution->GetDefaultBrowserControlPolicy() !=
 249           BrowserDistribution::DEFAULT_BROWSER_FULL_CONTROL)
 250     return SET_DEFAULT_NOT_ALLOWED;
 251
 252   if (ShellUtil::CanMakeChromeDefaultUnattended())
 253     return SET_DEFAULT_UNATTENDED;
 254   else
 255     return SET_DEFAULT_INTERACTIVE;
 256 }
 257
 258 bool ShellIntegration::SetAsDefaultBrowser() {
 259   base::FilePath chrome_exe;
 260   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
 261     LOG(ERROR) << "Error getting app exe path";
 262     return false;
 263   }
 264
 265   // From UI currently we only allow setting default browser for current user.
 266   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 267   if (!ShellUtil::MakeChromeDefault(dist, ShellUtil::CURRENT_USER, chrome_exe,
 268                                     true /* elevate_if_not_admin */)) {
 269     LOG(ERROR) << "Chrome could not be set as default browser.";
 270     return false;
 271   }
 272
 273   VLOG(1) << "Chrome registered as default browser.";
 274   return true;
 275 }
 276
 277 bool ShellIntegration::SetAsDefaultProtocolClient(const std::string& protocol) {
 278   if (protocol.empty())
 279     return false;
 280
 281   base::FilePath chrome_exe;
 282   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
 283     LOG(ERROR) << "Error getting app exe path";
 284     return false;
 285   }
 286
 287   base::string16 wprotocol(base::UTF8ToUTF16(protocol));
 288   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 289   if (!ShellUtil::MakeChromeDefaultProtocolClient(dist, chrome_exe,
 290                                                   wprotocol)) {
 291     LOG(ERROR) << "Chrome could not be set as default handler for "
 292                << protocol << ".";
 293     return false;
 294   }
 295
 296   VLOG(1) << "Chrome registered as default handler for " << protocol << ".";
 297   return true;
 298 }
 299
 300 bool ShellIntegration::SetAsDefaultBrowserInteractive() {
 301   base::FilePath chrome_exe;
 302   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
 303     NOTREACHED() << "Error getting app exe path";
 304     return false;
 305   }
 306
 307   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 308   if (!ShellUtil::ShowMakeChromeDefaultSystemUI(dist, chrome_exe)) {
 309     LOG(ERROR) << "Failed to launch the set-default-browser Windows UI.";
 310     return false;
 311   }
 312
 313   VLOG(1) << "Set-default-browser Windows UI completed.";
 314   return true;
 315 }
 316
 317 bool ShellIntegration::SetAsDefaultProtocolClientInteractive(
 318     const std::string& protocol) {
 319   base::FilePath chrome_exe;
 320   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
 321     NOTREACHED() << "Error getting app exe path";
 322     return false;
 323   }
 324
 325   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 326   base::string16 wprotocol(base::UTF8ToUTF16(protocol));
 327   if (!ShellUtil::ShowMakeChromeDefaultProtocolClientSystemUI(dist, chrome_exe,
 328                                                               wprotocol)) {
 329     LOG(ERROR) << "Failed to launch the set-default-client Windows UI.";
 330     return false;
 331   }
 332
 333   VLOG(1) << "Set-default-client Windows UI completed.";
 334   return true;
 335 }
 336
 337 ShellIntegration::DefaultWebClientState ShellIntegration::GetDefaultBrowser() {
 338   return GetDefaultWebClientStateFromShellUtilDefaultState(
 339       ShellUtil::GetChromeDefaultState());
 340 }
 341
 342 ShellIntegration::DefaultWebClientState
 343     ShellIntegration::IsDefaultProtocolClient(const std::string& protocol) {
 344   return GetDefaultWebClientStateFromShellUtilDefaultState(
 345       ShellUtil::GetChromeDefaultProtocolClientState(
 346           base::UTF8ToUTF16(protocol)));
 347 }
 348
 349 base::string16 ShellIntegration::GetApplicationNameForProtocol(
 350     const GURL& url) {
 351   // Windows 8 or above requires a new protocol association query.
 352   if (base::win::GetVersion() >= base::win::VERSION_WIN8)
 353     return GetAppForProtocolUsingAssocQuery(url);
 354   else
 355     return GetAppForProtocolUsingRegistry(url);
 356 }
 357
 358 // There is no reliable way to say which browser is default on a machine (each
 359 // browser can have some of the protocols/shortcuts). So we look for only HTTP
 360 // protocol handler. Even this handler is located at different places in
 361 // registry on XP and Vista:
 362 // - HKCR\http\shell\open\command (XP)
 363 // - HKCU\Software\Microsoft\Windows\Shell\Associations\UrlAssociations\
 364 //   http\UserChoice (Vista)
 365 // This method checks if Firefox is defualt browser by checking these
 366 // locations and returns true if Firefox traces are found there. In case of
 367 // error (or if Firefox is not found)it returns the default value which
 368 // is false.
 369 bool ShellIntegration::IsFirefoxDefaultBrowser() {
 370   bool ff_default = false;
 371   if (base::win::GetVersion() >= base::win::VERSION_VISTA) {
 372     base::string16 app_cmd;
 373     base::win::RegKey key(HKEY_CURRENT_USER,
 374                           ShellUtil::kRegVistaUrlPrefs, KEY_READ);
 375     if (key.Valid() && (key.ReadValue(L"Progid", &app_cmd) == ERROR_SUCCESS) &&
 376         app_cmd == L"FirefoxURL")
 377       ff_default = true;
 378   } else {
 379     base::string16 key_path(L"http");
 380     key_path.append(ShellUtil::kRegShellOpen);
 381     base::win::RegKey key(HKEY_CLASSES_ROOT, key_path.c_str(), KEY_READ);
 382     base::string16 app_cmd;
 383     if (key.Valid() && (key.ReadValue(L"", &app_cmd) == ERROR_SUCCESS) &&
 384         base::string16::npos !=
 385         base::ToLowerASCII(app_cmd).find(L"firefox"))
 386       ff_default = true;
 387   }
 388   return ff_default;
 389 }
 390
 391 base::string16 ShellIntegration::GetAppModelIdForProfile(
 392     const base::string16& app_name,
 393     const base::FilePath& profile_path) {
 394   std::vector<base::string16> components;
 395   components.push_back(app_name);
 396   const base::string16 profile_id(GetProfileIdFromPath(profile_path));
 397   if (!profile_id.empty())
 398     components.push_back(profile_id);
 399   return ShellUtil::BuildAppModelId(components);
 400 }
 401
 402 base::string16 ShellIntegration::GetChromiumModelIdForProfile(
 403     const base::FilePath& profile_path) {
 404   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 405   base::FilePath chrome_exe;
 406   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
 407     NOTREACHED();
 408     return dist->GetBaseAppId();
 409   }
 410   return GetAppModelIdForProfile(
 411       ShellUtil::GetBrowserModelId(dist,
 412                                    InstallUtil::IsPerUserInstall(chrome_exe)),
 413       profile_path);
 414 }
 415
 416 base::string16 ShellIntegration::GetAppListAppModelIdForProfile(
 417     const base::FilePath& profile_path) {
 418   return ShellIntegration::GetAppModelIdForProfile(
 419       GetAppListAppName(), profile_path);
 420 }
 421
 422 void ShellIntegration::MigrateChromiumShortcuts() {
 423   if (base::win::GetVersion() < base::win::VERSION_WIN7)
 424     return;
 425
 426   // This needs to happen eventually (e.g. so that the appid is fixed and the
 427   // run-time Chrome icon is merged with the taskbar shortcut), but this is not
 428   // urgent and shouldn't delay Chrome startup.
 429   static const int64 kMigrateChromiumShortcutsDelaySeconds = 15;
 430   BrowserThread::PostDelayedTask(
 431       BrowserThread::FILE, FROM_HERE,
 432       base::Bind(&MigrateChromiumShortcutsCallback),
 433       base::TimeDelta::FromSeconds(kMigrateChromiumShortcutsDelaySeconds));
 434 }
 435
 436 int ShellIntegration::MigrateShortcutsInPathInternal(
 437     const base::FilePath& chrome_exe,
 438     const base::FilePath& path,
 439     bool check_dual_mode) {
 440   DCHECK(base::win::GetVersion() >= base::win::VERSION_WIN7);
 441
 442   // Enumerate all pinned shortcuts in the given path directly.
 443   base::FileEnumerator shortcuts_enum(
 444       path, false,  // not recursive
 445       base::FileEnumerator::FILES, FILE_PATH_LITERAL("*.lnk"));
 446
 447   bool is_per_user_install = InstallUtil::IsPerUserInstall(chrome_exe);
 448
 449   int shortcuts_migrated = 0;
 450   base::FilePath target_path;
 451   base::string16 arguments;
 452   base::win::ScopedPropVariant propvariant;
 453   for (base::FilePath shortcut = shortcuts_enum.Next(); !shortcut.empty();
 454        shortcut = shortcuts_enum.Next()) {
 455     // TODO(gab): Use ProgramCompare instead of comparing FilePaths below once
 456     // it is fixed to work with FilePaths with spaces.
 457     if (!base::win::ResolveShortcut(shortcut, &target_path, &arguments) ||
 458         chrome_exe != target_path) {
 459       continue;
 460     }
 461     base::CommandLine command_line(
 462         base::CommandLine::FromString(base::StringPrintf(
 463             L"\"%ls\" %ls", target_path.value().c_str(), arguments.c_str())));
 464
 465     // Get the expected AppId for this Chrome shortcut.
 466     base::string16 expected_app_id(
 467         GetExpectedAppId(command_line, is_per_user_install));
 468     if (expected_app_id.empty())
 469       continue;
 470
 471     // Load the shortcut.
 472     base::win::ScopedComPtr<IShellLink> shell_link;
 473     base::win::ScopedComPtr<IPersistFile> persist_file;
 474     if (FAILED(shell_link.CreateInstance(CLSID_ShellLink, NULL,
 475                                          CLSCTX_INPROC_SERVER)) ||
 476         FAILED(persist_file.QueryFrom(shell_link.get())) ||
 477         FAILED(persist_file->Load(shortcut.value().c_str(), STGM_READ))) {
 478       DLOG(WARNING) << "Failed loading shortcut at " << shortcut.value();
 479       continue;
 480     }
 481
 482     // Any properties that need to be updated on the shortcut will be stored in
 483     // |updated_properties|.
 484     base::win::ShortcutProperties updated_properties;
 485
 486     // Validate the existing app id for the shortcut.
 487     base::win::ScopedComPtr<IPropertyStore> property_store;
 488     propvariant.Reset();
 489     if (FAILED(property_store.QueryFrom(shell_link.get())) ||
 490         property_store->GetValue(PKEY_AppUserModel_ID, propvariant.Receive()) !=
 491             S_OK) {
 492       // When in doubt, prefer not updating the shortcut.
 493       NOTREACHED();
 494       continue;
 495     } else {
 496       switch (propvariant.get().vt) {
 497         case VT_EMPTY:
 498           // If there is no app_id set, set our app_id if one is expected.
 499           if (!expected_app_id.empty())
 500             updated_properties.set_app_id(expected_app_id);
 501           break;
 502         case VT_LPWSTR:
 503           if (expected_app_id != base::string16(propvariant.get().pwszVal))
 504             updated_properties.set_app_id(expected_app_id);
 505           break;
 506         default:
 507           NOTREACHED();
 508           continue;
 509       }
 510     }
 511
 512     // Only set dual mode if the expected app id is the default app id.
 513     BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 514     base::string16 default_chromium_model_id(
 515         ShellUtil::GetBrowserModelId(dist, is_per_user_install));
 516     if (check_dual_mode && expected_app_id == default_chromium_model_id) {
 517       const bool dual_mode_desired =
 518           InstallUtil::ShouldInstallMetroProperties();
 519       propvariant.Reset();
 520       if (property_store->GetValue(PKEY_AppUserModel_IsDualMode,
 521                                    propvariant.Receive()) != S_OK) {
 522         // When in doubt, prefer to not update the shortcut.
 523         NOTREACHED();
 524         continue;
 525       } else {
 526         switch (propvariant.get().vt) {
 527           case VT_EMPTY:
 528             // If dual_mode is not set at all, make sure it gets set to true if
 529             // desired.
 530             if (dual_mode_desired)
 531               updated_properties.set_dual_mode(true);
 532             break;
 533           case VT_BOOL:
 534             // Make sure dual_mode is set as desired.
 535             if ((!!propvariant.get().boolVal) != dual_mode_desired)
 536               updated_properties.set_dual_mode(dual_mode_desired);
 537             break;
 538           default:
 539             NOTREACHED();
 540             continue;
 541         }
 542       }
 543     }
 544
 545     persist_file.Release();
 546     shell_link.Release();
 547
 548     // Update the shortcut if some of its properties need to be updated.
 549     if (updated_properties.options &&
 550         base::win::CreateOrUpdateShortcutLink(
 551             shortcut, updated_properties,
 552             base::win::SHORTCUT_UPDATE_EXISTING)) {
 553       ++shortcuts_migrated;
 554     }
 555   }
 556   return shortcuts_migrated;
 557 }
 558
 559 base::FilePath ShellIntegration::GetStartMenuShortcut(
 560     const base::FilePath& chrome_exe) {
 561   static const int kFolderIds[] = {
 562     base::DIR_COMMON_START_MENU,
 563     base::DIR_START_MENU,
 564   };
 565   BrowserDistribution* dist = BrowserDistribution::GetDistribution();
 566   base::string16 shortcut_name(
 567       dist->GetShortcutName(BrowserDistribution::SHORTCUT_CHROME));
 568   base::FilePath shortcut;
 569
 570   // Check both the common and the per-user Start Menu folders for system-level
 571   // installs.
 572   size_t folder = InstallUtil::IsPerUserInstall(chrome_exe) ? 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 }