Move shared constants to //components/chrome_cleaner

chrome/browser/component_updater/sw_reporter_installer_win.cc

 // Copyright (c) 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/component_updater/sw_reporter_installer_win.h"
 
 #include <stdint.h>
 
 #include <algorithm>
 #include <map>
@@ skipping 18 matching lines @@
 #include "base/strings/string_tokenizer.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/time/time.h"
 #include "base/win/registry.h"
 #include "base/win/windows_version.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/safe_browsing/srt_fetcher_win.h"
 #include "chrome/browser/safe_browsing/srt_field_trial_win.h"
+#include "components/chrome_cleaner/public/constants/constants.h"
 #include "components/component_updater/component_updater_paths.h"
 #include "components/component_updater/component_updater_service.h"
 #include "components/component_updater/pref_names.h"
 #include "components/pref_registry/pref_registry_syncable.h"
 #include "components/prefs/pref_registry_simple.h"
 #include "components/update_client/update_client.h"
 #include "components/update_client/utils.h"
 #include "components/variations/variations_associated_data.h"
 #include "content/public/browser/browser_thread.h"
 
@@ skipping 16 matching lines @@
 // generated in Python with something like this:
 // hashlib.sha256().update(open("<file>.crx").read()[16:16+294]).digest().
 const uint8_t kSha256Hash[] = {0x6a, 0xc6, 0x0e, 0xe8, 0xf3, 0x97, 0xc0, 0xd6,
                                0xf4, 0xc9, 0x78, 0x6c, 0x0c, 0x24, 0x73, 0x3e,
                                0x05, 0xa5, 0x62, 0x4b, 0x2e, 0xc7, 0xb7, 0x1c,
                                0x5f, 0xea, 0xf0, 0x88, 0xf6, 0x97, 0x9b, 0xc7};
 
 const base::FilePath::CharType kSwReporterExeName[] =
     FILE_PATH_LITERAL("software_reporter_tool.exe");
 
-constexpr char kSessionIdSwitch[] = "session-id";
-
-// SRT registry keys and value names.
-const wchar_t kCleanerSuffixRegistryKey[] = L"Cleaner";
-const wchar_t kExitCodeValueName[] = L"ExitCode";
-const wchar_t kUploadResultsValueName[] = L"UploadResults";
-const wchar_t kVersionValueName[] = L"Version";
-
 constexpr base::Feature kExperimentalEngineFeature{
     "ExperimentalSwReporterEngine", base::FEATURE_DISABLED_BY_DEFAULT};
 constexpr base::Feature kExperimentalEngineAllArchsFeature{
     "ExperimentalSwReporterEngineOnAllArchitectures",
     base::FEATURE_DISABLED_BY_DEFAULT
 };
 
 void SRTHasCompleted(SRTCompleted value) {
   UMA_HISTOGRAM_ENUMERATION("SoftwareReporter.Cleaner.HasCompleted", value,
                             SRT_COMPLETED_MAX);
@@ skipping 151 matching lines @@
         ReportExperimentError(SW_REPORTER_EXPERIMENT_ERROR_BAD_PARAMS);
         return;
       }
       if (!argument.empty())
         argv.push_back(argument);
     }
 
     base::CommandLine command_line(argv);
 
     // Add a random session id to link experimental reporter runs together.
-    command_line.AppendSwitchASCII(kSessionIdSwitch, session_id);
+    command_line.AppendSwitchASCII(chrome_cleaner::kSessionIdSwitch,
+                                   session_id);
 
     const std::string experiment_group =
         variations::GetVariationParamValueByFeature(
             kExperimentalEngineFeature, "experiment_group_for_reporting");
     command_line.AppendSwitchNative("engine-experiment-group",
                                     experiment_group.empty()
                                         ? L"missing_experiment_group"
                                         : base::UTF8ToUTF16(experiment_group));
 
     // Add the histogram suffix to the command-line as well, so that the
@@ skipping 58 matching lines @@
     const base::Version& version,
     const base::FilePath& install_dir,
     std::unique_ptr<base::DictionaryValue> manifest) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   const base::FilePath exe_path(install_dir.Append(kSwReporterExeName));
   if (IsExperimentalEngineEnabled()) {
     RunExperimentalSwReporter(exe_path, version, std::move(manifest),
                               reporter_runner_);
   } else {
     base::CommandLine command_line(exe_path);
-    command_line.AppendSwitchASCII(kSessionIdSwitch, GenerateSessionId());
+    command_line.AppendSwitchASCII(chrome_cleaner::kSessionIdSwitch,
+                                   GenerateSessionId());
     auto invocation = SwReporterInvocation::FromCommandLine(command_line);
     invocation.supported_behaviours =
         SwReporterInvocation::BEHAVIOUR_LOG_EXIT_CODE_TO_PREFS |
         SwReporterInvocation::BEHAVIOUR_TRIGGER_PROMPT |
         SwReporterInvocation::BEHAVIOUR_ALLOW_SEND_REPORTER_LOGS;
 
     safe_browsing::SwReporterQueue invocations;
     invocations.push(invocation);
     reporter_runner_.Run(invocations, version);
   }
@@ skipping 46 matching lines @@
   return is_experimental_engine_supported_ &&
          base::FeatureList::IsEnabled(kExperimentalEngineFeature);
 }
 
 void RegisterSwReporterComponent(ComponentUpdateService* cus) {
   if (!safe_browsing::IsSwReporterEnabled())
     return;
 
   // Check if we have information from Cleaner and record UMA statistics.
   base::string16 cleaner_key_name(
-      safe_browsing::kSoftwareRemovalToolRegistryKey);
-  cleaner_key_name.append(1, L'\\').append(kCleanerSuffixRegistryKey);
+      chrome_cleaner::kSoftwareRemovalToolRegistryKey);
+  cleaner_key_name.append(1, L'\\').append(chrome_cleaner::kCleanerSubKey);
   base::win::RegKey cleaner_key(
       HKEY_CURRENT_USER, cleaner_key_name.c_str(), KEY_ALL_ACCESS);
   // Cleaner is assumed to have run if we have a start time.
   if (cleaner_key.Valid()) {
-    if (cleaner_key.HasValue(safe_browsing::kStartTimeValueName)) {
+    if (cleaner_key.HasValue(chrome_cleaner::kStartTimeValueName)) {
       // Get version number.
-      if (cleaner_key.HasValue(kVersionValueName)) {
+      if (cleaner_key.HasValue(chrome_cleaner::kVersionValueName)) {
         DWORD version;
-        cleaner_key.ReadValueDW(kVersionValueName, &version);
+        cleaner_key.ReadValueDW(chrome_cleaner::kVersionValueName, &version);
         UMA_HISTOGRAM_SPARSE_SLOWLY("SoftwareReporter.Cleaner.Version",
                                     version);
-        cleaner_key.DeleteValue(kVersionValueName);
+        cleaner_key.DeleteValue(chrome_cleaner::kVersionValueName);
       }
       // Get start & end time. If we don't have an end time, we can assume the
       // cleaner has not completed.
       int64_t start_time_value;
-      cleaner_key.ReadInt64(safe_browsing::kStartTimeValueName,
+      cleaner_key.ReadInt64(chrome_cleaner::kStartTimeValueName,
                             &start_time_value);
 
-      bool completed = cleaner_key.HasValue(safe_browsing::kEndTimeValueName);
+      bool completed = cleaner_key.HasValue(chrome_cleaner::kEndTimeValueName);
       SRTHasCompleted(completed ? SRT_COMPLETED_YES : SRT_COMPLETED_NOT_YET);
       if (completed) {
         int64_t end_time_value;
-        cleaner_key.ReadInt64(safe_browsing::kEndTimeValueName,
+        cleaner_key.ReadInt64(chrome_cleaner::kEndTimeValueName,
                               &end_time_value);
-        cleaner_key.DeleteValue(safe_browsing::kEndTimeValueName);
+        cleaner_key.DeleteValue(chrome_cleaner::kEndTimeValueName);
         base::TimeDelta run_time(
             base::Time::FromInternalValue(end_time_value) -
             base::Time::FromInternalValue(start_time_value));
         UMA_HISTOGRAM_LONG_TIMES("SoftwareReporter.Cleaner.RunningTime",
                                  run_time);
       }
       // Get exit code. Assume nothing was found if we can't read the exit code.
-      DWORD exit_code = safe_browsing::kSwReporterNothingFound;
-      if (cleaner_key.HasValue(kExitCodeValueName)) {
-        cleaner_key.ReadValueDW(kExitCodeValueName, &exit_code);
+      DWORD exit_code = chrome_cleaner::kSwReporterNothingFound;
+      if (cleaner_key.HasValue(chrome_cleaner::kExitCodeValueName)) {
+        cleaner_key.ReadValueDW(chrome_cleaner::kExitCodeValueName, &exit_code);
         UMA_HISTOGRAM_SPARSE_SLOWLY("SoftwareReporter.Cleaner.ExitCode",
                                     exit_code);
-        cleaner_key.DeleteValue(kExitCodeValueName);
+        cleaner_key.DeleteValue(chrome_cleaner::kExitCodeValueName);
       }
-      cleaner_key.DeleteValue(safe_browsing::kStartTimeValueName);
+      cleaner_key.DeleteValue(chrome_cleaner::kStartTimeValueName);
 
-      if (exit_code == safe_browsing::kSwReporterPostRebootCleanupNeeded ||
+      if (exit_code == chrome_cleaner::kSwReporterPostRebootCleanupNeeded ||
           exit_code ==
-              safe_browsing::kSwReporterDelayedPostRebootCleanupNeeded) {
+              chrome_cleaner::kSwReporterDelayedPostRebootCleanupNeeded) {
         // Check if we are running after the user has rebooted.
         base::TimeDelta elapsed(
             base::Time::Now() -
             base::Time::FromInternalValue(start_time_value));
         DCHECK_GT(elapsed.InMilliseconds(), 0);
         UMA_HISTOGRAM_BOOLEAN(
             "SoftwareReporter.Cleaner.HasRebooted",
             static_cast<uint64_t>(elapsed.InMilliseconds()) > ::GetTickCount());
       }
 
-      if (cleaner_key.HasValue(kUploadResultsValueName)) {
+      if (cleaner_key.HasValue(chrome_cleaner::kUploadResultsValueName)) {
         base::string16 upload_results;
-        cleaner_key.ReadValue(kUploadResultsValueName, &upload_results);
+        cleaner_key.ReadValue(chrome_cleaner::kUploadResultsValueName,
+                              &upload_results);
         ReportUploadsWithUma(upload_results);
       }
     } else {
-      if (cleaner_key.HasValue(safe_browsing::kEndTimeValueName)) {
+      if (cleaner_key.HasValue(chrome_cleaner::kEndTimeValueName)) {
         SRTHasCompleted(SRT_COMPLETED_LATER);
-        cleaner_key.DeleteValue(safe_browsing::kEndTimeValueName);
+        cleaner_key.DeleteValue(chrome_cleaner::kEndTimeValueName);
       }
     }
   }
 
   // If the experiment is not explicitly enabled on all platforms, it
   // should be only enabled on x86. There's no way to check this in the
   // variations config so we'll hard-code it.
   const bool is_x86_architecture =
       base::win::OSInfo::GetInstance()->architecture() ==
       base::win::OSInfo::X86_ARCHITECTURE;
@@ skipping 19 matching lines @@
 }
 
 void RegisterProfilePrefsForSwReporter(
     user_prefs::PrefRegistrySyncable* registry) {
   registry->RegisterStringPref(prefs::kSwReporterPromptVersion, "");
 
   registry->RegisterStringPref(prefs::kSwReporterPromptSeed, "");
 }
 
 }  // namespace component_updater