Correct const accessors in base/values.(h|cc)

base/values.cc

 // Copyright (c) 2012 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 <algorithm>
 
 #include "base/float_util.h"
 #include "base/logging.h"
@@ skipping 423 matching lines @@
   // we own all our children.
   std::pair<ValueMap::iterator, bool> ins_res =
       dictionary_.insert(std::make_pair(key, in_value));
   if (!ins_res.second) {
     DCHECK_NE(ins_res.first->second, in_value);  // This would be bogus
     delete ins_res.first->second;
     ins_res.first->second = in_value;
   }
 }
 
-bool DictionaryValue::Get(const std::string& path, Value** out_value) const {
+bool DictionaryValue::Get(
+    const std::string& path, const 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;
+    const DictionaryValue* child_dictionary = NULL;
     if (!current_dictionary->GetDictionary(
             current_path.substr(0, delimiter_position), &child_dictionary))
       return false;
 
     current_dictionary = child_dictionary;
     current_path.erase(0, delimiter_position + 1);
   }
 
   return current_dictionary->GetWithoutPathExpansion(current_path, out_value);
 }
 
+bool DictionaryValue::Get(const std::string& path, Value** out_value)  {
+  return static_cast<const DictionaryValue&>(*this).Get(
+      path,
+      const_cast<const Value**>(out_value));
+}
+
 bool DictionaryValue::GetBoolean(const std::string& path,
                                  bool* bool_value) const {
-  Value* value;
+  const Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsBoolean(bool_value);
 }
 
 bool DictionaryValue::GetInteger(const std::string& path,
                                  int* out_value) const {
-  Value* value;
+  const Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsInteger(out_value);
 }
 
 bool DictionaryValue::GetDouble(const std::string& path,
                                 double* out_value) const {
-  Value* value;
+  const Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsDouble(out_value);
 }
 
 bool DictionaryValue::GetString(const std::string& path,
                                 std::string* out_value) const {
-  Value* value;
+  const Value* value;
   if (!Get(path, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
 bool DictionaryValue::GetString(const std::string& path,
                                 string16* out_value) const {
-  Value* value;
+  const Value* value;
   if (!Get(path, &value))
     return false;
 
   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();
     return false;
   }
 
   out_value->assign(out);
   return true;
 }
 
 bool DictionaryValue::GetBinary(const std::string& path,
-                                BinaryValue** out_value) const {
-  Value* value;
+                                const BinaryValue** out_value) const {
+  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);
+    *out_value = static_cast<const BinaryValue*>(value);
+
+  return true;
+}
+
+bool DictionaryValue::GetBinary(const std::string& path,
+                                BinaryValue** out_value) {
+  return static_cast<const DictionaryValue&>(*this).GetBinary(
+      path,
+      const_cast<const BinaryValue**>(out_value));
+}
+
+bool DictionaryValue::GetDictionary(const std::string& path,
+                                    const DictionaryValue** out_value) const {
+  const Value* value;
+  bool result = Get(path, &value);
+  if (!result || !value->IsType(TYPE_DICTIONARY))
+    return false;
+
+  if (out_value)
+    *out_value = static_cast<const DictionaryValue*>(value);
 
   return true;
 }
 
 bool DictionaryValue::GetDictionary(const std::string& 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;
+                                    DictionaryValue** out_value) {
+  return static_cast<const DictionaryValue&>(*this).GetDictionary(
+      path,
+      const_cast<const DictionaryValue**>(out_value));
 }
 
 bool DictionaryValue::GetList(const std::string& path,
-                              ListValue** out_value) const {
-  Value* value;
+                              const ListValue** out_value) const {
+  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);
+    *out_value = static_cast<const ListValue*>(value);
 
   return true;
 }
 
+bool DictionaryValue::GetList(const std::string& path, ListValue** out_value) {
+  return static_cast<const DictionaryValue&>(*this).GetList(
+      path,
+      const_cast<const ListValue**>(out_value));
+}
+
 bool DictionaryValue::GetWithoutPathExpansion(const std::string& key,
-                                              Value** out_value) const {
+                                              const 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;
+  const Value* entry = entry_iterator->second;
   if (out_value)
     *out_value = entry;
   return true;
 }
 
+bool DictionaryValue::GetWithoutPathExpansion(const std::string& key,
+                                              Value** out_value) {
+  return static_cast<const DictionaryValue&>(*this).GetWithoutPathExpansion(
+      key,
+      const_cast<const Value**>(out_value));
+}
+
 bool DictionaryValue::GetIntegerWithoutPathExpansion(const std::string& key,
                                                      int* out_value) const {
-  Value* value;
+  const Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsInteger(out_value);
 }
 
 bool DictionaryValue::GetDoubleWithoutPathExpansion(const std::string& key,
                                                     double* out_value) const {
-  Value* value;
+  const Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsDouble(out_value);
 }
 
 bool DictionaryValue::GetStringWithoutPathExpansion(
     const std::string& key,
     std::string* out_value) const {
-  Value* value;
+  const Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
-bool DictionaryValue::GetStringWithoutPathExpansion(
-    const std::string& key,
-    string16* out_value) const {
-  Value* value;
+bool DictionaryValue::GetStringWithoutPathExpansion(const std::string& key,
+                                                    string16* out_value) const {
+  const Value* value;
   if (!GetWithoutPathExpansion(key, &value))
     return false;
 
   return value->GetAsString(out_value);
 }
 
 bool DictionaryValue::GetDictionaryWithoutPathExpansion(
     const std::string& key,
-    DictionaryValue** out_value) const {
-  Value* value;
+    const DictionaryValue** out_value) const {
+  const Value* value;
   bool result = GetWithoutPathExpansion(key, &value);
   if (!result || !value->IsType(TYPE_DICTIONARY))
     return false;
 
   if (out_value)
-    *out_value = static_cast<DictionaryValue*>(value);
+    *out_value = static_cast<const DictionaryValue*>(value);
+
+  return true;
+}
+
+bool DictionaryValue::GetDictionaryWithoutPathExpansion(
+    const std::string& key,
+    DictionaryValue** out_value) {
+  const DictionaryValue& const_this =
+      static_cast<const DictionaryValue&>(*this);
+  return const_this.GetDictionaryWithoutPathExpansion(
+          key,
+          const_cast<const DictionaryValue**>(out_value));
+}
+
+bool DictionaryValue::GetListWithoutPathExpansion(
+    const std::string& key,
+    const ListValue** out_value) const {
+  const Value* value;
+  bool result = GetWithoutPathExpansion(key, &value);
+  if (!result || !value->IsType(TYPE_LIST))
+    return false;
+
+  if (out_value)
+    *out_value = static_cast<const ListValue*>(value);
 
   return true;
 }
 
 bool DictionaryValue::GetListWithoutPathExpansion(const std::string& key,
-                                                  ListValue** out_value) const {
-  Value* value;
-  bool result = GetWithoutPathExpansion(key, &value);
-  if (!result || !value->IsType(TYPE_LIST))
-    return false;
-
-  if (out_value)
-    *out_value = static_cast<ListValue*>(value);
-
-  return true;
+                                                  ListValue** out_value) {
+  return
+      static_cast<const DictionaryValue&>(*this).GetListWithoutPathExpansion(
+          key,
+          const_cast<const ListValue**>(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))
@@ skipping 22 matching lines @@
 }
 
 DictionaryValue* DictionaryValue::DeepCopyWithoutEmptyChildren() {
   Value* copy = CopyWithoutEmptyChildren(this);
   return copy ? static_cast<DictionaryValue*>(copy) : new DictionaryValue;
 }
 
 void DictionaryValue::MergeDictionary(const DictionaryValue* dictionary) {
   for (DictionaryValue::key_iterator key(dictionary->begin_keys());
        key != dictionary->end_keys(); ++key) {
-    Value* merge_value;
+    const Value* merge_value;
     if (dictionary->GetWithoutPathExpansion(*key, &merge_value)) {
       // Check whether we have to merge dictionaries.
       if (merge_value->IsType(Value::TYPE_DICTIONARY)) {
         DictionaryValue* sub_dict;
         if (GetDictionaryWithoutPathExpansion(*key, &sub_dict)) {
           sub_dict->MergeDictionary(
               static_cast<const DictionaryValue*>(merge_value));
           continue;
         }
       }
@@ skipping 21 matching lines @@
 
 bool DictionaryValue::Equals(const Value* other) const {
   if (other->GetType() != GetType())
     return false;
 
   const DictionaryValue* other_dict =
       static_cast<const DictionaryValue*>(other);
   key_iterator lhs_it(begin_keys());
   key_iterator rhs_it(other_dict->begin_keys());
   while (lhs_it != end_keys() && rhs_it != other_dict->end_keys()) {
-    Value* lhs;
-    Value* rhs;
+    const Value* lhs;
+    const Value* rhs;
     if (*lhs_it != *rhs_it ||
         !GetWithoutPathExpansion(*lhs_it, &lhs) ||
         !other_dict->GetWithoutPathExpansion(*rhs_it, &rhs) ||
         !lhs->Equals(rhs)) {
       return false;
     }
     ++lhs_it;
     ++rhs_it;
   }
   if (lhs_it != end_keys() || rhs_it != other_dict->end_keys())
@@ skipping 228 matching lines @@
   if (lhs_it != end() || rhs_it != other_list->end())
     return false;
 
   return true;
 }
 
 ValueSerializer::~ValueSerializer() {
 }
 
 }  // namespace base