Remove Value/StringValue's ...UTF16() methods in favour of overloading.

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 38 matching lines @@
   virtual ~Value();
 
   // Convenience methods for creating Value objects for various
   // kinds of values without thinking about which class implements them.
   // These can always be expected to return a valid Value*.
   static Value* CreateNullValue();
   static Value* CreateBooleanValue(bool in_value);
   static Value* CreateIntegerValue(int in_value);
   static Value* CreateRealValue(double in_value);
   static Value* CreateStringValue(const std::string& in_value);
-  static Value* CreateStringValue(const std::wstring& in_value);
-  static Value* CreateStringValueFromUTF16(const string16& in_value);
+  static Value* CreateStringValue(const string16& in_value);
+#if !defined(WCHAR_T_IS_UTF16)
+  /*DEPRECATED*/static Value* CreateStringValue(const std::wstring& in_value);
+#endif
 
   // This one can return NULL if the input isn't valid.  If the return value
   // is non-null, the new object has taken ownership of the buffer pointer.
   static BinaryValue* CreateBinaryValue(char* buffer, size_t size);
 
   typedef enum {
     TYPE_NULL = 0,
     TYPE_BOOLEAN,
     TYPE_INTEGER,
     TYPE_REAL,
@@ skipping 14 matching lines @@
   bool IsType(ValueType type) const { return type == type_; }
 
   // These methods allow the convenient retrieval of settings.
   // 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 GetAsReal(double* out_value) const;
   virtual bool GetAsString(std::string* out_value) const;
-  virtual bool GetAsString(std::wstring* out_value) const;
-  virtual bool GetAsUTF16(string16* out_value) const;
+  virtual bool GetAsString(string16* out_value) const;
+#if !defined(WCHAR_T_IS_UTF16)
+  /*DEPRECATED*/virtual bool GetAsString(std::wstring* out_value) const;
+#endif
 
   // 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()
@@ skipping 31 matching lines @@
   };
 
   DISALLOW_COPY_AND_ASSIGN(FundamentalValue);
 };
 
 class StringValue : public Value {
  public:
   // Initializes a StringValue with a UTF-8 narrow character string.
   explicit StringValue(const std::string& in_value);
 
-  // Initializes a StringValue with a wide character string.
-  explicit StringValue(const std::wstring& in_value);
+  // Initializes a StringValue with a string16.
+  explicit StringValue(const string16& in_value);
 
 #if !defined(WCHAR_T_IS_UTF16)
-  // Initializes a StringValue with a string16.
-  explicit StringValue(const string16& in_value);
+  // Initializes a StringValue with a wide character string.
+  /*DEPRECATED*/explicit StringValue(const std::wstring& in_value);
 #endif
 
   ~StringValue();
 
   // Subclassed methods
   bool GetAsString(std::string* out_value) const;
-  bool GetAsString(std::wstring* out_value) const;
-  bool GetAsUTF16(string16* out_value) const;
+  bool GetAsString(string16* out_value) const;
+#if !defined(WCHAR_T_IS_UTF16)
+  /*DEPRECATED*/bool GetAsString(std::wstring* out_value) const;
+#endif
   Value* DeepCopy() const;
   virtual bool Equals(const Value* other) const;
 
  private:
   std::string value_;
 
   DISALLOW_COPY_AND_ASSIGN(StringValue);
 };
 
 class BinaryValue: public Value {
@@ skipping 313 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_