Add a simple API around the pref controlling the default browser prompt.

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/macros.h"
@@ skipping 26 matching lines @@
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/vector_icons_public.h"
 
 namespace {
 
 // 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);
+  static void Create(InfoBarService* infobar_service, Profile* profile);
 
  private:
   // Possible user interactions with the default browser info bar.
   // Do not modify the ordering as it is important for UMA.
   enum InfoBarUserInteraction {
     // The user clicked the "Set as default" button.
     START_SET_AS_DEFAULT,
     // The user doesn't want to be reminded again.
     DONT_ASK_AGAIN,
     // The user did not interact with the info bar.
     IGNORE_INFO_BAR,
     NUM_INFO_BAR_USER_INTERACTION_TYPES
   };
 
-  explicit DefaultBrowserInfoBarDelegate(PrefService* prefs);
+  explicit DefaultBrowserInfoBarDelegate(Profile* profile);
   ~DefaultBrowserInfoBarDelegate() override;
 
   void AllowExpiry() { should_expire_ = true; }
 
   // ConfirmInfoBarDelegate:
   Type GetInfoBarType() const override;
   infobars::InfoBarDelegate::InfoBarIdentifier GetIdentifier() const override;
   int GetIconId() const override;
   gfx::VectorIconId GetVectorIconId() 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_;
+  // The WebContents's corresponding profile.
+  Profile* profile_;
 
   // 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_;
 
   // 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) {
+                                           Profile* profile) {
   infobar_service->AddInfoBar(
       infobar_service->CreateConfirmInfoBar(scoped_ptr<ConfirmInfoBarDelegate>(
-          new DefaultBrowserInfoBarDelegate(prefs))));
+          new DefaultBrowserInfoBarDelegate(profile))));
 }
 
-DefaultBrowserInfoBarDelegate::DefaultBrowserInfoBarDelegate(PrefService* prefs)
+DefaultBrowserInfoBarDelegate::DefaultBrowserInfoBarDelegate(Profile* profile)
     : ConfirmInfoBarDelegate(),
-      prefs_(prefs),
+      profile_(profile),
       action_taken_(false),
       should_expire_(false),
       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));
 }
@@ skipping 72 matching lines @@
 }
 
 bool DefaultBrowserInfoBarDelegate::Cancel() {
   action_taken_ = true;
   content::RecordAction(
       base::UserMetricsAction("DefaultBrowserInfoBar_DontAskAgain"));
   UMA_HISTOGRAM_ENUMERATION("DefaultBrowser.InfoBar.UserInteraction",
                             InfoBarUserInteraction::DONT_ASK_AGAIN,
                             NUM_INFO_BAR_USER_INTERACTION_TYPES);
   // User clicked "Don't ask me again", remember that.
-  prefs_->SetBoolean(prefs::kCheckDefaultBrowser, false);
+  chrome::DefaultBrowserPromptDeclined(profile_);
   return true;
 }
 
 void ResetCheckDefaultBrowserPref(const base::FilePath& profile_path) {
   Profile* profile =
       g_browser_process->profile_manager()->GetProfileByPath(profile_path);
   if (profile)
-    profile->GetPrefs()->SetBoolean(prefs::kCheckDefaultBrowser, true);
+    chrome::ResetDefaultBrowserPrompt(profile);
 }
 
 void ShowPrompt() {
   Browser* browser = chrome::FindLastActive();
   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());
+      InfoBarService::FromWebContents(web_contents), browser->profile());
 }
 
 void OnCheckIsDefaultBrowserFinished(
     const base::FilePath& profile_path,
     bool show_prompt,
     shell_integration::DefaultWebClientState state) {
   if (state == shell_integration::IS_DEFAULT) {
     // Notify the user in the future if Chrome ceases to be the user's chosen
     // default browser.
     ResetCheckDefaultBrowserPref(profile_path);
@@ skipping 20 matching lines @@
       prefs::kDefaultBrowserSettingEnabled)) {
     // Handling of the browser.default_browser_setting_enabled policy setting is
     // taken care of in BrowserProcessImpl.
     return;
   }
 
   PrefService* prefs = profile->GetPrefs();
   // Reset preferences if kResetCheckDefaultBrowser is true.
   if (prefs->GetBoolean(prefs::kResetCheckDefaultBrowser)) {
     prefs->SetBoolean(prefs::kResetCheckDefaultBrowser, false);
-    prefs->SetBoolean(prefs::kCheckDefaultBrowser, true);
+    ResetDefaultBrowserPrompt(profile);
   }
 
   // Check if Chrome is the default browser but do not prompt if:
   // - The user said "don't ask me again" on the infobar earlier.
   // - The "suppress_default_browser_prompt_for_version" master preference is
   //     set to the current version.
   bool show_prompt = prefs->GetBoolean(prefs::kCheckDefaultBrowser);
   if (show_prompt) {
     const std::string disable_version_string =
         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() &&
         disable_version == Version(version_info::GetVersionNumber())) {
       show_prompt = false;
     }
   }
 
   scoped_refptr<shell_integration::DefaultBrowserWorker>(
       new shell_integration::DefaultBrowserWorker(base::Bind(
           &OnCheckIsDefaultBrowserFinished, profile->GetPath(), show_prompt)))
       ->StartCheckIsDefault();
 }
 
+void DefaultBrowserPromptDeclined(Profile* profile) {
+  profile->GetPrefs()->SetBoolean(prefs::kCheckDefaultBrowser, false);
+}
+
+void ResetDefaultBrowserPrompt(Profile* profile) {
+  profile->GetPrefs()->ClearPref(prefs::kCheckDefaultBrowser);

[msw, 2016/04/06 22:04:55]

q: does this yield equivalent behavior as setting the pref to true?
(just checking that this won't regress ResetCheckDefaultBrowserPref, etc.)

[grt (UTC plus 2), 2016/04/07 00:49:30]

The default is true at the point of registration
(https://code.google.com/p/chromium/codesearch#chromium/src/chrome/browser/ui/...),
so I figured that clearing it is better than setting it since it will remove a
few bytes from the pref file. Is there any risk in this?

[msw, 2016/04/07 01:42:59]

Not afaik, so that sg. Still lgtm

+}
+
 #if !defined(OS_WIN)
 bool ShowFirstRunDefaultBrowserPrompt(Profile* profile) {
   return false;
 }
 #endif
 
 }  // namespace chrome