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
43using content::BrowserThread;
44
45namespace {
46
47const 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 ".".
52base::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
85base::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|).
94base::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
135void 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.
183base::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
208base::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
232ShellIntegration::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
248ShellIntegration::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
261bool 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
280bool 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
303bool 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
320bool 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
340ShellIntegration::DefaultWebClientState ShellIntegration::GetDefaultBrowser() {
341  return GetDefaultWebClientStateFromShellUtilDefaultState(
342      ShellUtil::GetChromeDefaultState());
343}
344
345ShellIntegration::DefaultWebClientState
346    ShellIntegration::IsDefaultProtocolClient(const std::string& protocol) {
347  return GetDefaultWebClientStateFromShellUtilDefaultState(
348      ShellUtil::GetChromeDefaultProtocolClientState(
349          base::UTF8ToUTF16(protocol)));
350}
351
352base::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.
372bool 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
394base::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
405base::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
419base::string16 ShellIntegration::GetAppListAppModelIdForProfile(
420    const base::FilePath& profile_path) {
421  return ShellIntegration::GetAppModelIdForProfile(
422      GetAppListAppName(), profile_path);
423}
424
425void 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
439int 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
558base::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