Post-cleanup settings reset.

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_controller_win_unittest.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/chrome_cleaner_controller_win.h"
 
 #include <string>
 #include <tuple>
 #include <utility>
 
 #include "base/command_line.h"
 #include "base/run_loop.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/test/multiprocess_test.h"
 #include "base/test/scoped_feature_list.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
+#include "chrome/browser/profiles/profile.h"
+#include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/browser/safe_browsing/chrome_cleaner/mock_chrome_cleaner_process_win.h"
 #include "chrome/browser/safe_browsing/chrome_cleaner/reporter_runner_win.h"
 #include "chrome/browser/safe_browsing/chrome_cleaner/srt_field_trial_win.h"
+#include "chrome/test/base/testing_browser_process.h"
+#include "chrome/test/base/testing_profile.h"
+#include "chrome/test/base/testing_profile_manager.h"
 #include "components/chrome_cleaner/public/constants/constants.h"
 #include "content/public/browser/browser_thread.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gmock/include/gmock/gmock.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "testing/multiprocess_func_list.h"
 
 namespace safe_browsing {
 namespace {
 
@@ skipping 74 matching lines @@
     std::move(fetched_callback)
         .Run(base::FilePath(FILE_PATH_LITERAL("chrome_cleaner.exe")));
   }
 
   bool SafeBrowsingExtendedReportingScoutEnabled() override {
     return scout_enabled_;
   }
 
   bool IsMetricsAndCrashReportingEnabled() override { return metrics_enabled_; }
 
+  void InvokeTagProfileForResetting(Profile* profile) override {
+    // This function should never be called by these tests.
+    ASSERT_TRUE(false);
+  }
+
+  void InvokeResetPostCleanupSettingsIfTagged(
+      std::vector<Profile*> profiles,
+      base::OnceClosure continuation) override {
+    // This function should never be called by these tests.
+    ASSERT_TRUE(false);
+  }
+
   // ChromeCleanerRunnerTestDelegate overrides.
 
   base::Process LaunchTestProcess(
       const base::CommandLine& command_line,
       const base::LaunchOptions& launch_options) override {
     command_line_ = command_line;
     // Return an invalid process.
     return base::Process();
   }
 
@@ skipping 71 matching lines @@
 // configurations and mocks the user's response.
 class ChromeCleanerControllerTest
     : public testing::TestWithParam<
           std::tuple<CleanerProcessStatus,
                      MockChromeCleanerProcess::CrashPoint,
                      UwsFoundStatus,
                      ChromeCleanerController::UserResponse>>,
       public ChromeCleanerRunnerTestDelegate,
       public ChromeCleanerControllerDelegate {
  public:
+  ChromeCleanerControllerTest()
+      : profile_manager_(TestingBrowserProcess::GetGlobal()) {}
   ~ChromeCleanerControllerTest() override {}
 
   void SetUp() override {
+    ASSERT_TRUE(profile_manager_.SetUp());
+
     std::tie(process_status_, crash_point_, uws_found_status_, user_response_) =
         GetParam();
 
     cleaner_process_options_.SetDoFindUws(uws_found_status_ !=
                                           UwsFoundStatus::kNoUwsFound);
     cleaner_process_options_.set_reboot_required(
         uws_found_status_ == UwsFoundStatus::kUwsFoundRebootRequired);
     cleaner_process_options_.set_crash_point(crash_point_);
 
     controller_ = ChromeCleanerController::GetInstance();
     ASSERT_TRUE(controller_);
 
     scoped_feature_list_.InitAndEnableFeature(kInBrowserCleanerUIFeature);
     SetChromeCleanerRunnerTestDelegateForTesting(this);
     controller_->SetDelegateForTesting(this);
   }
 
   void TearDown() override {
     if (controller_->state() == State::kRebootRequired)
       controller_->DismissRebootForTesting();
 
     controller_->SetDelegateForTesting(nullptr);
     SetChromeCleanerRunnerTestDelegateForTesting(nullptr);
   }
 
+  TestingProfileManager* profile_manager() { return &profile_manager_; }
+
   // ChromeCleanerControllerDelegate overrides.
 
   void FetchAndVerifyChromeCleaner(FetchedCallback fetched_callback) override {
     base::ThreadTaskRunnerHandle::Get()->PostTask(
         FROM_HERE,
         base::BindOnce(
             std::move(fetched_callback),
             process_status_ != CleanerProcessStatus::kFetchFailure
                 ? base::FilePath(FILE_PATH_LITERAL("chrome_cleaner.exe"))
                 : base::FilePath()));
   }
 
   bool SafeBrowsingExtendedReportingScoutEnabled() override {
     // Returning an arbitrary value since this is not being tested in this
     // fixture.
     return false;
   }
 
   bool IsMetricsAndCrashReportingEnabled() override {
     // Returning an arbitrary value since this is not being tested in this
     // fixture.
     return false;
   }
 
+  void InvokeTagProfileForResetting(Profile* profile) override {
+    ++tagged_profiles_;
+  }
+
+  void InvokeResetPostCleanupSettingsIfTagged(
+      std::vector<Profile*> profiles,
+      base::OnceClosure continuation) override {
+    profiles_reset_ += profiles.size();
+  }
+
   // ChromeCleanerRunnerTestDelegate overrides.
 
   base::Process LaunchTestProcess(
       const base::CommandLine& command_line,
       const base::LaunchOptions& launch_options) override {
     if (process_status_ != CleanerProcessStatus::kFetchSuccessValidProcess)
       return base::Process();
 
     // Add switches and program name that the test process needs for the multi
     // process tests.
@@ skipping 37 matching lines @@
            crash_point_ != CrashPoint::kAfterRequestSent &&
            user_response_ == UserResponse::kAccepted;
   }
 
   bool ExpectedOnRebootRequiredCalled() {
     return ExpectedFinalState() == State::kRebootRequired;
   }
 
   bool ExpectedUwsFound() { return ExpectedOnInfectedCalled(); }
 
+  bool ExpectedToTagProfiles() {
+    return process_status_ == CleanerProcessStatus::kFetchSuccessValidProcess &&
+           (crash_point_ == CrashPoint::kNone ||
+            crash_point_ == CrashPoint::kAfterResponseReceived) &&
+           (uws_found_status_ == UwsFoundStatus::kUwsFoundNoRebootRequired ||
+            uws_found_status_ == UwsFoundStatus::kUwsFoundRebootRequired) &&
+           user_response_ == UserResponse::kAccepted;
+  }
+
+  bool ExpectedToResetSettings() {
+    return process_status_ == CleanerProcessStatus::kFetchSuccessValidProcess &&
+           crash_point_ == CrashPoint::kNone &&
+           uws_found_status_ == UwsFoundStatus::kUwsFoundNoRebootRequired &&
+           user_response_ == UserResponse::kAccepted;
+  }
+
   ChromeCleanerController::IdleReason ExpectedIdleReason() {
     EXPECT_EQ(ExpectedFinalState(), State::kIdle);
 
     if (process_status_ != CleanerProcessStatus::kFetchSuccessValidProcess ||
         crash_point_ == CrashPoint::kOnStartup ||
         crash_point_ == CrashPoint::kAfterConnection) {
       return IdleReason::kScanningFailed;
     }
 
     if (uws_found_status_ == UwsFoundStatus::kNoUwsFound)
@@ skipping 23 matching lines @@
 
   CleanerProcessStatus process_status_;
   MockChromeCleanerProcess::CrashPoint crash_point_;
   UwsFoundStatus uws_found_status_;
   ChromeCleanerController::UserResponse user_response_;
 
   MockChromeCleanerProcess::Options cleaner_process_options_;
 
   StrictMock<MockChromeCleanerControllerObserver> mock_observer_;
   ChromeCleanerController* controller_;
+
+  TestingProfileManager profile_manager_;
+  int tagged_profiles_ = 0;
+  int profiles_reset_ = 0;
 };
 
 MULTIPROCESS_TEST_MAIN(MockChromeCleanerProcessMain) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   MockChromeCleanerProcess::Options options;
   EXPECT_TRUE(MockChromeCleanerProcess::Options::FromCommandLine(*command_line,
                                                                  &options));
 
   std::string chrome_mojo_pipe_token = command_line->GetSwitchValueASCII(
       chrome_cleaner::kChromeMojoPipeTokenSwitch);
   EXPECT_FALSE(chrome_mojo_pipe_token.empty());
 
   // Since failures in any of the above calls to EXPECT_*() do not actually fail
   // the test, we need to ensure that we return an exit code to indicate test
   // failure in such cases.
   if (::testing::Test::HasFailure())
     return MockChromeCleanerProcess::kInternalTestFailureExitCode;
 
   MockChromeCleanerProcess mock_cleaner_process(options,
                                                 chrome_mojo_pipe_token);
   return mock_cleaner_process.Run();
 }
 
 TEST_P(ChromeCleanerControllerTest, WithMockCleanerProcess) {
+  ASSERT_TRUE(profile_manager()->CreateTestingProfile("Test 1"));
+  ASSERT_TRUE(profile_manager()->CreateTestingProfile("Test 2"));
+  ASSERT_TRUE(profile_manager()->CreateTestingProfile("Test 3"));
+  const int num_profiles =
+      profile_manager()->profile_manager()->GetNumberOfProfiles();
+  ASSERT_EQ(3, num_profiles);
+
   EXPECT_CALL(mock_observer_, OnIdle(_)).Times(1);
   controller_->AddObserver(&mock_observer_);
   EXPECT_EQ(controller_->state(), State::kIdle);
 
   EXPECT_CALL(mock_observer_, OnScanning()).Times(1);
   controller_->Scan(GetInvocationWithPromptTrigger());
   EXPECT_EQ(controller_->state(), State::kScanning);
 
   base::RunLoop run_loop;
 
@@ skipping 33 matching lines @@
 
   EXPECT_EQ(controller_->state(), ExpectedFinalState());
   EXPECT_EQ(!files_to_delete_on_infected.empty(), ExpectedUwsFound());
   EXPECT_EQ(!files_to_delete_on_cleaning.empty(),
             ExpectedUwsFound() && ExpectedOnCleaningCalled());
   if (!files_to_delete_on_infected.empty() &&
       !files_to_delete_on_cleaning.empty()) {
     EXPECT_EQ(files_to_delete_on_infected, files_to_delete_on_cleaning);
   }
 
+  EXPECT_EQ(ExpectedToTagProfiles() ? num_profiles : 0, tagged_profiles_);
+  EXPECT_EQ(ExpectedToResetSettings() ? num_profiles : 0, profiles_reset_);
+
   controller_->RemoveObserver(&mock_observer_);
 }
 
 INSTANTIATE_TEST_CASE_P(
     All,
     ChromeCleanerControllerTest,
     Combine(Values(CleanerProcessStatus::kFetchFailure,
                    CleanerProcessStatus::kFetchSuccessInvalidProcess,
                    CleanerProcessStatus::kFetchSuccessValidProcess),
             Values(CrashPoint::kNone,
                    CrashPoint::kOnStartup,
                    CrashPoint::kAfterConnection,
                    // CrashPoint::kAfterRequestSent is not used because we
                    // cannot ensure the order between the Mojo request being
                    // received by Chrome and the connection being lost.
                    CrashPoint::kAfterResponseReceived),
             Values(UwsFoundStatus::kNoUwsFound,
                    UwsFoundStatus::kUwsFoundRebootRequired,
                    UwsFoundStatus::kUwsFoundNoRebootRequired),
             Values(UserResponse::kAccepted,
                    UserResponse::kDenied,
                    UserResponse::kDismissed)));
 
 }  // namespace
 }  // namespace safe_browsing