Settings reset prompt: Fetch default settings only when needed.

chrome/browser/safe_browsing/settings_reset_prompt/settings_reset_prompt_model.cc

 // Copyright 2017 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/safe_browsing/settings_reset_prompt/settings_reset_prompt_model.h"
 
 #include <utility>
 
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/metrics/histogram_macros.h"
 #include "chrome/browser/extensions/extension_service.h"
 #include "chrome/browser/prefs/session_startup_pref.h"
 #include "chrome/browser/profile_resetter/brandcoded_default_settings.h"
+#include "chrome/browser/profile_resetter/profile_resetter.h"
 #include "chrome/browser/profile_resetter/resettable_settings_snapshot.h"
 #include "chrome/browser/profiles/profile.h"
-#include "chrome/browser/safe_browsing/settings_reset_prompt/default_settings_fetcher.h"
 #include "chrome/browser/safe_browsing/settings_reset_prompt/settings_reset_prompt_config.h"
 #include "chrome/browser/search_engines/template_url_service_factory.h"
 #include "chrome/common/extensions/manifest_handlers/settings_overrides_handler.h"
 #include "chrome/common/pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "components/search_engines/template_url_service.h"
 #include "components/url_formatter/url_fixer.h"
 #include "content/public/browser/browser_thread.h"
 #include "extensions/browser/extension_registry.h"
 #include "extensions/browser/extension_system.h"
@@ skipping 30 matching lines @@
   return extensions::ExtensionRegistry::Get(profile)->GetInstalledExtension(
       extension_id);
 }
 
 GURL FixupUrl(const std::string& url_text) {
   return url_formatter::FixupURL(url_text, /*desired_tld=*/std::string());
 }
 
 }  // namespace
 
-// static
-void SettingsResetPromptModel::Create(
+SettingsResetPromptModel::SettingsResetPromptModel(
     Profile* profile,
     std::unique_ptr<SettingsResetPromptConfig> prompt_config,
-    CreateCallback callback) {
+    std::unique_ptr<ProfileResetter> profile_resetter)
+    : profile_(profile),
+      prefs_manager_(profile, prompt_config->prompt_wave()),
+      prompt_config_(std::move(prompt_config)),
+      settings_snapshot_(base::MakeUnique<ResettableSettingsSnapshot>(profile)),
+      profile_resetter_(std::move(profile_resetter)),
+      time_since_last_prompt_(base::Time::Now() -
+                              prefs_manager_.LastTriggeredPrompt()) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  DCHECK(profile);
-  DCHECK(prompt_config);
+  DCHECK(profile_);
+  DCHECK(prompt_config_);
+  DCHECK(settings_snapshot_);
+  DCHECK(profile_resetter_);
 
-  DefaultSettingsFetcher::FetchDefaultSettings(
-      base::Bind(SettingsResetPromptModel::OnSettingsFetched, profile,
-                 base::Passed(&prompt_config), base::Passed(&callback)));
-}
+  InitDefaultSearchData();
+  InitStartupUrlsData();
+  InitHomepageData();
+  DCHECK_EQ(settings_types_initialized_, SETTINGS_TYPE_ALL);
 
-// static
-std::unique_ptr<SettingsResetPromptModel>
-SettingsResetPromptModel::CreateForTesting(
-    Profile* profile,
-    std::unique_ptr<SettingsResetPromptConfig> prompt_config,
-    std::unique_ptr<ResettableSettingsSnapshot> settings_snapshot,
-    std::unique_ptr<BrandcodedDefaultSettings> default_settings,
-    std::unique_ptr<ProfileResetter> profile_resetter) {
-  return base::WrapUnique(new SettingsResetPromptModel(
-      profile, std::move(prompt_config), std::move(settings_snapshot),
-      std::move(default_settings), std::move(profile_resetter)));
+  InitExtensionData();
+
+  if (!SomeSettingRequiresReset())
+    return;
+
+  // For now, during the experimental phase, if policy controls any of the
+  // settings that we consider for reset (search, startup pages, homepage) or if
+  // an extension that needs to be disabled is managed by policy, then we do not
+  // show the reset prompt.
+  //
+  // TODO(alito): Consider how clients with policies should be prompted for
+  // reset.
+  if (SomeSettingIsManaged() || SomeExtensionMustRemainEnabled()) {
+    if (homepage_reset_state_ == RESET_REQUIRED)
+      homepage_reset_state_ = NO_RESET_REQUIRED_DUE_TO_POLICY;
+    if (default_search_reset_state_ == RESET_REQUIRED)
+      default_search_reset_state_ = NO_RESET_REQUIRED_DUE_TO_POLICY;
+    if (startup_urls_reset_state_ == RESET_REQUIRED)
+      startup_urls_reset_state_ = NO_RESET_REQUIRED_DUE_TO_POLICY;
+  }
 }
 
 SettingsResetPromptModel::~SettingsResetPromptModel() {}
 
 Profile* SettingsResetPromptModel::profile() const {
   return profile_;
 }
 
 SettingsResetPromptConfig* SettingsResetPromptModel::config() const {
   return prompt_config_.get();
 }
 
 bool SettingsResetPromptModel::ShouldPromptForReset() const {
   return SomeSettingRequiresReset();
 }
 
 void SettingsResetPromptModel::PerformReset(
+    std::unique_ptr<BrandcodedDefaultSettings> default_settings,
     const base::Closure& done_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  // |default_settings_| is set in the constructor and will be passed on to
-  // |profile_resetter_| who will take over ownership. This method should never
-  // be called more than once during the lifetime of this object.
-  DCHECK(default_settings_);
+  DCHECK(default_settings);
 
   // Disable all extensions that override settings that need to be reset.
   ExtensionService* extension_service =
       extensions::ExtensionSystem::Get(profile_)->extension_service();
   DCHECK(extension_service);
   for (const auto& item : extensions_to_disable()) {
     const extensions::ExtensionId& extension_id = item.first;
     extension_service->DisableExtension(
         extension_id, extensions::Extension::DISABLE_USER_ACTION);
   }
@@ skipping 12 matching lines @@
     UMA_HISTOGRAM_ENUMERATION("SettingsResetPrompt.SettingsReset",
                               SETTINGS_RESET_DEFAULT_SEARCH,
                               SETTINGS_RESET_MAX);
   }
   if (startup_urls_reset_state() == RESET_REQUIRED) {
     reset_flags |= ProfileResetter::STARTUP_PAGES;
     UMA_HISTOGRAM_ENUMERATION("SettingsResetPrompt.SettingsReset",
                               SETTINGS_RESET_STARTUP_URLS, SETTINGS_RESET_MAX);
   }
 
-  profile_resetter_->Reset(reset_flags, std::move(default_settings_),
+  profile_resetter_->Reset(reset_flags, std::move(default_settings),
                            done_callback);
 }
 
 void SettingsResetPromptModel::DialogShown() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   DCHECK(SomeSettingRequiresReset());
 
   base::Time now = base::Time::Now();
   if (default_search_reset_state() == RESET_REQUIRED)
     prefs_manager_.RecordPromptShownForDefaultSearch(now);
@@ skipping 53 matching lines @@
                             startup_urls_reset_state(), RESET_STATE_MAX);
   UMA_HISTOGRAM_ENUMERATION("SettingsResetPrompt.ResetState_Homepage",
                             homepage_reset_state(), RESET_STATE_MAX);
   UMA_HISTOGRAM_COUNTS_100("SettingsResetPrompt.NumberOfExtensionsToDisable",
                            extensions_to_disable().size());
   UMA_HISTOGRAM_SPARSE_SLOWLY(
       "SettingsResetPrompt.DelayBeforePromptParam",
       prompt_config_->delay_before_prompt().InSeconds());
 }
 
-// static
-void SettingsResetPromptModel::OnSettingsFetched(
-    Profile* profile,
-    std::unique_ptr<SettingsResetPromptConfig> prompt_config,
-    SettingsResetPromptModel::CreateCallback callback,
-    std::unique_ptr<BrandcodedDefaultSettings> default_settings) {
-  DCHECK(profile);
-  DCHECK(prompt_config);
-  DCHECK(default_settings);
-
-  callback.Run(base::WrapUnique(new SettingsResetPromptModel(
-      profile, std::move(prompt_config),
-      base::MakeUnique<ResettableSettingsSnapshot>(profile),
-      std::move(default_settings),
-      base::MakeUnique<ProfileResetter>(profile))));
-}
-
-SettingsResetPromptModel::SettingsResetPromptModel(
-    Profile* profile,
-    std::unique_ptr<SettingsResetPromptConfig> prompt_config,
-    std::unique_ptr<ResettableSettingsSnapshot> settings_snapshot,
-    std::unique_ptr<BrandcodedDefaultSettings> default_settings,
-    std::unique_ptr<ProfileResetter> profile_resetter)
-    : profile_(profile),
-      prefs_manager_(profile, prompt_config->prompt_wave()),
-      prompt_config_(std::move(prompt_config)),
-      settings_snapshot_(std::move(settings_snapshot)),
-      default_settings_(std::move(default_settings)),
-      profile_resetter_(std::move(profile_resetter)),
-      time_since_last_prompt_(base::Time::Now() -
-                              prefs_manager_.LastTriggeredPrompt()),
-      settings_types_initialized_(0),
-      homepage_reset_domain_id_(-1),
-      homepage_reset_state_(NO_RESET_REQUIRED_DUE_TO_DOMAIN_NOT_MATCHED),
-      default_search_reset_domain_id_(-1),
-      default_search_reset_state_(NO_RESET_REQUIRED_DUE_TO_DOMAIN_NOT_MATCHED),
-      startup_urls_reset_state_(NO_RESET_REQUIRED_DUE_TO_DOMAIN_NOT_MATCHED) {
-  DCHECK(profile_);
-  DCHECK(prompt_config_);
-  DCHECK(settings_snapshot_);
-  DCHECK(default_settings_);
-  DCHECK(profile_resetter_);
-
-  InitDefaultSearchData();
-  InitStartupUrlsData();
-  InitHomepageData();
-  DCHECK_EQ(settings_types_initialized_, SETTINGS_TYPE_ALL);
-
-  InitExtensionData();
-
-  if (!SomeSettingRequiresReset())
-    return;
-
-  // For now, during the experimental phase, if policy controls any of the
-  // settings that we consider for reset (search, startup pages, homepage) or if
-  // an extension that needs to be disabled is managed by policy, then we do not
-  // show the reset prompt.
-  //
-  // TODO(alito): Consider how clients with policies should be prompted for
-  // reset.
-  if (SomeSettingIsManaged() || SomeExtensionMustRemainEnabled()) {
-    if (homepage_reset_state_ == RESET_REQUIRED)
-      homepage_reset_state_ = NO_RESET_REQUIRED_DUE_TO_POLICY;
-    if (default_search_reset_state_ == RESET_REQUIRED)
-      default_search_reset_state_ = NO_RESET_REQUIRED_DUE_TO_POLICY;
-    if (startup_urls_reset_state_ == RESET_REQUIRED)
-      startup_urls_reset_state_ = NO_RESET_REQUIRED_DUE_TO_POLICY;
-  }
-}
-
 void SettingsResetPromptModel::InitDefaultSearchData() {
   // Default search data must be the first setting type to be initialized.
   DCHECK_EQ(settings_types_initialized_, 0U);
 
   settings_types_initialized_ |= SETTINGS_TYPE_DEFAULT_SEARCH;
 
   default_search_url_ = FixupUrl(settings_snapshot_->dse_url());
   default_search_reset_domain_id_ =
       prompt_config_->UrlToResetDomainId(default_search_url_);
   if (default_search_reset_domain_id_ < 0)
@@ skipping 155 matching lines @@
           GetExtension(profile_, extension_id);
       if (extension && management_policy->MustRemainEnabled(extension, nullptr))
         return true;
     }
   }
 
   return false;
 }
 
 }  // namespace safe_browsing.