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