Port DictionaryValue to use string16 instead of wstring.

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 ////////////////////
 
@@ skipping 227 matching lines @@
 void DictionaryValue::Clear() {
   ValueMap::iterator dict_iterator = dictionary_.begin();
   while (dict_iterator != dictionary_.end()) {
     delete dict_iterator->second;
     ++dict_iterator;
   }
 
   dictionary_.clear();
 }
 
-bool DictionaryValue::HasKey(const std::wstring& key) const {
+bool DictionaryValue::HasKey(const string16& key) const {
   ValueMap::const_iterator current_entry = dictionary_.find(key);
   DCHECK((current_entry == dictionary_.end()) || current_entry->second);
   return current_entry != dictionary_.end();
 }
 
-void DictionaryValue::SetInCurrentNode(const std::wstring& key,
+void DictionaryValue::SetInCurrentNode(const string16& 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];
   }
 
   dictionary_[key] = in_value;
 }
 
-bool DictionaryValue::Set(const std::wstring& path, Value* in_value) {
+bool DictionaryValue::Set(const string16& path, Value* in_value) {
   DCHECK(in_value);
 
-  std::wstring key = path;
+  string16 key = path;
 
-  size_t delimiter_position = path.find_first_of(L".", 0);
+  size_t delimiter_position = path.find_first_of('.', 0);
   // If there isn't a dictionary delimiter in the path, we're done.
   if (delimiter_position == std::wstring::npos) {
     SetInCurrentNode(key, in_value);
     return true;
   } else {
     key = path.substr(0, delimiter_position);
   }
 
   // Assume that we're indexing into a dictionary.
   DictionaryValue* entry = NULL;
   if (!HasKey(key) || (dictionary_[key]->GetType() != TYPE_DICTIONARY)) {
     entry = new DictionaryValue;
     SetInCurrentNode(key, entry);
   } else {
     entry = static_cast<DictionaryValue*>(dictionary_[key]);
   }
 
-  std::wstring remaining_path = path.substr(delimiter_position + 1);
+  string16 remaining_path = path.substr(delimiter_position + 1);
   return entry->Set(remaining_path, in_value);
 }
 
-bool DictionaryValue::SetBoolean(const std::wstring& path, bool in_value) {
+bool DictionaryValue::SetBoolean(const string16& path, bool in_value) {
   return Set(path, CreateBooleanValue(in_value));
 }
 
-bool DictionaryValue::SetInteger(const std::wstring& path, int in_value) {
+bool DictionaryValue::SetInteger(const string16& path, int in_value) {
   return Set(path, CreateIntegerValue(in_value));
 }
 
-bool DictionaryValue::SetReal(const std::wstring& path, double in_value) {
+bool DictionaryValue::SetReal(const string16& path, double in_value) {
   return Set(path, CreateRealValue(in_value));
 }
 
-bool DictionaryValue::SetString(const std::wstring& path,
+bool DictionaryValue::SetString(const string16& 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::SetString(const string16& path,
+                                const string16& in_value) {
+  return Set(path, CreateStringValue(UTF16ToWideHack(in_value)));
 }
 
-bool DictionaryValue::Get(const std::wstring& path, Value** out_value) const {
-  std::wstring key = path;
+bool DictionaryValue::Get(const string16& path, Value** out_value) const {
+  string16 key = path;
 
-  size_t delimiter_position = path.find_first_of(L".", 0);
-  if (delimiter_position != std::wstring::npos) {
+  size_t delimiter_position = path.find_first_of('.', 0);
+  if (delimiter_position != string16::npos) {
     key = path.substr(0, delimiter_position);
   }
 
   ValueMap::const_iterator entry_iterator = dictionary_.find(key);
   if (entry_iterator == dictionary_.end())
     return false;
   Value* entry = entry_iterator->second;
 
-  if (delimiter_position == std::wstring::npos) {
+  if (delimiter_position == string16::npos) {
     if (out_value)
       *out_value = entry;
     return true;
   }
 
   if (entry->IsType(TYPE_DICTIONARY)) {
     DictionaryValue* dictionary = static_cast<DictionaryValue*>(entry);
     return dictionary->Get(path.substr(delimiter_position + 1), out_value);
   }
 
   return false;
 }
 
-bool DictionaryValue::GetBoolean(const std::wstring& path,
+bool DictionaryValue::GetBoolean(const string16& path,
                                  bool* bool_value) const {
   Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsBoolean(bool_value);
 }
 
-bool DictionaryValue::GetInteger(const std::wstring& path,
+bool DictionaryValue::GetInteger(const string16& path,
                                  int* out_value) const {
   Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsInteger(out_value);
 }
 
-bool DictionaryValue::GetReal(const std::wstring& path,
+bool DictionaryValue::GetReal(const string16& 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,
+bool DictionaryValue::GetString(const string16& 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 {
+bool DictionaryValue::GetString(const string16& path,
+                                string16* out_value) const {
   Value* value;
   if (!Get(path, &value))
     return false;
 
-  return value->GetAsString(out_value);
+  std::wstring wout_value;
+  bool success = value->GetAsString(&wout_value);
+  out_value->assign(WideToUTF16Hack(wout_value));
+  return success;
 }
 
-bool DictionaryValue::GetBinary(const std::wstring& path,
+bool DictionaryValue::GetBinary(const string16& path,
                                 BinaryValue** out_value) const {
   Value* value;
   bool result = Get(path, &value);
   if (!result || !value->IsType(TYPE_BINARY))
     return false;
 
   if (out_value)
     *out_value = static_cast<BinaryValue*>(value);
 
   return true;
 }
 
-bool DictionaryValue::GetDictionary(const std::wstring& path,
+bool DictionaryValue::GetDictionary(const string16& path,
                                     DictionaryValue** out_value) const {
   Value* value;
   bool result = Get(path, &value);
   if (!result || !value->IsType(TYPE_DICTIONARY))
     return false;
 
   if (out_value)
     *out_value = static_cast<DictionaryValue*>(value);
 
   return true;
 }
 
-bool DictionaryValue::GetList(const std::wstring& path,
+bool DictionaryValue::GetList(const string16& path,
                               ListValue** out_value) const {
   Value* value;
   bool result = Get(path, &value);
   if (!result || !value->IsType(TYPE_LIST))
     return false;
 
   if (out_value)
     *out_value = static_cast<ListValue*>(value);
 
   return true;
 }
 
-bool DictionaryValue::Remove(const std::wstring& path, Value** out_value) {
-  std::wstring key = path;
+bool DictionaryValue::Remove(const string16& path, Value** out_value) {
+  string16 key = path;
 
-  size_t delimiter_position = path.find_first_of(L".", 0);
-  if (delimiter_position != std::wstring::npos) {
+  size_t delimiter_position = path.find_first_of('.', 0);
+  if (delimiter_position != string16::npos) {
     key = path.substr(0, delimiter_position);
   }
 
   ValueMap::iterator entry_iterator = dictionary_.find(key);
   if (entry_iterator == dictionary_.end())
     return false;
   Value* entry = entry_iterator->second;
 
-  if (delimiter_position == std::wstring::npos) {
+  if (delimiter_position == string16::npos) {
     if (out_value)
       *out_value = entry;
     else
       delete entry;
 
     dictionary_.erase(entry_iterator);
     return true;
   }
 
   if (entry->IsType(TYPE_DICTIONARY)) {
@@ skipping 194 matching lines @@
        lhs_it != end() && rhs_it != other_list->end();
        ++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;
 }
-