Post-cleanup settings reset.

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_controller_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/chrome_cleaner_controller_win.h"
 
 #include <windows.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/files/file_util.h"
 #include "base/location.h"
 #include "base/logging.h"
 #include "base/memory/ptr_util.h"
 #include "base/task_scheduler/post_task.h"
 #include "base/task_scheduler/task_traits.h"
 #include "base/threading/thread_restrictions.h"
 #include "base/threading/thread_task_runner_handle.h"
+#include "chrome/browser/browser_process.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/chrome_cleaner_fetcher_win.h"
 #include "chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_runner_win.h"
+#include "chrome/browser/safe_browsing/chrome_cleaner/settings_resetter_win.h"
 #include "chrome/browser/safe_browsing/chrome_cleaner/srt_client_info_win.h"
 #include "chrome/installer/util/scoped_token_privilege.h"
 #include "components/chrome_cleaner/public/constants/constants.h"
 #include "components/safe_browsing/common/safe_browsing_prefs.h"
 #include "content/public/browser/browser_thread.h"
 #include "net/http/http_status_code.h"
 
 namespace safe_browsing {
 
 namespace {
@@ skipping 74 matching lines @@
 
 bool ChromeCleanerControllerDelegate::
     SafeBrowsingExtendedReportingScoutEnabled() {
   return safe_browsing::SafeBrowsingExtendedReportingScoutEnabled();
 }
 
 bool ChromeCleanerControllerDelegate::IsMetricsAndCrashReportingEnabled() {
   return ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled();
 }
 
+void ChromeCleanerControllerDelegate::TagForResetting(Profile* profile) {
+  if (PostCleanupSettingsResetter::IsEnabled())
+    PostCleanupSettingsResetter().TagForResetting(profile);
+}
+
+void ChromeCleanerControllerDelegate::ResetTaggedProfiles(
+    std::vector<Profile*> profiles,
+    base::OnceClosure continuation) {
+  if (PostCleanupSettingsResetter::IsEnabled()) {
+    PostCleanupSettingsResetter().ResetTaggedProfiles(
+        std::move(profiles), std::move(continuation),
+        base::MakeUnique<PostCleanupSettingsResetter::Delegate>());
+  }
+}
+
 // static
 ChromeCleanerController* ChromeCleanerController::GetInstance() {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
   static ChromeCleanerController* const kInstance =
       new ChromeCleanerController();
   g_instance_exists = true;
   return kInstance;
 }
 
@@ skipping 42 matching lines @@
       base::MakeUnique<SwReporterInvocation>(reporter_invocation);
   SetStateAndNotifyObservers(State::kScanning);
   // base::Unretained is safe because the ChromeCleanerController instance is
   // guaranteed to outlive the UI thread.
   delegate_->FetchAndVerifyChromeCleaner(base::BindOnce(
       &ChromeCleanerController::OnChromeCleanerFetchedAndVerified,
       base::Unretained(this)));
 }
 
 void ChromeCleanerController::ReplyWithUserResponse(
+    Profile* profile,
     UserResponse user_response) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
   DCHECK(prompt_user_callback_);
 
   if (state() != State::kInfected)
     return;
 
   PromptAcceptance acceptance = PromptAcceptance::DENIED;
   State new_state = State::kIdle;
   switch (user_response) {
     case UserResponse::kAccepted:
       acceptance = PromptAcceptance::ACCEPTED;
       new_state = State::kCleaning;
+      delegate_->TagForResetting(profile);
       break;
     case UserResponse::kDenied:  // Fallthrough
     case UserResponse::kDismissed:
       acceptance = PromptAcceptance::DENIED;
       idle_reason_ = IdleReason::kUserDeclinedCleanup;
       new_state = State::kIdle;
       break;
   }
 
   BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)
@@ skipping 186 matching lines @@
     SetStateAndNotifyObservers(State::kIdle);
     return;
   }
 
   if (process_status.exit_code == kRebootRequiredExitCode) {
     SetStateAndNotifyObservers(State::kRebootRequired);
     return;
   }
 
   if (process_status.exit_code == kRebootNotRequiredExitCode) {
-    idle_reason_ = IdleReason::kCleaningSucceeded;
-    SetStateAndNotifyObservers(State::kIdle);
+    delegate_->ResetTaggedProfiles(
+        g_browser_process->profile_manager()->GetLoadedProfiles(),
+        base::BindOnce(&ChromeCleanerController::OnSettingsResetCompleted,
+                       base::Unretained(this)));
+    ResetCleanerDataAndInvalidateWeakPtrs();
     return;
   }
 
   idle_reason_ = IdleReason::kCleaningFailed;
   SetStateAndNotifyObservers(State::kIdle);
 }
 
 void ChromeCleanerController::InitiateReboot() {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
 
   installer::ScopedTokenPrivilege scoped_se_shutdown_privilege(
       SE_SHUTDOWN_NAME);
   if (!scoped_se_shutdown_privilege.is_enabled() ||
       !::ExitWindowsEx(EWX_REBOOT, SHTDN_REASON_MAJOR_SOFTWARE |
                                        SHTDN_REASON_MINOR_OTHER |
                                        SHTDN_REASON_FLAG_PLANNED)) {
     for (auto& observer : observer_list_)
       observer.OnRebootFailed();
   }
 }
 
+void ChromeCleanerController::OnSettingsResetCompleted() {
+  idle_reason_ = IdleReason::kCleaningSucceeded;
+  SetStateAndNotifyObservers(State::kIdle);
+}
+
 }  // namespace safe_browsing