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