Add extension handling to chrome_cleaner/ipc and chrome_cleaner/ui

R=csharp@chromium.org

Bug: 830892
Change-Id: Ib3157dc17c2e2c7738f6b2a6af7d88ed72eb4d33
Reviewed-on: https://chromium-review.googlesource.com/c/1338402Reviewed-by: Chris Sharp <csharp@chromium.org>
Reviewed-by: Ken Rockot <rockot@google.com>
Commit-Queue: Joe Mason <joenotcharles@google.com>
Cr-Commit-Position: refs/heads/master@{#609001}

chrome/chrome_cleaner/ipc/DEPS

 include_rules = [
   "+mojo/core/embedder",
+  "+mojo/public/cpp",
 ]

chrome/chrome_cleaner/ipc/chrome_prompt_ipc.cc

@@ -53,13 +53,14 @@ ChromePromptIPC::~ChromePromptIPC() {
 void ChromePromptIPC::PostPromptUserTask(
     const std::vector<base::FilePath>& files_to_delete,
     const std::vector<base::string16>& registry_keys,
+    const std::vector<base::string16>& extension_ids,
     mojom::ChromePrompt::PromptUserCallback callback) {
   DCHECK(task_runner_);
   task_runner_->PostTask(
       FROM_HERE,
       base::BindOnce(
           &ChromePromptIPC::RunPromptUserTask, base::Unretained(this),
-          files_to_delete, registry_keys,
+          files_to_delete, registry_keys, extension_ids,
           base::BindOnce(&ChromePromptIPC::OnChromeResponseReceived,
                          base::Unretained(this), std::move(callback))));
 }
@@ -134,9 +135,30 @@ void ChromePromptIPC::InitializeChromePromptPtr() {
   state_ = State::kWaitingForScanResults;
 }
 
+void ChromePromptIPC::PromptUserCheckVersion(
+    const std::vector<base::FilePath>& files_to_delete,
+    const std::vector<base::string16>& registry_keys,
+    const std::vector<base::string16>& extension_ids,
+    mojom::ChromePrompt::PromptUserCallback callback,
+    uint32_t version) {
+  if (version >= 3) {
+    (*chrome_prompt_service_)
+        ->PromptUser(std::move(files_to_delete), std::move(registry_keys),
+                     std::move(extension_ids), std::move(callback));
+  } else {
+    // Before version 3 the delete extensions interface wasn't implemented.
+    // So we need to not notify the user that there are extensions to be
+    // deleted.
+    (*chrome_prompt_service_)
+        ->PromptUser(std::move(files_to_delete), std::move(registry_keys),
+                     base::nullopt, std::move(callback));
+  }
+}
+
 void ChromePromptIPC::RunPromptUserTask(
     const std::vector<base::FilePath>& files_to_delete,
     const std::vector<base::string16>& registry_keys,
+    const std::vector<base::string16>& extension_ids,
     mojom::ChromePrompt::PromptUserCallback callback) {
   DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
   DCHECK(chrome_prompt_service_);
@@ -151,9 +173,13 @@ void ChromePromptIPC::RunPromptUserTask(
 
   state_ = State::kWaitingForResponseFromChrome;
 
-  (*chrome_prompt_service_)
-      ->PromptUser(std::move(files_to_delete), std::move(registry_keys),
-                   base::nullopt, std::move(callback));
+  const auto& version_callback = base::BindRepeating(
+      &ChromePromptIPC::PromptUserCheckVersion, base::Unretained(this),
+      std::move(files_to_delete), std::move(registry_keys),
+      // Uses the AdaptCallbackForRepeating because we are bound by the mojo API
+      // to use a RepeatingCallback even though this only should be called once.
+      std::move(extension_ids), AdaptCallbackForRepeating(std::move(callback)));
+  (*chrome_prompt_service_).QueryVersion(version_callback);
 }
 
 void ChromePromptIPC::RunDisableExtensionsTask(

chrome/chrome_cleaner/ipc/chrome_prompt_ipc.h

@@ -77,6 +77,7 @@ class ChromePromptIPC {
   virtual void PostPromptUserTask(
       const std::vector<base::FilePath>& files_to_delete,
       const std::vector<base::string16>& registry_keys,
+      const std::vector<base::string16>& extension_ids,
       mojom::ChromePrompt::PromptUserCallback callback);
 
   // Posts a PromptDisableExtensions() task to the IPC controller's thread.
@@ -113,6 +114,7 @@ class ChromePromptIPC {
   virtual void RunPromptUserTask(
       const std::vector<base::FilePath>& files_to_delete,
       const std::vector<base::string16>& registry_keys,
+      const std::vector<base::string16>& extension_ids,
       mojom::ChromePrompt::PromptUserCallback callback);
 
   virtual void RunDisableExtensionsTask(
@@ -138,6 +140,13 @@ class ChromePromptIPC {
   // state.
   void OnConnectionError();
 
+  void PromptUserCheckVersion(
+      const std::vector<base::FilePath>& files_to_delete,
+      const std::vector<base::string16>& registry_keys,
+      const std::vector<base::string16>& extension_ids,
+      mojom::ChromePrompt::PromptUserCallback callback,
+      uint32_t version);
+
   State state_ = State::kUninitialized;
   scoped_refptr<MojoTaskRunner> task_runner_;
   std::string chrome_mojo_pipe_token_;

chrome/chrome_cleaner/ipc/chrome_prompt_ipc_unittest.cc

@@ -226,6 +226,7 @@ class ChromePromptIPCChildProcess : public ChildProcess {
 
     std::vector<base::FilePath> files_to_delete;
     std::vector<base::string16> registry_keys;
+    std::vector<base::string16> extension_ids;
     if (uws_expected()) {
       files_to_delete.push_back(kBadFilePath);
       if (with_registry_keys())
@@ -234,6 +235,7 @@ class ChromePromptIPCChildProcess : public ChildProcess {
 
     chrome_prompt_ipc->PostPromptUserTask(
         std::move(files_to_delete), std::move(registry_keys),
+        std::move(extension_ids),
         base::BindOnce(&ChromePromptIPCChildProcess::ReceivePromptResult,
                        base::Unretained(this), base::Passed(&done)));
   }

chrome/chrome_cleaner/ipc/mock_chrome_prompt_ipc.cc

@@ -16,8 +16,10 @@ MockChromePromptIPC::~MockChromePromptIPC() = default;
 void MockChromePromptIPC::PostPromptUserTask(
     const std::vector<base::FilePath>& files_to_delete,
     const std::vector<base::string16>& registry_keys,
+    const std::vector<base::string16>& extension_ids,
     mojom::ChromePrompt::PromptUserCallback callback) {
-  MockPostPromptUserTask(files_to_delete, registry_keys, &callback);
+  MockPostPromptUserTask(files_to_delete, registry_keys, extension_ids,
+                         &callback);
 }
 
 }  // namespace chrome_cleaner

chrome/chrome_cleaner/ipc/mock_chrome_prompt_ipc.h

@@ -27,10 +27,12 @@ class MockChromePromptIPC : public ChromePromptIPC {
   void PostPromptUserTask(
       const std::vector<base::FilePath>& files_to_delete,
       const std::vector<base::string16>& registry_keys,
+      const std::vector<base::string16>& extension_ids,
       mojom::ChromePrompt::PromptUserCallback callback) override;
-  MOCK_METHOD3(MockPostPromptUserTask,
+  MOCK_METHOD4(MockPostPromptUserTask,
                void(const std::vector<base::FilePath>& files_to_delete,
                     const std::vector<base::string16>& registry_keys,
+                    const std::vector<base::string16>& extension_ids,
                     mojom::ChromePrompt::PromptUserCallback* callback));
 };
 

chrome/chrome_cleaner/ui/chrome_proxy_main_dialog.cc

@@ -7,8 +7,10 @@
 #include <utility>
 
 #include "base/logging.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "chrome/chrome_cleaner/os/file_path_set.h"
+#include "chrome/chrome_cleaner/pup_data/pup_data.h"
 #include "chrome/chrome_cleaner/settings/settings.h"
 
 namespace chrome_cleaner {
@@ -29,6 +31,7 @@ bool ChromeProxyMainDialog::Create() {
 void ChromeProxyMainDialog::NoPUPsFound() {
   chrome_prompt_ipc_->PostPromptUserTask(
       std::vector<base::FilePath>(), std::vector<base::string16>(),
+      std::vector<base::string16>(),
       base::BindOnce(
           &ChromeProxyMainDialog::PostCloseAfterReceivingResponseTask,
           base::Unretained(this), base::SequencedTaskRunnerHandle::Get()));
@@ -40,8 +43,21 @@ void ChromeProxyMainDialog::ConfirmCleanup(
     const std::vector<base::string16>& registry_keys) {
   std::vector<base::FilePath> files_out = files.ToVector();
   std::vector<base::string16> registry_keys_out = registry_keys;
+  std::vector<base::string16> extension_ids;
+  for (const UwSId& pup_id : found_pups) {
+    if (!PUPData::IsKnownPUP(pup_id)) {
+      continue;
+    }
+    PUPData::PUP* pup = PUPData::GetPUP(pup_id);
+    for (const ForceInstalledExtension& matched_extension :
+         pup->matched_extensions) {
+      extension_ids.push_back(
+          base::UTF8ToUTF16(matched_extension.id.AsString()));
+    }
+  }
   chrome_prompt_ipc_->PostPromptUserTask(
       std::move(files_out), std::move(registry_keys_out),
+      std::move(extension_ids),
       base::BindOnce(&ChromeProxyMainDialog::PostPromptResultReceivedTask,
                      base::Unretained(this),
                      base::SequencedTaskRunnerHandle::Get()));
@@ -55,6 +71,13 @@ void ChromeProxyMainDialog::Close() {
   delegate()->OnClose();
 }
 
+void ChromeProxyMainDialog::DisableExtensions(
+    const std::vector<base::string16>& extensions,
+    base::OnceCallback<void(bool)> on_disable) {
+  chrome_prompt_ipc_->PostDisableExtensionsTask(extensions,
+                                                std::move(on_disable));
+}
+
 void ChromeProxyMainDialog::PostPromptResultReceivedTask(
     scoped_refptr<base::SequencedTaskRunner> task_runner,
     mojom::PromptAcceptance prompt_acceptance) {

chrome/chrome_cleaner/ui/chrome_proxy_main_dialog.h

@@ -32,6 +32,8 @@ class ChromeProxyMainDialog : public MainDialogAPI {
   void NoPUPsFound() override;
   void CleanupDone(ResultCode cleanup_result) override;
   void Close() override;
+  void DisableExtensions(const std::vector<base::string16>& extensions,
+                         base::OnceCallback<void(bool)> on_disable) override;
 
  protected:
   void ConfirmCleanup(

chrome/chrome_cleaner/ui/chrome_proxy_main_dialog_unittest.cc

@@ -51,9 +51,10 @@ TEST_F(ChromeProxyMainDialogTest, NoPUPsFound) {
   base::RunLoop run_loop;
   EXPECT_CALL(delegate_, OnClose())
       .WillOnce(testing::InvokeWithoutArgs([&run_loop]() { run_loop.Quit(); }));
-  EXPECT_CALL(chrome_prompt_ipc_, MockPostPromptUserTask(_, _, _))
+  EXPECT_CALL(chrome_prompt_ipc_, MockPostPromptUserTask(_, _, _, _))
       .WillOnce(Invoke([](const std::vector<base::FilePath>& files_to_delete,
                           const std::vector<base::string16>& registry_keys,
+                          const std::vector<base::string16>& extension_ids,
                           mojom::ChromePrompt::PromptUserCallback* callback) {
         std::move(*callback).Run(PromptAcceptance::DENIED);
       }));
@@ -119,10 +120,11 @@ TEST_P(ConfirmCleanupChromeProxyMainDialogTest, ConfirmCleanup) {
 
   StrictMock<MockChromePromptIPC> chrome_prompt_ipc;
   EXPECT_CALL(chrome_prompt_ipc,
-              MockPostPromptUserTask(SizeIs(2), SizeIs(1), _))
+              MockPostPromptUserTask(SizeIs(2), SizeIs(1), _, _))
       .WillOnce(Invoke([prompt_acceptance](
                            const std::vector<base::FilePath>& files_to_delete,
                            const std::vector<base::string16>& registry_keys,
+                           const std::vector<base::string16>& extension_ids,
                            mojom::ChromePrompt::PromptUserCallback* callback) {
         std::move(*callback).Run(prompt_acceptance);
       }));

chrome/chrome_cleaner/ui/main_dialog_api.h

@@ -9,6 +9,7 @@
 
 #include <vector>
 
+#include "base/callback.h"
 #include "base/strings/string16.h"
 #include "chrome/chrome_cleaner/constants/uws_id.h"
 #include "chrome/chrome_cleaner/os/file_path_set.h"
@@ -48,6 +49,11 @@ class MainDialogAPI {
   // Close the window.
   virtual void Close() = 0;
 
+  // Disables |extensions| by telling Chrome to do so.
+  // Calls the |on_disable| with the result on completion.
+  virtual void DisableExtensions(const std::vector<base::string16>& extensions,
+                                 base::OnceCallback<void(bool)> on_disable) = 0;
+
   // Checks if |found_pups| contains any files to clean. If so, calls
   // ConfirmCleanupWithFiles, otherwise calls NoPUPsFound.
   void ConfirmCleanupIfNeeded(const std::vector<UwSId>& found_pups);

chrome/chrome_cleaner/ui/silent_main_dialog.cc

@@ -4,6 +4,10 @@
 
 #include "chrome/chrome_cleaner/ui/silent_main_dialog.h"
 
+#include <utility>
+#include <vector>
+
+#include "base/callback.h"
 #include "base/logging.h"
 
 namespace chrome_cleaner {
@@ -38,4 +42,10 @@ void SilentMainDialog::Close() {
   delegate()->OnClose();
 }
 
+void SilentMainDialog::DisableExtensions(
+    const std::vector<base::string16>& extensions,
+    base::OnceCallback<void(bool)> on_disable) {
+  std::move(on_disable).Run(true);
+}
+
 }  // namespace chrome_cleaner

chrome/chrome_cleaner/ui/silent_main_dialog.h

@@ -28,6 +28,8 @@ class SilentMainDialog : public MainDialogAPI {
   void NoPUPsFound() override;
   void CleanupDone(ResultCode cleanup_result) override;
   void Close() override;
+  void DisableExtensions(const std::vector<base::string16>& extensions,
+                         base::OnceCallback<void(bool)> on_disable) override;
 
  protected:
   void ConfirmCleanup(