Setting chrome as the default browser is now fixed on Windows 10

chrome/browser/shell_integration_win.cc

Index: chrome/browser/shell_integration_win.cc
diff --git a/chrome/browser/shell_integration_win.cc b/chrome/browser/shell_integration_win.cc
index 07f7b4b9f8e465faaad7240654e82ebedbb91644..dd7b1b0545065fbe894c34ce2aa861ef711e1614 100644
--- a/chrome/browser/shell_integration_win.cc
+++ b/chrome/browser/shell_integration_win.cc
@@ -14,17 +14,22 @@
 #include "base/files/file_enumerator.h"
 #include "base/files/file_util.h"
 #include "base/message_loop/message_loop.h"
+#include "base/metrics/field_trial.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/path_service.h"
+#include "base/process/launch.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
+#include "base/timer/timer.h"
 #include "base/win/registry.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_propvariant.h"
 #include "base/win/shortcut.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/policy/policy_path_parser.h"
+#include "chrome/browser/ui/startup/startup_browser_creator.h"
 #include "chrome/browser/web_applications/web_app.h"
 #include "chrome/common/chrome_constants.h"
 #include "chrome/common/chrome_paths_internal.h"
@@ -38,6 +43,7 @@
 #include "chrome/installer/util/util_constants.h"
 #include "chrome/installer/util/work_item.h"
 #include "chrome/installer/util/work_item_list.h"
+#include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 
 using content::BrowserThread;
@@ -46,6 +52,10 @@ namespace {
 
 const wchar_t kAppListAppNameSuffix[] = L"AppList";
 
+const char kAsyncSetAsDefaultExperimentName[] = "AsyncSetAsDefault";
+const char kEnableAsyncSetAsDefault[] = "enable-async-set-as-default";
+const char kDisableAsyncSetAsDefault[] = "disable-async-set-as-default";
+
 // Helper function for ShellIntegration::GetAppId to generates profile id
 // from profile path. "profile_id" is composed of sanitized basenames of
 // user data dir and profile dir joined by a ".".
@@ -240,19 +250,72 @@ ShellIntegration::DefaultWebClientState
   }
 }
 
+// Resets the default browser choice for the current user.
+void ResetDefaultBrowser() {
+  static const wchar_t* const kUrlAssociationKeyFormats[] = {
+      L"SOFTWARE\\Microsoft\\Windows\\Shell\\Associations\\UrlAssociations\\"
+      L"%ls\\UserChoice",
+      L"SOFTWARE\\Microsoft\\Windows\\Roaming\\OpenWith\\UrlAssociations\\"
+      L"%ls\\UserChoice"};
+  static const wchar_t* const kProtocols[] = {L"http", L"https"};
+
+  for (const wchar_t* format : kUrlAssociationKeyFormats) {
+    for (const wchar_t* protocol : kProtocols) {
+      base::win::RegKey registry_key(
+          HKEY_CURRENT_USER, base::StringPrintf(format, protocol).c_str(),
+          KEY_SET_VALUE);
+      registry_key.DeleteValue(L"Hash");
+    }
+  }
+}
+
+// Returns true if the AsyncSetAsDefault field trial is activated.
+bool IsAsyncSetAsDefaultEnabled() {
+  using base::CommandLine;
+
+  // Note: It's important to query the field trial state first, to ensure that
+  // UMA reports the correct group.

[Peter Kasting, 2015/09/28 23:57:49]

Is this what we actually want?  If we're letting the command line control state,
then the user's field trial status is not in fact controlling behavior.  It
seems like calling this first would corrupt our metrics.  I realize the doc you
linked to shows this as an example, but at least to my layman's eyes, that code
looks wrong.

[rkaplow, 2015/09/29 14:20:53]

This is still correct although it's a bit subtle. The group that the user will
get put in is a specific forcing group which is tracked separately from the
usual probabalistic groups.

+  const std::string group_name =
+      base::FieldTrialList::FindFullName("AsyncSetAsDefault");
+  if (CommandLine::ForCurrentProcess()->HasSwitch(kDisableAsyncSetAsDefault))
+    return false;
+  if (CommandLine::ForCurrentProcess()->HasSwitch(kEnableAsyncSetAsDefault))
+    return true;
+
+  return base::StartsWith(group_name, "Enabled", base::CompareCase::SENSITIVE);
+}
+
 }  // namespace
 
+// static
+bool ShellIntegration::IsSetAsDefaultAsynchronous() {
+  return base::win::GetVersion() >= base::win::VERSION_WIN10 &&
+         IsAsyncSetAsDefaultEnabled();
+}
+
+void ShellIntegration::SetAsDefaultBrowserAsynchronous() {
+  DCHECK(ShellIntegration::IsSetAsDefaultAsynchronous());
+
+  ResetDefaultBrowser();
+
+  base::CommandLine cmdline(base::FilePath(L"openwith.exe"));
+  cmdline.AppendArgNative(StartupBrowserCreator::GetDefaultBrowserUrl());
+  base::Process process(base::LaunchProcess(cmdline, base::LaunchOptions()));
+  UMA_HISTOGRAM_BOOLEAN("DefaultBrowser.AsyncSetAsDefault.Launched",
+                        process.IsValid());
+}
+
 ShellIntegration::DefaultWebClientSetPermission
     ShellIntegration::CanSetAsDefaultBrowser() {
   BrowserDistribution* distribution = BrowserDistribution::GetDistribution();
   if (distribution->GetDefaultBrowserControlPolicy() !=
           BrowserDistribution::DEFAULT_BROWSER_FULL_CONTROL)
     return SET_DEFAULT_NOT_ALLOWED;
-
   if (ShellUtil::CanMakeChromeDefaultUnattended())
     return SET_DEFAULT_UNATTENDED;
-  else
-    return SET_DEFAULT_INTERACTIVE;
+  if (IsSetAsDefaultAsynchronous())
+    return SET_DEFAULT_ASYNCHRONOUS;
+  return SET_DEFAULT_INTERACTIVE;
 }
 
 bool ShellIntegration::SetAsDefaultBrowser() {
@@ -588,3 +651,62 @@ base::FilePath ShellIntegration::GetStartMenuShortcut(
 
   return base::FilePath();
 }
+
+void ShellIntegration::DefaultBrowserWorker::InitializeSetAsDefault() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (!IsSetAsDefaultAsynchronous())
+    return;
+
+  // On Windows 10+, there is no official way to prompt the user to set a
+  // default browser. This is the workaround:
+  // 1. Unregister the default browser.
+  // 2. Open "How to make Chrome my default browser" link with openwith.exe.
+  // 3. Windows will prompt the user with "How would you link to open this?".
+  // 4. If Chrome is selected, we intercept the attempt to open the URL and
+  //    instead call OnSetAsDefaultAttemptComplete(), passing true to indicate
+  //    success.
+  // 5. If Chrome is not selected, the url is opened in the selected browser.
+  //    After a certain amount of time, we notify the observer that the
+  //    process failed.
+
+  // Remember the start time.
+  start_time_ = base::TimeTicks::Now();
+
+  if (!StartupBrowserCreator::SetDefaultBrowserCallback(base::Bind(
+          &DefaultBrowserWorker::OnSetAsDefaultAttemptComplete, this, true))) {
+    // Another worker is currently processing.
+    OnSetAsDefaultAttemptComplete(false);
+    return;
+  }
+
+  // Start the timer.
+  if (!async_timer_)
+    async_timer_.reset(new base::OneShotTimer());
+  std::string value = variations::GetVariationParamValue(
+      kAsyncSetAsDefaultExperimentName, "TimerDuration");
+  int seconds = 0;
+  if (!value.empty())
+    base::StringToInt(value, &seconds);
+  if (!seconds)
+    seconds = 120;  // Default value of 2 minutes.
+  async_timer_->Start(
+      FROM_HERE, base::TimeDelta::FromSeconds(seconds),
+      base::Bind(&DefaultBrowserWorker::OnSetAsDefaultAttemptComplete, this,
+                 false));
+}
+
+void ShellIntegration::DefaultBrowserWorker::FinalizeSetAsDefault(
+    bool succeeded) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (async_timer_) {
+    async_timer_.reset();
+
+    StartupBrowserCreator::ClearDefaultBrowserCallback();
+    UMA_HISTOGRAM_BOOLEAN("DefaultBrowser.AsyncSetAsDefault.Succeeded",
+                          succeeded);
+    UMA_HISTOGRAM_TIMES("DefaultBrowser.AsyncSetAsDefault.Duration",
+                        base::TimeTicks::Now() - start_time_);
+  }
+}