Settings reset prompt: Fetch default settings only when needed.

chrome/browser/ui/views/settings_reset_prompt_dialog_browsertest.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 <algorithm>
 #include <initializer_list>
 #include <map>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 50 matching lines @@
     : public safe_browsing::SettingsResetPromptModel {
  public:
   // Create a mock model that pretends that the settings passed in via
   // |settings_to_reset| require resetting. |settings_to_reset| must not be
   // empty or have |EXTENSIONS| as the only member.
   explicit MockSettingsResetPromptModel(Profile* profile,
                                         const ModelParams& params)
       : SettingsResetPromptModel(
             profile,
             base::MakeUnique<NiceMock<MockSettingsResetPromptConfig>>(),
-            base::MakeUnique<ResettableSettingsSnapshot>(profile),
-            base::MakeUnique<BrandcodedDefaultSettings>(),
             base::MakeUnique<NiceMock<MockProfileResetter>>(profile)) {
     EXPECT_LE(params.startup_pages, arraysize(kStartupUrls));
 
     // Set up startup URLs and extensions to be returned by member functions
     // based on the constructor arguments.
     for (size_t i = 0;
          i < std::min(arraysize(kStartupUrls), params.startup_pages); ++i) {
       startup_urls_.push_back(GURL(kStartupUrls[i]));
     }
 
     if (params.setting_to_reset == SettingType::STARTUP_PAGE)
       startup_urls_to_reset_ = startup_urls_;
 
     for (size_t i = 0; i < params.extensions_to_disable; ++i) {
       std::string id = "id" + base::IntToString(i);
       extensions_.insert(
           std::make_pair(id, safe_browsing::ExtensionInfo(
                                  id, "Extension " + base::IntToString(i))));
     }
 
     ON_CALL(*this, ShouldPromptForReset()).WillByDefault(Return(true));
-    ON_CALL(*this, PerformReset(_)).WillByDefault(Return());
+    ON_CALL(*this, MockPerformReset(_, _)).WillByDefault(Return());
     ON_CALL(*this, DialogShown()).WillByDefault(Return());
 
     ON_CALL(*this, homepage()).WillByDefault(Return(GURL(kHomepageUrl)));
     ON_CALL(*this, homepage_reset_state())
         .WillByDefault(
             Return(params.setting_to_reset == SettingType::HOMEPAGE
                        ? RESET_REQUIRED
                        : NO_RESET_REQUIRED_DUE_TO_DOMAIN_NOT_MATCHED));
 
     ON_CALL(*this, default_search()).WillByDefault(Return(GURL(kSearchUrl)));
@@ skipping 10 matching lines @@
         .WillByDefault(
             Return(params.setting_to_reset == SettingType::STARTUP_PAGE
                        ? RESET_REQUIRED
                        : NO_RESET_REQUIRED_DUE_TO_DOMAIN_NOT_MATCHED));
 
     ON_CALL(*this, extensions_to_disable())
         .WillByDefault(ReturnRef(extensions_));
   }
   ~MockSettingsResetPromptModel() override {}
 
-  MOCK_METHOD1(PerformReset, void(const base::Closure&));
+  void PerformReset(std::unique_ptr<BrandcodedDefaultSettings> default_settings,
+                    const base::Closure& callback) override {
+    MockPerformReset(default_settings.get(), callback);
+  }
+  MOCK_METHOD2(MockPerformReset,
+               void(BrandcodedDefaultSettings*, const base::Closure&));
   MOCK_CONST_METHOD0(ShouldPromptForReset, bool());
   MOCK_METHOD0(DialogShown, void());
   MOCK_CONST_METHOD0(homepage, GURL());
   MOCK_CONST_METHOD0(homepage_reset_state, ResetState());
   MOCK_CONST_METHOD0(default_search, GURL());
   MOCK_CONST_METHOD0(default_search_reset_state, ResetState());
   MOCK_CONST_METHOD0(startup_urls, const std::vector<GURL>&());
   MOCK_CONST_METHOD0(startup_urls_to_reset, const std::vector<GURL>&());
   MOCK_CONST_METHOD0(startup_urls_reset_state, ResetState());
   MOCK_CONST_METHOD0(extensions_to_disable, const ExtensionMap&());
@@ skipping 23 matching lines @@
         {"sp2_ext2", {SettingType::STARTUP_PAGE, 2, 2}},
         {"hp_ext2", {SettingType::HOMEPAGE, 0, 2}},
     };
 
     ASSERT_NE(name_to_model_params.find(name), name_to_model_params.end());
     auto model = base::MakeUnique<NiceMock<MockSettingsResetPromptModel>>(
         browser()->profile(), name_to_model_params.find(name)->second);
 
     safe_browsing::SettingsResetPromptController::ShowSettingsResetPrompt(
         browser(),
-        new safe_browsing::SettingsResetPromptController(std::move(model)));
+        new safe_browsing::SettingsResetPromptController(
+            std::move(model), base::MakeUnique<BrandcodedDefaultSettings>()));
   }
 };
 
 IN_PROC_BROWSER_TEST_F(SettingsResetPromptDialogTest, InvokeDialog_dse) {
   RunDialog();
 }
 IN_PROC_BROWSER_TEST_F(SettingsResetPromptDialogTest, InvokeDialog_sp1) {
   RunDialog();
 }
 IN_PROC_BROWSER_TEST_F(SettingsResetPromptDialogTest, InvokeDialog_sp2) {
@@ skipping 21 matching lines @@
   RunDialog();
 }
 IN_PROC_BROWSER_TEST_F(SettingsResetPromptDialogTest, InvokeDialog_sp2_ext2) {
   RunDialog();
 }
 IN_PROC_BROWSER_TEST_F(SettingsResetPromptDialogTest, InvokeDialog_hp_ext2) {
   RunDialog();
 }
 
 }  // namespace