Move shared constants to //components/chrome_cleaner

chrome/browser/safe_browsing/srt_global_error_win.cc

 // Copyright 2014 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_global_error_win.h"
 
 #include "base/base_paths.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 11 matching lines @@
 #include "chrome/browser/metrics/chrome_metrics_service_accessor.h"
 #include "chrome/browser/safe_browsing/srt_client_info_win.h"
 #include "chrome/browser/safe_browsing/srt_field_trial_win.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/global_error/global_error_service.h"
 #include "chrome/common/channel_info.h"
 #include "chrome/grit/chromium_strings.h"
 #include "chrome/grit/generated_resources.h"
 #include "chrome/installer/util/install_util.h"
+#include "components/chrome_cleaner/public/constants/constants.h"
 #include "components/component_updater/pref_names.h"
 #include "components/prefs/pref_service.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/base/l10n/l10n_util.h"
 
 using base::SingleThreadTaskRunner;
 using base::ThreadTaskRunnerHandle;
 using content::BrowserThread;
 
 namespace safe_browsing {
 
 namespace {
 
 // Used as a backup plan in case the SRT executable was not successfully
 // downloaded or run.
 const char kSRTDownloadURL[] =
     "https://www.google.com/chrome/srt/?chrome-prompt=1";
 
 // The extension to use to replace the temporary one created when the SRT was
 // downloaded.
 const base::FilePath::CharType kExecutableExtension[] = L"exe";
 
-// Switches to add to the command line when executing the SRT.
-const char kChromePromptSwitch[] = "chrome-prompt";
-const char kChromeExePathSwitch[] = "chrome-exe-path";
-const char kChromeSystemInstallSwitch[] = "chrome-system-install";
-const char kUmaUserSwitch[] = "uma-user";
-
-// Values to be passed to the kChromePromptSwitch of the Chrome Cleanup Tool to
-// indicate how the user interacted with the accept button.
-enum class ChromePromptValue {
-  // The user accepted the prompt when the prompt was first shown.
-  kPrompted = 3,
-  // The user accepted the prompt after navigating to it from the menu.
-  kShownFromMenu = 4
-};
-
 void MaybeExecuteSRTFromBlockingPool(
     const base::FilePath& downloaded_path,
     bool metrics_enabled,
     bool sber_enabled,
-    ChromePromptValue prompt_value,
+    chrome_cleaner::ChromePromptValue prompt_value,
     const scoped_refptr<SingleThreadTaskRunner>& task_runner,
     const base::Closure& success_callback,
     const base::Closure& failure_callback) {
   DCHECK(!downloaded_path.empty());
 
   if (base::PathExists(downloaded_path)) {
     base::FilePath executable_path(
         downloaded_path.ReplaceExtension(kExecutableExtension));
     if (base::ReplaceFile(downloaded_path, executable_path, nullptr)) {
       base::CommandLine srt_command_line(executable_path);
       srt_command_line.AppendSwitchASCII(
-          kChromePromptSwitch,
+          chrome_cleaner::kChromePromptSwitch,
           base::IntToString(static_cast<int>(prompt_value)));
-      srt_command_line.AppendSwitchASCII(kChromeVersionSwitch,
+      srt_command_line.AppendSwitchASCII(chrome_cleaner::kChromeVersionSwitch,
                                          version_info::GetVersionNumber());
-      srt_command_line.AppendSwitchASCII(kChromeChannelSwitch,
+      srt_command_line.AppendSwitchASCII(chrome_cleaner::kChromeChannelSwitch,
                                          base::IntToString(ChannelAsInt()));
 
       base::FilePath chrome_exe_path;
       PathService::Get(base::FILE_EXE, &chrome_exe_path);
-      srt_command_line.AppendSwitchPath(kChromeExePathSwitch, chrome_exe_path);
+      srt_command_line.AppendSwitchPath(chrome_cleaner::kChromeExePathSwitch,
+                                        chrome_exe_path);
       if (!InstallUtil::IsPerUserInstall())
-        srt_command_line.AppendSwitch(kChromeSystemInstallSwitch);
+        srt_command_line.AppendSwitch(
+            chrome_cleaner::kChromeSystemInstallSwitch);
 
       if (metrics_enabled) {
-        srt_command_line.AppendSwitch(kUmaUserSwitch);
-        srt_command_line.AppendSwitch(kEnableCrashReporting);
+        srt_command_line.AppendSwitch(chrome_cleaner::kUmaUserSwitch);
+        srt_command_line.AppendSwitch(
+            chrome_cleaner::kEnableCrashReportingSwitch);
       }
 
       if (sber_enabled)
-        srt_command_line.AppendSwitch(kExtendedSafeBrowsingEnabledSwitch);
+        srt_command_line.AppendSwitch(
+            chrome_cleaner::kExtendedSafeBrowsingEnabledSwitch);
 
       base::Process srt_process(
           base::LaunchProcess(srt_command_line, base::LaunchOptions()));
       if (srt_process.IsValid()) {
         task_runner->PostTask(FROM_HERE, success_callback);
         return;
       }
     }
   }
 
@@ skipping 110 matching lines @@
 
 void SRTGlobalError::MaybeExecuteSRT() {
   if (downloaded_path_.empty()) {
     FallbackToDownloadPage();
     return;
   }
   // At this point, this object owns itself, since ownership has been taken back
   // from the global_error_service_ in the call to OnUserInteractionStarted.
   // This means that it is safe to use base::Unretained here.
   base::PostTaskWithTraits(
-      FROM_HERE, base::TaskTraits().MayBlock().WithPriority(
-                     base::TaskPriority::BACKGROUND),
+      FROM_HERE,
+      base::TaskTraits().MayBlock().WithPriority(
+          base::TaskPriority::BACKGROUND),
       base::Bind(
           &MaybeExecuteSRTFromBlockingPool, downloaded_path_,
           ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled(),
           SafeBrowsingExtendedReportingEnabled(),
-          bubble_shown_from_menu_ ? ChromePromptValue::kShownFromMenu
-                                  : ChromePromptValue::kPrompted,
+          bubble_shown_from_menu_
+              ? chrome_cleaner::ChromePromptValue::kShownFromMenu
+              : chrome_cleaner::ChromePromptValue::kPrompted,
           base::ThreadTaskRunnerHandle::Get(),
           base::Bind(&SRTGlobalError::OnUserinteractionDone,
                      base::Unretained(this)),
           base::Bind(&SRTGlobalError::FallbackToDownloadPage,
                      base::Unretained(this))));
 }
 
 void SRTGlobalError::FallbackToDownloadPage() {
   RecordSRTPromptHistogram(SRT_PROMPT_FALLBACK);
 
@@ skipping 29 matching lines @@
 void SRTGlobalError::OnUserinteractionDone() {
   DCHECK(interacted_);
   // Once the user interacted with the bubble, we can forget about any pending
   // prompt.
   g_browser_process->local_state()->SetBoolean(prefs::kSwReporterPendingPrompt,
                                                false);
   delete this;
 }
 
 }  // namespace safe_browsing