Update some uses of Value in chrome/browser to use the base:: namespace.

chrome/browser/bookmarks/bookmark_codec.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 "chrome/browser/bookmarks/bookmark_codec.h"
 
 #include <algorithm>
 
 #include "base/json/json_string_value_serializer.h"
 #include "base/strings/string_number_conversions.h"
@@ skipping 31 matching lines @@
 BookmarkCodec::BookmarkCodec()
     : ids_reassigned_(false),
       ids_valid_(true),
       maximum_id_(0),
       model_sync_transaction_version_(
           BookmarkNode::kInvalidSyncTransactionVersion) {
 }
 
 BookmarkCodec::~BookmarkCodec() {}
 
-Value* BookmarkCodec::Encode(BookmarkModel* model) {
+base::Value* BookmarkCodec::Encode(BookmarkModel* model) {
   return Encode(model->bookmark_bar_node(),
                 model->other_node(),
                 model->mobile_node(),
                 model->root_node()->GetMetaInfoMap(),
                 model->root_node()->sync_transaction_version());
 }
 
-Value* BookmarkCodec::Encode(
+base::Value* BookmarkCodec::Encode(
     const BookmarkNode* bookmark_bar_node,
     const BookmarkNode* other_folder_node,
     const BookmarkNode* mobile_folder_node,
     const BookmarkNode::MetaInfoMap* model_meta_info_map,
     int64 sync_transaction_version) {
   ids_reassigned_ = false;
   InitializeChecksum();
-  DictionaryValue* roots = new DictionaryValue();
+  base::DictionaryValue* roots = new base::DictionaryValue();
   roots->Set(kRootFolderNameKey, EncodeNode(bookmark_bar_node));
   roots->Set(kOtherBookmarkFolderNameKey, EncodeNode(other_folder_node));
   roots->Set(kMobileBookmarkFolderNameKey, EncodeNode(mobile_folder_node));
   if (model_meta_info_map)
     roots->Set(kMetaInfo, EncodeMetaInfo(*model_meta_info_map));
   if (sync_transaction_version !=
       BookmarkNode::kInvalidSyncTransactionVersion) {
     roots->SetString(kSyncTransactionVersion,
                      base::Int64ToString(sync_transaction_version));
   }
-  DictionaryValue* main = new DictionaryValue();
+  base::DictionaryValue* main = new base::DictionaryValue();
   main->SetInteger(kVersionKey, kCurrentVersion);
   FinalizeChecksum();
   // We are going to store the computed checksum. So set stored checksum to be
   // the same as computed checksum.
   stored_checksum_ = computed_checksum_;
   main->Set(kChecksumKey, new base::StringValue(computed_checksum_));
   main->Set(kRootsKey, roots);
   return main;
 }
 
 bool BookmarkCodec::Decode(BookmarkNode* bb_node,
                            BookmarkNode* other_folder_node,
                            BookmarkNode* mobile_folder_node,
                            int64* max_id,
-                           const Value& value) {
+                           const base::Value& value) {
   ids_.clear();
   ids_reassigned_ = false;
   ids_valid_ = true;
   maximum_id_ = 0;
   stored_checksum_.clear();
   InitializeChecksum();
   bool success = DecodeHelper(bb_node, other_folder_node, mobile_folder_node,
                               value);
   FinalizeChecksum();
   // If either the checksums differ or some IDs were missing/not unique,
   // reassign IDs.
   if (!ids_valid_ || computed_checksum() != stored_checksum())
     ReassignIDs(bb_node, other_folder_node, mobile_folder_node);
   *max_id = maximum_id_ + 1;
   return success;
 }
 
-Value* BookmarkCodec::EncodeNode(const BookmarkNode* node) {
-  DictionaryValue* value = new DictionaryValue();
+base::Value* BookmarkCodec::EncodeNode(const BookmarkNode* node) {
+  base::DictionaryValue* value = new base::DictionaryValue();
   std::string id = base::Int64ToString(node->id());
   value->SetString(kIdKey, id);
   const base::string16& title = node->GetTitle();
   value->SetString(kNameKey, title);
   value->SetString(kDateAddedKey,
                    base::Int64ToString(node->date_added().ToInternalValue()));
   if (node->is_url()) {
     value->SetString(kTypeKey, kTypeURL);
     std::string url = node->url().possibly_invalid_spec();
     value->SetString(kURLKey, url);
     UpdateChecksumWithUrlNode(id, title, url);
   } else {
     value->SetString(kTypeKey, kTypeFolder);
     value->SetString(kDateModifiedKey,
                      base::Int64ToString(node->date_folder_modified().
                                    ToInternalValue()));
     UpdateChecksumWithFolderNode(id, title);
 
-    ListValue* child_values = new ListValue();
+    base::ListValue* child_values = new base::ListValue();
     value->Set(kChildrenKey, child_values);
     for (int i = 0; i < node->child_count(); ++i)
       child_values->Append(EncodeNode(node->GetChild(i)));
   }
   const BookmarkNode::MetaInfoMap* meta_info_map = node->GetMetaInfoMap();
   if (meta_info_map)
     value->Set(kMetaInfo, EncodeMetaInfo(*meta_info_map));
   if (node->sync_transaction_version() !=
       BookmarkNode::kInvalidSyncTransactionVersion) {
     value->SetString(kSyncTransactionVersion,
                      base::Int64ToString(node->sync_transaction_version()));
   }
   return value;
 }
 
 base::Value* BookmarkCodec::EncodeMetaInfo(
     const BookmarkNode::MetaInfoMap& meta_info_map) {
   base::DictionaryValue* meta_info = new base::DictionaryValue;
   for (BookmarkNode::MetaInfoMap::const_iterator it = meta_info_map.begin();
       it != meta_info_map.end(); ++it) {
     meta_info->SetStringWithoutPathExpansion(it->first, it->second);
   }
   return meta_info;
 }
 
 bool BookmarkCodec::DecodeHelper(BookmarkNode* bb_node,
                                  BookmarkNode* other_folder_node,
                                  BookmarkNode* mobile_folder_node,
-                                 const Value& value) {
-  if (value.GetType() != Value::TYPE_DICTIONARY)
+                                 const base::Value& value) {
+  if (value.GetType() != base::Value::TYPE_DICTIONARY)
     return false;  // Unexpected type.
 
-  const DictionaryValue& d_value = static_cast<const DictionaryValue&>(value);
+  const base::DictionaryValue& d_value =
+      static_cast<const base::DictionaryValue&>(value);
 
   int version;
   if (!d_value.GetInteger(kVersionKey, &version) || version != kCurrentVersion)
     return false;  // Unknown version.
 
-  const Value* checksum_value;
+  const base::Value* checksum_value;
   if (d_value.Get(kChecksumKey, &checksum_value)) {
-    if (checksum_value->GetType() != Value::TYPE_STRING)
+    if (checksum_value->GetType() != base::Value::TYPE_STRING)
       return false;
     if (!checksum_value->GetAsString(&stored_checksum_))
       return false;
   }
 
-  const Value* roots;
+  const base::Value* roots;
   if (!d_value.Get(kRootsKey, &roots))
     return false;  // No roots.
 
-  if (roots->GetType() != Value::TYPE_DICTIONARY)
+  if (roots->GetType() != base::Value::TYPE_DICTIONARY)
     return false;  // Invalid type for roots.
 
-  const DictionaryValue* roots_d_value =
-      static_cast<const DictionaryValue*>(roots);
-  const Value* root_folder_value;
-  const Value* other_folder_value = NULL;
+  const base::DictionaryValue* roots_d_value =
+      static_cast<const base::DictionaryValue*>(roots);
+  const base::Value* root_folder_value;
+  const base::Value* other_folder_value = NULL;
   if (!roots_d_value->Get(kRootFolderNameKey, &root_folder_value) ||
-      root_folder_value->GetType() != Value::TYPE_DICTIONARY ||
+      root_folder_value->GetType() != base::Value::TYPE_DICTIONARY ||
       !roots_d_value->Get(kOtherBookmarkFolderNameKey, &other_folder_value) ||
-      other_folder_value->GetType() != Value::TYPE_DICTIONARY) {
+      other_folder_value->GetType() != base::Value::TYPE_DICTIONARY) {
     return false;  // Invalid type for root folder and/or other
                    // folder.
   }
-  DecodeNode(*static_cast<const DictionaryValue*>(root_folder_value), NULL,
-             bb_node);
-  DecodeNode(*static_cast<const DictionaryValue*>(other_folder_value), NULL,
-             other_folder_node);
+  DecodeNode(*static_cast<const base::DictionaryValue*>(root_folder_value),
+             NULL, bb_node);
+  DecodeNode(*static_cast<const base::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.
-  const Value* mobile_folder_value;
+  const base::Value* mobile_folder_value;
   if (roots_d_value->Get(kMobileBookmarkFolderNameKey, &mobile_folder_value) &&
-      mobile_folder_value->GetType() == Value::TYPE_DICTIONARY) {
-    DecodeNode(*static_cast<const DictionaryValue*>(mobile_folder_value), NULL,
-               mobile_folder_node);
+      mobile_folder_value->GetType() == base::Value::TYPE_DICTIONARY) {
+    DecodeNode(*static_cast<const base::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 16 matching lines @@
   mobile_folder_node->set_type(BookmarkNode::MOBILE);
   bb_node->SetTitle(l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_FOLDER_NAME));
   other_folder_node->SetTitle(
       l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_OTHER_FOLDER_NAME));
   mobile_folder_node->SetTitle(
         l10n_util::GetStringUTF16(IDS_BOOKMARK_BAR_MOBILE_FOLDER_NAME));
 
   return true;
 }
 
-bool BookmarkCodec::DecodeChildren(const ListValue& child_value_list,
+bool BookmarkCodec::DecodeChildren(const base::ListValue& child_value_list,
                                    BookmarkNode* parent) {
   for (size_t i = 0; i < child_value_list.GetSize(); ++i) {
-    const Value* child_value;
+    const base::Value* child_value;
     if (!child_value_list.Get(i, &child_value))
       return false;
 
-    if (child_value->GetType() != Value::TYPE_DICTIONARY)
+    if (child_value->GetType() != base::Value::TYPE_DICTIONARY)
       return false;
 
-    DecodeNode(*static_cast<const DictionaryValue*>(child_value), parent, NULL);
+    DecodeNode(*static_cast<const base::DictionaryValue*>(child_value),
+               parent, NULL);
   }
   return true;
 }
 
-bool BookmarkCodec::DecodeNode(const DictionaryValue& value,
+bool BookmarkCodec::DecodeNode(const base::DictionaryValue& value,
                                BookmarkNode* parent,
                                BookmarkNode* node) {
   // If no |node| is specified, we'll create one and add it to the |parent|.
   // Therefore, in that case, |parent| must be non-NULL.
   if (!node && !parent) {
     NOTREACHED();
     return false;
   }
 
   std::string id_string;
@@ skipping 39 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());
 
-    const Value* child_values;
+    const base::Value* child_values;
     if (!value.Get(kChildrenKey, &child_values))
       return false;
 
-    if (child_values->GetType() != Value::TYPE_LIST)
+    if (child_values->GetType() != base::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<const ListValue*>(child_values), node))
+    if (!DecodeChildren(*static_cast<const base::ListValue*>(child_values),
+                        node)) {
       return false;
+    }
   }
 
   node->SetTitle(title);
   node->set_date_added(base::Time::FromInternalValue(internal_time));
 
   int64 sync_transaction_version = node->sync_transaction_version();
   BookmarkNode::MetaInfoMap meta_info_map;
   if (!DecodeMetaInfo(value, &meta_info_map, &sync_transaction_version))
     return false;
   node->SetMetaInfoMap(meta_info_map);
@@ skipping 119 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);
 }