Added std::string to Value via Set/GetString overloading.

base/values.cc

 // 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.
 
 #include "base/logging.h"
+#include "base/string_util.h"
 #include "base/values.h"
 
 ///////////////////// Value ////////////////////
 
 Value::~Value() {
 }
 
 // static
 Value* Value::CreateNullValue() {
   return new Value(TYPE_NULL);
 }
 
 // static
 Value* Value::CreateBooleanValue(bool in_value) {
   return new FundamentalValue(in_value);
 }
 
 // static
 Value* Value::CreateIntegerValue(int in_value) {
   return new FundamentalValue(in_value);
 }
 
 // static
 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 std::wstring& in_value) {
   return new StringValue(in_value);
 }
 
 // static
 BinaryValue* Value::CreateBinaryValue(char* buffer, size_t size) {
   return BinaryValue::Create(buffer, size);
 }
 
 bool Value::GetAsBoolean(bool* in_value) const {
   return false;
 }
 
 bool Value::GetAsInteger(int* in_value) const {
   return false;
 }
 
 bool Value::GetAsReal(double* in_value) const {
   return false;
 }
 
+bool Value::GetAsString(std::string* in_value) const {
+  return false;
+}
+
 bool Value::GetAsString(std::wstring* in_value) const {
   return false;
 }
 
 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();
 }
@@ skipping 63 matching lines @@
       return GetAsReal(&lhs) && other->GetAsReal(&rhs) && lhs == rhs;
     }
     default:
       NOTREACHED();
       return false;
   }
 }
 
 ///////////////////// StringValue ////////////////////
 
+StringValue::StringValue(const std::string& in_value)
+    : Value(TYPE_STRING),
+      value_(in_value) {
+  DCHECK(IsStringUTF8(in_value));
+}
+
+StringValue::StringValue(const std::wstring& in_value)
+    : Value(TYPE_STRING),
+      value_(WideToUTF8(in_value)) {
+}
+
 StringValue::~StringValue() {
 }
 
+bool StringValue::GetAsString(std::string* out_value) const {
+  if (out_value)
+    *out_value = value_;
+  return true;
+}
+
 bool StringValue::GetAsString(std::wstring* out_value) const {
   if (out_value)
-    *out_value = value_;
+    *out_value = UTF8ToWide(value_);
   return true;
 }
 
 Value* StringValue::DeepCopy() const {
   return CreateStringValue(value_);
 }
 
 bool StringValue::Equals(const Value* other) const {
   if (other->GetType() != GetType())
     return false;
-  std::wstring lhs, rhs;
+  std::string lhs, rhs;
   return GetAsString(&lhs) && other->GetAsString(&rhs) && lhs == rhs;
 }
 
 ///////////////////// BinaryValue ////////////////////
 
 //static
 BinaryValue* BinaryValue::Create(char* buffer, size_t size) {
   if (!buffer)
     return NULL;
 
@@ skipping 104 matching lines @@
 
 bool DictionaryValue::SetInteger(const std::wstring& path, int in_value) {
   return Set(path, CreateIntegerValue(in_value));
 }
 
 bool DictionaryValue::SetReal(const std::wstring& path, double in_value) {
   return Set(path, CreateRealValue(in_value));
 }
 
 bool DictionaryValue::SetString(const std::wstring& path,
+                                const std::string& in_value) {
+  return Set(path, CreateStringValue(in_value));
+}
+
+bool DictionaryValue::SetString(const std::wstring& path,
                                 const std::wstring& in_value) {
   return Set(path, CreateStringValue(in_value));
 }
 
 bool DictionaryValue::Get(const std::wstring& path, Value** out_value) const {
   std::wstring key = path;
 
   size_t delimiter_position = path.find_first_of(L".", 0);
   if (delimiter_position != std::wstring::npos) {
     key = path.substr(0, delimiter_position);
@@ skipping 39 matching lines @@
 bool DictionaryValue::GetReal(const std::wstring& path,
                               double* out_value) const {
   Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsReal(out_value);
 }
 
 bool DictionaryValue::GetString(const std::wstring& path,
+                                std::string* out_value) const {
+  Value* value;
+  if (!Get(path, &value))
+    return false;
+
+  return value->GetAsString(out_value);
+}
+
+bool DictionaryValue::GetString(const std::wstring& path,
                                 std::wstring* out_value) const {
   Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
 bool DictionaryValue::GetBinary(const std::wstring& path,
                                 BinaryValue** out_value) const {
@@ skipping 201 matching lines @@
        ++lhs_it, ++rhs_it) {
     if (!(*lhs_it)->Equals(*rhs_it))
       return false;
   }
   if (lhs_it != end() || rhs_it != other_list->end())
     return false;
 
   return true;
 }