Replace elevation required bool with an enum.

chrome/browser/safe_browsing/srt_fetcher_browsertest_win.cc

 // Copyright 2015 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/srt_fetcher_win.h"
 
 #include <initializer_list>
 #include <set>
 #include <tuple>
 #include <utility>
@@ skipping 31 matching lines @@
 #include "components/safe_browsing_db/safe_browsing_prefs.h"
 #include "mojo/edk/embedder/embedder.h"
 #include "mojo/edk/embedder/scoped_ipc_support.h"
 #include "mojo/edk/system/core.h"
 #include "testing/multiprocess_func_list.h"
 
 namespace safe_browsing {
 
 namespace {
 
+using chrome_cleaner::mojom::ElevationStatus;
 using chrome_cleaner::mojom::PromptAcceptance;
 
 // Special switches passed by the parent process (test case) to the reporter
 // child process to indicate the behavior that should be mocked.
 constexpr char kExitCodeToReturnSwitch[] = "exit-code-to-return";
 constexpr char kReportUwSFoundSwitch[] = "report-uws-found";
 constexpr char kReportElevationRequiredSwitch[] = "report-elevation-required";
 constexpr char kExpectedPromptAcceptanceSwitch[] = "expected-prompt-acceptance";
 
 // The exit code to be returned in case of failure in the child process.
@@ skipping 67 matching lines @@
       std::move(message_pipe_handle), 0));
 
   std::vector<chrome_cleaner::mojom::UwSPtr> removable_uws_found;
   if (command_line.HasSwitch(kReportUwSFoundSwitch)) {
     chrome_cleaner::mojom::UwSPtr uws = chrome_cleaner::mojom::UwS::New();
     uws->id = kDefaultUwSId;
     uws->name = kDefaultUwSName;
     uws->observed_behaviours = chrome_cleaner::mojom::ObservedBehaviours::New();
     removable_uws_found.push_back(std::move(uws));
   }
-  const bool elevation_required =
-      command_line.HasSwitch(kReportElevationRequiredSwitch);
+  const ElevationStatus elevation_status =
+      command_line.HasSwitch(kReportElevationRequiredSwitch)
+          ? ElevationStatus::REQUIRED
+          : ElevationStatus::NOT_REQUIRED;
   const PromptAcceptance expected_prompt_acceptance =
       PromptAcceptanceFromCommandLine(command_line);
 
   (*g_chrome_prompt_ptr)
       ->PromptUser(
-          std::move(removable_uws_found), elevation_required,
+          std::move(removable_uws_found), elevation_status,
           base::Bind(&PromptUserCallback, done, expected_prompt_acceptance,
                      expected_value_received));
 }
 
 // Connects to the parent process and sends mocked scan results. Returns true
 // if connection was successful and the prompt acceptance results sent by the
 // parent process are the same as expected.
 bool ConnectAndSendDataToParentProcess(
     const std::string& chrome_mojo_pipe_token,
     const base::CommandLine& command_line) {
@@ skipping 44 matching lines @@
                  (chrome_mojo_pipe_token.empty() ||
                   ConnectAndSendDataToParentProcess(chrome_mojo_pipe_token,
                                                     *command_line));
   return success ? exit_code_to_report : kFailureExitCode;
 }
 
 // Parameters for this test:
 //  - bool in_browser_cleaner_ui: indicates if InBrowserCleanerUI experiment
 //    is enabled; if so, the parent and the child processes will communicate
 //    via a Mojo IPC;
-//  - bool elevation_required: indicates if the scan results sent by the child
-//    process should consider that elevation will be required for cleanup.
+//  - ElevationStatus elevation_status: indicates if the scan results sent by
+//    the child process should consider that elevation will be required for
+//    cleanup.
 class SRTFetcherTest
     : public InProcessBrowserTest,
       public SwReporterTestingDelegate,
-      public ::testing::WithParamInterface<std::tuple<bool, bool>> {
+      public ::testing::WithParamInterface<std::tuple<bool, ElevationStatus>> {
  public:
   void SetUpInProcessBrowserTestFixture() override {
     SetSwReporterTestingDelegate(this);
 
-    std::tie(in_browser_cleaner_ui_, elevation_required_) = GetParam();
-    // The config should only accept elevation_required_ if InBrowserCleanerUI
+    std::tie(in_browser_cleaner_ui_, elevation_status_) = GetParam();
+    // The config should only accept elevation_status_ if InBrowserCleanerUI
     // feature is enabled.
-    ASSERT_TRUE(!elevation_required_ || in_browser_cleaner_ui_);
+    ASSERT_TRUE(elevation_status_ == ElevationStatus::NOT_REQUIRED ||
+                in_browser_cleaner_ui_);
 
     if (in_browser_cleaner_ui_)
       scoped_feature_list_.InitAndEnableFeature(kInBrowserCleanerUIFeature);
     else
       scoped_feature_list_.InitAndDisableFeature(kInBrowserCleanerUIFeature);
   }
 
   void SetUpOnMainThread() override {
     // During the test, use a task runner with a mock clock.
     saved_task_runner_ = base::ThreadTaskRunnerHandle::Get();
@@ skipping 42 matching lines @@
     base::CommandLine command_line(
         base::GetMultiProcessTestChildBaseCommandLine());
     command_line.AppendArguments(invocation.command_line,
                                  /*include_program=*/false);
     command_line.AppendSwitchASCII(kExitCodeToReturnSwitch,
                                    base::IntToString(exit_code_to_report_));
     if (in_browser_cleaner_ui_) {
       AddPromptAcceptanceToCommandLine(PromptAcceptance::DENIED, &command_line);
       if (exit_code_to_report_ == kSwReporterCleanupNeeded) {
         command_line.AppendSwitch(kReportUwSFoundSwitch);
-        if (elevation_required_)
+        if (elevation_status_ == ElevationStatus::REQUIRED)
           command_line.AppendSwitch(kReportElevationRequiredSwitch);
       }
     }
     base::SpawnChildResult result = base::SpawnMultiProcessTestChild(
         "MockSwReporterProcess", command_line, launch_options);
     return std::move(result.process);
   }
 
   // Returns the test's idea of the current time.
   base::Time Now() const override { return mock_time_task_runner_->Now(); }
@@ skipping 154 matching lines @@
   }
 
   // A task runner with a mock clock.
   scoped_refptr<base::TestMockTimeTaskRunner> mock_time_task_runner_ =
       new base::TestMockTimeTaskRunner();
 
   // The task runner that was in use before installing |mock_time_task_runner_|.
   scoped_refptr<base::SingleThreadTaskRunner> saved_task_runner_;
 
   bool in_browser_cleaner_ui_;
-  bool elevation_required_;
+  ElevationStatus elevation_status_;
 
   bool prompt_trigger_called_ = false;
   int reporter_launch_count_ = 0;
   std::vector<SwReporterInvocation> reporter_launch_parameters_;
   int exit_code_to_report_ = kReporterFailureExitCode;
 
   // A callback to invoke when the first reporter of a queue is launched. This
   // can be used to perform actions in the middle of a queue of reporters which
   // all launch on the same mock clock tick.
   base::OnceClosure first_launch_callback_;
@@ skipping 314 matching lines @@
   // Logs should also be sent for the next run, even though LastTimeSentReport
   // is now recent, because the run is part of the same set of invocations.
   {
     SCOPED_TRACE("second launch");
     ExpectLoggingSwitches(reporter_launch_parameters_[1], true);
     ExpectLastReportSentInTheLastHour();
   }
   ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
 }
 
-INSTANTIATE_TEST_CASE_P(NoInBrowserCleanerUI,
-                        SRTFetcherTest,
-                        testing::Combine(testing::Values(false),
-                                         testing::Values(false)));
+INSTANTIATE_TEST_CASE_P(
+    NoInBrowserCleanerUI,
+    SRTFetcherTest,
+    testing::Combine(testing::Values(false),
+                     testing::Values(ElevationStatus::NOT_REQUIRED)));
 
-INSTANTIATE_TEST_CASE_P(InBrowserCleanerUI,
-                        SRTFetcherTest,
-                        testing::Combine(testing::Values(true),
-                                         testing::Bool()));
+INSTANTIATE_TEST_CASE_P(
+    InBrowserCleanerUI,
+    SRTFetcherTest,
+    testing::Combine(testing::Values(true),
+                     testing::Values(ElevationStatus::NOT_REQUIRED,
+                                     ElevationStatus::REQUIRED)));
 
 // This provide tests which allows explicit invocation of the SRT Prompt
 // useful for checking dialog layout or any other interactive functionality
 // tests. See docs/testing/test_browser_dialog.md for description of the
 // testing framework.
 IN_PROC_BROWSER_TEST_F(SRTFetcherPromptTest, InvokeDialog_SRTErrorNoFile) {
   RunDialog();
 }
 
 IN_PROC_BROWSER_TEST_F(SRTFetcherPromptTest, InvokeDialog_SRTErrorFile) {
   RunDialog();
 }
 
 }  // namespace safe_browsing