Fix the hash generation algorithm to be consistent with prior implementation.

chrome/browser/prefs/pref_hash_calculator.h

 // 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.
 
 #ifndef CHROME_BROWSER_PREFS_PREF_HASH_CALCULATOR_H_
 #define CHROME_BROWSER_PREFS_PREF_HASH_CALCULATOR_H_
 
 #include <string>
 
 #include "base/basictypes.h"
 
 namespace base {
 class Value;
 }  // namespace base
 
 // Calculates and validates preference value hashes.
 class PrefHashCalculator {
  public:
   enum ValidationResult {
     INVALID,
     VALID,
     VALID_LEGACY,
   };
 
   // Constructs a PrefHashCalculator using |seed| and |device_id|. The same
   // parameters must be used in order to successfully validate generated hashes.
   // |device_id| may be empty.
   PrefHashCalculator(const std::string& seed, const std::string& device_id);

[Ryan Sleevi, 2014/01/09 22:35:16]

naming nit: |seed| is usually used as the base for some derivation, but within
the implementation, you're using |seed| directly as the key.

Likewise, the naming (PrefHashCalculator) implies a hash, but you're actually
generating a MAC/MIC - Message Authentication/Integrity Code.

PrefMacCalculator, perhaps?

[gab, 2014/01/09 23:03:45]

Yea, that had been bugging me too, but the term "hash" has been used for this
entire feature all over the place (code, comments, docs) since it was only a
simple MAC based tracker.

Hence I didn't insist with changing the naming scheme when me and Erik took
ownership.

Perhaps we should change the naming scheme but definitely not in this CL.

To be fair I don't think it matters, to me a hash is a deterministic short
representation of some data which a MAC also is despite having extra
characteristics.

 
   // Calculates a hash value for the supplied preference |path| and |value|.
   // |value| may be null if the preference has no value.
   std::string Calculate(const std::string& path, const base::Value* value)
       const;
 
   // Validates the provided preference hash using current and legacy hashing
   // algorithms.
   ValidationResult Validate(const std::string& path,
                             const base::Value* value,
                             const std::string& hash) const;
 
  private:
-  // Calculate a hash using a deprecated hash algorithm. For validating old
-  // hashes during migration.
-  std::string CalculateLegacyHash(const std::string& path,
-                                  const base::Value* value) const;
+  std::string GetMessage(const std::string& path,
+                         const base::Value* value) const;
 
   std::string seed_;
   std::string device_id_;
 
   DISALLOW_COPY_AND_ASSIGN(PrefHashCalculator);
 };
 
 #endif  // CHROME_BROWSER_PREFS_PREF_HASH_CALCULATOR_H_