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/time/time.h"
 #include "ui/gfx/image/image_family.h"
 #include "url/gurl.h"
 
 namespace base {
 class CommandLine;
+class OneShotTimer;
 }
 
 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();
+
   // 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
-  // flow. We will distinguish between two types of permissions here to avoid
-  // forcing the user into UI interaction when this should not be done.
+  // Windows 8 and Windows 10 introduced different ways to set the default
+  // browser.
   enum DefaultWebClientSetPermission {
+    // The browser distribution is not permitted to be made default.
     SET_DEFAULT_NOT_ALLOWED,
+    // This is the most common case where no special permission or interaction

[brettw, 2015/10/05 19:58:02]

This comment is weird to me. This doesn't cover Windows 8-10+ so it's weird to
see it described as the "most common". Maybe just say Windows 7 and before?

[Patrick Monette, 2015/10/05 20:10:09]

Yeah but it also includes Linux and Mac. I updated the comment.

+    // is required to set the default browser.
     SET_DEFAULT_UNATTENDED,
+    // On Windows 8, a browser can be made default only in an interactive flow.
     SET_DEFAULT_INTERACTIVE,
+    // On Windows 10+, the set default browser flow is both interactive and
+    // asynchronous.
+    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 152 matching lines @@
     // 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() {}
+    // Possible result codes for a set-as-default operation.
+    // Do not modify the ordering as it is important for UMA.
+    enum AttemptResult {
+      // No errors encountered.
+      SUCCESS,
+      // Chrome was already the default web client. This counts as a successful
+      // attempt.
+      ALREADY_DEFAULT,
+      // Chrome was not set as the default web client.
+      FAILURE,
+      // The attempt was abandoned because the observer was destroyed.
+      ABANDONED,
+      // Failed to launch the process to set Chrome as the default web client
+      // asynchronously.
+      LAUNCH_FAILURE,
+      // Another worker is already in progress to make Chrome the default web
+      // client.
+      OTHER_WORKER,
+      // The user initiated another attempt while the asynchronous operation was
+      // already in progress.
+      RETRY,
+      NUM_ATTEMPT_RESULT_TYPES
+    };
+
+    virtual ~DefaultWebClientWorker();
+
+    // Communicates the result to the observer. In contrast to
+    // OnSetAsDefaultAttemptComplete(), this should not be called multiple
+    // times.
+    void OnCheckIsDefaultComplete(DefaultWebClientState state);
+
+    // Called when the set as default operation is completed. This then invokes
+    // FinalizeSetAsDefault() and, if an observer is present, starts the check
+    // is default process.
+    // It is safe to call this multiple times. Only the first call is processed
+    // after StartSetAsDefault() is invoked.
+    void OnSetAsDefaultAttemptComplete(AttemptResult result);
+
+    // Returns true if FinalizeSetAsDefault() will be called.
+    bool set_as_default_initialized() const {
+      return set_as_default_initialized_;
+    }
+
+    // Flag that indicates if the set-as-default operation is in progess to
+    // prevent multiple notifications to the observer.
+    bool set_as_default_in_progress_ = false;
 
    private:
-    // Function that performs the check.
-    virtual DefaultWebClientState CheckIsDefault() = 0;
+    // Checks whether Chrome is the default web client. Always called on the
+    // FILE thread. Subclasses are responsible for calling
+    // OnCheckIsDefaultComplete() on the UI thread.
+    virtual void 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;
+    // Sets Chrome as the default web client. Always called on the FILE thread.
+    // |interactive_permitted| will make SetAsDefault() fail if it requires
+    // interaction with the user. Subclasses are responsible for calling
+    // OnSetAsDefaultAttemptComplete() on the UI thread.
+    virtual void SetAsDefault(bool interactive_permitted) = 0;
 
-    // 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();
+    // Invoked on the UI thread prior to starting a set-as-default operation.
+    // Returns true if the initialization succeeded and a subsequent call to
+    // FinalizeSetAsDefault() is required.
+    virtual bool InitializeSetAsDefault();
 
-    // 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.
-    void CompleteCheckIsDefault(DefaultWebClientState state);
+    // Invoked on the UI thread following a set-as-default operation.
+    virtual void FinalizeSetAsDefault();
 
-    // 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);
+    // Returns true if the attempt results should be reported to UMA.
+    static bool ShouldReportAttemptResults();
 
-    // 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);
+    // Reports the result and duration for one set-as-default attempt.
+    void ReportAttemptResult(AttemptResult result);
 
     // Updates the UI in our associated view with the current default web
     // client state.
     void UpdateUI(DefaultWebClientState state);
 
     DefaultWebClientObserver* observer_;
 
+    // Flag that indicates the return value of InitializeSetAsDefault(). If
+    // true, FinalizeSetAsDefault() will be called to clear what was
+    // initialized.
+    bool set_as_default_initialized_ = false;
+
+    // Records the time it takes to set the default browser.
+    base::TimeTicks start_time_;
+
     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 {}
+    ~DefaultBrowserWorker() override;
 
     // Check if Chrome is the default browser.
-    DefaultWebClientState CheckIsDefault() override;
+    void CheckIsDefault() override;
 
     // Set Chrome as the default browser.
-    bool SetAsDefault(bool interactive_permitted) override;
+    void SetAsDefault(bool interactive_permitted) override;
+
+#if defined(OS_WIN)
+    // On Windows 10+, adds the default browser callback and starts the timer
+    // that determines if the operation was successful or not.
+    bool InitializeSetAsDefault() override;
+
+    // On Windows 10+, removes the default browser callback and stops the timer.
+    void FinalizeSetAsDefault() override;
+
+    // Prompts the user to select the default browser by trying to open the help
+    // page that explains how to set Chrome as the default browser. Returns
+    // false if the process needed to set Chrome default failed to launch.
+    static bool SetAsDefaultBrowserAsynchronous();
+
+    // Used to determine if setting the default browser was unsuccesful.
+    scoped_ptr<base::OneShotTimer> async_timer_;
+#endif  // !defined(OS_WIN)
 
     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 {}
+    ~DefaultProtocolClientWorker() override;
 
    private:
     // Check is Chrome is the default handler for this protocol.
-    DefaultWebClientState CheckIsDefault() override;
+    void 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_