Home | History | Annotate | Download | only in browser 
      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