Componentize //chrome/browser/prefs/tracked.

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 "chrome/browser/prefs/tracked/pref_hash_store_impl.h"
+#include "components/user_prefs/tracked/pref_hash_store_impl.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/values.h"
-#include "chrome/browser/prefs/tracked/hash_store_contents.h"
-#include "chrome/browser/prefs/tracked/pref_hash_store_transaction.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,
                                scoped_ptr<HashStoreContents> storage);
   ~PrefHashStoreTransactionImpl() override;
 
@@ skipping 34 matching lines @@
 
   bool super_mac_valid_;
   bool super_mac_dirty_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefHashStoreTransactionImpl);
 };
 
 PrefHashStoreImpl::PrefHashStoreImpl(const std::string& seed,
                                      const std::string& device_id,
                                      bool use_super_mac)
-    : pref_hash_calculator_(seed, device_id),
-      use_super_mac_(use_super_mac) {
+    : pref_hash_calculator_(seed, device_id), use_super_mac_(use_super_mac) {
 }
 
 PrefHashStoreImpl::~PrefHashStoreImpl() {
 }
 
 void PrefHashStoreImpl::set_legacy_hash_store_contents(
     scoped_ptr<HashStoreContents> legacy_hash_store_contents) {
   legacy_hash_store_contents_ = legacy_hash_store_contents.Pass();
 }
 
@@ skipping 16 matching lines @@
   // The store must be initialized and have a valid super MAC to be trusted.
 
   const base::DictionaryValue* store_contents = contents()->GetContents();
   if (!store_contents)
     return;
 
   std::string super_mac = contents()->GetSuperMac();
   if (super_mac.empty())
     return;
 
-  super_mac_valid_ =
-      outer_->pref_hash_calculator_.Validate(
-          contents()->hash_store_id(), store_contents, super_mac) ==
-      PrefHashCalculator::VALID;
+  super_mac_valid_ = outer_->pref_hash_calculator_.Validate(
+                         contents()->hash_store_id(), store_contents,
+                         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(
         contents()->hash_store_id(), hashes_dict));
   }
@@ skipping 70 matching lines @@
   for (base::DictionaryValue::Iterator it(*initial_split_value); !it.IsAtEnd();
        it.Advance()) {
     std::map<std::string, std::string>::iterator entry =
         split_macs.find(it.key());
     if (entry == split_macs.end()) {
       invalid_keys->push_back(it.key());
     } else {
       // 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());
-      switch (outer_->pref_hash_calculator_.Validate(
-          keyed_path, &it.value(), entry->second)) {
+      switch (outer_->pref_hash_calculator_.Validate(keyed_path, &it.value(),
+                                                     entry->second)) {
         case PrefHashCalculator::VALID:
           break;
         case SECURE_LEGACY:
           // Secure legacy device IDs based hashes are still accepted, but we
           // should make sure to notify the caller for him to update the legacy
           // hashes.
           has_secure_legacy_id_hashes = true;
           break;
         case PrefHashCalculator::INVALID:
           invalid_keys->push_back(it.key());
           break;
       }
       // Remove processed MACs, remaining MACs at the end will also be
       // considered invalid.
       split_macs.erase(entry);
     }
   }
 
   // Anything left in the map is missing from the data.
   for (std::map<std::string, std::string>::const_iterator it =
            split_macs.begin();
-       it != split_macs.end();
-       ++it) {
+       it != split_macs.end(); ++it) {
     invalid_keys->push_back(it->first);
   }
 
   return invalid_keys->empty()
              ? (has_secure_legacy_id_hashes ? SECURE_LEGACY : UNCHANGED)
              : CHANGED;
 }
 
 void PrefHashStoreImpl::PrefHashStoreTransactionImpl::StoreSplitHash(
     const std::string& path,
     const base::DictionaryValue* split_value) {
   scoped_ptr<HashStoreContents::MutableDictionary> mutable_dictionary =
       contents()->GetMutableContents();
   (*mutable_dictionary)->Remove(path, NULL);
 
   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();
          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());
-      (*mutable_dictionary)->SetString(
-          keyed_path,
-          outer_->pref_hash_calculator_.Calculate(keyed_path, &it.value()));
+      (*mutable_dictionary)
+          ->SetString(keyed_path, outer_->pref_hash_calculator_.Calculate(
+                                      keyed_path, &it.value()));
     }
   }
   super_mac_dirty_ = true;
 }
 
 bool PrefHashStoreImpl::PrefHashStoreTransactionImpl::GetSplitMacs(
     const std::string& key,
     std::map<std::string, std::string>* split_macs) const {
   DCHECK(split_macs);
   DCHECK(split_macs->empty());
@@ skipping 42 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;
 }