Use GetDeterministicMachineSpecificId instead of RLZ for device_id

components/user_prefs/tracked/pref_hash_calculator.cc

 // Copyright 2013 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 "components/user_prefs/tracked/pref_hash_calculator.h"
 
 #include <stdint.h>
 
 #include <memory>
 #include <vector>
@@ skipping 61 matching lines @@
                        const std::string& path,
                        const std::string& value_as_string) {
   std::string message;
   message.reserve(device_id.size() + path.size() + value_as_string.size());
   message.append(device_id);
   message.append(path);
   message.append(value_as_string);
   return message;
 }
 
-// Generates a device ID based on the input device ID. The derived device ID has
-// no useful properties beyond those of the input device ID except that it is
-// consistent with previous implementations.
-// TODO(gab): Remove this once UMA reports for
-// Settings.TrackedPreferenceMigratedLegacyDeviceId become insignificant.
-std::string GenerateDeviceIdLikePrefMetricsServiceDid(
-    const std::string& original_device_id) {
-  if (original_device_id.empty())
-    return std::string();
-  return base::ToLowerASCII(
-      GetDigestString(original_device_id, "PrefMetricsService"));
-}
-
 }  // namespace
 
 PrefHashCalculator::PrefHashCalculator(const std::string& seed,
-                                       const std::string& device_id)
-    : seed_(seed),
-      device_id_(device_id),
-      legacy_device_id_(GenerateDeviceIdLikePrefMetricsServiceDid(device_id)) {
-}
+                                       const std::string& device_id,
+                                       const std::string& legacy_device_id)
+    : seed_(seed), device_id_(device_id), legacy_device_id_(legacy_device_id) {}
 
 PrefHashCalculator::~PrefHashCalculator() {
 }
 
 std::string PrefHashCalculator::Calculate(const std::string& path,
                                           const base::Value* value) const {
   return GetDigestString(seed_,
                          GetMessage(device_id_, path, ValueAsString(value)));
 }
 
 PrefHashCalculator::ValidationResult PrefHashCalculator::Validate(
     const std::string& path,
     const base::Value* value,
     const std::string& digest_string) const {
   const std::string value_as_string(ValueAsString(value));
   if (VerifyDigestString(seed_, GetMessage(device_id_, path, value_as_string),
                          digest_string)) {
     return VALID;
   }
   if (VerifyDigestString(seed_,
                          GetMessage(legacy_device_id_, path, value_as_string),
                          digest_string)) {
     return VALID_SECURE_LEGACY;
   }
   return INVALID;
 }