Integrate registry_hash_store_contents with the rest of tracked prefs.

components/user_prefs/tracked/registry_hash_store_contents_win.cc

 // Copyright (c) 2016 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/registry_hash_store_contents_win.h"
 
 #include <windows.h>
 
 #include "base/logging.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "base/win/registry.h"
 #include "components/user_prefs/tracked/tracked_preference_histogram_names.h"
 
 using base::win::RegistryValueIterator;
 
 namespace {
 
-constexpr size_t kMacSize = 32;
+constexpr size_t kMacSize = 64;
 
 base::string16 GetSplitPrefKeyName(const base::string16& reg_key_name,
                                    const std::string& split_key_name) {
   return reg_key_name + L"\\" + base::UTF8ToUTF16(split_key_name);
 }
 
 bool ReadMacFromRegistry(const base::win::RegKey& key,
                          const std::string& value_name,
                          std::string* out_mac) {
   base::string16 string_value;
@@ skipping 32 matching lines @@
   return false;
 }
 
 }  // namespace
 
 RegistryHashStoreContentsWin::RegistryHashStoreContentsWin(
     const base::string16& registry_path,
     const base::string16& store_key)
     : preference_key_name_(registry_path + L"\\PreferenceMACs\\" + store_key) {}
 
+RegistryHashStoreContentsWin::RegistryHashStoreContentsWin(
+    const base::string16& preference_key_name)
+    : preference_key_name_(preference_key_name) {}
+
+bool RegistryHashStoreContentsWin::IsCopyable() const {
+  return true;
+}
+
+std::unique_ptr<HashStoreContents> RegistryHashStoreContentsWin::MakeCopy()
+    const {
+  return std::unique_ptr<HashStoreContents>(
+      new RegistryHashStoreContentsWin(preference_key_name_));

[gab, 2016/09/16 19:47:33]

return base::MakeUnique<RegistryHashStoreContentsWin>(*this);

[proberge, 2016/09/20 21:35:45]

Done, but getting compiler errors on this line related to 
cannot access private member declared in class 'RegistryHashStoreContentsWin'

[gab, 2016/09/21 17:55:30]

Ah indeed because MakeUnique needs access to the constructor, oops, use
WrapUnique instead in such rare cases :
https://www.chromium.org/developers/coding-style/cpp-dos-and-donts#TOC-Prefer...

[proberge, 2016/09/21 21:09:24]

Done.

+}
+
 base::StringPiece RegistryHashStoreContentsWin::GetUMASuffix() const {
   return user_prefs::tracked::kTrackedPrefRegistryValidationSuffix;
 }
 
 void RegistryHashStoreContentsWin::Reset() {
   base::win::RegKey key;
   if (key.Open(HKEY_CURRENT_USER, preference_key_name_.c_str(),
                KEY_SET_VALUE | KEY_WOW64_32KEY) == ERROR_SUCCESS) {
     LONG result = key.DeleteKey(L"");
     DCHECK(result == ERROR_SUCCESS || result == ERROR_FILE_NOT_FOUND) << result;
@@ skipping 49 matching lines @@
 
   if (key.Create(HKEY_CURRENT_USER,
                  GetSplitPrefKeyName(preference_key_name_, path).c_str(),
                  KEY_SET_VALUE | KEY_WOW64_32KEY) == ERROR_SUCCESS) {
     key.WriteValue(base::UTF8ToUTF16(split_path).c_str(),
                    base::UTF8ToUTF16(value).c_str());
   }
 }
 
 bool RegistryHashStoreContentsWin::RemoveEntry(const std::string& path) {
-  // ClearSplitMac is first to avoid short-circuit issues.
   return ClearAtomicMac(preference_key_name_, path) ||
          ClearSplitMac(preference_key_name_, path);
 }
 
 void RegistryHashStoreContentsWin::ImportEntry(const std::string& path,
                                                const base::Value* in_value) {
   NOTREACHED()
-      << "RegistryHashStore does not support the ImportEntry operation";
+      << "RegistryHashStoreContents does not support the ImportEntry operation";
 }
 
 const base::DictionaryValue* RegistryHashStoreContentsWin::GetContents() const {
   NOTREACHED()
-      << "RegistryHashStore does not support the GetContents operation";
+      << "RegistryHashStoreContents does not support the GetContents operation";
   return NULL;
 }
 
 std::string RegistryHashStoreContentsWin::GetSuperMac() const {
   NOTREACHED()
-      << "RegistryHashStore does not support the GetSuperMac operation";
+      << "RegistryHashStoreContents does not support the GetSuperMac operation";
   return NULL;
 }
 
 void RegistryHashStoreContentsWin::SetSuperMac(const std::string& super_mac) {
   NOTREACHED()
-      << "RegistryHashStore does not support the SetSuperMac operation";
+      << "RegistryHashStoreContents does not support the SetSuperMac operation";
 }