Post-cleanup settings reset.

chrome/browser/safe_browsing/chrome_cleaner/settings_resetter_browsertest_win.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/chrome_cleaner/settings_resetter_win.h"
+
+#include <memory>
+
+#include "base/run_loop.h"
+#include "base/test/scoped_feature_list.h"
+#include "base/test/test_reg_util_win.h"
+#include "base/win/registry.h"
+#include "chrome/browser/browser_process.h"
+#include "chrome/browser/profile_resetter/brandcoded_default_settings.h"
+#include "chrome/browser/profile_resetter/profile_resetter.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
+#include "chrome/browser/safe_browsing/chrome_cleaner/srt_field_trial_win.h"
+#include "chrome/browser/safe_browsing/settings_reset_prompt/settings_reset_prompt_test_utils.h"
+#include "chrome/browser/ui/browser.h"
+#include "chrome/browser/ui/browser_finder.h"
+#include "chrome/common/pref_names.h"
+#include "chrome/test/base/in_process_browser_test.h"
+#include "components/chrome_cleaner/public/constants/constants.h"
+#include "components/prefs/pref_service.h"
+#include "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace safe_browsing {
+namespace {
+
+using ::testing::_;
+using ::testing::StrictMock;
+
+// Ensures the settings resetter class can only be instantiated if
+// kInBrowserCleanerUIFeature is enabled.
+// Test param:
+//  - in_browser_cleaner_ui: if the feature is enabled.
+class PostCleanupSettingsResetEnabledTest
+    : public InProcessBrowserTest,
+      public ::testing::WithParamInterface<bool> {
+ public:
+  void SetUpInProcessBrowserTestFixture() override {
+    InProcessBrowserTest::SetUpInProcessBrowserTestFixture();
+
+    in_browser_cleaner_ui_ = GetParam();
+    if (in_browser_cleaner_ui_)
+      scoped_feature_list_.InitAndEnableFeature(kInBrowserCleanerUIFeature);
+    else
+      scoped_feature_list_.InitAndDisableFeature(kInBrowserCleanerUIFeature);
+  }
+
+ protected:
+  base::test::ScopedFeatureList scoped_feature_list_;
+  bool in_browser_cleaner_ui_;
+};
+
+IN_PROC_BROWSER_TEST_P(PostCleanupSettingsResetEnabledTest, Run) {
+  ASSERT_EQ(in_browser_cleaner_ui_,
+            PostCleanupSettingsResetter::Create() != nullptr);
+}
+
+INSTANTIATE_TEST_CASE_P(Default,
+                        PostCleanupSettingsResetEnabledTest,
+                        testing::Bool());
+
+// Callback for CreateProfile() that assigns |profile| to |*out_profile|
+// if the profile creation is successful.
+void CreateProfileCallback(Profile** out_profile,
+                           const base::Closure& closure,
+                           Profile* profile,
+                           Profile::CreateStatus status) {
+  DCHECK(out_profile);
+  if (status == Profile::CREATE_STATUS_INITIALIZED)
+    *out_profile = profile;
+  closure.Run();
+}
+
+// Creates a new profile from the UI thread.
+Profile* CreateProfile() {
+  ProfileManager* profile_manager = g_browser_process->profile_manager();
+  Profile* profile = nullptr;
+  base::RunLoop run_loop;
+  profile_manager->CreateProfileAsync(
+      profile_manager->GenerateNextProfileDirectoryPath(),
+      base::Bind(&CreateProfileCallback, &profile, run_loop.QuitClosure()),
+      base::string16(), std::string(), std::string());
+  run_loop.Run();
+  return profile;
+}
+
+// Returns true if |profile| is tagged for settings reset.
+bool ProfileIsTagged(Profile* profile) {
+  return profile->GetPrefs()->GetBoolean(prefs::kChromeCleanerResetPending);
+}
+
+// If |value| is positive, saves it in the registry at the Chrome Cleaner
+// registry key under |value_name|.
+void SetValueIfPositive(const wchar_t* value_name, int64_t value) {
+  if (value <= 0)
+    return;
+
+  base::string16 cleaner_key_path(
+      chrome_cleaner::kSoftwareRemovalToolRegistryKey);
+  cleaner_key_path.append(L"\\").append(chrome_cleaner::kCleanerSubKey);
+
+  LONG result = base::win::RegKey(HKEY_CURRENT_USER, cleaner_key_path.c_str(),
+                                  KEY_SET_VALUE)
+                    .WriteValue(value_name, &value, sizeof(value), REG_QWORD);
+  ASSERT_EQ(ERROR_SUCCESS, result);
+}
+
+class ChromeCleanerTagForResettingTest : public InProcessBrowserTest {
+ public:
+  void SetUpInProcessBrowserTestFixture() override {
+    InProcessBrowserTest::SetUpInProcessBrowserTestFixture();
+
+    scoped_feature_list_.InitAndEnableFeature(kInBrowserCleanerUIFeature);
+  }
+
+ protected:
+  base::test::ScopedFeatureList scoped_feature_list_;
+};
+
+IN_PROC_BROWSER_TEST_F(ChromeCleanerTagForResettingTest, Run) {
+  Browser* browser = chrome::FindLastActive();
+  ASSERT_TRUE(browser);
+  Profile* profile = browser->profile();
+  ASSERT_TRUE(profile);
+
+  std::unique_ptr<PostCleanupSettingsResetter> resetter =
+      PostCleanupSettingsResetter::Create();
+  ASSERT_TRUE(resetter);
+  resetter->TagForResetting(profile);
+  EXPECT_TRUE(ProfileIsTagged(profile));
+}
+
+class SettingsResetterTestDelegate
+    : public PostCleanupSettingsResetter::Delegate {
+ public:
+  explicit SettingsResetterTestDelegate(int* num_resets)
+      : num_resets_(num_resets) {}
+  ~SettingsResetterTestDelegate() override = default;
+
+  void FetchDefaultSettings(
+      DefaultSettingsFetcher::SettingsCallback callback) override {
+    callback.Run(base::MakeUnique<BrandcodedDefaultSettings>());
+  }
+
+  // Returns a MockProfileResetter that requires Reset() be called.
+  std::unique_ptr<ProfileResetter> GetProfileResetter(
+      Profile* profile) override {
+    ++(*num_resets_);
+    auto mock_profile_resetter =
+        base::MakeUnique<StrictMock<MockProfileResetter>>(profile);
+    EXPECT_CALL(*mock_profile_resetter, MockReset(_, _, _));
+    return std::move(mock_profile_resetter);
+  }
+
+ private:
+  int* num_resets_;
+
+  DISALLOW_COPY_AND_ASSIGN(SettingsResetterTestDelegate);
+};
+
+const struct SettingsResetTestParams {
+  int64_t ts_cleanup_started;
+  int64_t ts_cleanup_completed;
+  bool settings_reset;
+} kSettingsResetTestParams[] = {{0, 0, false},
+                                {10000, 0, false},
+                                {0, 20000, false},
+                                {20000, 10000, false},
+                                {10000, 20000, true}};
+
+// Param for this test:
+//  - SettingsResetTestParams params: values to write to the registry and
+//                                    whether settings should be reset.
+class ChromeCleanerResetTaggedProfilesTest
+    : public InProcessBrowserTest,
+      public ::testing::WithParamInterface<SettingsResetTestParams> {
+ public:
+  void SetUpInProcessBrowserTestFixture() override {
+    InProcessBrowserTest::SetUpInProcessBrowserTestFixture();
+
+    params_ = GetParam();
+    scoped_feature_list_.InitAndEnableFeature(kInBrowserCleanerUIFeature);
+  }
+
+ protected:
+  // Test params.
+  SettingsResetTestParams params_;
+
+  base::test::ScopedFeatureList scoped_feature_list_;
+  registry_util::RegistryOverrideManager registry_override_manager_;
+};
+
+IN_PROC_BROWSER_TEST_P(ChromeCleanerResetTaggedProfilesTest, Run) {
+  ASSERT_NO_FATAL_FAILURE(
+      registry_override_manager_.OverrideRegistry(HKEY_CURRENT_USER));
+  SetValueIfPositive(chrome_cleaner::kCleanupStartedTimestampValueName,
+                     params_.ts_cleanup_started);
+  SetValueIfPositive(chrome_cleaner::kCleanupConfirmedTimestampValueName,
+                     params_.ts_cleanup_completed);
+
+  // Profile objects are owned by ProfileManager.
+  Profile* profile1 = CreateProfile();
+  ASSERT_TRUE(profile1);
+  Profile* profile2 = CreateProfile();
+  ASSERT_TRUE(profile2);
+  Profile* profile3 = CreateProfile();
+  ASSERT_TRUE(profile3);
+
+  profile1->GetPrefs()->SetBoolean(prefs::kChromeCleanerResetPending, true);
+  profile3->GetPrefs()->SetBoolean(prefs::kChromeCleanerResetPending, true);
+
+  int num_resets = 0;
+  auto delegate = base::MakeUnique<SettingsResetterTestDelegate>(&num_resets);
+
+  std::unique_ptr<PostCleanupSettingsResetter> resetter =
+      PostCleanupSettingsResetter::Create();
+  ASSERT_TRUE(resetter);
+
+  base::RunLoop run_loop_for_reset;
+  resetter->ResetTaggedProfiles({profile1, profile2, profile3},
+                                run_loop_for_reset.QuitClosure(),
+                                std::move(delegate));
+  run_loop_for_reset.Run();
+
+  // Profiles 1 and 3 should be reset only if a cleanup has completed according
+  // to the registry entries written by the cleaner and indicated by
+  // params_.settings_reset. Profile 2 should remain not-tagged by the
+  // operation.
+  EXPECT_EQ(params_.settings_reset ? 2 : 0, num_resets);
+  EXPECT_EQ(!params_.settings_reset, ProfileIsTagged(profile1));
+  EXPECT_EQ(false, ProfileIsTagged(profile2));
+  EXPECT_EQ(!params_.settings_reset, ProfileIsTagged(profile3));
+}
+
+INSTANTIATE_TEST_CASE_P(Default,
+                        ChromeCleanerResetTaggedProfilesTest,
+                        testing::ValuesIn(kSettingsResetTestParams));
+
+}  // namespace
+}  // namespace safe_browsing