[Sync] Make P2PNotifier behave more like InvalidationNotifier

base/values.h

 // Copyright (c) 2011 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 83 matching lines @@
   // If the current setting object can be converted into the given type,
   // the value is returned through the |out_value| parameter and true is
   // returned;  otherwise, false is returned and |out_value| is unchanged.
   virtual bool GetAsBoolean(bool* out_value) const;
   virtual bool GetAsInteger(int* out_value) const;
   virtual bool GetAsDouble(double* out_value) const;
   virtual bool GetAsString(std::string* out_value) const;
   virtual bool GetAsString(string16* out_value) const;
   virtual bool GetAsList(ListValue** out_value);
   virtual bool GetAsList(const ListValue** out_value) const;
+  virtual bool GetAsDictionary(DictionaryValue** out_value);
+  virtual bool GetAsDictionary(const DictionaryValue** out_value) const;

[Evan Martin, 2011/08/26 18:46:33]

I think we're trying to move to a different API, like:

virtual DictionaryValue* AsDictionary() const;
which returns NULL for non-dictionaries.

[akalin, 2011/08/26 18:56:43]

Okay.  It seems kinda weird to have a mixture of old/new APIs, though.  I'd
rather have it be consistent and them all be changed at once.

[tfarina, 2011/08/26 18:59:06]

Don't need to add AsDictionary in this patch. The others As* functions were
reverted by Steven already.

 
   // This creates a deep copy of the entire Value tree, and returns a pointer
   // to the copy.  The caller gets ownership of the copy, of course.
   //
   // Subclasses return their own type directly in their overrides;
   // this works because C++ supports covariant return types.
   virtual Value* DeepCopy() const;
 
   // Compares if two Value objects have equal contents.
   virtual bool Equals(const Value* other) const;
@@ skipping 226 matching lines @@
     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()); }
 
   // Overridden from Value:
+  virtual bool GetAsDictionary(DictionaryValue** out_value) OVERRIDE;
+  virtual bool GetAsDictionary(
+      const DictionaryValue** out_value) const OVERRIDE;
   virtual DictionaryValue* DeepCopy() const OVERRIDE;
   virtual bool Equals(const Value* other) const OVERRIDE;
 
  private:
   ValueMap dictionary_;
 
   DISALLOW_COPY_AND_ASSIGN(DictionaryValue);
 };
 
 // This type of Value represents a list of other Value values.
@@ skipping 106 matching lines @@
 
 }  // namespace base
 
 // http://crbug.com/88666
 using base::DictionaryValue;
 using base::ListValue;
 using base::StringValue;
 using base::Value;
 
 #endif  // BASE_VALUES_H_