Chrome Cleaner UI: Add registry keys to Chrome prompt mojo interface

Registry keys removed or changed by the cleaner will be shown to the
user on the Settings page card and need to be provided by the cleaner
via the Mojo IPC. Those keys are only used for visualization (no
validation will be done by Chrome) and we don't intend to add any
sophisticated visualization support (such as expandable trees); because
of that, we decided to go with the simplest approach and only transmit
lists of strings instead of more structured data.

This CL only propagates registry keys to the places they may be used,
so most files in this CL are simply adding a new parameter to
functions. A follow-up CL will actually use the new parameter in UI
code.

Bug: 776538
Change-Id: Ifd9faf79eea070d17452356c45ae37482bf77864
Reviewed-on: https://chromium-review.googlesource.com/780287
Commit-Queue: Fabio Tirelo <ftirelo@chromium.org>
Reviewed-by: danakj <danakj@chromium.org>
Reviewed-by: Jialiu Lin <jialiul@chromium.org>
Reviewed-by: Peter Kasting <pkasting@chromium.org>
Reviewed-by: Jochen Eisinger <jochen@chromium.org>
Reviewed-by: Joe Mason <joenotcharles@chromium.org>
Reviewed-by: Will Harris <wfh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#519487}

chrome/browser/safe_browsing/BUILD.gn

@@ -25,6 +25,8 @@ static_library("safe_browsing") {
     "chrome_cleaner/chrome_cleaner_reboot_dialog_controller_win.h",
     "chrome_cleaner/chrome_cleaner_runner_win.cc",
     "chrome_cleaner/chrome_cleaner_runner_win.h",
+    "chrome_cleaner/chrome_cleaner_scanner_results.cc",
+    "chrome_cleaner/chrome_cleaner_scanner_results.h",
     "chrome_cleaner/chrome_cleaner_state_change_observer_win.cc",
     "chrome_cleaner/chrome_cleaner_state_change_observer_win.h",
     "chrome_cleaner/reporter_runner_win.cc",

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_controller_impl_win.cc

@@ -391,10 +391,10 @@ void ChromeCleanerControllerImpl::NotifyObserver(Observer* observer) const {
       observer->OnScanning();
       break;
     case State::kInfected:
-      observer->OnInfected(*files_to_delete_);
+      observer->OnInfected(scanner_results_);
       break;
     case State::kCleaning:
-      observer->OnCleaning(*files_to_delete_);
+      observer->OnCleaning(scanner_results_);
       break;
     case State::kRebootRequired:
       observer->OnRebootRequired();
@@ -420,7 +420,6 @@ void ChromeCleanerControllerImpl::ResetCleanerDataAndInvalidateWeakPtrs() {
 
   weak_factory_.InvalidateWeakPtrs();
   reporter_invocation_.reset();
-  files_to_delete_.reset();
   prompt_user_callback_.Reset();
 }
 
@@ -462,7 +461,7 @@ void ChromeCleanerControllerImpl::OnChromeCleanerFetchedAndVerified(
 // static
 void ChromeCleanerControllerImpl::WeakOnPromptUser(
     const base::WeakPtr<ChromeCleanerControllerImpl>& controller,
-    std::unique_ptr<std::set<base::FilePath>> files_to_delete,
+    ChromeCleanerScannerResults&& scanner_results,
     ChromePrompt::PromptUserCallback prompt_user_callback) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
 
@@ -474,24 +473,24 @@ void ChromeCleanerControllerImpl::WeakOnPromptUser(
                                              PromptAcceptance::DENIED));
   }
 
-  controller->OnPromptUser(std::move(files_to_delete),
+  controller->OnPromptUser(std::move(scanner_results),
                            std::move(prompt_user_callback));
 }
 
 void ChromeCleanerControllerImpl::OnPromptUser(
-    std::unique_ptr<std::set<base::FilePath>> files_to_delete,
+    ChromeCleanerScannerResults&& scanner_results,
     ChromePrompt::PromptUserCallback prompt_user_callback) {
   DCHECK_CALLED_ON_VALID_THREAD(thread_checker_);
-  DCHECK(files_to_delete);
   DCHECK_EQ(State::kScanning, state());
-  DCHECK(!files_to_delete_);
+  DCHECK(scanner_results_.files_to_delete().empty());
+  DCHECK(scanner_results_.registry_keys().empty());
   DCHECK(!prompt_user_callback_);
   DCHECK(!time_scanning_started_.is_null());
 
   UMA_HISTOGRAM_LONG_TIMES_100("SoftwareReporter.Cleaner.ScanningTime",
                                base::Time::Now() - time_scanning_started_);
 
-  if (files_to_delete->empty()) {
+  if (scanner_results.files_to_delete().empty()) {
     BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)
         ->PostTask(FROM_HERE, base::BindOnce(std::move(prompt_user_callback),
                                              PromptAcceptance::DENIED));
@@ -502,8 +501,8 @@ void ChromeCleanerControllerImpl::OnPromptUser(
   }
 
   UMA_HISTOGRAM_COUNTS_1000("SoftwareReporter.NumberOfFilesToDelete",
-                            files_to_delete->size());
-  files_to_delete_ = std::move(files_to_delete);
+                            scanner_results.files_to_delete().size());
+  scanner_results_ = std::move(scanner_results);
   prompt_user_callback_ = std::move(prompt_user_callback);
   SetStateAndNotifyObservers(State::kInfected);
 }

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_controller_impl_win.h

@@ -15,6 +15,7 @@
 #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/chrome_cleaner_scanner_results.h"
 
 namespace safe_browsing {
 
@@ -94,11 +95,11 @@ class ChromeCleanerControllerImpl : public ChromeCleanerController {
   // objects become no-ops if the bound weak pointer is not valid).
   static void WeakOnPromptUser(
       const base::WeakPtr<ChromeCleanerControllerImpl>& controller,
-      std::unique_ptr<std::set<base::FilePath>> files_to_delete,
+      ChromeCleanerScannerResults&& reported_results,
       chrome_cleaner::mojom::ChromePrompt::PromptUserCallback
           prompt_user_callback);
 
-  void OnPromptUser(std::unique_ptr<std::set<base::FilePath>> files_to_delete,
+  void OnPromptUser(ChromeCleanerScannerResults&& reported_results,
                     chrome_cleaner::mojom::ChromePrompt::PromptUserCallback
                         prompt_user_callback);
   void OnConnectionClosed();
@@ -117,7 +118,7 @@ class ChromeCleanerControllerImpl : public ChromeCleanerController {
   bool powered_by_partner_ = false;
   IdleReason idle_reason_ = IdleReason::kInitial;
   std::unique_ptr<SwReporterInvocation> reporter_invocation_;
-  std::unique_ptr<std::set<base::FilePath>> files_to_delete_;
+  ChromeCleanerScannerResults scanner_results_;
   // 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_;

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_controller_impl_win_unittest.cc

@@ -46,6 +46,7 @@ using ::testing::Values;
 using ::testing::_;
 using CrashPoint = MockChromeCleanerProcess::CrashPoint;
 using IdleReason = ChromeCleanerController::IdleReason;
+using RegistryKeysReporting = MockChromeCleanerProcess::RegistryKeysReporting;
 using State = ChromeCleanerController::State;
 using UserResponse = ChromeCleanerController::UserResponse;
 
@@ -72,8 +73,8 @@ class MockChromeCleanerControllerObserver
  public:
   MOCK_METHOD1(OnIdle, void(ChromeCleanerController::IdleReason));
   MOCK_METHOD0(OnScanning, void());
-  MOCK_METHOD1(OnInfected, void(const std::set<base::FilePath>&));
-  MOCK_METHOD1(OnCleaning, void(const std::set<base::FilePath>&));
+  MOCK_METHOD1(OnInfected, void(const ChromeCleanerScannerResults&));
+  MOCK_METHOD1(OnCleaning, void(const ChromeCleanerScannerResults&));
   MOCK_METHOD0(OnRebootRequired, void());
   MOCK_METHOD0(OnRebootFailed, void());
   MOCK_METHOD1(OnLogsEnabledChanged, void(bool));
@@ -221,9 +222,12 @@ enum class UwsFoundStatus {
   kUwsFoundNoRebootRequired,
 };
 
-typedef std::
-    tuple<CleanerProcessStatus, CrashPoint, UwsFoundStatus, UserResponse>
-        ChromeCleanerControllerTestParams;
+typedef std::tuple<CleanerProcessStatus,
+                   CrashPoint,
+                   UwsFoundStatus,
+                   RegistryKeysReporting,
+                   UserResponse>
+    ChromeCleanerControllerTestParams;
 
 // Test fixture that runs a mock Chrome Cleaner process in various
 // configurations and mocks the user's response.
@@ -236,11 +240,12 @@ class ChromeCleanerControllerTest
   ~ChromeCleanerControllerTest() override {}
 
   void SetUp() override {
-    std::tie(process_status_, crash_point_, uws_found_status_, user_response_) =
-        GetParam();
+    std::tie(process_status_, crash_point_, uws_found_status_,
+             registry_keys_reporting_, user_response_) = GetParam();
 
-    cleaner_process_options_.SetDoFindUws(uws_found_status_ !=
-                                          UwsFoundStatus::kNoUwsFound);
+    cleaner_process_options_.SetReportedResults(
+        uws_found_status_ != UwsFoundStatus::kNoUwsFound,
+        registry_keys_reporting_);
     cleaner_process_options_.set_reboot_required(
         uws_found_status_ == UwsFoundStatus::kUwsFoundRebootRequired);
     cleaner_process_options_.set_crash_point(crash_point_);
@@ -357,6 +362,11 @@ class ChromeCleanerControllerTest
 
   bool ExpectedUwsFound() { return ExpectedOnInfectedCalled(); }
 
+  bool ExpectedRegistryKeysReported() {
+    return ExpectedOnInfectedCalled() &&
+           registry_keys_reporting_ == RegistryKeysReporting::kReported;
+  }
+
   bool ExpectedPromptAccepted() {
     return user_response_ == UserResponse::kAcceptedWithLogs ||
            user_response_ == UserResponse::kAcceptedWithoutLogs;
@@ -420,6 +430,7 @@ class ChromeCleanerControllerTest
   CleanerProcessStatus process_status_;
   MockChromeCleanerProcess::CrashPoint crash_point_;
   UwsFoundStatus uws_found_status_;
+  RegistryKeysReporting registry_keys_reporting_;
   ChromeCleanerController::UserResponse user_response_;
 
   MockChromeCleanerProcess::Options cleaner_process_options_;
@@ -481,8 +492,8 @@ TEST_P(ChromeCleanerControllerTest, WithMockCleanerProcess) {
 
   base::RunLoop run_loop;
 
-  std::set<base::FilePath> files_to_delete_on_infected;
-  std::set<base::FilePath> files_to_delete_on_cleaning;
+  ChromeCleanerScannerResults scanner_results_on_infected;
+  ChromeCleanerScannerResults scanner_results_on_cleaning;
 
   if (ExpectedOnIdleCalled()) {
     EXPECT_CALL(mock_observer_, OnIdle(ExpectedIdleReason()))
@@ -494,7 +505,7 @@ TEST_P(ChromeCleanerControllerTest, WithMockCleanerProcess) {
 
   if (ExpectedOnInfectedCalled()) {
     EXPECT_CALL(mock_observer_, OnInfected(_))
-        .WillOnce(DoAll(SaveArg<0>(&files_to_delete_on_infected),
+        .WillOnce(DoAll(SaveArg<0>(&scanner_results_on_infected),
                         InvokeWithoutArgs([this, profile1]() {
                           controller_->ReplyWithUserResponse(profile1,
                                                              user_response_);
@@ -509,7 +520,7 @@ TEST_P(ChromeCleanerControllerTest, WithMockCleanerProcess) {
 
   if (ExpectedOnCleaningCalled()) {
     EXPECT_CALL(mock_observer_, OnCleaning(_))
-        .WillOnce(SaveArg<0>(&files_to_delete_on_cleaning));
+        .WillOnce(SaveArg<0>(&scanner_results_on_cleaning));
   } else {
     EXPECT_CALL(mock_observer_, OnCleaning(_)).Times(0);
   }
@@ -534,12 +545,25 @@ TEST_P(ChromeCleanerControllerTest, WithMockCleanerProcess) {
   EXPECT_NE(cleaner_process_status_.exit_code,
             MockChromeCleanerProcess::kInternalTestFailureExitCode);
   EXPECT_EQ(controller_->state(), ExpectedFinalState());
-  EXPECT_EQ(!files_to_delete_on_infected.empty(), ExpectedUwsFound());
-  EXPECT_EQ(!files_to_delete_on_cleaning.empty(),
+
+  EXPECT_EQ(!scanner_results_on_infected.files_to_delete().empty(),
+            ExpectedUwsFound());
+  EXPECT_EQ(!scanner_results_on_cleaning.files_to_delete().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);
+  if (!scanner_results_on_cleaning.files_to_delete().empty()) {
+    EXPECT_THAT(scanner_results_on_cleaning.files_to_delete(),
+                UnorderedElementsAreArray(
+                    scanner_results_on_infected.files_to_delete()));
+  }
+
+  EXPECT_EQ(!scanner_results_on_infected.registry_keys().empty(),
+            ExpectedRegistryKeysReported());
+  EXPECT_EQ(!scanner_results_on_cleaning.registry_keys().empty(),
+            ExpectedRegistryKeysReported() && ExpectedOnCleaningCalled());
+  if (!scanner_results_on_cleaning.registry_keys().empty()) {
+    EXPECT_THAT(
+        scanner_results_on_cleaning.registry_keys(),
+        UnorderedElementsAreArray(scanner_results_on_infected.registry_keys()));
   }
 
   EXPECT_EQ(ExpectedRebootFlowStarted(), reboot_flow_started_);
@@ -608,6 +632,21 @@ std::ostream& operator<<(std::ostream& out, UwsFoundStatus status) {
   }
 }
 
+std::ostream& operator<<(std::ostream& out,
+                         RegistryKeysReporting registry_keys_reporting) {
+  switch (registry_keys_reporting) {
+    case RegistryKeysReporting::kUnsupported:
+      return out << "kUnsupported";
+    case RegistryKeysReporting::kNotReported:
+      return out << "kNotReported";
+    case RegistryKeysReporting::kReported:
+      return out << "kReported";
+    default:
+      NOTREACHED();
+      return out << "UnknownRegistryKeysReporting";
+  }
+}
+
 std::ostream& operator<<(std::ostream& out, UserResponse response) {
   switch (response) {
     case UserResponse::kAcceptedWithLogs:
@@ -635,7 +674,8 @@ struct ChromeCleanerControllerTestParamsToString {
     param_name << std::get<0>(info.param) << "_";
     param_name << std::get<1>(info.param) << "_";
     param_name << std::get<2>(info.param) << "_";
-    param_name << std::get<3>(info.param);
+    param_name << std::get<3>(info.param) << "_";
+    param_name << std::get<4>(info.param);
     return param_name.str();
   }
 };
@@ -656,6 +696,9 @@ INSTANTIATE_TEST_CASE_P(
             Values(UwsFoundStatus::kNoUwsFound,
                    UwsFoundStatus::kUwsFoundRebootRequired,
                    UwsFoundStatus::kUwsFoundNoRebootRequired),
+            Values(RegistryKeysReporting::kUnsupported,
+                   RegistryKeysReporting::kNotReported,
+                   RegistryKeysReporting::kReported),
             Values(UserResponse::kAcceptedWithLogs,
                    UserResponse::kAcceptedWithoutLogs,
                    UserResponse::kDenied,

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_controller_win.h

@@ -11,6 +11,7 @@
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
+#include "chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_scanner_results.h"
 #include "chrome/browser/safe_browsing/chrome_cleaner/reporter_runner_win.h"
 #include "components/chrome_cleaner/public/interfaces/chrome_prompt.mojom.h"
 
@@ -91,8 +92,10 @@ class ChromeCleanerController {
    public:
     virtual void OnIdle(IdleReason idle_reason) {}
     virtual void OnScanning() {}
-    virtual void OnInfected(const std::set<base::FilePath>& files_to_delete) {}
-    virtual void OnCleaning(const std::set<base::FilePath>& files_to_delete) {}
+    virtual void OnInfected(
+        const ChromeCleanerScannerResults& scanner_results) {}
+    virtual void OnCleaning(
+        const ChromeCleanerScannerResults& scanner_results) {}
     virtual void OnRebootRequired() {}
     virtual void OnRebootFailed() {}
     virtual void OnLogsEnabledChanged(bool logs_enabled) {}

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_dialog_controller_impl_browsertest_win.cc

@@ -98,14 +98,14 @@ class ChromeCleanerPromptUserTest
 IN_PROC_BROWSER_TEST_P(ChromeCleanerPromptUserTest,
                        OnInfectedBrowserAvailable) {
   EXPECT_CALL(mock_delegate_, ShowChromeCleanerPrompt(_, _, _)).Times(1);
-  dialog_controller_->OnInfected(std::set<base::FilePath>());
+  dialog_controller_->OnInfected(ChromeCleanerScannerResults());
 }
 
 IN_PROC_BROWSER_TEST_P(ChromeCleanerPromptUserTest,
                        DISABLED_OnInfectedBrowserNotAvailable) {
   browser()->window()->Minimize();
   base::RunLoop().RunUntilIdle();
-  dialog_controller_->OnInfected(std::set<base::FilePath>());
+  dialog_controller_->OnInfected(ChromeCleanerScannerResults());
 
   base::RunLoop run_loop;
   // We only set the expectation here because we want to make sure that the
@@ -124,7 +124,7 @@ IN_PROC_BROWSER_TEST_P(ChromeCleanerPromptUserTest, AllBrowsersClosed) {
 
   CloseAllBrowsers();
   base::RunLoop().RunUntilIdle();
-  dialog_controller_->OnInfected(std::set<base::FilePath>());
+  dialog_controller_->OnInfected(ChromeCleanerScannerResults());
 
   base::RunLoop run_loop;
   // We only set the expectation here because we want to make sure that the

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_dialog_controller_impl_win.cc

@@ -184,7 +184,7 @@ void ChromeCleanerDialogControllerImpl::OnScanning() {
 }
 
 void ChromeCleanerDialogControllerImpl::OnInfected(
-    const std::set<base::FilePath>& files_to_delete) {
+    const ChromeCleanerScannerResults& reported_results) {
   DCHECK(!dialog_shown_);
 
   browser_ = chrome_cleaner_util::FindBrowser();
@@ -201,7 +201,7 @@ void ChromeCleanerDialogControllerImpl::OnInfected(
 }
 
 void ChromeCleanerDialogControllerImpl::OnCleaning(
-    const std::set<base::FilePath>& files_to_delete) {
+    const ChromeCleanerScannerResults& reported_results) {
   if (!dialog_shown_)
     OnInteractionDone();
 }

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_dialog_controller_impl_win.h

@@ -51,8 +51,8 @@ class ChromeCleanerDialogControllerImpl
   // ChromeCleanerController::Observer overrides.
   void OnIdle(ChromeCleanerController::IdleReason idle_reason) override;
   void OnScanning() override;
-  void OnInfected(const std::set<base::FilePath>& files_to_delete) override;
-  void OnCleaning(const std::set<base::FilePath>& files_to_delete) override;
+  void OnInfected(const ChromeCleanerScannerResults& reported_results) override;
+  void OnCleaning(const ChromeCleanerScannerResults& reported_results) override;
   void OnRebootRequired() override;
 
   // chrome::BrowserListObserver overrides.

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_runner_win.cc

@@ -204,12 +204,12 @@ void ChromeCleanerRunner::CreateChromePromptImpl(
 }
 
 void ChromeCleanerRunner::OnPromptUser(
-    std::unique_ptr<std::set<base::FilePath>> files_to_delete,
+    ChromeCleanerScannerResults&& scanner_results,
     ChromePrompt::PromptUserCallback prompt_user_callback) {
   if (on_prompt_user_) {
     task_runner_->PostTask(FROM_HERE,
                            base::BindOnce(std::move(on_prompt_user_),
-                                          base::Passed(&files_to_delete),
+                                          base::Passed(&scanner_results),
                                           base::Passed(&prompt_user_callback)));
   }
 }

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_runner_win.h

@@ -124,7 +124,7 @@ class ChromeCleanerRunner
       chrome_cleaner::mojom::ChromePromptRequest chrome_prompt_request);
 
   // Callbacks received from the Mojo interface.
-  void OnPromptUser(std::unique_ptr<std::set<base::FilePath>> files_to_delete,
+  void OnPromptUser(ChromeCleanerScannerResults&& scanner_results,
                     chrome_cleaner::mojom::ChromePrompt::PromptUserCallback
                         prompt_user_callback);
   void OnConnectionClosed();

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_runner_win_unittest.cc

@@ -35,6 +35,7 @@ using ::chrome_cleaner::mojom::PromptAcceptance;
 using ::content::BrowserThread;
 using ::testing::Bool;
 using ::testing::Combine;
+using ::testing::UnorderedElementsAreArray;
 using ::testing::Values;
 using ChromeMetricsStatus = ChromeCleanerRunner::ChromeMetricsStatus;
 
@@ -113,7 +114,7 @@ class ChromeCleanerRunnerSimpleTest
 
   // IPC callbacks.
 
-  void OnPromptUser(std::unique_ptr<std::set<base::FilePath>> files_to_delete,
+  void OnPromptUser(ChromeCleanerScannerResults&& scanner_results,
                     ChromePrompt::PromptUserCallback response) {}
 
   void OnConnectionClosed() {}
@@ -204,22 +205,24 @@ enum class UwsFoundState {
 class ChromeCleanerRunnerTest
     : public testing::TestWithParam<
           std::tuple<UwsFoundState,
+                     MockChromeCleanerProcess::RegistryKeysReporting,
                      MockChromeCleanerProcess::CrashPoint,
                      PromptAcceptance>>,
       public ChromeCleanerRunnerTestDelegate {
  public:
   void SetUp() override {
     UwsFoundState uws_found_state;
+    MockChromeCleanerProcess::RegistryKeysReporting registry_keys_reporting;
     MockChromeCleanerProcess::CrashPoint crash_point;
     PromptAcceptance prompt_acceptance_to_send;
-    std::tie(uws_found_state, crash_point, prompt_acceptance_to_send) =
-        GetParam();
+    std::tie(uws_found_state, registry_keys_reporting, crash_point,
+             prompt_acceptance_to_send) = GetParam();
 
     ASSERT_FALSE(uws_found_state == UwsFoundState::kNoUwsFound &&
                  prompt_acceptance_to_send != PromptAcceptance::DENIED);
 
-    cleaner_process_options_.SetDoFindUws(uws_found_state !=
-                                          UwsFoundState::kNoUwsFound);
+    cleaner_process_options_.SetReportedResults(
+        uws_found_state != UwsFoundState::kNoUwsFound, registry_keys_reporting);
     cleaner_process_options_.set_reboot_required(
         uws_found_state == UwsFoundState::kUwsFoundRebootRequired);
     cleaner_process_options_.set_crash_point(crash_point);
@@ -272,10 +275,10 @@ class ChromeCleanerRunnerTest
   // IPC callbacks.
 
   // Will receive the main Mojo message from the Mock Chrome Cleaner process.
-  void OnPromptUser(std::unique_ptr<std::set<base::FilePath>> files_to_delete,
+  void OnPromptUser(ChromeCleanerScannerResults&& scanner_results,
                     ChromePrompt::PromptUserCallback response) {
     on_prompt_user_called_ = true;
-    received_files_to_delete_ = std::move(files_to_delete);
+    received_scanner_results_ = std::move(scanner_results);
     BrowserThread::GetTaskRunnerForThread(BrowserThread::IO)
         ->PostTask(FROM_HERE, base::BindOnce(std::move(response),
                                              prompt_acceptance_to_send_));
@@ -309,7 +312,7 @@ class ChromeCleanerRunnerTest
   ChromeCleanerRunner::ProcessStatus process_status_;
 
   // Set by OnPromptUser().
-  std::unique_ptr<std::set<base::FilePath>> received_files_to_delete_;
+  ChromeCleanerScannerResults received_scanner_results_;
 
   bool on_prompt_user_called_ = false;
   bool on_connection_closed_called_ = false;
@@ -351,8 +354,17 @@ TEST_P(ChromeCleanerRunnerTest, WithMockCleanerProcess) {
 
   if (on_prompt_user_called_ &&
       !cleaner_process_options_.files_to_delete().empty()) {
-    EXPECT_EQ(*received_files_to_delete_,
-              cleaner_process_options_.files_to_delete());
+    EXPECT_THAT(
+        received_scanner_results_.files_to_delete(),
+        UnorderedElementsAreArray(cleaner_process_options_.files_to_delete()));
+
+    if (cleaner_process_options_.registry_keys()) {
+      EXPECT_THAT(
+          received_scanner_results_.registry_keys(),
+          UnorderedElementsAreArray(*cleaner_process_options_.registry_keys()));
+    } else {
+      EXPECT_TRUE(received_scanner_results_.registry_keys().empty());
+    }
   }
 
   EXPECT_EQ(process_status_.launch_status,
@@ -367,6 +379,9 @@ INSTANTIATE_TEST_CASE_P(
     ChromeCleanerRunnerTest,
     Combine(
         Values(UwsFoundState::kNoUwsFound),
+        Values(MockChromeCleanerProcess::RegistryKeysReporting::kUnsupported,
+               MockChromeCleanerProcess::RegistryKeysReporting::kNotReported,
+               MockChromeCleanerProcess::RegistryKeysReporting::kReported),
         Values(MockChromeCleanerProcess::CrashPoint::kNone,
                MockChromeCleanerProcess::CrashPoint::kOnStartup,
                MockChromeCleanerProcess::CrashPoint::kAfterConnection,
@@ -380,6 +395,9 @@ INSTANTIATE_TEST_CASE_P(
     Combine(
         Values(UwsFoundState::kUwsFoundRebootRequired,
                UwsFoundState::kUwsFoundNoRebootRequired),
+        Values(MockChromeCleanerProcess::RegistryKeysReporting::kUnsupported,
+               MockChromeCleanerProcess::RegistryKeysReporting::kNotReported,
+               MockChromeCleanerProcess::RegistryKeysReporting::kReported),
         Values(MockChromeCleanerProcess::CrashPoint::kNone,
                MockChromeCleanerProcess::CrashPoint::kOnStartup,
                MockChromeCleanerProcess::CrashPoint::kAfterConnection,

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_scanner_results.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_scanner_results.h"
+
+namespace safe_browsing {
+
+ChromeCleanerScannerResults::ChromeCleanerScannerResults() = default;
+
+ChromeCleanerScannerResults::ChromeCleanerScannerResults(
+    const FileCollection& files_to_delete,
+    const RegistryKeyCollection& registry_keys)
+    : files_to_delete_(files_to_delete), registry_keys_(registry_keys) {}
+
+ChromeCleanerScannerResults::ChromeCleanerScannerResults(
+    const ChromeCleanerScannerResults& other)
+    : files_to_delete_(other.files_to_delete_),
+      registry_keys_(other.registry_keys_) {}
+
+ChromeCleanerScannerResults::~ChromeCleanerScannerResults() = default;
+
+ChromeCleanerScannerResults& ChromeCleanerScannerResults::operator=(
+    const ChromeCleanerScannerResults& other) {
+  files_to_delete_ = other.files_to_delete_;
+  registry_keys_ = other.registry_keys_;
+  return *this;
+}
+
+}  // namespace safe_browsing

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_scanner_results.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_SCANNER_RESULTS_H_
+#define CHROME_BROWSER_SAFE_BROWSING_CHROME_CLEANER_CHROME_CLEANER_SCANNER_RESULTS_H_
+
+#include <set>
+
+#include "base/files/file_path.h"
+#include "base/strings/string16.h"
+
+namespace safe_browsing {
+
+// Represents scanner results sent by the Chrome Cleanup tool via the Chrome
+// Prompt IPC, that needs to be propaged to visualization components.
+class ChromeCleanerScannerResults {
+ public:
+  using FileCollection = std::set<base::FilePath>;
+  using RegistryKeyCollection = std::set<base::string16>;
+
+  ChromeCleanerScannerResults();
+  ChromeCleanerScannerResults(const FileCollection& files_to_delete,
+                              const RegistryKeyCollection& registry_keys);
+  ChromeCleanerScannerResults(const ChromeCleanerScannerResults& other);
+  ~ChromeCleanerScannerResults();
+
+  ChromeCleanerScannerResults& operator=(
+      const ChromeCleanerScannerResults& other);
+
+  const FileCollection& files_to_delete() const { return files_to_delete_; }
+  const RegistryKeyCollection& registry_keys() const { return registry_keys_; }
+
+ private:
+  FileCollection files_to_delete_;
+  RegistryKeyCollection registry_keys_;
+};
+
+}  // namespace safe_browsing
+
+#endif  // CHROME_BROWSER_SAFE_BROWSING_CHROME_CLEANER_CHROME_CLEANER_SCANNER_RESULTS_H_

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_state_change_observer_win.cc

@@ -54,12 +54,12 @@ void ChromeCleanerStateChangeObserver::OnScanning() {
 }
 
 void ChromeCleanerStateChangeObserver::OnInfected(
-    const std::set<base::FilePath>& files) {
+    const ChromeCleanerScannerResults& reported_results) {
   OnCleanupStateChange();
 }
 
 void ChromeCleanerStateChangeObserver::OnCleaning(
-    const std::set<base::FilePath>& files) {
+    const ChromeCleanerScannerResults& reported_results) {
   OnCleanupStateChange();
 }
 

chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_state_change_observer_win.h

@@ -6,6 +6,7 @@
 #define CHROME_BROWSER_SAFE_BROWSING_CHROME_CLEANER_CHROME_CLEANER_STATE_CHANGE_OBSERVER_WIN_H_
 
 #include "chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_controller_win.h"
+#include "chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_scanner_results.h"
 
 namespace safe_browsing {
 
@@ -29,8 +30,8 @@ class ChromeCleanerStateChangeObserver
   // ChromeCleanerController::Observer implementation.
   void OnIdle(ChromeCleanerController::IdleReason idle_reason) override;
   void OnScanning() override;
-  void OnInfected(const std::set<base::FilePath>& files) override;
-  void OnCleaning(const std::set<base::FilePath>& files) override;
+  void OnInfected(const ChromeCleanerScannerResults& scanner_results) override;
+  void OnCleaning(const ChromeCleanerScannerResults& scanner_results) override;
   void OnRebootRequired() override;
   void OnLogsEnabledChanged(bool logs_enabled) override;
 

chrome/browser/safe_browsing/chrome_cleaner/mock_chrome_cleaner_process_win.cc

@@ -37,6 +37,7 @@ using ::chrome_cleaner::mojom::PromptAcceptance;
 constexpr char kCrashPointSwitch[] = "mock-crash-point";
 constexpr char kUwsFoundSwitch[] = "mock-uws-found";
 constexpr char kRebootRequiredSwitch[] = "mock-reboot-required";
+constexpr char kRegistryKeysReportingSwitch[] = "registry-keys-reporting";
 constexpr char kExpectedUserResponseSwitch[] = "mock-expected-user-response";
 
 }  // namespace
@@ -45,7 +46,19 @@ constexpr char kExpectedUserResponseSwitch[] = "mock-expected-user-response";
 bool MockChromeCleanerProcess::Options::FromCommandLine(
     const base::CommandLine& command_line,
     Options* options) {
-  options->SetDoFindUws(command_line.HasSwitch(kUwsFoundSwitch));
+  int registry_keys_reporting_int = -1;
+  if (!base::StringToInt(
+          command_line.GetSwitchValueASCII(kRegistryKeysReportingSwitch),
+          &registry_keys_reporting_int) ||
+      registry_keys_reporting_int < 0 ||
+      registry_keys_reporting_int >=
+          static_cast<int>(RegistryKeysReporting::kNumRegistryKeysReporting)) {
+    return false;
+  }
+
+  options->SetReportedResults(
+      command_line.HasSwitch(kUwsFoundSwitch),
+      static_cast<RegistryKeysReporting>(registry_keys_reporting_int));
   options->set_reboot_required(command_line.HasSwitch(kRebootRequiredSwitch));
 
   if (command_line.HasSwitch(kCrashPointSwitch)) {
@@ -82,15 +95,19 @@ MockChromeCleanerProcess::Options::Options() = default;
 
 MockChromeCleanerProcess::Options::Options(const Options& other)
     : files_to_delete_(other.files_to_delete_),
+      registry_keys_(other.registry_keys_),
       reboot_required_(other.reboot_required_),
       crash_point_(other.crash_point_),
+      registry_keys_reporting_(other.registry_keys_reporting_),
       expected_user_response_(other.expected_user_response_) {}
 
 MockChromeCleanerProcess::Options& MockChromeCleanerProcess::Options::operator=(
     const Options& other) {
   files_to_delete_ = other.files_to_delete_;
+  registry_keys_ = other.registry_keys_;
   reboot_required_ = other.reboot_required_;
   crash_point_ = other.crash_point_;
+  registry_keys_reporting_ = other.registry_keys_reporting_;
   expected_user_response_ = other.expected_user_response_;
   return *this;
 }
@@ -110,6 +127,10 @@ void MockChromeCleanerProcess::Options::AddSwitchesToCommandLine(
         kCrashPointSwitch, base::IntToString(static_cast<int>(crash_point())));
   }
 
+  command_line->AppendSwitchASCII(
+      kRegistryKeysReportingSwitch,
+      base::IntToString(static_cast<int>(registry_keys_reporting())));
+
   if (expected_user_response() != PromptAcceptance::UNSPECIFIED) {
     command_line->AppendSwitchASCII(
         kExpectedUserResponseSwitch,
@@ -117,17 +138,47 @@ void MockChromeCleanerProcess::Options::AddSwitchesToCommandLine(
   }
 }
 
-void MockChromeCleanerProcess::Options::SetDoFindUws(bool do_find_uws) {
-  files_to_delete_.clear();
-  if (!do_find_uws)
-    return;
-
-  files_to_delete_.insert(
-      base::FilePath(FILE_PATH_LITERAL("/path/to/file1.exe")));
-  files_to_delete_.insert(
-      base::FilePath(FILE_PATH_LITERAL("/path/to/other/file2.exe")));
-  files_to_delete_.insert(
-      base::FilePath(FILE_PATH_LITERAL("/path/to/some file.dll")));
+void MockChromeCleanerProcess::Options::SetReportedResults(
+    bool has_files_to_remove,
+    RegistryKeysReporting registry_keys_reporting) {
+  if (!has_files_to_remove)
+    files_to_delete_.clear();
+  if (has_files_to_remove) {
+    files_to_delete_.push_back(
+        base::FilePath(FILE_PATH_LITERAL("/path/to/file1.exe")));
+    files_to_delete_.push_back(
+        base::FilePath(FILE_PATH_LITERAL("/path/to/other/file2.exe")));
+    files_to_delete_.push_back(
+        base::FilePath(FILE_PATH_LITERAL("/path/to/some file.dll")));
+  }
+
+  registry_keys_reporting_ = registry_keys_reporting;
+  switch (registry_keys_reporting) {
+    case RegistryKeysReporting::kUnsupported:
+      // Defined as an optional object in which a registry keys vector is not
+      // present.
+      registry_keys_ = base::Optional<std::vector<base::string16>>();
+      break;
+
+    case RegistryKeysReporting::kNotReported:
+      // Defined as an optional object in which an empty registry keys vector is
+      // present.
+      registry_keys_ =
+          base::Optional<std::vector<base::string16>>(base::in_place);
+      break;
+
+    case RegistryKeysReporting::kReported:
+      // Defined as an optional object in which a non-empty registry keys vector
+      // is present.
+      registry_keys_ = base::Optional<std::vector<base::string16>>({
+          L"HKCU:32\\Software\\Some\\Unwanted Software",
+          L"HKCU:32\\Software\\Another\\Unwanted Software",
+      });
+      break;
+
+    default:
+      NOTREACHED();
+  }
 }
 
 int MockChromeCleanerProcess::Options::ExpectedExitCode(
@@ -229,8 +280,7 @@ void MockChromeCleanerProcess::SendScanResults(
 
   (*chrome_prompt_ptr_)
       ->PromptUser(
-          std::vector<base::FilePath>(options_.files_to_delete().begin(),
-                                      options_.files_to_delete().end()),
+          options_.files_to_delete(), options_.registry_keys(),
           base::BindOnce(&MockChromeCleanerProcess::PromptUserCallback,
                          base::Unretained(this), std::move(quit_closure)));
 }

chrome/browser/safe_browsing/chrome_cleaner/mock_chrome_cleaner_process_win.h

@@ -43,6 +43,19 @@ class MockChromeCleanerProcess {
     kNumCrashPoints,
   };
 
+  // Indicates if registry keys will be sent from the cleaner process.
+  enum class RegistryKeysReporting {
+    // Simulation of an older cleaner version that doesn't support sending
+    // registry keys.
+    kUnsupported,
+    // Simulation of a cleaner version that supports sending registry keys,
+    // but no registry key to be removed/changed reported.
+    kNotReported,
+    // The cleaner reported registry keys to be removed/changed.
+    kReported,
+    kNumRegistryKeysReporting,
+  };
+
   static constexpr int kInternalTestFailureExitCode = 100001;
   static constexpr int kDeliberateCrashExitCode = 100002;
   static constexpr int kNothingFoundExitCode = 2;
@@ -62,10 +75,15 @@ class MockChromeCleanerProcess {
 
     void AddSwitchesToCommandLine(base::CommandLine* command_line) const;
 
-    void SetDoFindUws(bool do_find_uws);
-    const std::set<base::FilePath>& files_to_delete() const {
+    void SetReportedResults(bool has_files_to_remove,
+                            RegistryKeysReporting registry_keys_reporting);
+
+    const std::vector<base::FilePath>& files_to_delete() const {
       return files_to_delete_;
     }
+    const base::Optional<std::vector<base::string16>>& registry_keys() const {
+      return registry_keys_;
+    }
 
     void set_reboot_required(bool reboot_required) {
       reboot_required_ = reboot_required;
@@ -84,13 +102,20 @@ class MockChromeCleanerProcess {
       return expected_user_response_;
     }
 
+    RegistryKeysReporting registry_keys_reporting() const {
+      return registry_keys_reporting_;
+    }
+
     int ExpectedExitCode(chrome_cleaner::mojom::PromptAcceptance
                              received_prompt_acceptance) const;
 
    private:
-    std::set<base::FilePath> files_to_delete_;
+    std::vector<base::FilePath> files_to_delete_;
+    base::Optional<std::vector<base::string16>> registry_keys_;
     bool reboot_required_ = false;
     CrashPoint crash_point_ = CrashPoint::kNone;
+    RegistryKeysReporting registry_keys_reporting_ =
+        RegistryKeysReporting::kUnsupported;
     chrome_cleaner::mojom::PromptAcceptance expected_user_response_ =
         chrome_cleaner::mojom::PromptAcceptance::UNSPECIFIED;
   };

chrome/browser/safe_browsing/chrome_cleaner/srt_chrome_prompt_impl.cc

@@ -35,12 +35,20 @@ ChromePromptImpl::~ChromePromptImpl() {
 
 void ChromePromptImpl::PromptUser(
     const std::vector<base::FilePath>& files_to_delete,
+    const base::Optional<std::vector<base::string16>>& registry_keys,
     ChromePrompt::PromptUserCallback callback) {
+  using FileCollection = ChromeCleanerScannerResults::FileCollection;
+  using RegistryKeyCollection =
+      ChromeCleanerScannerResults::RegistryKeyCollection;
+
   if (on_prompt_user_) {
+    ChromeCleanerScannerResults scanner_results(
+        FileCollection(files_to_delete.begin(), files_to_delete.end()),
+        registry_keys ? RegistryKeyCollection(registry_keys->begin(),
+                                              registry_keys->end())
+                      : RegistryKeyCollection());
     std::move(on_prompt_user_)
-        .Run(base::MakeUnique<std::set<base::FilePath>>(files_to_delete.begin(),
-                                                        files_to_delete.end()),
-             std::move(callback));
+        .Run(std::move(scanner_results), std::move(callback));
   }
 }
 

chrome/browser/safe_browsing/chrome_cleaner/srt_chrome_prompt_impl.h

@@ -12,6 +12,7 @@
 #include "base/callback.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
+#include "chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_scanner_results.h"
 #include "components/chrome_cleaner/public/interfaces/chrome_prompt.mojom.h"
 #include "mojo/public/cpp/bindings/binding.h"
 
@@ -22,7 +23,7 @@ namespace safe_browsing {
 class ChromePromptImpl : public chrome_cleaner::mojom::ChromePrompt {
  public:
   using OnPromptUser = base::OnceCallback<void(
-      std::unique_ptr<std::set<base::FilePath>>,
+      ChromeCleanerScannerResults&&,
       chrome_cleaner::mojom::ChromePrompt::PromptUserCallback)>;
 
   ChromePromptImpl(chrome_cleaner::mojom::ChromePromptRequest request,
@@ -30,9 +31,11 @@ class ChromePromptImpl : public chrome_cleaner::mojom::ChromePrompt {
                    OnPromptUser on_prompt_user);
   ~ChromePromptImpl() override;
 
-  void PromptUser(const std::vector<base::FilePath>& files_to_delete,
-                  chrome_cleaner::mojom::ChromePrompt::PromptUserCallback
-                      callback) override;
+  void PromptUser(
+      const std::vector<base::FilePath>& files_to_delete,
+      const base::Optional<std::vector<base::string16>>& registry_keys,
+      chrome_cleaner::mojom::ChromePrompt::PromptUserCallback callback)
+      override;
 
  private:
   mojo::Binding<chrome_cleaner::mojom::ChromePrompt> binding_;

chrome/browser/ui/views/chrome_cleaner_dialog_win.cc

@@ -219,7 +219,7 @@ void ChromeCleanerDialog::OnScanning() {
 }
 
 void ChromeCleanerDialog::OnCleaning(
-    const std::set<base::FilePath>& files_to_delete) {
+    const safe_browsing::ChromeCleanerScannerResults& scanner_results) {
   Abort();
 }
 

chrome/browser/ui/views/chrome_cleaner_dialog_win.h

@@ -72,7 +72,8 @@ class ChromeCleanerDialog
   void OnIdle(
       safe_browsing::ChromeCleanerController::IdleReason idle_reason) override;
   void OnScanning() override;
-  void OnCleaning(const std::set<base::FilePath>& files_to_delete) override;
+  void OnCleaning(const safe_browsing::ChromeCleanerScannerResults&
+                      scanner_results) override;
   void OnRebootRequired() override;
 
  private:

chrome/browser/ui/webui/settings/chrome_cleanup_handler.cc

@@ -124,16 +124,18 @@ void ChromeCleanupHandler::OnScanning() {
                          base::Value("chrome-cleanup-on-scanning"));
 }
 
-void ChromeCleanupHandler::OnInfected(const std::set<base::FilePath>& files) {
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("chrome-cleanup-on-infected"),
-                         GetFilesAsListStorage(files));
+void ChromeCleanupHandler::OnInfected(
+    const safe_browsing::ChromeCleanerScannerResults& scanner_results) {
+  CallJavascriptFunction(
+      "cr.webUIListenerCallback", base::Value("chrome-cleanup-on-infected"),
+      GetFilesAsListStorage(scanner_results.files_to_delete()));
 }
 
-void ChromeCleanupHandler::OnCleaning(const std::set<base::FilePath>& files) {
-  CallJavascriptFunction("cr.webUIListenerCallback",
-                         base::Value("chrome-cleanup-on-cleaning"),
-                         GetFilesAsListStorage(files));
+void ChromeCleanupHandler::OnCleaning(
+    const safe_browsing::ChromeCleanerScannerResults& scanner_results) {
+  CallJavascriptFunction(
+      "cr.webUIListenerCallback", base::Value("chrome-cleanup-on-cleaning"),
+      GetFilesAsListStorage(scanner_results.files_to_delete()));
 }
 
 void ChromeCleanupHandler::OnRebootRequired() {

chrome/browser/ui/webui/settings/chrome_cleanup_handler.h

@@ -10,6 +10,7 @@
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_controller_win.h"
+#include "chrome/browser/safe_browsing/chrome_cleaner/chrome_cleaner_scanner_results.h"
 #include "chrome/browser/ui/webui/settings/settings_page_ui_handler.h"
 
 class Profile;
@@ -33,8 +34,10 @@ class ChromeCleanupHandler
   void OnIdle(
       safe_browsing::ChromeCleanerController::IdleReason idle_reason) override;
   void OnScanning() override;
-  void OnInfected(const std::set<base::FilePath>& files) override;
-  void OnCleaning(const std::set<base::FilePath>& files) override;
+  void OnInfected(const safe_browsing::ChromeCleanerScannerResults&
+                      reported_results) override;
+  void OnCleaning(const safe_browsing::ChromeCleanerScannerResults&
+                      reported_results) override;
   void OnRebootRequired() override;
   void OnLogsEnabledChanged(bool logs_enabled) override;
 

components/chrome_cleaner/public/interfaces/chrome_prompt.mojom

@@ -31,14 +31,23 @@ struct FilePath {
   array<uint16> value;
 };
 
+struct RegistryKey {
+  // A string formatted for display to the user.
+  // Example: HKCU:32\software\unwanted_software
+  array<uint16> value;
+};
+
 // Service provided by Chrome to prompt the user to start a cleanup if the
 // Chrome Cleanup Tool detects unwanted software on the system.
 interface ChromePrompt {
   // Params:
-  //  - removable_uws_found: list of fully-qualified paths of the files that
-  //                         will be deleted by the Chrome Cleanup Tool.
+  //  - files_to_delete: list of fully-qualified paths of the files that will
+  //        be deleted by the Chrome Cleanup Tool.
+  //  - registry_keys: list of fully-qualified paths of the registry keys that
+  //        will be changed or deleted by the Chrome Cleanup Tool.
   // Returns:
   //  - prompt_acceptance: indicates if the user accepted the prompt.
-  PromptUser(array<FilePath> files_to_delete)
+  PromptUser(array<FilePath> files_to_delete,
+             [MinVersion=1] array<RegistryKey>? registry_keys)
       => (PromptAcceptance prompt_acceptance);
 };

components/chrome_cleaner/public/typemaps/DEPS

@@ -2,4 +2,6 @@
 include_rules = [
   '+base/containers/span.h',
   '+base/files/file_path.h',
+  '+base/strings/string16.h',
+  '+build/build_config.h',
 ]

components/chrome_cleaner/public/typemaps/chrome_prompt.typemap

@@ -3,10 +3,16 @@
 # found in the LICENSE file.
 
 mojom = "//components/chrome_cleaner/public/interfaces/chrome_prompt.mojom"
-public_headers = [ "//base/files/file_path.h" ]
+public_headers = [
+  "//base/files/file_path.h",
+  "//base/strings/string16.h",
+]
 traits_headers = [ "//components/chrome_cleaner/public/typemaps/chrome_prompt_struct_traits.h" ]
 sources = [
   "//components/chrome_cleaner/public/typemaps/chrome_prompt_struct_traits.cc",
 ]
 
-type_mappings = [ "chrome_cleaner.mojom.FilePath=base::FilePath" ]
+type_mappings = [
+  "chrome_cleaner.mojom.FilePath=base::FilePath",
+  "chrome_cleaner.mojom.RegistryKey=base::string16",
+]

components/chrome_cleaner/public/typemaps/chrome_prompt_struct_traits.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "components/chrome_cleaner/public/typemaps/chrome_prompt_struct_traits.h"
+#include "build/build_config.h"
 
 namespace mojo {
 
@@ -38,4 +39,34 @@ bool StructTraits<chrome_cleaner::mojom::FilePathDataView,
 #endif
 }
 
+// static
+base::span<const uint16_t>
+StructTraits<chrome_cleaner::mojom::RegistryKeyDataView, base::string16>::value(
+    const base::string16& registry_key) {
+#if defined(OS_WIN)
+  return base::make_span(reinterpret_cast<const uint16_t*>(registry_key.data()),
+                         registry_key.size());
+#else
+  NOTREACHED();
+  return base::span<const uint16_t>();
+#endif
+}
+
+// static
+bool StructTraits<chrome_cleaner::mojom::RegistryKeyDataView, base::string16>::
+    Read(chrome_cleaner::mojom::RegistryKeyDataView registry_key_view,
+         base::string16* out) {
+#if defined(OS_WIN)
+  ArrayDataView<uint16_t> view;
+  registry_key_view.GetValueDataView(&view);
+  base::string16 registry_key = base::string16(
+      reinterpret_cast<const base::char16*>(view.data()), view.size());
+  *out = std::move(registry_key);
+  return true;
+#else
+  NOTREACHED();
+  return false;
+#endif
+}
+
 }  // namespace mojo

components/chrome_cleaner/public/typemaps/chrome_prompt_struct_traits.h

@@ -7,6 +7,7 @@
 
 #include "base/containers/span.h"
 #include "base/files/file_path.h"
+#include "base/strings/string16.h"
 #include "components/chrome_cleaner/public/interfaces/chrome_prompt.mojom.h"
 
 namespace mojo {
@@ -18,6 +19,14 @@ struct StructTraits<chrome_cleaner::mojom::FilePathDataView, base::FilePath> {
                    base::FilePath* out);
 };
 
+template <>
+struct StructTraits<chrome_cleaner::mojom::RegistryKeyDataView,
+                    base::string16> {
+  static base::span<const uint16_t> value(const base::string16& registry_key);
+  static bool Read(chrome_cleaner::mojom::RegistryKeyDataView registry_key_view,
+                   base::string16* out);
+};
+
 }  // namespace mojo
 
 #endif  // COMPONENTS_CHROME_CLEANER_PUBLIC_TYPEMAPS_CHROME_CLEANER_STRUCT_TRAITS_H_