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

base/values.cc

 // 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.
 
 #include "base/values.h"
 
 #include "base/logging.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 
@@ skipping 72 matching lines @@
 Value* Value::CreateRealValue(double in_value) {
   return new FundamentalValue(in_value);
 }
 
 // static
 Value* Value::CreateStringValue(const std::string& in_value) {
   return new StringValue(in_value);
 }
 
 // static
+Value* Value::CreateStringValue(const string16& in_value) {
+  return new StringValue(in_value);
+}
+
+#if !defined(WCHAR_T_IS_UTF16)
+// TODO(viettrungluu): Deprecated and to be removed:
+// static
 Value* Value::CreateStringValue(const std::wstring& in_value) {
   return new StringValue(in_value);
 }
-
-// static
-Value* Value::CreateStringValueFromUTF16(const string16& in_value) {
-  return new StringValue(in_value);
-}
+#endif
 
 // static
 BinaryValue* Value::CreateBinaryValue(char* buffer, size_t size) {
   return BinaryValue::Create(buffer, size);
 }
 
-bool Value::GetAsBoolean(bool* in_value) const {
+bool Value::GetAsBoolean(bool* out_value) const {
   return false;
 }
 
-bool Value::GetAsInteger(int* in_value) const {
+bool Value::GetAsInteger(int* out_value) const {
   return false;
 }
 
-bool Value::GetAsReal(double* in_value) const {
+bool Value::GetAsReal(double* out_value) const {
   return false;
 }
 
-bool Value::GetAsString(std::string* in_value) const {
+bool Value::GetAsString(std::string* out_value) const {
   return false;
 }
 
-bool Value::GetAsString(std::wstring* in_value) const {
+bool Value::GetAsString(string16* out_value) const {
   return false;
 }
 
-bool Value::GetAsUTF16(string16* out_value) const {
+#if !defined(WCHAR_T_IS_UTF16)
+// TODO(viettrungluu): Deprecated and to be removed:
+bool Value::GetAsString(std::wstring* out_value) const {
   return false;
 }
+#endif
 
 Value* Value::DeepCopy() const {
   // This method should only be getting called for null Values--all subclasses
   // need to provide their own implementation;.
   DCHECK(IsType(TYPE_NULL));
   return CreateNullValue();
 }
 
 bool Value::Equals(const Value* other) const {
   // This method should only be getting called for null Values--all subclasses
@@ skipping 81 matching lines @@
 }
 
 ///////////////////// StringValue ////////////////////
 
 StringValue::StringValue(const std::string& in_value)
     : Value(TYPE_STRING),
       value_(in_value) {
   DCHECK(IsStringUTF8(in_value));
 }
 
+StringValue::StringValue(const string16& in_value)
+    : Value(TYPE_STRING),
+      value_(UTF16ToUTF8(in_value)) {
+}
+
+#if !defined(WCHAR_T_IS_UTF16)
+// TODO(viettrungluu): Deprecated and to be removed:
 StringValue::StringValue(const std::wstring& in_value)
     : Value(TYPE_STRING),
       value_(WideToUTF8(in_value)) {
 }
-
-#if !defined(WCHAR_T_IS_UTF16)
-StringValue::StringValue(const string16& in_value)
-    : Value(TYPE_STRING),
-      value_(UTF16ToUTF8(in_value)) {
-}
 #endif
 
 StringValue::~StringValue() {
 }
 
 bool StringValue::GetAsString(std::string* out_value) const {
   if (out_value)
     *out_value = value_;
   return true;
 }
 
+bool StringValue::GetAsString(string16* out_value) const {
+  if (out_value)
+    *out_value = UTF8ToUTF16(value_);
+  return true;
+}
+
+#if !defined(WCHAR_T_IS_UTF16)
+// TODO(viettrungluu): Deprecated and to be removed:
 bool StringValue::GetAsString(std::wstring* out_value) const {
   if (out_value)
     *out_value = UTF8ToWide(value_);
   return true;
 }
-
-bool StringValue::GetAsUTF16(string16* out_value) const {
-  if (out_value)
-    *out_value = UTF8ToUTF16(value_);
-  return true;
-}
+#endif
 
 Value* StringValue::DeepCopy() const {
   return CreateStringValue(value_);
 }
 
 bool StringValue::Equals(const Value* other) const {
   if (other->GetType() != GetType())
     return false;
   std::string lhs, rhs;
   return GetAsString(&lhs) && other->GetAsString(&rhs) && lhs == rhs;
@@ skipping 160 matching lines @@
   Set(path, CreateRealValue(in_value));
 }
 
 void DictionaryValue::SetString(const std::string& path,
                                 const std::string& in_value) {
   Set(path, CreateStringValue(in_value));
 }
 
 void DictionaryValue::SetStringFromUTF16(const std::string& path,
                                          const string16& in_value) {
-  Set(path, CreateStringValueFromUTF16(in_value));
+  Set(path, CreateStringValue(in_value));
 }
 
 // TODO(viettrungluu): Deprecated and to be removed:
 void DictionaryValue::SetBoolean(const std::wstring& path, bool in_value) {
   Set(path, CreateBooleanValue(in_value));
 }
 
 // TODO(viettrungluu): Deprecated and to be removed:
 void DictionaryValue::SetInteger(const std::wstring& path, int in_value) {
   Set(path, CreateIntegerValue(in_value));
@@ skipping 12 matching lines @@
 
 // TODO(viettrungluu): Deprecated and to be removed:
 void DictionaryValue::SetString(const std::wstring& path,
                                 const std::wstring& in_value) {
   Set(path, CreateStringValue(in_value));
 }
 
 // TODO(viettrungluu): Deprecated and to be removed:
 void DictionaryValue::SetStringFromUTF16(const std::wstring& path,
                                          const string16& in_value) {
-  Set(path, CreateStringValueFromUTF16(in_value));
+  Set(path, CreateStringValue(in_value));
 }
 
 void DictionaryValue::SetWithoutPathExpansion(const std::string& key,
                                               Value* in_value) {
   // If there's an existing value here, we need to delete it, because
   // we own all our children.
   if (HasKey(key)) {
     DCHECK(dictionary_[key] != in_value);  // This would be bogus
     delete dictionary_[key];
   }
@@ skipping 65 matching lines @@
 
   return value->GetAsString(out_value);
 }
 
 bool DictionaryValue::GetStringAsUTF16(const std::string& path,
                                        string16* out_value) const {
   Value* value;
   if (!Get(path, &value))
     return false;
 
-  return value->GetAsUTF16(out_value);
+  return value->GetAsString(out_value);
 }
 
 bool DictionaryValue::GetStringASCII(const std::string& path,
                                      std::string* out_value) const {
   std::string out;
   if (!GetString(path, &out))
     return false;
 
   if (!IsStringASCII(out)) {
     NOTREACHED();
@@ skipping 138 matching lines @@
   return value->GetAsString(out_value);
 }
 
 bool DictionaryValue::GetStringAsUTF16WithoutPathExpansion(
     const std::string& key,
     string16* out_value) const {
   Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
-  return value->GetAsUTF16(out_value);
+  return value->GetAsString(out_value);
 }
 
 bool DictionaryValue::GetDictionaryWithoutPathExpansion(
     const std::string& key,
     DictionaryValue** out_value) const {
   Value* value;
   bool result = GetWithoutPathExpansion(key, &value);
   if (!result || !value->IsType(TYPE_DICTIONARY))
     return false;
 
@@ skipping 212 matching lines @@
     return false;
 
   return value->GetAsString(out_value);
 }
 
 bool ListValue::GetStringAsUTF16(size_t index, string16* out_value) const {
   Value* value;
   if (!Get(index, &value))
     return false;
 
-  return value->GetAsUTF16(out_value);
+  return value->GetAsString(out_value);
 }
 
 bool ListValue::GetBinary(size_t index, BinaryValue** out_value) const {
   Value* value;
   bool result = Get(index, &value);
   if (!result || !value->IsType(TYPE_BINARY))
     return false;
 
   if (out_value)
     *out_value = static_cast<BinaryValue*>(value);
@@ skipping 102 matching lines @@
       return false;
   }
   if (lhs_it != end() || rhs_it != other_list->end())
     return false;
 
   return true;
 }
 
 ValueSerializer::~ValueSerializer() {
 }