Add dictionary comparing functions and unit tests

base/values.h

 // Copyright (c) 2010 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.
 
 // This file specifies a recursive data storage class called Value intended for
 // storing setting and other persistable data.  It includes the ability to
 // specify (recursive) lists and dictionaries, so it's fairly expressive.
 // However, the API is optimized for the common case, namely storing a
 // hierarchical tree of simple values.  Given a DictionaryValue root, you can
 // easily do things like:
@@ skipping 349 matching lines @@
   // Makes a copy of |this| but doesn't include empty dictionaries and lists in
   // the copy.  This never returns NULL, even if |this| itself is empty.
   DictionaryValue* DeepCopyWithoutEmptyChildren();
 
   // Merge a given dictionary into this dictionary. This is done recursively,
   // i.e. any subdictionaries will be merged as well. In case of key collisions,
   // the passed in dictionary takes precedence and data already present will be
   // replaced.
   void MergeDictionary(const DictionaryValue* dictionary);
 
+  // Builds a vector containing all of the paths that are different between
+  // the dictionary and a second specified dictionary. These are paths of
+  // values that are either in one dictionary or the other but not both, OR
+  // paths that are present in both dictionaries but differ in value.
+  // Path strings are in ascending lexicographical order in the generated
+  // vector. |different_paths| is cleared before added any paths.
+  void GetDifferingPaths(
+      const DictionaryValue* other,
+      std::vector<std::string>* different_paths) const;
+
   // This class provides an iterator for the keys in the dictionary.
   // It can't be used to modify the dictionary.
   //
   // YOU SHOULD ALWAYS USE THE XXXWithoutPathExpansion() APIs WITH THESE, NOT
   // THE NORMAL XXX() APIs.  This makes sure things will work correctly if any
   // keys have '.'s in them.
   class key_iterator
       : private std::iterator<std::input_iterator_tag, const std::string> {
    public:
     explicit key_iterator(ValueMap::const_iterator itr) { itr_ = itr; }
     key_iterator operator++() {
       ++itr_;
       return *this;
     }
     const std::string& operator*() { return itr_->first; }
     bool operator!=(const key_iterator& other) { return itr_ != other.itr_; }
     bool operator==(const key_iterator& other) { return itr_ == other.itr_; }
 
    private:
     ValueMap::const_iterator itr_;
   };
 
   key_iterator begin_keys() const { return key_iterator(dictionary_.begin()); }
   key_iterator end_keys() const { return key_iterator(dictionary_.end()); }
 
  private:
+  // Does the actual heavy lifting for GetDifferingPaths.
+  // Returns true if a path is added to different_paths, otherwise false.
+  // The difference compuation is calculated recursively. The keys for
+  // dictionaries that are handled by recursive calls more shallow than
+  // the current one are concatenated and passed through to deeper calls in
+  // |path_prefix|.
+  bool GetDifferingPathsHelper(
+      const std::string& path_prefix,
+      const DictionaryValue* other,
+      std::vector<std::string>* different_paths) const;
+
   ValueMap dictionary_;
 
   DISALLOW_COPY_AND_ASSIGN(DictionaryValue);
 };
 
 // This type of Value represents a list of other Value values.
 class ListValue : public Value {
  public:
   ListValue();
   ~ListValue();
@@ skipping 85 matching lines @@
   // This method deserializes the subclass-specific format into a Value object.
   // If the return value is non-NULL, the caller takes ownership of returned
   // Value. If the return value is NULL, and if error_code is non-NULL,
   // error_code will be set with the underlying error.
   // If |error_message| is non-null, it will be filled in with a formatted
   // error message including the location of the error if appropriate.
   virtual Value* Deserialize(int* error_code, std::string* error_str) = 0;
 };
 
 #endif  // BASE_VALUES_H_