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

chrome/browser/shell_integration_win.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "chrome/browser/shell_integration.h"
 
 #include <windows.h>
 #include <shlwapi.h>
 #include <shobjidl.h>
 #include <propkey.h>  // Needs to come after shobjidl.h.
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #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/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"
 #include "chrome/common/chrome_switches.h"
 #include "chrome/installer/setup/setup_util.h"
 #include "chrome/installer/util/browser_distribution.h"
 #include "chrome/installer/util/create_reg_key_work_item.h"
 #include "chrome/installer/util/install_util.h"
 #include "chrome/installer/util/set_reg_value_work_item.h"
 #include "chrome/installer/util/shell_util.h"
 #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;
 
 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 ".".
 base::string16 GetProfileIdFromPath(const base::FilePath& profile_path) {
   // Return empty string if profile_path is empty
   if (profile_path.empty())
     return base::string16();
 
   base::FilePath default_user_data_dir;
   // Return empty string if profile_path is in default user data
@@ skipping 174 matching lines @@
     case ShellUtil::NOT_DEFAULT:
       return ShellIntegration::NOT_DEFAULT;
     case ShellUtil::IS_DEFAULT:
       return ShellIntegration::IS_DEFAULT;
     default:
       DCHECK_EQ(ShellUtil::UNKNOWN_DEFAULT, default_state);
       return ShellIntegration::UNKNOWN_DEFAULT;
   }
 }
 
+// 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;
+
+  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_GE(base::win::GetVersion(), base::win::VERSION_WIN10);
+
+  ResetDefaultBrowser();
+
+  base::CommandLine cmdline(base::FilePath(L"openwith.exe"));
+  cmdline.AppendArgNative(StartupBrowserCreator::GetAsyncSetAsDefaultUrl());
+  base::LaunchProcess(cmdline, base::LaunchOptions());
+}

[grt (UTC plus 2), 2015/09/24 18:24:12]

suggestion: it would be good to know if this fails. how about
  base::Process process(base::LaunchProcess(cmdline, base::LaunchOptions()));
  UMA_HISTOGRAM_BOOLEAN("DefaultBrowser.AsyncSetAsDefault.Launched",
                        process.IsValid());

[Patrick Monette, 2015/09/25 20:06:25]

Done.

+
 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 if (IsSetAsDefaultAsynchronous())

[grt (UTC plus 2), 2015/09/24 18:24:11]

nit: remove these "else"es:
  if (foo)
    return blah;
  if (bar)
    return blorf;
  return spam;

[Patrick Monette, 2015/09/25 20:06:25]

Done.

+    return SET_DEFAULT_ASYNCHRONOUS;
   else
     return SET_DEFAULT_INTERACTIVE;
 }
 
 bool ShellIntegration::SetAsDefaultBrowser() {
   base::FilePath chrome_exe;
   if (!PathService::Get(base::FILE_EXE, &chrome_exe)) {
     LOG(ERROR) << "Error getting app exe path";
     return false;
   }
@@ skipping 317 matching lines @@
     }
 
     shortcut = shortcut.Append(shortcut_name).Append(shortcut_name +
                                                      installer::kLnkExt);
     if (base::PathExists(shortcut))
       return shortcut;
   }
 
   return base::FilePath();
 }
+
+void ShellIntegration::DefaultBrowserWorker::InitializeSetAsDefault() {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (IsSetAsDefaultAsynchronous()) {
+    // 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 prompt the user with "How would you link to open this?".
+    // 4. If Chrome is selected, the http url is intercepted and
+    //    CompleteSetAsDefault is called with succeeded equals to true.
+    // 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.
+    StartupBrowserCreator::SetAsyncSetAsDefaultFilter(
+        base::Bind(&DefaultBrowserWorker::CompleteSetAsDefault, this, true));
+
+    // Remember the start time.
+    start_time_ = base::TimeTicks::Now();
+
+    // Start the timer.
+    if (!async_timer_)
+      async_timer_.reset(new base::OneShotTimer<DefaultBrowserWorker>());
+
+    base::TimeDelta timer_duration = base::TimeDelta::FromMinutes(2);
+    std::string value = variations::GetVariationParamValue(
+        kAsyncSetAsDefaultExperimentName, "TimerDuration");
+    int seconds = 0;
+    if (!value.empty())
+      base::StringToInt(value, &seconds);
+    if (seconds)
+      timer_duration = base::TimeDelta::FromSeconds(seconds);
+
+    async_timer_->Start(
+        FROM_HERE, timer_duration,
+        base::Bind(&DefaultBrowserWorker::CompleteSetAsDefault, this, false));
+  }
+}
+
+void ShellIntegration::DefaultBrowserWorker::FinalizeSetAsDefault(
+    bool succeeded) {
+  DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
+  if (IsSetAsDefaultAsynchronous()) {

[grt (UTC plus 2), 2015/09/24 18:24:12]

how about:
    if (async_timer_) {
so that there are no surprises if the user's field trial config somehow changes
while the timer is running. this also naturally protects from multiple calls.

[Patrick Monette, 2015/09/25 20:06:24]

Done.

+    // Destroy timer.
+    async_timer_.reset();
+
+    StartupBrowserCreator::ClearAsyncSetAsDefaultFilter();
+
+    // Record the duration from starting to set as default browser to now.
+    UMA_HISTOGRAM_BOOLEAN("DefaultBrowser.AsyncSetAsDefault.Succeeded",
+                          succeeded);
+    UMA_HISTOGRAM_TIMES("DefaultBrowser.AsyncSetAsDefault.Duration",
+                        base::TimeTicks::Now() - start_time_);
+  }
+}