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

chrome/browser/bookmarks/bookmark_codec.cc

 // Copyright (c) 2011 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 "chrome/browser/bookmarks/bookmark_codec.h"
 
 #include <algorithm>
 
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 116 matching lines @@
                                  const Value& value) {
   if (value.GetType() != Value::TYPE_DICTIONARY)
     return false;  // Unexpected type.
 
   const DictionaryValue& d_value = static_cast<const DictionaryValue&>(value);
 
   int version;
   if (!d_value.GetInteger(kVersionKey, &version) || version != kCurrentVersion)
     return false;  // Unknown version.
 
-  Value* checksum_value;
+  const Value* checksum_value;
   if (d_value.Get(kChecksumKey, &checksum_value)) {
     if (checksum_value->GetType() != Value::TYPE_STRING)
       return false;
-    StringValue* checksum_value_str = static_cast<StringValue*>(checksum_value);
+    const StringValue* checksum_value_str =
+        static_cast<const StringValue*>(checksum_value);
     if (!checksum_value_str->GetAsString(&stored_checksum_))
       return false;
   }
 
-  Value* roots;
+  const Value* roots;
   if (!d_value.Get(kRootsKey, &roots))
     return false;  // No roots.
 
   if (roots->GetType() != Value::TYPE_DICTIONARY)
     return false;  // Invalid type for roots.
 
-  DictionaryValue* roots_d_value = static_cast<DictionaryValue*>(roots);
-  Value* root_folder_value;
-  Value* other_folder_value;
+  const DictionaryValue* roots_d_value =
+      static_cast<const DictionaryValue*>(roots);
+  const Value* root_folder_value;
+  const Value* other_folder_value;
   if (!roots_d_value->Get(kRootFolderNameKey, &root_folder_value) ||
       root_folder_value->GetType() != Value::TYPE_DICTIONARY ||
       !roots_d_value->Get(kOtherBookmarkFolderNameKey, &other_folder_value) ||
       other_folder_value->GetType() != Value::TYPE_DICTIONARY) {
     return false;  // Invalid type for root folder and/or other
                    // folder.
   }
-  DecodeNode(*static_cast<DictionaryValue*>(root_folder_value), NULL,
+  DecodeNode(*static_cast<const DictionaryValue*>(root_folder_value), NULL,
              bb_node);
-  DecodeNode(*static_cast<DictionaryValue*>(other_folder_value), NULL,
+  DecodeNode(*static_cast<const DictionaryValue*>(other_folder_value), NULL,
              other_folder_node);
 
   // Fail silently if we can't deserialize mobile bookmarks. We can't require
   // them to exist in order to be backwards-compatible with older versions of
   // chrome.
-  Value* mobile_folder_value;
+  const Value* mobile_folder_value;
   if (roots_d_value->Get(kMobileBookmarkFolderNameKey, &mobile_folder_value) &&
       mobile_folder_value->GetType() == Value::TYPE_DICTIONARY) {
-    DecodeNode(*static_cast<DictionaryValue*>(mobile_folder_value), NULL,
+    DecodeNode(*static_cast<const DictionaryValue*>(mobile_folder_value), NULL,
                mobile_folder_node);
   } else {
     // If we didn't find the mobile folder, we're almost guaranteed to have a
     // duplicate id when we add the mobile folder. Consequently, if we don't
     // intend to reassign ids in the future (ids_valid_ is still true), then at
     // least reassign the mobile bookmarks to avoid it colliding with anything
     // else.
     if (ids_valid_)
       ReassignIDsHelper(mobile_folder_node);
   }
@@ skipping 95 matching lines @@
 
     if (parent)
       parent->Add(node, parent->child_count());
     node->set_type(BookmarkNode::URL);
     UpdateChecksumWithUrlNode(id_string, title, url_string);
   } else {
     std::string last_modified_date;
     if (!value.GetString(kDateModifiedKey, &last_modified_date))
       last_modified_date = base::Int64ToString(Time::Now().ToInternalValue());
 
-    Value* child_values;
+    const Value* child_values;
     if (!value.Get(kChildrenKey, &child_values))
       return false;
 
     if (child_values->GetType() != Value::TYPE_LIST)
       return false;
 
     if (!node) {
       node = new BookmarkNode(id, GURL());
     } else {
       // If a new node is not created, explicitly assign ID to the existing one.
       node->set_id(id);
     }
 
     node->set_type(BookmarkNode::FOLDER);
     int64 internal_time;
     base::StringToInt64(last_modified_date, &internal_time);
     node->set_date_folder_modified(Time::FromInternalValue(internal_time));
 
     if (parent)
       parent->Add(node, parent->child_count());
 
     UpdateChecksumWithFolderNode(id_string, title);
 
-    if (!DecodeChildren(*static_cast<ListValue*>(child_values), node))
+    if (!DecodeChildren(*static_cast<const ListValue*>(child_values), node))
       return false;
   }
 
   node->SetTitle(title);
   node->set_date_added(date_added);
   return true;
 }
 
 void BookmarkCodec::ReassignIDs(BookmarkNode* bb_node,
                                 BookmarkNode* other_node,
@@ skipping 42 matching lines @@
 
 void BookmarkCodec::InitializeChecksum() {
   base::MD5Init(&md5_context_);
 }
 
 void BookmarkCodec::FinalizeChecksum() {
   base::MD5Digest digest;
   base::MD5Final(&digest, &md5_context_);
   computed_checksum_ = base::MD5DigestToBase16(digest);
 }