Move shared constants to //components/chrome_cleaner

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 18 matching lines @@
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/lifetime/keep_alive_types.h"
 #include "chrome/browser/lifetime/scoped_keep_alive.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/safe_browsing/srt_client_info_win.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/test/test_browser_dialog.h"
 #include "chrome/common/pref_names.h"
 #include "chrome/test/base/in_process_browser_test.h"
+#include "components/chrome_cleaner/public/constants/constants.h"
 #include "components/chrome_cleaner/public/interfaces/chrome_prompt.mojom.h"
 #include "components/component_updater/pref_names.h"
 #include "components/prefs/pref_service.h"
 #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 {
@@ skipping 141 matching lines @@
 }
 
 // Mocks a Software Reporter process that returns an exit code specified by
 // command line switch kExitCodeToReturnSwitch. If a Mojo IPC is available,
 // this will also connect to the parent process and send mocked scan results
 // to the parent process using data passed as command line switches.
 MULTIPROCESS_TEST_MAIN(MockSwReporterProcess) {
   base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
   const std::string& str =
       command_line->GetSwitchValueASCII(kExitCodeToReturnSwitch);
-  const std::string& chrome_mojo_pipe_token =
-      command_line->GetSwitchValueASCII(kChromeMojoPipeTokenSwitch);
+  const std::string& chrome_mojo_pipe_token = command_line->GetSwitchValueASCII(
+      chrome_cleaner::kChromeMojoPipeTokenSwitch);
   int exit_code_to_report = kFailureExitCode;
   bool success = base::StringToInt(str, &exit_code_to_report) &&
                  (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
@@ skipping 68 matching lines @@
       std::move(first_launch_callback_).Run();
 
     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) {
+      if (exit_code_to_report_ == chrome_cleaner::kSwReporterCleanupNeeded) {
         command_line.AppendSwitch(kReportUwSFoundSwitch);
         if (elevation_status_ == ElevationStatus::REQUIRED)
           command_line.AppendSwitch(kReportElevationRequiredSwitch);
       }
     }
     base::SpawnChildResult result = base::SpawnMultiProcessTestChild(
         "MockSwReporterProcess", command_line, launch_options);
     return std::move(result.process);
   }
 
@@ skipping 135 matching lines @@
     // which should be enough time if the execution does not fail.
     EXPECT_LT(now - base::TimeDelta::FromHours(1), last_time_sent_logs);
     EXPECT_GE(now, last_time_sent_logs);
   }
 
   // Expects |invocation|'s command line to contain all the switches required
   // for reporter logging if and only if |expect_switches| is true.
   void ExpectLoggingSwitches(const SwReporterInvocation& invocation,
                              bool expect_switches) {
     static const std::set<std::string> logging_switches{
-        kExtendedSafeBrowsingEnabledSwitch, kChromeVersionSwitch,
-        kChromeChannelSwitch};
+        chrome_cleaner::kExtendedSafeBrowsingEnabledSwitch,
+        chrome_cleaner::kChromeVersionSwitch,
+        chrome_cleaner::kChromeChannelSwitch};
 
     const base::CommandLine::SwitchMap& invocation_switches =
         invocation.command_line.GetSwitches();
     // Checks if switches that enable logging on the reporter are present on
     // the invocation if and only if logging is allowed.
     for (const std::string& logging_switch : logging_switches) {
       EXPECT_EQ(expect_switches, invocation_switches.find(logging_switch) !=
                                      invocation_switches.end());
     }
   }
@@ skipping 30 matching lines @@
       DisplaySRTPromptForTesting(
           base::FilePath().Append(FILE_PATH_LITERAL("c:\temp\testfile.txt")));
     else
       ADD_FAILURE() << "Unknown dialog type.";
   }
 };
 
 }  // namespace
 
 IN_PROC_BROWSER_TEST_P(SRTFetcherTest, NothingFound) {
-  RunReporter(kSwReporterNothingFound);
+  RunReporter(chrome_cleaner::kSwReporterNothingFound);
   ExpectReporterLaunches(0, 1, false);
   ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
 }
 
 IN_PROC_BROWSER_TEST_P(SRTFetcherTest, CleanupNeeded) {
-  RunReporter(kSwReporterCleanupNeeded);
+  RunReporter(chrome_cleaner::kSwReporterCleanupNeeded);
   ExpectReporterLaunches(0, 1, true);
   ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
 }
 
 IN_PROC_BROWSER_TEST_P(SRTFetcherTest, RanRecently) {
   constexpr int kDaysLeft = 1;
   SetDaysSinceLastTriggered(kDaysBetweenSuccessfulSwReporterRuns - kDaysLeft);
-  RunReporter(kSwReporterNothingFound);
+  RunReporter(chrome_cleaner::kSwReporterNothingFound);
   ExpectReporterLaunches(0, 0, false);
   ExpectToRunAgain(kDaysLeft);
   ExpectReporterLaunches(kDaysLeft, 1, false);
   ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
 }
 
 // Test is flaky. crbug.com/705608
 IN_PROC_BROWSER_TEST_P(SRTFetcherTest, DISABLED_WaitForBrowser) {
   Profile* profile = browser()->profile();
 
   // Ensure that even though we're closing the last browser, we don't enter the
   // "shutting down" state, which will prevent the test from starting another
   // browser.
   ScopedKeepAlive test_keep_alive(KeepAliveOrigin::SESSION_RESTORE,
                                   KeepAliveRestartOption::ENABLED);
 
   // Use the standard task runner for browser cleanup, which will wait forever
   // with the mock clock.
   base::MessageLoop::current()->SetTaskRunner(saved_task_runner_);
   CloseBrowserSynchronously(browser());
   base::MessageLoop::current()->SetTaskRunner(mock_time_task_runner_);
   ASSERT_EQ(0u, chrome::GetTotalBrowserCount());
   ASSERT_FALSE(chrome::FindLastActive());
 
   // Start the reporter while the browser is closed. The prompt should not open.
-  RunReporter(kSwReporterCleanupNeeded);
+  RunReporter(chrome_cleaner::kSwReporterCleanupNeeded);
   ExpectReporterLaunches(0, 1, false);
 
   // Create a Browser object directly instead of using helper functions like
   // CreateBrowser, because they all wait on timed events but do not advance the
   // mock timer. The Browser constructor registers itself with the global
   // BrowserList, which is cleaned up when InProcessBrowserTest exits.
   new Browser(Browser::CreateParams(profile, /*user_gesture=*/false));
   ASSERT_EQ(1u, chrome::GetTotalBrowserCount());
 
   // Some browser startup tasks are scheduled to run in the first few minutes
@@ skipping 13 matching lines @@
   ExpectReporterLaunches(0, 1, false);
   ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
 }
 
 IN_PROC_BROWSER_TEST_P(SRTFetcherTest, RunDaily) {
   PrefService* local_state = g_browser_process->local_state();
   local_state->SetBoolean(prefs::kSwReporterPendingPrompt, true);
   SetDaysSinceLastTriggered(kDaysBetweenSuccessfulSwReporterRuns - 1);
   ASSERT_GT(kDaysBetweenSuccessfulSwReporterRuns - 1,
             kDaysBetweenSwReporterRunsForPendingPrompt);
-  RunReporter(kSwReporterNothingFound);
+  RunReporter(chrome_cleaner::kSwReporterNothingFound);
 
   // Expect the reporter to run immediately, since a prompt is pending and it
   // has been more than kDaysBetweenSwReporterRunsForPendingPrompt days.
   ExpectReporterLaunches(0, 1, false);
   ExpectToRunAgain(kDaysBetweenSwReporterRunsForPendingPrompt);
 
   // Move the clock ahead kDaysBetweenSwReporterRunsForPendingPrompt days. The
   // expected run should trigger, but not cause the reporter to launch because
   // a prompt is no longer pending.
   local_state->SetBoolean(prefs::kSwReporterPendingPrompt, false);
@@ skipping 15 matching lines @@
   const base::FilePath path1(L"path1");
   const base::FilePath path2(L"path2");
   const base::FilePath path3(L"path3");
 
   // Schedule path1 with a day left in the reporting period.
   // The reporter should not launch.
   constexpr int kDaysLeft = 1;
   {
     SCOPED_TRACE("N days left until next reporter run");
     SetDaysSinceLastTriggered(kDaysBetweenSuccessfulSwReporterRuns - kDaysLeft);
-    RunReporter(kSwReporterNothingFound, path1);
+    RunReporter(chrome_cleaner::kSwReporterNothingFound, path1);
     ExpectReporterLaunches(0, {}, false);
   }
 
   // Schedule path2 just as we enter the next reporting period.
   // Now the reporter should launch, just once, using path2.
   {
     SCOPED_TRACE("Reporter runs now");
-    RunReporter(kSwReporterNothingFound, path2);
+    RunReporter(chrome_cleaner::kSwReporterNothingFound, path2);
     // Schedule it twice; it should only actually run once.
-    RunReporter(kSwReporterNothingFound, path2);
+    RunReporter(chrome_cleaner::kSwReporterNothingFound, path2);
     ExpectReporterLaunches(kDaysLeft, {path2}, false);
   }
 
   // Schedule path3 before any more time has passed.
   // The reporter should not launch.
   {
     SCOPED_TRACE("No more time passed");
-    RunReporter(kSwReporterNothingFound, path3);
+    RunReporter(chrome_cleaner::kSwReporterNothingFound, path3);
     ExpectReporterLaunches(0, {}, false);
   }
 
   // Enter the next reporting period as path3 is still scheduled.
   // Now the reporter should launch again using path3. (Tests that the
   // parameters from the first launch aren't reused.)
   {
     SCOPED_TRACE("Previous run still scheduled");
     ExpectReporterLaunches(kDaysBetweenSuccessfulSwReporterRuns, {path3},
                            false);
   }
 
   // Schedule path3 again in the next reporting period.
   // The reporter should launch again using path3, since enough time has
   // passed, even though the parameters haven't changed.
   {
     SCOPED_TRACE("Run with same parameters");
-    RunReporter(kSwReporterNothingFound, path3);
+    RunReporter(chrome_cleaner::kSwReporterNothingFound, path3);
     ExpectReporterLaunches(kDaysBetweenSuccessfulSwReporterRuns, {path3},
                            false);
   }
 
   ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
 }
 
 IN_PROC_BROWSER_TEST_P(SRTFetcherTest, MultipleLaunches) {
   const base::FilePath path1(L"path1");
   const base::FilePath path2(L"path2");
   const base::FilePath path3(L"path3");
 
   SwReporterQueue invocations;
   invocations.push(SwReporterInvocation::FromFilePath(path1));
   invocations.push(SwReporterInvocation::FromFilePath(path2));
 
   {
     SCOPED_TRACE("Launch 2 times");
     SetDaysSinceLastTriggered(kDaysBetweenSuccessfulSwReporterRuns);
-    RunReporterQueue(kSwReporterNothingFound, invocations);
+    RunReporterQueue(chrome_cleaner::kSwReporterNothingFound, invocations);
     ExpectReporterLaunches(0, {path1, path2}, false);
     ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
   }
 
   // Schedule a launch with 2 elements, then another with the same 2. It should
   // just run 2 times, not 4.
   {
     SCOPED_TRACE("Launch 2 times with retry");
-    RunReporterQueue(kSwReporterNothingFound, invocations);
-    RunReporterQueue(kSwReporterNothingFound, invocations);
+    RunReporterQueue(chrome_cleaner::kSwReporterNothingFound, invocations);
+    RunReporterQueue(chrome_cleaner::kSwReporterNothingFound, invocations);
     ExpectReporterLaunches(kDaysBetweenSuccessfulSwReporterRuns, {path1, path2},
                            false);
     ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
   }
 
   // Another launch with 2 elements is already scheduled. Add a third while the
   // queue is running.
   {
     SCOPED_TRACE("Add third launch while running");
     invocations.push(SwReporterInvocation::FromFilePath(path3));
     first_launch_callback_ = base::BindOnce(
         &SRTFetcherTest::RunReporterQueue, base::Unretained(this),
-        kSwReporterNothingFound, invocations);
+        chrome_cleaner::kSwReporterNothingFound, invocations);
 
     // Only the first two elements should execute since the third was added
     // during the cycle.
     ExpectReporterLaunches(kDaysBetweenSuccessfulSwReporterRuns, {path1, path2},
                            false);
     ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
 
     // Time passes... Now the 3-element queue should run.
     ExpectReporterLaunches(kDaysBetweenSuccessfulSwReporterRuns,
                            {path1, path2, path3}, false);
@@ skipping 13 matching lines @@
     ExpectReporterLaunches(0, {}, false);
 
     // After enough time has passed, should try the queue again.
     ExpectReporterLaunches(kDaysBetweenSuccessfulSwReporterRuns, {path1},
                            false);
     ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
   }
 }
 
 IN_PROC_BROWSER_TEST_P(SRTFetcherTest, ReporterLogging_NoSBExtendedReporting) {
-  RunReporter(kSwReporterNothingFound);
+  RunReporter(chrome_cleaner::kSwReporterNothingFound);
   ExpectReporterLaunches(0, 1, false);
   ExpectLoggingSwitches(reporter_launch_parameters_.front(), false);
   ExpectLastTimeSentReportNotSet();
   ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
 }
 
 IN_PROC_BROWSER_TEST_P(SRTFetcherTest, ReporterLogging_EnabledFirstRun) {
   EnableSBExtendedReporting();
   // Note: don't set last time sent logs in the local state.
   // SBER is enabled and there is no record in the local state of the last time
   // logs have been sent, so we should send logs in this run.
-  RunReporter(kSwReporterNothingFound);
+  RunReporter(chrome_cleaner::kSwReporterNothingFound);
   ExpectReporterLaunches(0, 1, false);
   ExpectLoggingSwitches(reporter_launch_parameters_.front(), true);
   ExpectLastReportSentInTheLastHour();
   ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
 }
 
 IN_PROC_BROWSER_TEST_P(SRTFetcherTest, ReporterLogging_EnabledNoRecentLogging) {
   // SBER is enabled and last time logs were sent was more than
   // |kDaysBetweenReporterLogsSent| day ago, so we should send logs in this run.
   EnableSBExtendedReporting();
   SetLastTimeSentReport(kDaysBetweenReporterLogsSent + 3);
-  RunReporter(kSwReporterNothingFound);
+  RunReporter(chrome_cleaner::kSwReporterNothingFound);
   ExpectReporterLaunches(0, 1, false);
   ExpectLoggingSwitches(reporter_launch_parameters_.front(), true);
   ExpectLastReportSentInTheLastHour();
   ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
 }
 
 IN_PROC_BROWSER_TEST_P(SRTFetcherTest, ReporterLogging_EnabledRecentlyLogged) {
   // SBER is enabled, but logs have been sent less than
   // |kDaysBetweenReporterLogsSent| day ago, so we shouldn't send any logs in
   // this run.
   EnableSBExtendedReporting();
   SetLastTimeSentReport(kDaysBetweenReporterLogsSent - 1);
   int64_t last_time_sent_logs = GetLastTimeSentReport();
-  RunReporter(kSwReporterNothingFound);
+  RunReporter(chrome_cleaner::kSwReporterNothingFound);
   ExpectReporterLaunches(0, 1, false);
   ExpectLoggingSwitches(reporter_launch_parameters_.front(), false);
   EXPECT_EQ(last_time_sent_logs, GetLastTimeSentReport());
   ExpectToRunAgain(kDaysBetweenSuccessfulSwReporterRuns);
 }
 
 IN_PROC_BROWSER_TEST_P(SRTFetcherTest, ReporterLogging_MultipleLaunches) {
   EnableSBExtendedReporting();
   SetLastTimeSentReport(kDaysBetweenReporterLogsSent + 3);
 
   const base::FilePath path1(L"path1");
   const base::FilePath path2(L"path2");
   SwReporterQueue invocations;
   for (const auto& path : {path1, path2}) {
     auto invocation = SwReporterInvocation::FromFilePath(path);
     invocation.supported_behaviours =
         SwReporterInvocation::BEHAVIOUR_ALLOW_SEND_REPORTER_LOGS;
     invocations.push(invocation);
   }
-  RunReporterQueue(kSwReporterNothingFound, invocations);
+  RunReporterQueue(chrome_cleaner::kSwReporterNothingFound, invocations);
 
   // SBER is enabled and last time logs were sent was more than
   // |kDaysBetweenReporterLogsSent| day ago, so we should send logs in this run.
   {
     SCOPED_TRACE("first launch");
     first_launch_callback_ =
         base::BindOnce(&SRTFetcherTest::ExpectLastReportSentInTheLastHour,
                        base::Unretained(this));
     ExpectReporterLaunches(0, {path1, path2}, false);
     ExpectLoggingSwitches(reporter_launch_parameters_[0], true);
@@ skipping 28 matching lines @@
 // testing framework.
 IN_PROC_BROWSER_TEST_F(SRTFetcherPromptTest, InvokeDialog_SRTErrorNoFile) {
   RunDialog();
 }
 
 IN_PROC_BROWSER_TEST_F(SRTFetcherPromptTest, InvokeDialog_SRTErrorFile) {
   RunDialog();
 }
 
 }  // namespace safe_browsing