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

chrome/browser/bookmarks/bookmark_html_writer.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_html_writer.h"
 
 #include "base/base64.h"
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
@@ skipping 84 matching lines @@
         path_(path),
         favicons_map_(favicons_map),
         observer_(observer) {
   }
 
   // Writing bookmarks and favicons data to file.
   void DoWrite() {
     if (!OpenFile())
       return;
 
-    Value* roots = NULL;
+    base::Value* roots = NULL;
     if (!Write(kHeader) ||
-        bookmarks_->GetType() != Value::TYPE_DICTIONARY ||
-        !static_cast<DictionaryValue*>(bookmarks_.get())->Get(
+        bookmarks_->GetType() != base::Value::TYPE_DICTIONARY ||
+        !static_cast<base::DictionaryValue*>(bookmarks_.get())->Get(
             BookmarkCodec::kRootsKey, &roots) ||
-        roots->GetType() != Value::TYPE_DICTIONARY) {
+        roots->GetType() != base::Value::TYPE_DICTIONARY) {
       NOTREACHED();
       return;
     }
 
-    DictionaryValue* roots_d_value = static_cast<DictionaryValue*>(roots);
-    Value* root_folder_value;
-    Value* other_folder_value = NULL;
-    Value* mobile_folder_value = NULL;
+    base::DictionaryValue* roots_d_value =
+        static_cast<base::DictionaryValue*>(roots);
+    base::Value* root_folder_value;
+    base::Value* other_folder_value = NULL;
+    base::Value* mobile_folder_value = NULL;
     if (!roots_d_value->Get(BookmarkCodec::kRootFolderNameKey,
                             &root_folder_value) ||
-        root_folder_value->GetType() != Value::TYPE_DICTIONARY ||
+        root_folder_value->GetType() != base::Value::TYPE_DICTIONARY ||
         !roots_d_value->Get(BookmarkCodec::kOtherBookmarkFolderNameKey,
                             &other_folder_value) ||
-        other_folder_value->GetType() != Value::TYPE_DICTIONARY ||
+        other_folder_value->GetType() != base::Value::TYPE_DICTIONARY ||
         !roots_d_value->Get(BookmarkCodec::kMobileBookmarkFolderNameKey,
                             &mobile_folder_value) ||
-        mobile_folder_value->GetType() != Value::TYPE_DICTIONARY) {
+        mobile_folder_value->GetType() != base::Value::TYPE_DICTIONARY) {
       NOTREACHED();
       return;  // Invalid type for root folder and/or other folder.
     }
 
     IncrementIndent();
 
-    if (!WriteNode(*static_cast<DictionaryValue*>(root_folder_value),
+    if (!WriteNode(*static_cast<base::DictionaryValue*>(root_folder_value),
                    BookmarkNode::BOOKMARK_BAR) ||
-        !WriteNode(*static_cast<DictionaryValue*>(other_folder_value),
+        !WriteNode(*static_cast<base::DictionaryValue*>(other_folder_value),
                    BookmarkNode::OTHER_NODE) ||
-        !WriteNode(*static_cast<DictionaryValue*>(mobile_folder_value),
+        !WriteNode(*static_cast<base::DictionaryValue*>(mobile_folder_value),
                    BookmarkNode::MOBILE)) {
       return;
     }
 
     DecrementIndent();
 
     Write(kFolderChildrenEnd);
     Write(kNewline);
     // File stream close is forced so that unit test could read it.
     file_stream_.reset();
@@ skipping 86 matching lines @@
   // Converts a time string written to the JSON codec into a time_t string
   // (used by bookmarks.html) and writes it.
   bool WriteTime(const std::string& time_string) {
     int64 internal_value;
     base::StringToInt64(time_string, &internal_value);
     return Write(base::Int64ToString(
         base::Time::FromInternalValue(internal_value).ToTimeT()));
   }
 
   // Writes the node and all its children, returning true on success.
-  bool WriteNode(const DictionaryValue& value,
+  bool WriteNode(const base::DictionaryValue& value,
                 BookmarkNode::Type folder_type) {
     std::string title, date_added_string, type_string;
     if (!value.GetString(BookmarkCodec::kNameKey, &title) ||
         !value.GetString(BookmarkCodec::kDateAddedKey, &date_added_string) ||
         !value.GetString(BookmarkCodec::kTypeKey, &type_string) ||
         (type_string != BookmarkCodec::kTypeURL &&
          type_string != BookmarkCodec::kTypeFolder))  {
       NOTREACHED();
       return false;
     }
@@ skipping 31 matching lines @@
           !Write(title, CONTENT) ||
           !Write(kBookmarkEnd) ||
           !Write(kNewline)) {
         return false;
       }
       return true;
     }
 
     // Folder.
     std::string last_modified_date;
-    const Value* child_values = NULL;
+    const base::Value* child_values = NULL;
     if (!value.GetString(BookmarkCodec::kDateModifiedKey,
                          &last_modified_date) ||
         !value.Get(BookmarkCodec::kChildrenKey, &child_values) ||
-        child_values->GetType() != Value::TYPE_LIST) {
+        child_values->GetType() != base::Value::TYPE_LIST) {
       NOTREACHED();
       return false;
     }
     if (folder_type != BookmarkNode::OTHER_NODE &&
         folder_type != BookmarkNode::MOBILE) {
       // The other/mobile folder name are not written out. This gives the effect
       // of making the contents of the 'other folder' be a sibling to the
       // bookmark bar folder.
       if (!WriteIndent() ||
           !Write(kFolderStart) ||
@@ skipping 14 matching lines @@
           !Write(kNewline) ||
           !WriteIndent() ||
           !Write(kFolderChildren) ||
           !Write(kNewline)) {
         return false;
       }
       IncrementIndent();
     }
 
     // Write the children.
-    const ListValue* children = static_cast<const ListValue*>(child_values);
+    const base::ListValue* children =
+        static_cast<const base::ListValue*>(child_values);
     for (size_t i = 0; i < children->GetSize(); ++i) {
-      const Value* child_value;
+      const base::Value* child_value;
       if (!children->Get(i, &child_value) ||
-          child_value->GetType() != Value::TYPE_DICTIONARY) {
+          child_value->GetType() != base::Value::TYPE_DICTIONARY) {
         NOTREACHED();
         return false;
       }
-      if (!WriteNode(*static_cast<const DictionaryValue*>(child_value),
+      if (!WriteNode(*static_cast<const base::DictionaryValue*>(child_value),
                      BookmarkNode::FOLDER)) {
         return false;
       }
     }
     if (folder_type != BookmarkNode::OTHER_NODE &&
         folder_type != BookmarkNode::MOBILE) {
       // Close out the folder.
       DecrementIndent();
       if (!WriteIndent() ||
           !Write(kFolderChildrenEnd) ||
           !Write(kNewline)) {
         return false;
       }
     }
     return true;
   }
 
-  // The BookmarkModel as a Value. This value was generated from the
+  // The BookmarkModel as a base::Value. This value was generated from the
   // BookmarkCodec.
-  scoped_ptr<Value> bookmarks_;
+  scoped_ptr<base::Value> bookmarks_;
 
   // Path we're writing to.
   base::FilePath path_;
 
   // Map that stores favicon per URL.
   scoped_ptr<BookmarkFaviconFetcher::URLFaviconMap> favicons_map_;
 
   // Observer to be notified on finish.
   BookmarksExportObserver* observer_;
 
@@ skipping 126 matching lines @@
   // BookmarkModel isn't thread safe (nor would we want to lock it down
   // for the duration of the write), as such we make a copy of the
   // BookmarkModel using BookmarkCodec then write from that.
   if (fetcher == NULL) {
     fetcher = new BookmarkFaviconFetcher(profile, path, observer);
     fetcher->ExportBookmarks();
   }
 }
 
 }  // namespace bookmark_html_writer