Integrate registry_hash_store_contents with the rest of tracked prefs.

components/user_prefs/tracked/pref_hash_store_impl.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_store_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/logging.h"
 #include "base/macros.h"
+#include "base/memory/ptr_util.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
 #include "components/user_prefs/tracked/hash_store_contents.h"
 #include "components/user_prefs/tracked/pref_hash_store_transaction.h"
 
 class PrefHashStoreImpl::PrefHashStoreTransactionImpl
     : public PrefHashStoreTransaction {
  public:
   // Constructs a PrefHashStoreTransactionImpl which can use the private
   // members of its |outer| PrefHashStoreImpl.
   PrefHashStoreTransactionImpl(PrefHashStoreImpl* outer,
                                std::unique_ptr<HashStoreContents> storage);
   ~PrefHashStoreTransactionImpl() override;
 
   // PrefHashStoreTransaction implementation.
+  HashStoreContentsType GetStoreType() const override;
   ValueState CheckValue(const std::string& path,
                         const base::Value* value) const override;
   void StoreHash(const std::string& path, const base::Value* value) override;
   ValueState CheckSplitValue(
       const std::string& path,
       const base::DictionaryValue* initial_split_value,
       std::vector<std::string>* invalid_keys) const override;
   void StoreSplitHash(const std::string& path,
                       const base::DictionaryValue* split_value) override;
   bool HasHash(const std::string& path) const override;
@@ skipping 20 matching lines @@
 
 PrefHashStoreImpl::~PrefHashStoreImpl() {
 }
 
 std::unique_ptr<PrefHashStoreTransaction> PrefHashStoreImpl::BeginTransaction(
     std::unique_ptr<HashStoreContents> storage) {
   return std::unique_ptr<PrefHashStoreTransaction>(
       new PrefHashStoreTransactionImpl(this, std::move(storage)));
 }
 
+std::unique_ptr<base::DictionaryValue> PrefHashStoreImpl::ComputeSplitMacs(
+    const std::string& path,
+    const base::DictionaryValue* split_values) {
+  if (!split_values)
+    return nullptr;
+
+  std::string keyed_path(path);
+  keyed_path.push_back('.');
+  const size_t common_part_length = keyed_path.length();
+
+  base::DictionaryValue* split_macs = new base::DictionaryValue;

[gab, 2016/08/03 18:19:36]

std::unique_ptr here instead of only wrapping it at the end

[proberge, 2016/08/04 00:13:46]

Done.

+
+  for (base::DictionaryValue::Iterator it(*split_values); !it.IsAtEnd();
+       it.Advance()) {
+    // Keep the common part from the old |keyed_path| and replace the key to
+    // get the new |keyed_path|.
+    keyed_path.replace(common_part_length, std::string::npos, it.key());
+
+    split_macs->SetString(it.key(), ComputeMac(keyed_path, &it.value()));

[gab, 2016/08/03 18:19:35]

SetStringWithoutPathExpansion

[proberge, 2016/08/04 00:13:46]

Done.

+  }
+
+  return base::WrapUnique(split_macs);
+}
+
+std::string PrefHashStoreImpl::ComputeMac(const std::string& path,

[gab, 2016/08/03 18:19:35]

Same order as in header (this method before ComputeSplitMacs())

[proberge, 2016/08/04 00:13:46]

Done.

+                                          const base::Value* new_value) {
+  return pref_hash_calculator_.Calculate(path, new_value);
+}
+
 PrefHashStoreImpl::PrefHashStoreTransactionImpl::PrefHashStoreTransactionImpl(
     PrefHashStoreImpl* outer,
     std::unique_ptr<HashStoreContents> storage)
     : outer_(outer),
       contents_(std::move(storage)),
       super_mac_valid_(false),
       super_mac_dirty_(false) {
   if (!outer_->use_super_mac_)
     return;
 
   // The store must have a valid super MAC to be trusted.
   std::string super_mac = contents_->GetSuperMac();
   if (super_mac.empty())
     return;
 
   super_mac_valid_ =
       outer_->pref_hash_calculator_.Validate(
           "", contents_->GetContents(), super_mac) == PrefHashCalculator::VALID;
 }
 
 PrefHashStoreImpl::PrefHashStoreTransactionImpl::
     ~PrefHashStoreTransactionImpl() {
   if (super_mac_dirty_ && outer_->use_super_mac_) {
     // Get the dictionary of hashes (or NULL if it doesn't exist).
     const base::DictionaryValue* hashes_dict = contents_->GetContents();
-    contents_->SetSuperMac(
-        outer_->pref_hash_calculator_.Calculate("", hashes_dict));
+    contents_->SetSuperMac(outer_->ComputeMac("", hashes_dict));
   }
 }
 
+HashStoreContentsType
+PrefHashStoreImpl::PrefHashStoreTransactionImpl::GetStoreType() const {
+  return contents_->GetType();
+}
+
 PrefHashStoreTransaction::ValueState
 PrefHashStoreImpl::PrefHashStoreTransactionImpl::CheckValue(
     const std::string& path,
     const base::Value* initial_value) const {
   std::string last_hash;
   contents_->GetMac(path, &last_hash);
 
   if (last_hash.empty()) {
     // In the absence of a hash for this pref, always trust a NULL value, but
     // only trust an existing value if the initial hashes dictionary is trusted.
@@ skipping 16 matching lines @@
       return initial_value ? CHANGED : CLEARED;
   }
   NOTREACHED() << "Unexpected PrefHashCalculator::ValidationResult: "
                << validation_result;
   return UNTRUSTED_UNKNOWN_VALUE;
 }
 
 void PrefHashStoreImpl::PrefHashStoreTransactionImpl::StoreHash(
     const std::string& path,
     const base::Value* new_value) {
-  const std::string mac =
-      outer_->pref_hash_calculator_.Calculate(path, new_value);
+  const std::string mac = outer_->ComputeMac(path, new_value);
   contents_->SetMac(path, mac);
   super_mac_dirty_ = true;
 }
 
 PrefHashStoreTransaction::ValueState
 PrefHashStoreImpl::PrefHashStoreTransactionImpl::CheckSplitValue(
     const std::string& path,
     const base::DictionaryValue* initial_split_value,
     std::vector<std::string>* invalid_keys) const {
   DCHECK(invalid_keys && invalid_keys->empty());
@@ skipping 55 matching lines @@
              ? (has_secure_legacy_id_hashes ? SECURE_LEGACY : UNCHANGED)
              : CHANGED;
 }
 
 void PrefHashStoreImpl::PrefHashStoreTransactionImpl::StoreSplitHash(
     const std::string& path,
     const base::DictionaryValue* split_value) {
   contents_->RemoveEntry(path);
 
   if (split_value) {
-    std::string keyed_path(path);
-    keyed_path.push_back('.');
-    const size_t common_part_length = keyed_path.length();
-    for (base::DictionaryValue::Iterator it(*split_value); !it.IsAtEnd();
+    std::unique_ptr<base::DictionaryValue> split_macs =
+        outer_->ComputeSplitMacs(path, split_value);
+
+    for (base::DictionaryValue::Iterator it(*split_macs); !it.IsAtEnd();
          it.Advance()) {
-      // Keep the common part from the old |keyed_path| and replace the key to
-      // get the new |keyed_path|.
-      keyed_path.replace(common_part_length, std::string::npos, it.key());
-      contents_->SetSplitMac(
-          path, it.key(),
-          outer_->pref_hash_calculator_.Calculate(keyed_path, &it.value()));
+      std::string mac;
+      bool is_string = it.value().GetAsString(&mac);

[gab, 2016/08/03 18:19:35]

Too bad that we now have an extra string copy, I guess this is the fault of
values.h for not exposing something like GetAsStringPiece() for users not caring
for an actual copy... oh well, fine for now (assuming we don't see a regressions
in timing stats).

[proberge, 2016/08/04 00:13:46]

Tried some StringValue shenanigans. From my reading this ends up not copying the
string, but I'm not 100% sure. 

[gab, 2016/08/08 04:37:44]

Yes, your method of getting the underlying StringValue* and then using its
GetString method to get a const& out of it is the way to avoid the copy, yay :-)

+      DCHECK(is_string);
+
+      contents_->SetSplitMac(path, it.key(), mac);
     }
   }
   super_mac_dirty_ = true;
 }
 
 bool PrefHashStoreImpl::PrefHashStoreTransactionImpl::HasHash(
     const std::string& path) const {
   std::string out_value;
   std::map<std::string, std::string> out_values;
   return contents_->GetMac(path, &out_value) ||
@@ skipping 21 matching lines @@
 bool PrefHashStoreImpl::PrefHashStoreTransactionImpl::IsSuperMACValid() const {
   return super_mac_valid_;
 }
 
 bool PrefHashStoreImpl::PrefHashStoreTransactionImpl::StampSuperMac() {
   if (!outer_->use_super_mac_ || super_mac_valid_)
     return false;
   super_mac_dirty_ = true;
   return true;
 }