Post-cleanup settings reset.

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_controller_win.h

 // 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.
 
 #ifndef CHROME_BROWSER_SAFE_BROWSING_CHROME_CLEANER_CHROME_CLEANER_CONTROLLER_WIN_H_
 #define CHROME_BROWSER_SAFE_BROWSING_CHROME_CLEANER_CHROME_CLEANER_CONTROLLER_WIN_H_
 
 #include <memory>
 #include <set>
+#include <vector>
 
+#include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/memory/weak_ptr.h"
 #include "base/observer_list.h"
 #include "base/threading/thread_checker.h"
 #include "chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_runner_win.h"
 #include "chrome/browser/safe_browsing/chrome_cleaner/reporter_runner_win.h"
 #include "components/chrome_cleaner/public/interfaces/chrome_prompt.mojom.h"
 
+class Profile;
+
 namespace safe_browsing {
 
 // Delegate class that provides services to the ChromeCleanerController class
 // and can be overridden by tests via
 // SetChromeCleanerControllerDelegateForTesting().
 class ChromeCleanerControllerDelegate {
  public:
   using FetchedCallback = base::OnceCallback<void(base::FilePath)>;
 
   ChromeCleanerControllerDelegate();
   virtual ~ChromeCleanerControllerDelegate();
 
   // Fetches and verifies the Chrome Cleaner binary and passes the name of the
   // executable to |fetched_callback|. The file name will have the ".exe"
   // extension. If the operation fails, the file name passed to
   // |fecthed_callback| will be empty.
   virtual void FetchAndVerifyChromeCleaner(FetchedCallback fetched_callback);
   virtual bool SafeBrowsingExtendedReportingScoutEnabled();
   virtual bool IsMetricsAndCrashReportingEnabled();
+
+  // Auxiliary methods for tagging and resetting open profiles.
+  virtual void TagForResetting(Profile* profile);
+  virtual void ResetTaggedProfiles(std::vector<Profile*> profiles,
+                                   base::OnceClosure continuation);
 };
 
 // Controller class that keeps track of the execution of the Chrome Cleaner and
 // the various states through which the execution will transition. Observers can
 // register themselves to be notified of state changes. Intended to be used by
 // the Chrome Cleaner webui page and the Chrome Cleaner prompt dialog.
 //
 // This class lives on, and all its members should be called only on, the UI
 // thread.
 class ChromeCleanerController {
@@ skipping 82 matching lines @@
   // which found possible harmful software on the system.
   //
   // A call to Scan() will be a no-op if the controller is not in the kIdle
   // state. This gracefully handles cases where multiple user responses are
   // received, for example if a user manages to click on a "Scan" button
   // multiple times.
   void Scan(const SwReporterInvocation& reporter_invocation);
 
   // Sends the user's response, as to whether or not they want the Chrome
   // Cleaner to remove harmful software that was found, to the Chrome Cleaner
-  // process.
+  // process. If the user accepted the prompt, then tags |profile| for
+  // post-cleanup settings reset.
   //
   // A call to ReplyWithUserResponse() will be a no-op if the controller is not
   // in the kInfected state. This gracefully handles cases where multiple user
   // responses are received, for example if a user manages to click on a
   // "Cleanup" button multiple times.
-  void ReplyWithUserResponse(UserResponse user_response);
+  void ReplyWithUserResponse(Profile* profile, UserResponse user_response);
 
   // If the controller is in the kRebootRequired state, initiates a reboot of
   // the computer. Call this after obtaining permission from the user to
   // reboot.
   //
   // If initiating the reboot fails, observers will be notified via a call to
   // OnRebootFailed().
   //
   // Note that there are no guarantees that the reboot will in fact happen even
   // if the system calls to initiate a reboot return success.
@@ skipping 33 matching lines @@
       chrome_cleaner::mojom::ChromePrompt::PromptUserCallback
           prompt_user_callback);
 
   void OnPromptUser(std::unique_ptr<std::set<base::FilePath>> files_to_delete,
                     chrome_cleaner::mojom::ChromePrompt::PromptUserCallback
                         prompt_user_callback);
   void OnConnectionClosed();
   void OnCleanerProcessDone(ChromeCleanerRunner::ProcessStatus process_status);
   void InitiateReboot();
 
+  // Invoked once settings reset is done for tagged profiles.
+  void OnSettingsResetCompleted();
+
   std::unique_ptr<ChromeCleanerControllerDelegate> real_delegate_;
   // Pointer to either real_delegate_ or one set by tests.
   ChromeCleanerControllerDelegate* delegate_;
 
   State state_ = State::kIdle;
   IdleReason idle_reason_ = IdleReason::kInitial;
   std::unique_ptr<SwReporterInvocation> reporter_invocation_;
   std::unique_ptr<std::set<base::FilePath>> files_to_delete_;
   // The Mojo callback that should be called to send a response to the Chrome
   // Cleaner process. This must be posted to run on the IO thread.
   chrome_cleaner::mojom::ChromePrompt::PromptUserCallback prompt_user_callback_;
 
   base::ObserverList<Observer> observer_list_;
 
   THREAD_CHECKER(thread_checker_);
 
   base::WeakPtrFactory<ChromeCleanerController> weak_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(ChromeCleanerController);
 };
 
 }  // namespace safe_browsing
 
 #endif  // CHROME_BROWSER_SAFE_BROWSING_CHROME_CLEANER_CHROME_CLEANER_CONTROLLER_WIN_H_