Settings reset prompt: add startup logic

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"
@@ skipping 200 matching lines @@
   if (homepage_reset_state() == RESET_REQUIRED)
     reset_flags |= ProfileResetter::HOMEPAGE;
   if (default_search_reset_state() == RESET_REQUIRED)
     reset_flags |= ProfileResetter::DEFAULT_SEARCH_ENGINE;
   if (startup_urls_reset_state() == RESET_REQUIRED)
     reset_flags |= ProfileResetter::STARTUP_PAGES;
   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);
+  if (startup_urls_reset_state() == RESET_REQUIRED)
+    prefs_manager_.RecordPromptShownForStartupUrls(now);
+  if (homepage_reset_state() == RESET_REQUIRED)
+    prefs_manager_.RecordPromptShownForHomepage(now);
+}
+
 GURL SettingsResetPromptModel::homepage() const {
   return homepage_url_;
 }
 
 SettingsResetPromptModel::ResetState
 SettingsResetPromptModel::homepage_reset_state() const {
   DCHECK(homepage_reset_state_ != RESET_REQUIRED ||
          homepage_reset_domain_id_ >= 0);
   return homepage_reset_state_;
 }
@@ skipping 45 matching lines @@
       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_);
@@ skipping 15 matching lines @@
   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)
     return;
 
-  default_search_reset_state_ = RESET_REQUIRED;
+  default_search_reset_state_ = GetResetStateForSetting(
+      prefs_manager_.LastTriggeredPromptForDefaultSearch());
 }
 
 void SettingsResetPromptModel::InitStartupUrlsData() {
   // Default search data must have been initialized before startup URLs data.
   DCHECK_EQ(settings_types_initialized_, SETTINGS_TYPE_DEFAULT_SEARCH);
 
   settings_types_initialized_ |= SETTINGS_TYPE_STARTUP_URLS;
 
   // Only the SessionStartupPref::URLS startup type is a candidate for
   // resetting.
   if (settings_snapshot_->startup_type() != SessionStartupPref::URLS)
     return;
 
   for (const GURL& startup_url : settings_snapshot_->startup_urls()) {
     GURL fixed_url = FixupUrl(startup_url.possibly_invalid_spec());
     startup_urls_.push_back(fixed_url);
     int reset_domain_id = prompt_config_->UrlToResetDomainId(fixed_url);
     if (reset_domain_id >= 0) {
-      startup_urls_reset_state_ =
-          SomeSettingRequiresReset()
-              ? NO_RESET_REQUIRED_DUE_TO_OTHER_SETTING_REQUIRING_RESET
-              : RESET_REQUIRED;
       startup_urls_to_reset_.push_back(fixed_url);
       domain_ids_for_startup_urls_to_reset_.insert(reset_domain_id);
     }
   }
+
+  if (startup_urls_to_reset_.empty())
+    return;
+
+  startup_urls_reset_state_ = GetResetStateForSetting(
+      prefs_manager_.LastTriggeredPromptForStartupUrls());
 }
 
 void SettingsResetPromptModel::InitHomepageData() {
   // Homepage data must be initialized after default search and startup URLs
   // data.
   DCHECK_EQ(settings_types_initialized_,
             SETTINGS_TYPE_DEFAULT_SEARCH | SETTINGS_TYPE_STARTUP_URLS);
 
   settings_types_initialized_ |= SETTINGS_TYPE_HOMEPAGE;
 
   homepage_url_ = FixupUrl(settings_snapshot_->homepage());
 
   // If the home button is not visible to the user, then the homepage setting
   // has no real user-visible effect.
   if (!settings_snapshot_->show_home_button())
     return;
 
   // We do not currently support resetting New Tab pages that are set by
   // extensions.
   if (settings_snapshot_->homepage_is_ntp())
     return;
 
   homepage_reset_domain_id_ = prompt_config_->UrlToResetDomainId(homepage_url_);
   if (homepage_reset_domain_id_ < 0)
     return;
 
   homepage_reset_state_ =
-      SomeSettingRequiresReset()
-          ? NO_RESET_REQUIRED_DUE_TO_OTHER_SETTING_REQUIRING_RESET
-          : RESET_REQUIRED;
+      GetResetStateForSetting(prefs_manager_.LastTriggeredPromptForHomepage());
 }
 
 // Populate |extensions_to_disable_| with all enabled extensions that override
 // the settings whose values were determined to need resetting. Note that all
 // extensions that override such settings are included in the list, not just the
 // one that is currently actively overriding the setting, in order to ensure
 // that default values can be restored. This function should be called after
 // other Init*() functions.
 void SettingsResetPromptModel::InitExtensionData() {
   DCHECK_EQ(settings_types_initialized_, SETTINGS_TYPE_ALL);
@@ skipping 21 matching lines @@
          overrides->search_engine) ||
         (startup_urls_reset_state_ == RESET_REQUIRED &&
          !overrides->startup_pages.empty())) {
       ExtensionInfo extension_info(extension);
       extensions_to_disable_.insert(
           std::make_pair(extension_info.id, extension_info));
     }
   }
 }
 
+SettingsResetPromptModel::ResetState
+SettingsResetPromptModel::GetResetStateForSetting(
+    const base::Time& last_triggered_for_setting) const {
+  if (!last_triggered_for_setting.is_null())
+    return NO_RESET_REQUIRED_DUE_TO_ALREADY_PROMPTED_FOR_SETTING;
+
+  if (time_since_last_prompt_ < prompt_config_->time_between_prompts())
+    return NO_RESET_REQUIRED_DUE_TO_RECENTLY_PROMPTED;
+
+  if (SomeSettingRequiresReset())
+    return NO_RESET_REQUIRED_DUE_TO_OTHER_SETTING_REQUIRING_RESET;
+
+  return RESET_REQUIRED;
+}
+
 bool SettingsResetPromptModel::SomeSettingRequiresReset() const {
   return default_search_reset_state_ == RESET_REQUIRED ||
          startup_urls_reset_state_ == RESET_REQUIRED ||
          homepage_reset_state_ == RESET_REQUIRED;
 }
 
 }  // namespace safe_browsing.