Fix some styles issues reported by lint in base\values

base/values.h

 // Copyright (c) 2006-2008 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 82 matching lines @@
   // 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.
   virtual Value* DeepCopy() const;
 
   // Compares if two Value objects have equal contents.
   virtual bool Equals(const Value* other) const;
 
  protected:
   // This isn't safe for end-users (they should use the Create*Value()
   // static methods above), but it's useful for subclasses.
-  Value(ValueType type) : type_(type) {}
+  explicit Value(ValueType type) : type_(type) {}
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(Value);
   Value();
 
   ValueType type_;
+
+  DISALLOW_COPY_AND_ASSIGN(Value);
 };
 
 // FundamentalValue represents the simple fundamental types of values.
 class FundamentalValue : public Value {
  public:
-  FundamentalValue(bool in_value)
+  explicit FundamentalValue(bool in_value)
     : Value(TYPE_BOOLEAN), boolean_value_(in_value) {}
-  FundamentalValue(int in_value)
+  explicit FundamentalValue(int in_value)
     : Value(TYPE_INTEGER), integer_value_(in_value) {}
-  FundamentalValue(double in_value)
+  explicit FundamentalValue(double in_value)
     : Value(TYPE_REAL), real_value_(in_value) {}
   ~FundamentalValue();
 
   // Subclassed methods
   virtual bool GetAsBoolean(bool* out_value) const;
   virtual bool GetAsInteger(int* out_value) const;
   virtual bool GetAsReal(double* out_value) const;
   virtual Value* DeepCopy() const;
   virtual bool Equals(const Value* other) const;
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(FundamentalValue);
-
   union {
     bool boolean_value_;
     int integer_value_;
     double real_value_;
   };
+
+  DISALLOW_COPY_AND_ASSIGN(FundamentalValue);
 };
 
 class StringValue : public Value {
  public:
   // Initializes a StringValue with a UTF-8 narrow character string.
-  StringValue(const std::string& in_value);
+  explicit StringValue(const std::string& in_value);
 
   // Initializes a StringValue with a wide character string.
-  StringValue(const std::wstring& in_value);
+  explicit StringValue(const std::wstring& in_value);
 
   ~StringValue();
 
   // Subclassed methods
   bool GetAsString(std::string* out_value) const;
   bool GetAsString(std::wstring* out_value) const;
   Value* DeepCopy() const;
   virtual bool Equals(const Value* other) const;
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(StringValue);
+  std::string value_;
 
-  std::string value_;
+  DISALLOW_COPY_AND_ASSIGN(StringValue);
 };
 
 class BinaryValue: public Value {
-public:
+ public:
   // Creates a Value to represent a binary buffer.  The new object takes
   // ownership of the pointer passed in, if successful.
   // Returns NULL if buffer is NULL.
   static BinaryValue* Create(char* buffer, size_t size);
 
   // For situations where you want to keep ownership of your buffer, this
   // factory method creates a new BinaryValue by copying the contents of the
   // buffer that's passed in.
   // Returns NULL if buffer is NULL.
   static BinaryValue* CreateWithCopiedBuffer(char* buffer, size_t size);
 
   ~BinaryValue();
 
   // Subclassed methods
   Value* DeepCopy() const;
   virtual bool Equals(const Value* other) const;
 
   size_t GetSize() const { return size_; }
   char* GetBuffer() { return buffer_; }
 
-private:
-  DISALLOW_EVIL_CONSTRUCTORS(BinaryValue);
-
+ private:
   // Constructor is private so that only objects with valid buffer pointers
   // and size values can be created.
   BinaryValue(char* buffer, size_t size);
 
   char* buffer_;
   size_t size_;
+
+  DISALLOW_COPY_AND_ASSIGN(BinaryValue);
 };
 
 class DictionaryValue : public Value {
  public:
   DictionaryValue() : Value(TYPE_DICTIONARY) {}
   ~DictionaryValue();
 
   // Subclassed methods
   Value* DeepCopy() const;
   virtual bool Equals(const Value* other) const;
@@ skipping 54 matching lines @@
   // passed out via out_value.  If |out_value| is NULL, the removed value will
   // be deleted.  This method returns true if |path| is a valid path; otherwise
   // it will return false and the DictionaryValue object will be unchanged.
   bool Remove(const std::wstring& path, Value** out_value);
 
   // This class provides an iterator for the keys in the dictionary.
   // It can't be used to modify the dictionary.
   class key_iterator
     : private std::iterator<std::input_iterator_tag, const std::wstring> {
    public:
-    key_iterator(ValueMap::const_iterator itr) { itr_ = itr; }
+    explicit key_iterator(ValueMap::const_iterator itr) { itr_ = itr; }
     key_iterator operator++() { ++itr_; return *this; }
     const std::wstring& 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:
-  DISALLOW_EVIL_CONSTRUCTORS(DictionaryValue);
-
   // Associates the value |in_value| with the |key|.  This method should be
   // used instead of "dictionary_[key] = foo" so that any previous value can
   // be properly deleted.
   void SetInCurrentNode(const std::wstring& key, Value* in_value);
 
   ValueMap dictionary_;
+
+  DISALLOW_COPY_AND_ASSIGN(DictionaryValue);
 };
 
 // This type of Value represents a list of other Value values.
 class ListValue : public Value {
  public:
   ListValue() : Value(TYPE_LIST) {}
   ~ListValue();
 
   // Subclassed methods
   Value* DeepCopy() const;
@@ skipping 50 matching lines @@
   typedef ValueVector::iterator iterator;
   typedef ValueVector::const_iterator const_iterator;
 
   ListValue::iterator begin() { return list_.begin(); }
   ListValue::iterator end() { return list_.end(); }
 
   ListValue::const_iterator begin() const { return list_.begin(); }
   ListValue::const_iterator end() const { return list_.end(); }
 
  private:
-  DISALLOW_EVIL_CONSTRUCTORS(ListValue);
+  ValueVector list_;
 
-  ValueVector list_;
+  DISALLOW_COPY_AND_ASSIGN(ListValue);
 };
 
 // This interface is implemented by classes that know how to serialize and
 // deserialize Value objects.
 class ValueSerializer {
  public:
   virtual ~ValueSerializer() {}
 
   virtual bool Serialize(const Value& root) = 0;
 
   // 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_message is non-NULL,
   // error_message should be filled with a message describing the error.
   virtual Value* Deserialize(std::string* error_message) = 0;
 };
 
 #endif  // BASE_VALUES_H_