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

chrome/browser/shell_integration.h

 // 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.
 
 #ifndef CHROME_BROWSER_SHELL_INTEGRATION_H_
 #define CHROME_BROWSER_SHELL_INTEGRATION_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 #include "base/files/file_path.h"
 #include "base/memory/ref_counted.h"
 #include "base/strings/string16.h"
+#include "base/timer/timer.h"
 #include "ui/gfx/image/image_family.h"
 #include "url/gurl.h"
 
 namespace base {
 class CommandLine;
 }
 
 class ShellIntegration {
  public:
   // Sets Chrome as the default browser (only for the current user). Returns
   // false if this operation fails.
   static bool SetAsDefaultBrowser();
 
   // Initiates an OS shell flow which (if followed by the user) should set
   // Chrome as the default browser. Returns false if the flow cannot be
   // initialized, if it is not supported (introduced for Windows 8) or if the
   // user cancels the operation. This is a blocking call and requires a FILE
   // thread. If Chrome is already default browser, no interactive dialog will be
   // shown and this method returns true.
   static bool SetAsDefaultBrowserInteractive();
 
+  // Returns true if setting the default browser is an asynchronous operation.
+  // In practice, this is only true on Windows 10+.
+  static bool IsSetAsDefaultAsynchronous();
+
+  // Prompt the user to select the default browser by trying to open
+  // https://support.google.com/chrome?p=default_browser which is the "How to
+  // set Chrome as your default browser" help page. Only call this if
+  // |IsSetAsDefaultAsynchronous| is true.
+  //
+  // The caller should add an URL filter to intercept the link navigation (See
+  // startup_browser_creator.h).
+  // The caller should also set up a timer to represent an unsuccessful attempt
+  // after a certain amount of time.
+  static void SetAsDefaultBrowserAsynchronous();
+
   // Sets Chrome as the default client application for the given protocol
   // (only for the current user). Returns false if this operation fails.
   static bool SetAsDefaultProtocolClient(const std::string& protocol);
 
   // Initiates an OS shell flow which (if followed by the user) should set
   // Chrome as the default handler for |protocol|. Returns false if the flow
   // cannot be initialized, if it is not supported (introduced for Windows 8)
   // or if the user cancels the operation. This is a blocking call and requires
   // a FILE thread. If Chrome is already default for |protocol|, no interactive
   // dialog will be shown and this method returns true.
   static bool SetAsDefaultProtocolClientInteractive(
       const std::string& protocol);
 
   // In Windows 8 a browser can be made default-in-metro only in an interactive

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

please update comment with a note about Win10 using an asynchronous flow.

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

Done.

   // flow. We will distinguish between two types of permissions here to avoid
   // forcing the user into UI interaction when this should not be done.
   enum DefaultWebClientSetPermission {
     SET_DEFAULT_NOT_ALLOWED,
     SET_DEFAULT_UNATTENDED,
     SET_DEFAULT_INTERACTIVE,
+    SET_DEFAULT_ASYNCHRONOUS,
   };
 
   // Returns requirements for making the running browser the user's default.
   static DefaultWebClientSetPermission CanSetAsDefaultBrowser();
 
   // Returns requirements for making the running browser the user's default
   // client application for specific protocols.
   static DefaultWebClientSetPermission CanSetAsDefaultProtocolClient();
 
   // Returns true if making the running browser the default client for any
@@ skipping 131 matching lines @@
     // An observer can permit or decline set-as-default operation if it
     // requires triggering user interaction. By default not allowed.
     virtual bool IsInteractiveSetDefaultPermitted();
   };
 
   //  Helper objects that handle checking if Chrome is the default browser
   //  or application for a url protocol on Windows and Linux, and also setting
   //  it as the default. These operations are performed asynchronously on the
   //  file thread since registry access (on Windows) or the preference database
   //  (on Linux) are involved and this can be slow.
+  //
+  //  On windows 10+, there is no official way to prompt the user to set a

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

this seems like an implementation detail that consumers don't need to know
about. please move into the .cc file.

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

Done.

+  //  default browser. This is the workaround:
+  //    1. Unregister the default browser.
+  //    2. Open "How to make Chrome my default browser" link with ShellExecute.
+  //    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.
   class DefaultWebClientWorker
       : public base::RefCountedThreadSafe<DefaultWebClientWorker> {
    public:
     explicit DefaultWebClientWorker(DefaultWebClientObserver* observer);
 
     // Checks to see if Chrome is the default web client application. The result
     // will be passed back to the observer via the SetDefaultWebClientUIState
     // function. If there is no observer, this function does not do anything.
     void StartCheckIsDefault();
 
     // Sets Chrome as the default web client application. If there is an
     // observer, once the operation has completed the new default will be
     // queried and the current status reported via SetDefaultWebClientUIState.
     void StartSetAsDefault();
 
     // Called to notify the worker that the view is gone.
     void ObserverDestroyed();
 
    protected:
     friend class base::RefCountedThreadSafe<DefaultWebClientWorker>;
 
     virtual ~DefaultWebClientWorker() {}
 
+    // When the action to set Chrome as the default has completed this function
+    // is run. This function will call UninitializeSetAsDefault and then start
+    // the check process, which, if an observer is present, reports to it the
+    // new status. |succeeded| is true if the actual call to a set-default
+    // function (from ExecuteSetAsDefault) was successful.
+    void CompleteSetAsDefault(bool succeeded);
+
+#if defined(OS_WIN)

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

move these into the private: block at the bottom of the class (just above
DISALLOW_COPY_AND_ASSIGN); see
http://google-styleguide.googlecode.com/svn/trunk/cppguide.html#Declaration_O....

[grt (UTC plus 2), 2015/09/22 19:17:48]

actually, it looks like they can be among DefaultBrowserWorker's private
members.

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

Done.

+    // Used to determine if setting the default browser was unsuccesful.
+    scoped_ptr<base::OneShotTimer<DefaultWebClientWorker>> async_timer_;
+
+    // Records the time it takes to set the default browser asynchronously.
+    base::TimeTicks start_time_;
+#endif  // !defined(OS_WIN)
+
    private:
     // Function that performs the check.
     virtual DefaultWebClientState CheckIsDefault() = 0;
 
-    // Function that sets Chrome as the default web client. Returns false if
-    // the operation fails or has been cancelled by the user.
-    virtual bool SetAsDefault(bool interactive_permitted) = 0;
+    // Function that sets Chrome as the default web client.
+    virtual void SetAsDefault(bool interactive_permitted) = 0;
+
+    // Executed before calling |ExecuteSetAsDefault|.
+    virtual void InitializeSetAsDefault() {}
+
+    // Called in CompleteSetAsDefault right. Should return true to notify the
+    // observer of the result of setting Chrome as the default browser.
+    virtual bool UninitializeSetAsDefault(bool succeeded) { return true; }
 
     // Function that handles performing the check on the file thread. This
     // function is posted as a task onto the file thread, where it performs
     // the check. When the check has finished the CompleteCheckIsDefault
     // function is posted to the UI thread, where the result is sent back to
     // the observer.
     void ExecuteCheckIsDefault();
 
     // Function that handles setting Chrome as the default web client on the
     // file thread. This function is posted as a task onto the file thread.
     // Once it is finished the CompleteSetAsDefault function is posted to the
     // UI thread which will check the status of Chrome as the default, and
     // send this to the observer.
     // |interactive_permitted| indicates if the routine is allowed to carry on
     // in context where user interaction is required (CanSetAsDefault*
     // returns SET_DEFAULT_INTERACTIVE).
     void ExecuteSetAsDefault(bool interactive_permitted);
 
-    // Communicate results to the observer. This function is posted as a task
-    // onto the UI thread by the ExecuteCheckIsDefault function running in the
-    // file thread.
+    // Calls |UninitializeSetAsDefault| and then communicate results to the
+    // observer.
     void CompleteCheckIsDefault(DefaultWebClientState state);
 
-    // When the action to set Chrome as the default has completed this function
-    // is run. It is posted as a task back onto the UI thread by the
-    // ExecuteSetAsDefault function running in the file thread. This function
-    // will the start the check process, which, if an observer is present,
-    // reports to it the new status.
-    // |succeeded| is true if the actual call to a set-default function (from
-    // ExecuteSetAsDefault) was successful.
-    void CompleteSetAsDefault(bool succeeded);
-
     // Updates the UI in our associated view with the current default web
     // client state.
     void UpdateUI(DefaultWebClientState state);
 
     DefaultWebClientObserver* observer_;
 
     DISALLOW_COPY_AND_ASSIGN(DefaultWebClientWorker);
   };
 
   // Worker for checking and setting the default browser.
   class DefaultBrowserWorker : public DefaultWebClientWorker {
    public:
     explicit DefaultBrowserWorker(DefaultWebClientObserver* observer);
 
    private:
     ~DefaultBrowserWorker() override {}
 
     // Check if Chrome is the default browser.
     DefaultWebClientState CheckIsDefault() override;
 
     // Set Chrome as the default browser.
-    bool SetAsDefault(bool interactive_permitted) override;
+    void SetAsDefault(bool interactive_permitted) override;
+
+    // On windows 10+, add the URL filter and starts the timer that determines
+    // if the operation was successful or not.
+    void InitializeSetAsDefault() override;
+
+    // On windows 10+, remove the URL filter and stops the timer.
+    bool UninitializeSetAsDefault(bool succeeded) override;
 
     DISALLOW_COPY_AND_ASSIGN(DefaultBrowserWorker);
   };
 
   // Worker for checking and setting the default client application
   // for a given protocol. A different worker instance is needed for each
   // protocol you are interested in, so to check or set the default for
   // multiple protocols you should use multiple worker objects.
   class DefaultProtocolClientWorker : public DefaultWebClientWorker {
    public:
     DefaultProtocolClientWorker(DefaultWebClientObserver* observer,
                                 const std::string& protocol);
 
     const std::string& protocol() const { return protocol_; }
 
    protected:
     ~DefaultProtocolClientWorker() override {}
 
    private:
     // Check is Chrome is the default handler for this protocol.
     DefaultWebClientState CheckIsDefault() override;
 
     // Set Chrome as the default handler for this protocol.
-    bool SetAsDefault(bool interactive_permitted) override;
+    void SetAsDefault(bool interactive_permitted) override;
 
     std::string protocol_;
 
     DISALLOW_COPY_AND_ASSIGN(DefaultProtocolClientWorker);
   };
 };
 
 #endif  // CHROME_BROWSER_SHELL_INTEGRATION_H_