Chrome Cleaner UI: Add logs upload permission checkbox to the dialog

chrome/browser/safe_browsing/chrome_cleaner/mock_chrome_cleaner_process_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/mock_chrome_cleaner_process_win.h"
 
 #include <utility>
+#include <vector>
 
 #include "base/bind_helpers.h"
 #include "base/memory/ref_counted.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/sequenced_task_runner.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/threading/sequenced_task_runner_handle.h"
 #include "base/threading/thread.h"
 #include "mojo/edk/embedder/connection_params.h"
@@ skipping 11 matching lines @@
 namespace {
 
 using ::chrome_cleaner::mojom::ChromePrompt;
 using ::chrome_cleaner::mojom::ChromePromptPtr;
 using ::chrome_cleaner::mojom::ChromePromptPtrInfo;
 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 kExpectedUserResponseSwitch[] = "mock-expected-user-response";
 
 }  // namespace
 
 // static
 bool MockChromeCleanerProcess::Options::FromCommandLine(
     const base::CommandLine& command_line,
     Options* options) {
   options->SetDoFindUws(command_line.HasSwitch(kUwsFoundSwitch));
   options->set_reboot_required(command_line.HasSwitch(kRebootRequiredSwitch));
 
   if (command_line.HasSwitch(kCrashPointSwitch)) {
     int crash_point_int = 0;
     if (base::StringToInt(command_line.GetSwitchValueASCII(kCrashPointSwitch),
                           &crash_point_int) &&
         crash_point_int >= 0 &&
         crash_point_int < static_cast<int>(CrashPoint::kNumCrashPoints)) {
       options->set_crash_point(static_cast<CrashPoint>(crash_point_int));
     } else {
       return false;
     }
   }
 
+  if (command_line.HasSwitch(kExpectedUserResponseSwitch)) {
+    int expected_response_int = 0;
+    if (base::StringToInt(
+            command_line.GetSwitchValueASCII(kExpectedUserResponseSwitch),
+            &expected_response_int) &&
+        expected_response_int >= 0 &&
+        expected_response_int <
+            static_cast<int>(PromptAcceptance::NUM_VALUES)) {
+      options->set_expected_user_response(
+          static_cast<PromptAcceptance>(expected_response_int));
+    } else {
+      return false;
+    }
+  }
+
   return true;
 }
 
 MockChromeCleanerProcess::Options::Options() = default;
 
 MockChromeCleanerProcess::Options::Options(const Options& other)
     : files_to_delete_(other.files_to_delete_),
       reboot_required_(other.reboot_required_),
-      crash_point_(other.crash_point_) {
-}
+      crash_point_(other.crash_point_),
+      expected_user_response_(other.expected_user_response_) {}
 
 MockChromeCleanerProcess::Options& MockChromeCleanerProcess::Options::operator=(
     const Options& other) {
   files_to_delete_ = other.files_to_delete_;
   reboot_required_ = other.reboot_required_;
   crash_point_ = other.crash_point_;
+  expected_user_response_ = other.expected_user_response_;
   return *this;
 }
 
 MockChromeCleanerProcess::Options::~Options() {}
 
 void MockChromeCleanerProcess::Options::AddSwitchesToCommandLine(
     base::CommandLine* command_line) const {
   if (!files_to_delete_.empty())
     command_line->AppendSwitch(kUwsFoundSwitch);
 
   if (reboot_required())
     command_line->AppendSwitch(kRebootRequiredSwitch);
 
   if (crash_point() != CrashPoint::kNone) {
     command_line->AppendSwitchASCII(
         kCrashPointSwitch, base::IntToString(static_cast<int>(crash_point())));
   }
+
+  if (expected_user_response() != PromptAcceptance::UNSPECIFIED) {
+    command_line->AppendSwitchASCII(
+        kExpectedUserResponseSwitch,
+        base::IntToString(static_cast<int>(expected_user_response())));
+  }
 }
 
 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")));
 }
 
 int MockChromeCleanerProcess::Options::ExpectedExitCode(
     PromptAcceptance received_prompt_acceptance) const {
   if (crash_point() != CrashPoint::kNone)
     return kDeliberateCrashExitCode;
 
   if (files_to_delete_.empty())
     return kNothingFoundExitCode;
 
-  if (received_prompt_acceptance == PromptAcceptance::ACCEPTED) {
+  if (received_prompt_acceptance == PromptAcceptance::ACCEPTED_WITH_LOGS ||
+      received_prompt_acceptance == PromptAcceptance::ACCEPTED_WITHOUT_LOGS) {
     return reboot_required() ? kRebootRequiredExitCode
                              : kRebootNotRequiredExitCode;
   }
 
   return kDeclinedExitCode;
 }
 
 MockChromeCleanerProcess::MockChromeCleanerProcess(
     const Options& options,
     const std::string& chrome_mojo_pipe_token)
@@ skipping 46 matching lines @@
 
   io_thread.task_runner()->PostTask(
       FROM_HERE,
       base::BindOnce(&MockChromeCleanerProcess::SendScanResults,
                      base::Unretained(this), std::move(prompt_ptr_info),
                      base::Passed(&quit_closure)));
 
   run_loop.Run();
 
   EXPECT_NE(received_prompt_acceptance_, PromptAcceptance::UNSPECIFIED);
+  EXPECT_EQ(received_prompt_acceptance_, options_.expected_user_response());
   if (::testing::Test::HasFailure())
     return kInternalTestFailureExitCode;
   return options_.ExpectedExitCode(received_prompt_acceptance_);
 }
 
 void MockChromeCleanerProcess::SendScanResults(
     ChromePromptPtrInfo prompt_ptr_info,
     base::OnceClosure quit_closure) {
   // This pointer will be deleted by PromptUserCallback.
   chrome_prompt_ptr_ = new ChromePromptPtr();
@@ skipping 23 matching lines @@
 
   received_prompt_acceptance_ = prompt_acceptance;
 
   if (options_.crash_point() == CrashPoint::kAfterResponseReceived)
     exit(kDeliberateCrashExitCode);
 
   std::move(quit_closure).Run();
 }
 
 }  // namespace safe_browsing