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
42using content::BrowserThread;
43
44namespace {
45
46const 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 ".".
51string16 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
84string16 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|).
93string16 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
132void 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
177ShellIntegration::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
193ShellIntegration::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
204bool 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
223bool 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
246bool 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
263bool 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
283ShellIntegration::DefaultWebClientState ShellIntegration::GetDefaultBrowser() {
284  return GetDefaultWebClientStateFromShellUtilDefaultState(
285      ShellUtil::GetChromeDefaultState());
286}
287
288ShellIntegration::DefaultWebClientState
289    ShellIntegration::IsDefaultProtocolClient(const std::string& protocol) {
290  return GetDefaultWebClientStateFromShellUtilDefaultState(
291      ShellUtil::GetChromeDefaultProtocolClientState(UTF8ToUTF16(protocol)));
292}
293
294std::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.
312bool 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
333string16 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
344string16 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
358string16 ShellIntegration::GetAppListAppModelIdForProfile(
359    const base::FilePath& profile_path) {
360  return ShellIntegration::GetAppModelIdForProfile(
361      GetAppListAppName(), profile_path);
362}
363
364string16 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
378void 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
392int 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
511base::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