Use the DefaultBrowserWorker to check/set Chrome as the default browser.

chrome/browser/ui/startup/default_browser_prompt.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/ui/startup/default_browser_prompt.h"
 
 #include <string>
 
 #include "base/location.h"
 #include "base/memory/weak_ptr.h"
-#include "base/metrics/histogram.h"
+#include "base/metrics/histogram_macros.h"
 #include "base/prefs/pref_registry_simple.h"
 #include "base/prefs/pref_service.h"
 #include "base/single_thread_task_runner.h"
 #include "base/thread_task_runner_handle.h"
 #include "base/version.h"
 #include "chrome/browser/browser_process.h"
-#include "chrome/browser/first_run/first_run.h"
 #include "chrome/browser/infobars/infobar_service.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/shell_integration.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
-#include "chrome/installer/util/master_preferences.h"
-#include "chrome/installer/util/master_preferences_constants.h"
 #include "components/infobars/core/confirm_infobar_delegate.h"
 #include "components/infobars/core/infobar.h"
 #include "components/version_info/version_info.h"
-#include "content/public/browser/browser_thread.h"
 #include "content/public/browser/navigation_details.h"
 #include "content/public/browser/web_contents.h"
 #include "grit/theme_resources.h"
 #include "ui/base/l10n/l10n_util.h"
 
 
 namespace {
 
-// Calls the appropriate function for setting Chrome as the default browser.
-// This requires IO access (registry) and may result in interaction with a
-// modal system UI.
-void SetChromeAsDefaultBrowser(bool interactive_flow, PrefService* prefs) {
-  if (interactive_flow) {
+// A ShellIntegration::DefaultWebClientObserver that records user metrics for
+// the result of making Chrome the default browser.
+class SetDefaultBrowserObserver
+    : public ShellIntegration::DefaultWebClientObserver {
+ public:
+  SetDefaultBrowserObserver();
+  ~SetDefaultBrowserObserver() override;
+
+ private:
+  void SetDefaultWebClientUIState(
+      ShellIntegration::DefaultWebClientUIState state) override;
+  void OnSetAsDefaultConcluded(bool succeeded) override;
+  bool IsOwnedByWorker() override;
+  bool IsInteractiveSetDefaultPermitted() override;
+
+  // True if an interactive flow will be used (i.e., Windows 8+).
+  bool interactive_;
+
+  // The result of the call to ShellIntegration::SetAsDefaultBrowser() or
+  // ShellIntegration::SetAsDefaultBrowserInteractive().
+  bool interaction_succeeded_ = false;
+
+  DISALLOW_COPY_AND_ASSIGN(SetDefaultBrowserObserver);
+};
+
+SetDefaultBrowserObserver::SetDefaultBrowserObserver()
+    : interactive_(ShellIntegration::CanSetAsDefaultBrowser() ==
+                   ShellIntegration::SET_DEFAULT_INTERACTIVE) {
+  // Log that an attempt is about to be made to set one way or the other.
+  if (interactive_)
     UMA_HISTOGRAM_BOOLEAN("DefaultBrowserWarning.SetAsDefaultUI", true);
-    if (!ShellIntegration::SetAsDefaultBrowserInteractive()) {
-      UMA_HISTOGRAM_BOOLEAN("DefaultBrowserWarning.SetAsDefaultUIFailed", true);
-    } else if (ShellIntegration::GetDefaultBrowser() ==
-               ShellIntegration::NOT_DEFAULT) {
-      // If the interaction succeeded but we are still not the default browser
-      // it likely means the user simply selected another browser from the
-      // panel. We will respect this choice and write it down as 'no, thanks'.
-      UMA_HISTOGRAM_BOOLEAN("DefaultBrowserWarning.DontSetAsDefault", true);
-    }
-  } else {
+  else
     UMA_HISTOGRAM_BOOLEAN("DefaultBrowserWarning.SetAsDefault", true);
-    ShellIntegration::SetAsDefaultBrowser();
+}
+
+SetDefaultBrowserObserver::~SetDefaultBrowserObserver() {}
+
+void SetDefaultBrowserObserver::SetDefaultWebClientUIState(
+    ShellIntegration::DefaultWebClientUIState state) {
+  if (interactive_ && interaction_succeeded_ &&
+      state == ShellIntegration::STATE_NOT_DEFAULT) {
+    // The interactive flow succeeded, yet Chrome is not the default browser.
+    // This likely means that the user selected another browser from the panel.
+    // Consider this the same as canceling the infobar.
+    UMA_HISTOGRAM_BOOLEAN("DefaultBrowserWarning.DontSetAsDefault", true);
   }
 }
 
+void SetDefaultBrowserObserver::OnSetAsDefaultConcluded(bool succeeded) {
+  interaction_succeeded_ = succeeded;
+  if (interactive_ && !succeeded) {
+    // Log that the interactive flow failed.
+    UMA_HISTOGRAM_BOOLEAN("DefaultBrowserWarning.SetAsDefaultUIFailed", true);
+  }
+}
+
+bool SetDefaultBrowserObserver::IsOwnedByWorker() {
+  // Instruct the DefaultBrowserWorker to delete this instance when it is done.
+  return true;
+}
+
+bool SetDefaultBrowserObserver::IsInteractiveSetDefaultPermitted() {
+  return true;
+}
+
 // The delegate for the infobar shown when Chrome is not the default browser.
 class DefaultBrowserInfoBarDelegate : public ConfirmInfoBarDelegate {
  public:
   // Creates a default browser infobar and delegate and adds the infobar to
   // |infobar_service|.
-  static void Create(InfoBarService* infobar_service,
-                     PrefService* prefs,
-                     bool interactive_flow_required);
+  static void Create(InfoBarService* infobar_service, PrefService* prefs);
 
  private:
-  DefaultBrowserInfoBarDelegate(PrefService* prefs,
-                                bool interactive_flow_required);
+  explicit DefaultBrowserInfoBarDelegate(PrefService* prefs);
   ~DefaultBrowserInfoBarDelegate() override;
 
   void AllowExpiry() { should_expire_ = true; }
 
   // ConfirmInfoBarDelegate:
   int GetIconId() const override;
   bool ShouldExpire(const NavigationDetails& details) const override;
   base::string16 GetMessageText() const override;
   base::string16 GetButtonLabel(InfoBarButton button) const override;
   bool OKButtonTriggersUACPrompt() const override;
   bool Accept() override;
   bool Cancel() override;
 
   // The prefs to use.
   PrefService* prefs_;
 
   // Whether the user clicked one of the buttons.
   bool action_taken_;
 
   // Whether the info-bar should be dismissed on the next navigation.
   bool should_expire_;
 
-  // Whether changing the default application will require entering the
-  // modal-UI flow.
-  const bool interactive_flow_required_;
-
   // Used to delay the expiration of the info-bar.
   base::WeakPtrFactory<DefaultBrowserInfoBarDelegate> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DefaultBrowserInfoBarDelegate);
 };
 
 // static
 void DefaultBrowserInfoBarDelegate::Create(InfoBarService* infobar_service,
-                                           PrefService* prefs,
-                                           bool interactive_flow_required) {
-  infobar_service->AddInfoBar(infobar_service->CreateConfirmInfoBar(
-      scoped_ptr<ConfirmInfoBarDelegate>(new DefaultBrowserInfoBarDelegate(
-          prefs, interactive_flow_required))));
+                                           PrefService* prefs) {
+  infobar_service->AddInfoBar(
+      infobar_service->CreateConfirmInfoBar(scoped_ptr<ConfirmInfoBarDelegate>(
+          new DefaultBrowserInfoBarDelegate(prefs))));
 }
 
-DefaultBrowserInfoBarDelegate::DefaultBrowserInfoBarDelegate(
-    PrefService* prefs,
-    bool interactive_flow_required)
+DefaultBrowserInfoBarDelegate::DefaultBrowserInfoBarDelegate(PrefService* prefs)
     : ConfirmInfoBarDelegate(),
       prefs_(prefs),
       action_taken_(false),
       should_expire_(false),
-      interactive_flow_required_(interactive_flow_required),
       weak_factory_(this) {
   // We want the info-bar to stick-around for few seconds and then be hidden
   // on the next navigation after that.
   base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
       FROM_HERE, base::Bind(&DefaultBrowserInfoBarDelegate::AllowExpiry,
                             weak_factory_.GetWeakPtr()),
       base::TimeDelta::FromSeconds(8));
 }
 
 DefaultBrowserInfoBarDelegate::~DefaultBrowserInfoBarDelegate() {
@@ skipping 23 matching lines @@
 
 // Setting an app as the default browser doesn't require elevation directly, but
 // it does require registering it as the protocol handler for "http", so if
 // protocol registration in general requires elevation, this does as well.
 bool DefaultBrowserInfoBarDelegate::OKButtonTriggersUACPrompt() const {
   return ShellIntegration::IsElevationNeededForSettingDefaultProtocolClient();
 }
 
 bool DefaultBrowserInfoBarDelegate::Accept() {
   action_taken_ = true;
-  content::BrowserThread::PostTask(
-      content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&SetChromeAsDefaultBrowser, interactive_flow_required_,
-                 prefs_));
-
+  scoped_refptr<ShellIntegration::DefaultBrowserWorker>(
+      new ShellIntegration::DefaultBrowserWorker(new SetDefaultBrowserObserver))
+      ->StartSetAsDefault();
   return true;
 }
 
 bool DefaultBrowserInfoBarDelegate::Cancel() {
   action_taken_ = true;
   UMA_HISTOGRAM_BOOLEAN("DefaultBrowserWarning.DontSetAsDefault", true);
   // User clicked "Don't ask me again", remember that.
   prefs_->SetBoolean(prefs::kCheckDefaultBrowser, false);
   return true;
 }
 
-void NotifyNotDefaultBrowserCallback(chrome::HostDesktopType desktop_type) {
-  Browser* browser = chrome::FindLastActiveWithHostDesktopType(desktop_type);
+// A ShellIntegration::DefaultWebClientObserver that handles the check to
+// determine whether or not to show the default browser prompt. If Chrome is the
+// default browser, then the kCheckDefaultBrowser pref is reset.  Otherwise, the
+// prompt is shown.
+class CheckDefaultBrowserObserver
+    : public ShellIntegration::DefaultWebClientObserver {
+ public:
+  CheckDefaultBrowserObserver(const base::FilePath& profile_path,
+                              bool show_prompt,
+                              chrome::HostDesktopType desktop_type);
+  ~CheckDefaultBrowserObserver() override;
+
+ private:
+  void SetDefaultWebClientUIState(
+      ShellIntegration::DefaultWebClientUIState state) override;
+  bool IsOwnedByWorker() override;
+
+  void ResetCheckDefaultBrowserPref();
+  void ShowPrompt();
+
+  // The path to the profile for which the prompt is to be shown.
+  base::FilePath profile_path_;
+
+  // True if the prompt is to be shown if Chrome is not the default browser.
+  bool show_prompt_;
+  chrome::HostDesktopType desktop_type_;
+
+  DISALLOW_COPY_AND_ASSIGN(CheckDefaultBrowserObserver);
+};
+
+CheckDefaultBrowserObserver::CheckDefaultBrowserObserver(
+    const base::FilePath& profile_path,
+    bool show_prompt,
+    chrome::HostDesktopType desktop_type)
+    : profile_path_(profile_path),
+      show_prompt_(show_prompt),
+      desktop_type_(desktop_type) {}
+
+CheckDefaultBrowserObserver::~CheckDefaultBrowserObserver() {}
+
+void CheckDefaultBrowserObserver::SetDefaultWebClientUIState(
+    ShellIntegration::DefaultWebClientUIState state) {
+  if (state == ShellIntegration::STATE_IS_DEFAULT) {
+    // Notify the user in the future if Chrome ceases to be the user's chosen
+    // default browser.
+    ResetCheckDefaultBrowserPref();
+  } else if (show_prompt_ && state == ShellIntegration::STATE_NOT_DEFAULT &&
+             ShellIntegration::CanSetAsDefaultBrowser() !=
+                 ShellIntegration::SET_DEFAULT_NOT_ALLOWED) {
+    ShowPrompt();
+  }
+}
+
+bool CheckDefaultBrowserObserver::IsOwnedByWorker() {
+  // Instruct the DefaultBrowserWorker to delete this instance when it is done.
+  return true;
+}
+
+void CheckDefaultBrowserObserver::ResetCheckDefaultBrowserPref() {
+  Profile* profile =
+      g_browser_process->profile_manager()->GetProfileByPath(profile_path_);
+  if (profile)
+    profile->GetPrefs()->SetBoolean(prefs::kCheckDefaultBrowser, true);
+}
+
+void CheckDefaultBrowserObserver::ShowPrompt() {
+  Browser* browser = chrome::FindLastActiveWithHostDesktopType(desktop_type_);
   if (!browser)
     return;  // Reached during ui tests.
 
   // In ChromeBot tests, there might be a race. This line appears to get
   // called during shutdown and |tab| can be NULL.
   content::WebContents* web_contents =
       browser->tab_strip_model()->GetActiveWebContents();
   if (!web_contents)
     return;
 
   DefaultBrowserInfoBarDelegate::Create(
       InfoBarService::FromWebContents(web_contents),
-      Profile::FromBrowserContext(
-          web_contents->GetBrowserContext())->GetPrefs(),
-      (ShellIntegration::CanSetAsDefaultBrowser() ==
-          ShellIntegration::SET_DEFAULT_INTERACTIVE));
-}
-
-void ResetCheckDefaultBrowserPrefOnUIThread(
-    const base::FilePath& profile_path) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  Profile* profile =
-      g_browser_process->profile_manager()->GetProfileByPath(profile_path);
-  if (profile)
-    profile->GetPrefs()->SetBoolean(prefs::kCheckDefaultBrowser, true);
-}
-
-void CheckDefaultBrowserOnFileThread(const base::FilePath& profile_path,
-                                     bool show_prompt,
-                                     chrome::HostDesktopType desktop_type) {
-  DCHECK_CURRENTLY_ON(content::BrowserThread::FILE);
-  ShellIntegration::DefaultWebClientState state =
-      ShellIntegration::GetDefaultBrowser();
-  if (state == ShellIntegration::IS_DEFAULT) {
-    // Notify the user in the future if Chrome ceases to be the user's chosen
-    // default browser.
-    content::BrowserThread::PostTask(
-        content::BrowserThread::UI, FROM_HERE,
-        base::Bind(&ResetCheckDefaultBrowserPrefOnUIThread, profile_path));
-  } else if (show_prompt && state == ShellIntegration::NOT_DEFAULT) {
-    ShellIntegration::DefaultWebClientSetPermission default_change_mode =
-        ShellIntegration::CanSetAsDefaultBrowser();
-
-    if (default_change_mode != ShellIntegration::SET_DEFAULT_NOT_ALLOWED) {
-      content::BrowserThread::PostTask(
-          content::BrowserThread::UI, FROM_HERE,
-          base::Bind(&NotifyNotDefaultBrowserCallback, desktop_type));
-    }
-  }
+      Profile::FromBrowserContext(web_contents->GetBrowserContext())
+          ->GetPrefs());
 }
 
 }  // namespace
 
 namespace chrome {
 
 void RegisterDefaultBrowserPromptPrefs(PrefRegistrySimple* registry) {
   registry->RegisterStringPref(
       prefs::kBrowserSuppressDefaultBrowserPrompt, std::string());
 }
@@ skipping 19 matching lines @@
         g_browser_process->local_state()->GetString(
             prefs::kBrowserSuppressDefaultBrowserPrompt);
     const Version disable_version(disable_version_string);
     DCHECK(disable_version_string.empty() || disable_version.IsValid());
     if (disable_version.IsValid()) {
       if (disable_version.Equals(Version(version_info::GetVersionNumber())))
         show_prompt = false;
     }
   }
 
-  content::BrowserThread::PostTask(
-      content::BrowserThread::FILE, FROM_HERE,
-      base::Bind(&CheckDefaultBrowserOnFileThread, profile->GetPath(),
-                 show_prompt, desktop_type));
+  scoped_refptr<ShellIntegration::DefaultBrowserWorker>(
+      new ShellIntegration::DefaultBrowserWorker(
+          new CheckDefaultBrowserObserver(profile->GetPath(), show_prompt,
+                                          desktop_type)))
+      ->StartCheckIsDefault();
 }
 
 #if !defined(OS_WIN)
 bool ShowFirstRunDefaultBrowserPrompt(Profile* profile) {
   return false;
 }
 #endif
 
 }  // namespace chrome