Add UTF-8 DCHECK()s in values.cc (since keys/paths are expected to be UTF-8).

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 360 matching lines @@
     ++lhs_it;
     ++rhs_it;
   }
   if (lhs_it != end_keys() || rhs_it != other_dict->end_keys())
     return false;
 
   return true;
 }
 
 bool DictionaryValue::HasKey(const std::string& key) const {
+  DCHECK(IsStringUTF8(key));
   ValueMap::const_iterator current_entry = dictionary_.find(key);
   DCHECK((current_entry == dictionary_.end()) || current_entry->second);
   return current_entry != dictionary_.end();
 }
 
 // TODO(viettrungluu): Deprecated and to be removed:
 bool DictionaryValue::HasKeyASCII(const std::string& key) const {
   return HasKey(key);
 }
 
 // TODO(viettrungluu): Deprecated and to be removed:
 bool DictionaryValue::HasKey(const std::wstring& key) const {
   return HasKey(WideToUTF8(key));
 }
 
 void DictionaryValue::Clear() {
   ValueMap::iterator dict_iterator = dictionary_.begin();
   while (dict_iterator != dictionary_.end()) {
     delete dict_iterator->second;
     ++dict_iterator;
   }
 
   dictionary_.clear();
 }
 
 void DictionaryValue::Set(const std::string& path, Value* in_value) {
+  DCHECK(IsStringUTF8(path));
   DCHECK(in_value);
 
   std::string current_path(path);
   DictionaryValue* current_dictionary = this;
   for (size_t delimiter_position = current_path.find('.');
        delimiter_position != std::string::npos;
        delimiter_position = current_path.find('.')) {
     // Assume that we're indexing into a dictionary.
     std::string key(current_path, 0, delimiter_position);
     DictionaryValue* child_dictionary = NULL;
@@ skipping 83 matching lines @@
   dictionary_[key] = in_value;
 }
 
 // TODO(viettrungluu): Deprecated and to be removed:
 void DictionaryValue::SetWithoutPathExpansion(const std::wstring& key,
                                               Value* in_value) {
   SetWithoutPathExpansion(WideToUTF8(key), in_value);
 }
 
 bool DictionaryValue::Get(const std::string& path, Value** out_value) const {
+  DCHECK(IsStringUTF8(path));
   std::string current_path(path);
   const DictionaryValue* current_dictionary = this;
   for (size_t delimiter_position = current_path.find('.');
        delimiter_position != std::string::npos;
        delimiter_position = current_path.find('.')) {
     DictionaryValue* child_dictionary = NULL;
     if (!current_dictionary->GetDictionary(
             current_path.substr(0, delimiter_position), &child_dictionary))
       return false;
 
@@ skipping 155 matching lines @@
 }
 
 // TODO(viettrungluu): Deprecated and to be removed:
 bool DictionaryValue::GetList(const std::wstring& path,
                               ListValue** out_value) const {
   return GetList(WideToUTF8(path), out_value);
 }
 
 bool DictionaryValue::GetWithoutPathExpansion(const std::string& key,
                                               Value** out_value) const {
+  DCHECK(IsStringUTF8(key));
   ValueMap::const_iterator entry_iterator = dictionary_.find(key);
   if (entry_iterator == dictionary_.end())
     return false;
 
   Value* entry = entry_iterator->second;
   if (out_value)
     *out_value = entry;
   return true;
 }
 
@@ skipping 90 matching lines @@
   return GetDictionaryWithoutPathExpansion(WideToUTF8(key), out_value);
 }
 
 // TODO(viettrungluu): Deprecated and to be removed:
 bool DictionaryValue::GetListWithoutPathExpansion(const std::wstring& key,
                                                   ListValue** out_value) const {
   return GetListWithoutPathExpansion(WideToUTF8(key), out_value);
 }
 
 bool DictionaryValue::Remove(const std::string& path, Value** out_value) {
+  DCHECK(IsStringUTF8(path));
   std::string current_path(path);
   DictionaryValue* current_dictionary = this;
   size_t delimiter_position = current_path.rfind('.');
   if (delimiter_position != std::string::npos) {
     if (!GetDictionary(current_path.substr(0, delimiter_position),
                        &current_dictionary))
       return false;
     current_path.erase(0, delimiter_position + 1);
   }
 
   return current_dictionary->RemoveWithoutPathExpansion(current_path,
                                                         out_value);
 }
 
 // TODO(viettrungluu): Deprecated and to be removed:
 bool DictionaryValue::Remove(const std::wstring& path, Value** out_value) {
   return Remove(WideToUTF8(path), out_value);
 }
 
 bool DictionaryValue::RemoveWithoutPathExpansion(const std::string& key,
                                                  Value** out_value) {
+  DCHECK(IsStringUTF8(key));
   ValueMap::iterator entry_iterator = dictionary_.find(key);
   if (entry_iterator == dictionary_.end())
     return false;
 
   Value* entry = entry_iterator->second;
   if (out_value)
     *out_value = entry;
   else
     delete entry;
   dictionary_.erase(entry_iterator);
@@ skipping 345 matching lines @@
       return false;
   }
   if (lhs_it != end() || rhs_it != other_list->end())
     return false;
 
   return true;
 }
 
 ValueSerializer::~ValueSerializer() {
 }