Move shared constants to //components/chrome_cleaner

chrome/browser/safe_browsing/srt_fetcher_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 <stdint.h>
 
 #include <algorithm>
 #include <memory>
@@ skipping 26 matching lines @@
 #include "chrome/browser/profiles/profile_io_data.h"
 #include "chrome/browser/safe_browsing/srt_chrome_prompt_impl.h"
 #include "chrome/browser/safe_browsing/srt_client_info_win.h"
 #include "chrome/browser/safe_browsing/srt_global_error_win.h"
 #include "chrome/browser/ui/browser_finder.h"
 #include "chrome/browser/ui/browser_list.h"
 #include "chrome/browser/ui/browser_list_observer.h"
 #include "chrome/browser/ui/global_error/global_error_service.h"
 #include "chrome/browser/ui/global_error/global_error_service_factory.h"
 #include "chrome/common/pref_names.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/data_use_measurement/core/data_use_user_data.h"
 #include "components/prefs/pref_service.h"
 #include "components/variations/net/variations_http_headers.h"
 #include "components/version_info/version_info.h"
 #include "content/public/browser/browser_thread.h"
 #include "mojo/edk/embedder/connection_params.h"
 #include "mojo/edk/embedder/pending_process_connection.h"
 #include "mojo/edk/embedder/platform_channel_pair.h"
 #include "mojo/public/cpp/system/message_pipe.h"
 #include "net/base/load_flags.h"
 #include "net/http/http_status_code.h"
 #include "net/url_request/url_fetcher.h"
 #include "net/url_request/url_fetcher_delegate.h"
 #include "net/url_request/url_request_context_getter.h"
 
 using content::BrowserThread;
 
 namespace safe_browsing {
 
-// TODO(b/647763) Change the registry key to properly handle cases when the user
-// runs Google Chrome stable alongside Google Chrome SxS.
-const wchar_t kSoftwareRemovalToolRegistryKey[] =
-    L"Software\\Google\\Software Removal Tool";
-
-const wchar_t kCleanerSubKey[] = L"Cleaner";
-
-const wchar_t kEndTimeValueName[] = L"EndTime";
-const wchar_t kStartTimeValueName[] = L"StartTime";
-
 const base::Feature kInBrowserCleanerUIFeature{
     "InBrowserCleanerUI", base::FEATURE_DISABLED_BY_DEFAULT};
 
-const char kChromeMojoPipeTokenSwitch[] = "chrome-mojo-pipe-token";
-
 namespace {
 
 // Used to send UMA information about missing start and end time registry
 // values for the reporter. Replicated in the histograms.xml file, so the order
 // MUST NOT CHANGE.
 enum SwReporterRunningTimeRegistryError {
   REPORTER_RUNNING_TIME_ERROR_NO_ERROR = 0,
   REPORTER_RUNNING_TIME_ERROR_REGISTRY_KEY_INVALID = 1,
   REPORTER_RUNNING_TIME_ERROR_MISSING_START_TIME = 2,
   REPORTER_RUNNING_TIME_ERROR_MISSING_END_TIME = 3,
@@ skipping 48 matching lines @@
   REPORTER_LOGS_UPLOAD_RESULT_ERROR_VALUE_NOT_FOUND = 2,
   REPORTER_LOGS_UPLOAD_RESULT_ERROR_VALUE_OUT_OF_BOUNDS = 3,
   REPORTER_LOGS_UPLOAD_RESULT_ERROR_MAX,
 };
 
 const char kRunningTimeErrorMetricName[] =
     "SoftwareReporter.RunningTimeRegistryError";
 
 SwReporterTestingDelegate* g_testing_delegate_ = nullptr;
 
-const wchar_t kScanTimesSubKey[] = L"ScanTimes";
-const wchar_t kFoundUwsValueName[] = L"FoundUws";
-const wchar_t kMemoryUsedValueName[] = L"MemoryUsed";
-const wchar_t kLogsUploadResultValueName[] = L"LogsUploadResult";
-const wchar_t kExitCodeValueName[] = L"ExitCode";
-const wchar_t kEngineErrorCodeValueName[] = L"EngineErrorCode";
-
 const char kFoundUwsMetricName[] = "SoftwareReporter.FoundUwS";
 const char kFoundUwsReadErrorMetricName[] =
     "SoftwareReporter.FoundUwSReadError";
 const char kScanTimesMetricName[] = "SoftwareReporter.UwSScanTimes";
 const char kMemoryUsedMetricName[] = "SoftwareReporter.MemoryUsed";
 const char kStepMetricName[] = "SoftwareReporter.Step";
 const char kLogsUploadEnabledMetricName[] =
     "SoftwareReporter.LogsUploadEnabled";
 const char kLogsUploadResultMetricName[] = "SoftwareReporter.LogsUploadResult";
 const char kLogsUploadResultRegistryErrorMetricName[] =
     "SoftwareReporter.LogsUploadResultRegistryError";
 const char kExitCodeMetricName[] = "SoftwareReporter.ExitCodeFromRegistry";
 const char kEngineErrorCodeMetricName[] = "SoftwareReporter.EngineErrorCode";
 
 // The max value for histogram SoftwareReporter.LogsUploadResult, which is used
 // to send UMA information about the result of Software Reporter's attempt to
 // upload logs, when logs are enabled. This value must be consistent with the
 // SoftwareReporterLogsUploadResult enum defined in the histograms.xml file.
 const int kSwReporterLogsUploadResultMax = 30;
 
 // Reports metrics about the software reporter via UMA (and sometimes Rappor).
 class UMAHistogramReporter {
  public:
   UMAHistogramReporter() : UMAHistogramReporter(std::string()) {}
 
   explicit UMAHistogramReporter(const std::string& suffix)
       : suffix_(suffix),
-        registry_key_(suffix.empty() ? kSoftwareRemovalToolRegistryKey
-                                     : base::StringPrintf(
-                                           L"%ls\\%ls",
-                                           kSoftwareRemovalToolRegistryKey,
-                                           base::UTF8ToUTF16(suffix).c_str())) {
-  }
+        registry_key_(suffix.empty()
+                          ? chrome_cleaner::kSoftwareRemovalToolRegistryKey
+                          : base::StringPrintf(
+                                L"%ls\\%ls",
+                                chrome_cleaner::kSoftwareRemovalToolRegistryKey,
+                                base::UTF8ToUTF16(suffix).c_str())) {}
 
   // Reports the software reporter tool's version via UMA.
   void ReportVersion(const base::Version& version) const {
     DCHECK(!version.components().empty());
     // The minor version is the 2nd last component of the version,
     // or just the first component if there is only 1.
     uint32_t minor_version = 0;
     if (version.components().size() > 1)
       minor_version = version.components()[version.components().size() - 2];
     else
@@ skipping 17 matching lines @@
   }
 
   void ReportExitCode(int exit_code) const {
     RecordSparseHistogram("SoftwareReporter.ExitCode", exit_code);
 
     // Also report the exit code that the reporter writes to the registry.
     base::win::RegKey reporter_key;
     DWORD exit_code_in_registry;
     if (reporter_key.Open(HKEY_CURRENT_USER, registry_key_.c_str(),
                           KEY_QUERY_VALUE | KEY_SET_VALUE) != ERROR_SUCCESS ||
-        reporter_key.ReadValueDW(kExitCodeValueName, &exit_code_in_registry) !=
-            ERROR_SUCCESS) {
+        reporter_key.ReadValueDW(chrome_cleaner::kExitCodeValueName,
+                                 &exit_code_in_registry) != ERROR_SUCCESS) {
       return;
     }
 
     RecordSparseHistogram(kExitCodeMetricName, exit_code_in_registry);
-    reporter_key.DeleteValue(kExitCodeValueName);
+    reporter_key.DeleteValue(chrome_cleaner::kExitCodeValueName);
   }
 
   void ReportEngineErrorCode() const {
     base::win::RegKey reporter_key;
     DWORD engine_error_code;
     if (reporter_key.Open(HKEY_CURRENT_USER, registry_key_.c_str(),
                           KEY_QUERY_VALUE | KEY_SET_VALUE) != ERROR_SUCCESS ||
-        reporter_key.ReadValueDW(kEngineErrorCodeValueName,
+        reporter_key.ReadValueDW(chrome_cleaner::kEngineErrorCodeValueName,
                                  &engine_error_code) != ERROR_SUCCESS) {
       return;
     }
 
     RecordSparseHistogram(kEngineErrorCodeMetricName, engine_error_code);
-    reporter_key.DeleteValue(kEngineErrorCodeValueName);
+    reporter_key.DeleteValue(chrome_cleaner::kEngineErrorCodeValueName);
   }
 
   // Reports UwS found by the software reporter tool via UMA and RAPPOR.
   void ReportFoundUwS() const {
     base::win::RegKey reporter_key;
     std::vector<base::string16> found_uws_strings;
     if (reporter_key.Open(HKEY_CURRENT_USER, registry_key_.c_str(),
                           KEY_QUERY_VALUE | KEY_SET_VALUE) != ERROR_SUCCESS ||
-        reporter_key.ReadValues(kFoundUwsValueName, &found_uws_strings) !=
-            ERROR_SUCCESS) {
+        reporter_key.ReadValues(chrome_cleaner::kFoundUwsValueName,
+                                &found_uws_strings) != ERROR_SUCCESS) {
       return;
     }
 
     bool parse_error = false;
     for (const base::string16& uws_string : found_uws_strings) {
       // All UwS ids are expected to be integers.
       uint32_t uws_id = 0;
       if (base::StringToUint(uws_string, &uws_id)) {
         RecordSparseHistogram(kFoundUwsMetricName, uws_id);
       } else {
         parse_error = true;
       }
     }
 
     // Clean up the old value.
-    reporter_key.DeleteValue(kFoundUwsValueName);
+    reporter_key.DeleteValue(chrome_cleaner::kFoundUwsValueName);
     RecordBooleanHistogram(kFoundUwsReadErrorMetricName, parse_error);
   }
 
   // Reports to UMA the memory usage of the software reporter tool as reported
   // by the tool itself in the Windows registry.
   void ReportMemoryUsage() const {
     base::win::RegKey reporter_key;
     DWORD memory_used = 0;
     if (reporter_key.Open(HKEY_CURRENT_USER, registry_key_.c_str(),
                           KEY_QUERY_VALUE | KEY_SET_VALUE) != ERROR_SUCCESS ||
-        reporter_key.ReadValueDW(kMemoryUsedValueName, &memory_used) !=
-            ERROR_SUCCESS) {
+        reporter_key.ReadValueDW(chrome_cleaner::kMemoryUsedValueName,
+                                 &memory_used) != ERROR_SUCCESS) {
       return;
     }
     RecordMemoryKBHistogram(kMemoryUsedMetricName, memory_used);
-    reporter_key.DeleteValue(kMemoryUsedValueName);
+    reporter_key.DeleteValue(chrome_cleaner::kMemoryUsedValueName);
   }
 
   // Reports the SwReporter run time with UMA both as reported by the tool via
   // the registry and as measured by |ReporterRunner|.
   void ReportRuntime(const base::TimeDelta& reporter_running_time) const {
     RecordLongTimesHistogram("SoftwareReporter.RunningTimeAccordingToChrome",
                              reporter_running_time);
 
     // TODO(b/641081): This should only have KEY_QUERY_VALUE and KEY_SET_VALUE.
     base::win::RegKey reporter_key;
     if (reporter_key.Open(HKEY_CURRENT_USER, registry_key_.c_str(),
                           KEY_ALL_ACCESS) != ERROR_SUCCESS) {
       RecordEnumerationHistogram(
           kRunningTimeErrorMetricName,
           REPORTER_RUNNING_TIME_ERROR_REGISTRY_KEY_INVALID,
           REPORTER_RUNNING_TIME_ERROR_MAX);
       return;
     }
 
     bool has_start_time = false;
     int64_t start_time_value = 0;
-    if (reporter_key.HasValue(kStartTimeValueName) &&
-        reporter_key.ReadInt64(kStartTimeValueName, &start_time_value) ==
-            ERROR_SUCCESS) {
+    if (reporter_key.HasValue(chrome_cleaner::kStartTimeValueName) &&
+        reporter_key.ReadInt64(chrome_cleaner::kStartTimeValueName,
+                               &start_time_value) == ERROR_SUCCESS) {
       has_start_time = true;
-      reporter_key.DeleteValue(kStartTimeValueName);
+      reporter_key.DeleteValue(chrome_cleaner::kStartTimeValueName);
     }
 
     bool has_end_time = false;
     int64_t end_time_value = 0;
-    if (reporter_key.HasValue(kEndTimeValueName) &&
-        reporter_key.ReadInt64(kEndTimeValueName, &end_time_value) ==
-            ERROR_SUCCESS) {
+    if (reporter_key.HasValue(chrome_cleaner::kEndTimeValueName) &&
+        reporter_key.ReadInt64(chrome_cleaner::kEndTimeValueName,
+                               &end_time_value) == ERROR_SUCCESS) {
       has_end_time = true;
-      reporter_key.DeleteValue(kEndTimeValueName);
+      reporter_key.DeleteValue(chrome_cleaner::kEndTimeValueName);
     }
 
     if (has_start_time && has_end_time) {
       base::TimeDelta registry_run_time =
           base::Time::FromInternalValue(end_time_value) -
           base::Time::FromInternalValue(start_time_value);
       RecordLongTimesHistogram("SoftwareReporter.RunningTime",
                                registry_run_time);
       RecordEnumerationHistogram(kRunningTimeErrorMetricName,
                                  REPORTER_RUNNING_TIME_ERROR_NO_ERROR,
@@ skipping 10 matching lines @@
       DCHECK(!has_end_time);
       RecordEnumerationHistogram(kRunningTimeErrorMetricName,
                                  REPORTER_RUNNING_TIME_ERROR_MISSING_END_TIME,
                                  REPORTER_RUNNING_TIME_ERROR_MAX);
     }
   }
 
   // Reports the UwS scan times of the software reporter tool via UMA.
   void ReportScanTimes() const {
     base::string16 scan_times_key_path = base::StringPrintf(
-        L"%ls\\%ls", registry_key_.c_str(), kScanTimesSubKey);
+        L"%ls\\%ls", registry_key_.c_str(), chrome_cleaner::kScanTimesSubKey);
     // TODO(b/641081): This should only have KEY_QUERY_VALUE and KEY_SET_VALUE.
     base::win::RegKey scan_times_key;
     if (scan_times_key.Open(HKEY_CURRENT_USER, scan_times_key_path.c_str(),
                             KEY_ALL_ACCESS) != ERROR_SUCCESS) {
       return;
     }
 
     base::string16 value_name;
     int uws_id = 0;
     int64_t raw_scan_time = 0;
@@ skipping 11 matching lines @@
         RecordSparseHistogramCount(kScanTimesMetricName, uws_id,
                                    scan_time.InSeconds() + 1);
       }
     }
     // Clean up by deleting the scan times key, which is a subkey of the main
     // reporter key.
     scan_times_key.Close();
     base::win::RegKey reporter_key;
     if (reporter_key.Open(HKEY_CURRENT_USER, registry_key_.c_str(),
                           KEY_ENUMERATE_SUB_KEYS) == ERROR_SUCCESS) {
-      reporter_key.DeleteKey(kScanTimesSubKey);
+      reporter_key.DeleteKey(chrome_cleaner::kScanTimesSubKey);
     }
   }
 
   void RecordReporterStep(SwReporterUmaValue value) {
     RecordEnumerationHistogram(kStepMetricName, value, SW_REPORTER_MAX);
   }
 
   void RecordLogsUploadEnabled(SwReporterLogsUploadsEnabled value) {
     RecordEnumerationHistogram(kLogsUploadEnabledMetricName, value,
                                REPORTER_LOGS_UPLOADS_MAX);
   }
 
   void RecordLogsUploadResult() {
     base::win::RegKey reporter_key;
     DWORD logs_upload_result = 0;
     if (reporter_key.Open(HKEY_CURRENT_USER, registry_key_.c_str(),
                           KEY_QUERY_VALUE | KEY_SET_VALUE) != ERROR_SUCCESS) {
       RecordEnumerationHistogram(
           kLogsUploadResultRegistryErrorMetricName,
           REPORTER_LOGS_UPLOAD_RESULT_ERROR_REGISTRY_KEY_INVALID,
           REPORTER_LOGS_UPLOAD_RESULT_ERROR_MAX);
       return;
     }
 
-    if (reporter_key.ReadValueDW(kLogsUploadResultValueName,
+    if (reporter_key.ReadValueDW(chrome_cleaner::kLogsUploadResultValueName,
                                  &logs_upload_result) != ERROR_SUCCESS) {
       RecordEnumerationHistogram(
           kLogsUploadResultRegistryErrorMetricName,
           REPORTER_LOGS_UPLOAD_RESULT_ERROR_VALUE_NOT_FOUND,
           REPORTER_LOGS_UPLOAD_RESULT_ERROR_MAX);
       return;
     }
 
     if (logs_upload_result >= kSwReporterLogsUploadResultMax) {
       RecordEnumerationHistogram(
           kLogsUploadResultRegistryErrorMetricName,
           REPORTER_LOGS_UPLOAD_RESULT_ERROR_VALUE_OUT_OF_BOUNDS,
           REPORTER_LOGS_UPLOAD_RESULT_ERROR_MAX);
       return;
     }
 
     RecordEnumerationHistogram(kLogsUploadResultMetricName,
                                static_cast<Sample>(logs_upload_result),
                                kSwReporterLogsUploadResultMax);
-    reporter_key.DeleteValue(kLogsUploadResultValueName);
+    reporter_key.DeleteValue(chrome_cleaner::kLogsUploadResultValueName);
     RecordEnumerationHistogram(kLogsUploadResultRegistryErrorMetricName,
                                REPORTER_LOGS_UPLOAD_RESULT_ERROR_NO_ERROR,
                                REPORTER_LOGS_UPLOAD_RESULT_ERROR_MAX);
   }
 
  private:
   using Sample = base::HistogramBase::Sample;
 
   static constexpr base::HistogramBase::Flags kUmaHistogramFlag =
       base::HistogramBase::kUmaTargetedHistogramFlag;
@@ skipping 215 matching lines @@
   }
 }
 
 base::Process SwReporterProcess::LaunchConnectedReporterProcess() {
   DCHECK(base::FeatureList::IsEnabled(kInBrowserCleanerUIFeature));
 
   mojo::edk::PendingProcessConnection pending_process_connection;
   std::string mojo_pipe_token;
   mojo::ScopedMessagePipeHandle mojo_pipe =
       pending_process_connection.CreateMessagePipe(&mojo_pipe_token);
-  invocation_.command_line.AppendSwitchASCII(kChromeMojoPipeTokenSwitch,
-                                             mojo_pipe_token);
+  invocation_.command_line.AppendSwitchASCII(
+      chrome_cleaner::kChromeMojoPipeTokenSwitch, mojo_pipe_token);
 
   mojo::edk::PlatformChannelPair channel;
   base::HandlesToInheritVector handles_to_inherit;
   channel.PrepareToPassClientHandleToChildProcess(&invocation_.command_line,
                                                   &handles_to_inherit);
 
   base::LaunchOptions launch_options;
   launch_options.handles_to_inherit = &handles_to_inherit;
   base::Process reporter_process =
       LaunchReporterProcess(invocation_, launch_options);
@@ skipping 317 matching lines @@
       return;
     }
 
     if (!IsInSRTPromptFieldTrialGroups()) {
       // Knowing about disabled field trial is more important than reporter not
       // finding anything to remove, so check this case first.
       RecordReporterStepHistogram(SW_REPORTER_NO_PROMPT_FIELD_TRIAL);
       return;
     }
 
-    if (exit_code != kSwReporterPostRebootCleanupNeeded &&
-        exit_code != kSwReporterCleanupNeeded) {
+    if (exit_code != chrome_cleaner::kSwReporterPostRebootCleanupNeeded &&
+        exit_code != chrome_cleaner::kSwReporterCleanupNeeded) {
       RecordReporterStepHistogram(SW_REPORTER_NO_PROMPT_NEEDED);
       return;
     }
 
     // Find the last active browser, which may be NULL, in which case we need
     // to wait for one to be available. We can't use other ways of finding a
     // browser because we don't have a profile. And we need a browser to get to
     // a profile, which we need, to tell whether we should prompt or not.
     // TODO(mad): crbug.com/503269, investigate whether we should change how we
     // decide when it's time to download the SRT and when to display the prompt.
@@ skipping 100 matching lines @@
       // Set the local state value before the first attempt to run the
       // reporter, because we only want to upload logs once in the window
       // defined by |kDaysBetweenReporterLogsSent|. If we set with other local
       // state values after the reporter runs, we could send logs again too
       // quickly (for example, if Chrome stops before the reporter finishes).
       local_state->SetInt64(prefs::kSwReporterLastTimeSentReport,
                             Now().ToInternalValue());
     }
 
     if (ChromeMetricsServiceAccessor::IsMetricsAndCrashReportingEnabled())
-      next_invocation->command_line.AppendSwitch(kEnableCrashReporting);
+      next_invocation->command_line.AppendSwitch(
+          chrome_cleaner::kEnableCrashReporting);
   }
 
   // Adds switches to be sent to the Software Reporter when the user opted into
   // extended Safe Browsing reporting and is not incognito.
   void AddSwitchesForExtendedReportingUser(SwReporterInvocation* invocation) {
-    invocation->command_line.AppendSwitch(kExtendedSafeBrowsingEnabledSwitch);
+    invocation->command_line.AppendSwitch(
+        chrome_cleaner::kExtendedSafeBrowsingEnabledSwitch);
     invocation->command_line.AppendSwitchASCII(
-        kChromeVersionSwitch, version_info::GetVersionNumber());
+        chrome_cleaner::kChromeVersionSwitch, version_info::GetVersionNumber());
     invocation->command_line.AppendSwitchNative(
-        kChromeChannelSwitch, base::IntToString16(ChannelAsInt()));
+        chrome_cleaner::kChromeChannelSwitch,
+        base::IntToString16(ChannelAsInt()));
   }
 
   bool first_run_ = true;
 
   // The queue of invocations that are currently running.
   SwReporterQueue current_invocations_;
 
   // The invocations to run next time the SwReporter is run.
   SwReporterQueue pending_invocations_;
 
@@ skipping 62 matching lines @@
   DCHECK(!invocations.empty());
   DCHECK(version.IsValid());
   ReporterRunner::ScheduleInvocations(invocations, version);
 }
 
 bool ReporterFoundUws() {
   PrefService* local_state = g_browser_process->local_state();
   if (!local_state)
     return false;
   int exit_code = local_state->GetInteger(prefs::kSwReporterLastExitCode);
-  return exit_code == kSwReporterCleanupNeeded;
+  return exit_code == chrome_cleaner::kSwReporterCleanupNeeded;
 }
 
 bool UserHasRunCleaner() {
-  base::string16 cleaner_key_path(kSoftwareRemovalToolRegistryKey);
-  cleaner_key_path.append(L"\\").append(kCleanerSubKey);
+  base::string16 cleaner_key_path(
+      chrome_cleaner::kSoftwareRemovalToolRegistryKey);
+  cleaner_key_path.append(L"\\").append(
+      chrome_cleaner::kCleanerSuffixRegistryKey);
 
   base::win::RegKey srt_cleaner_key;
   return srt_cleaner_key.Open(HKEY_CURRENT_USER, cleaner_key_path.c_str(),
                               KEY_QUERY_VALUE) == ERROR_SUCCESS &&
          srt_cleaner_key.GetValueCount() > 0;
 }
 
 void SetSwReporterTestingDelegate(SwReporterTestingDelegate* delegate) {
   g_testing_delegate_ = delegate;
 }
 
 }  // namespace safe_browsing