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

chrome/browser/shell_integration.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 "base/bind.h"
 #include "base/command_line.h"
 #include "base/files/file_util.h"
 #include "base/prefs/pref_service.h"
@@ skipping 11 matching lines @@
 #endif
 
 #if !defined(OS_WIN)
 #include "chrome/common/channel_info.h"
 #include "chrome/grit/chromium_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #endif
 
 using content::BrowserThread;
 
+#if !defined(OS_WIN)
+// static
+bool ShellIntegration::IsSetAsDefaultAsynchronous() {
+  return false;
+}
+
+// static
+void ShellIntegration::SetAsDefaultBrowserAsynchronous() {
+  NOTREACHED();
+}
+#endif  // !defined(OS_WIN)
+
 // static
 ShellIntegration::DefaultWebClientSetPermission
     ShellIntegration::CanSetAsDefaultProtocolClient() {
   // Allowed as long as the browser can become the operating system default
   // browser.
   return CanSetAsDefaultBrowser();
 }
 
 static const struct ShellIntegration::AppModeInfo* gAppModeInfo = NULL;
 
@@ skipping 86 matching lines @@
 bool ShellIntegration::SetAsDefaultProtocolClientInteractive(
     const std::string& protocol) {
   return false;
 }
 
 // static
 bool ShellIntegration::IsElevationNeededForSettingDefaultProtocolClient() {
   return false;
 }
 
+void ShellIntegration::DefaultBrowserWorker::InitializeSetAsDefault() {}
+
+bool ShellIntegration::DefaultBrowserWorker::UninitializeSetAsDefault(
+    bool succeeded) {
+  return true;
+}
+
 #endif  // !defined(OS_WIN)
 
 bool ShellIntegration::DefaultWebClientObserver::IsOwnedByWorker() {
   return false;
 }
 
 bool ShellIntegration::DefaultWebClientObserver::
     IsInteractiveSetDefaultPermitted() {
   return false;
 }
@@ skipping 16 matching lines @@
             &DefaultWebClientWorker::ExecuteCheckIsDefault, this));
   }
 }
 
 void ShellIntegration::DefaultWebClientWorker::StartSetAsDefault() {
   bool interactive_permitted = false;
   if (observer_) {
     observer_->SetDefaultWebClientUIState(STATE_PROCESSING);
     interactive_permitted = observer_->IsInteractiveSetDefaultPermitted();
   }
+
+  InitializeSetAsDefault();
+
   BrowserThread::PostTask(
       BrowserThread::FILE, FROM_HERE,
       base::Bind(&DefaultWebClientWorker::ExecuteSetAsDefault, this,
                  interactive_permitted));
 }
 
 void ShellIntegration::DefaultWebClientWorker::ObserverDestroyed() {
   // Our associated view has gone away, so we shouldn't call back to it if
   // our worker thread returns after the view is dead.
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
   observer_ = NULL;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // DefaultWebClientWorker, private:
 
 void ShellIntegration::DefaultWebClientWorker::ExecuteCheckIsDefault() {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
   DefaultWebClientState state = CheckIsDefault();
   BrowserThread::PostTask(
       BrowserThread::UI, FROM_HERE,
       base::Bind(
           &DefaultWebClientWorker::CompleteCheckIsDefault, this, state));
 }
 
 void ShellIntegration::DefaultWebClientWorker::CompleteCheckIsDefault(
     DefaultWebClientState state) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
+
   UpdateUI(state);
+
   // The worker has finished everything it needs to do, so free the observer
   // if we own it.
   if (observer_ && observer_->IsOwnedByWorker()) {
     delete observer_;
     observer_ = NULL;
   }
 }
 
 void ShellIntegration::DefaultWebClientWorker::ExecuteSetAsDefault(
     bool interactive_permitted) {
   DCHECK_CURRENTLY_ON(BrowserThread::FILE);
 
-  bool result = SetAsDefault(interactive_permitted);
-  BrowserThread::PostTask(
-      BrowserThread::UI, FROM_HERE,
-      base::Bind(&DefaultWebClientWorker::CompleteSetAsDefault, this, result));
+  SetAsDefault(interactive_permitted);
 }
 
 void ShellIntegration::DefaultWebClientWorker::CompleteSetAsDefault(
     bool succeeded) {
   DCHECK_CURRENTLY_ON(BrowserThread::UI);
-  // First tell the observer what the SetAsDefault call has returned.
-  if (observer_)
-    observer_->OnSetAsDefaultConcluded(succeeded);
-  // Set as default completed, check again to make sure it stuck...
-  StartCheckIsDefault();
+
+  // Only notify observer is |UninitializeSetAsDefault| returns true. This is to

[grt (UTC plus 2), 2015/09/22 18:21:47]

is -> if

[Patrick Monette, 2015/09/23 22:40:44]

Comment removed.

+  // filter out multiple calls to |CompleteSetAsDefault| due to possible race
+  // conditions.
+  if (UninitializeSetAsDefault(succeeded)) {
+    // First tell the observer what the SetAsDefault call has returned.
+    if (observer_)
+      observer_->OnSetAsDefaultConcluded(succeeded);
+    // Set as default completed, check again to make sure it stuck...
+    StartCheckIsDefault();
+  }
 }
 
 void ShellIntegration::DefaultWebClientWorker::UpdateUI(
     DefaultWebClientState state) {
   if (observer_) {
     switch (state) {
       case NOT_DEFAULT:
         observer_->SetDefaultWebClientUIState(STATE_NOT_DEFAULT);
         break;
       case IS_DEFAULT:
@@ skipping 18 matching lines @@
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // DefaultBrowserWorker, private:
 
 ShellIntegration::DefaultWebClientState
 ShellIntegration::DefaultBrowserWorker::CheckIsDefault() {
   return ShellIntegration::GetDefaultBrowser();
 }
 
-bool ShellIntegration::DefaultBrowserWorker::SetAsDefault(
+void ShellIntegration::DefaultBrowserWorker::SetAsDefault(
     bool interactive_permitted) {
   bool result = false;
   switch (ShellIntegration::CanSetAsDefaultBrowser()) {
     case ShellIntegration::SET_DEFAULT_UNATTENDED:
       result = ShellIntegration::SetAsDefaultBrowser();
+      BrowserThread::PostTask(
+          BrowserThread::UI, FROM_HERE,
+          base::Bind(&DefaultBrowserWorker::CompleteSetAsDefault, this,
+                     result));
       break;
     case ShellIntegration::SET_DEFAULT_INTERACTIVE:
+      if (interactive_permitted) {
+        result = ShellIntegration::SetAsDefaultBrowserInteractive();
+        BrowserThread::PostTask(
+            BrowserThread::UI, FROM_HERE,
+            base::Bind(&DefaultBrowserWorker::CompleteSetAsDefault, this,
+                       result));
+      }

[grt (UTC plus 2), 2015/09/22 18:21:47]

this should run CompleteSetAsDefault with result=false, no?
if (interactive_permitted)
  result = ShellIntegration::SetAsDefaultBrowserInteractive();
BrowserThread::PostTask(...);

[Patrick Monette, 2015/09/23 22:40:44]

CompleteSetAsDefault is not called at the end with the Asynchronous case
returning early.

+      break;
+    case ShellIntegration::SET_DEFAULT_ASYNCHRONOUS:
       if (interactive_permitted)
-        result = ShellIntegration::SetAsDefaultBrowserInteractive();
+        ShellIntegration::SetAsDefaultBrowserAsynchronous();
       break;
     default:

[grt (UTC plus 2), 2015/09/22 18:21:47]

while you're here, please change this from "default:" to "case
SET_DEFAULT_NOT_ALLOWED:" so that the compiler will spew errors if/when new
values are added to the enum.

[Patrick Monette, 2015/09/23 22:40:44]

Done. Moved the cases around so they are in the same order as they are defined.

       NOTREACHED();
   }
-
-  return result;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // ShellIntegration::DefaultProtocolClientWorker
 //
 
 ShellIntegration::DefaultProtocolClientWorker::DefaultProtocolClientWorker(
     DefaultWebClientObserver* observer, const std::string& protocol)
     : DefaultWebClientWorker(observer),
       protocol_(protocol) {
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 // DefaultProtocolClientWorker, private:
 
 ShellIntegration::DefaultWebClientState
 ShellIntegration::DefaultProtocolClientWorker::CheckIsDefault() {
   return ShellIntegration::IsDefaultProtocolClient(protocol_);
 }
 
-bool ShellIntegration::DefaultProtocolClientWorker::SetAsDefault(
+void ShellIntegration::DefaultProtocolClientWorker::SetAsDefault(
     bool interactive_permitted) {
   bool result = false;
   switch (ShellIntegration::CanSetAsDefaultProtocolClient()) {
     case ShellIntegration::SET_DEFAULT_NOT_ALLOWED:
-      result = false;
+      BrowserThread::PostTask(
+          BrowserThread::UI, FROM_HERE,
+          base::Bind(&DefaultProtocolClientWorker::CompleteSetAsDefault, this,
+                     false));
       break;
     case ShellIntegration::SET_DEFAULT_UNATTENDED:
       result = ShellIntegration::SetAsDefaultProtocolClient(protocol_);
+      BrowserThread::PostTask(
+          BrowserThread::UI, FROM_HERE,
+          base::Bind(&DefaultProtocolClientWorker::CompleteSetAsDefault, this,
+                     result));
       break;
     case ShellIntegration::SET_DEFAULT_INTERACTIVE:
       if (interactive_permitted) {
-        result = ShellIntegration::SetAsDefaultProtocolClientInteractive(
-            protocol_);
+        result =
+            ShellIntegration::SetAsDefaultProtocolClientInteractive(protocol_);
+        BrowserThread::PostTask(
+            BrowserThread::UI, FROM_HERE,
+            base::Bind(&DefaultProtocolClientWorker::CompleteSetAsDefault, this,
+                       result));
       }
       break;
   }
-
-  return result;
 }