Convert most of extensions and some other random stuff to using the base namespace for Values.

chrome/browser/extensions/api/bookmarks/bookmarks_api.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/extensions/api/bookmarks/bookmarks_api.h"
 
 #include "base/bind.h"
 #include "base/files/file_path.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/i18n/time_formatting.h"
@@ skipping 130 matching lines @@
 }
 
 BookmarkEventRouter::~BookmarkEventRouter() {
   if (model_) {
     model_->RemoveObserver(this);
   }
 }
 
 void BookmarkEventRouter::DispatchEvent(
     const char* event_name,
-    scoped_ptr<ListValue> event_args) {
+    scoped_ptr<base::ListValue> event_args) {
   if (extensions::ExtensionSystem::Get(profile_)->event_router()) {
     extensions::ExtensionSystem::Get(profile_)->event_router()->BroadcastEvent(
         make_scoped_ptr(new extensions::Event(event_name, event_args.Pass())));
   }
 }
 
 void BookmarkEventRouter::Loaded(BookmarkModel* model, bool ids_reassigned) {
   // TODO(erikkay): Perhaps we should send this event down to the extension
   // so they know when it's safe to use the API?
 }
 
 void BookmarkEventRouter::BookmarkModelBeingDeleted(BookmarkModel* model) {
   model_ = NULL;
 }
 
 void BookmarkEventRouter::BookmarkNodeMoved(BookmarkModel* model,
                                             const BookmarkNode* old_parent,
                                             int old_index,
                                             const BookmarkNode* new_parent,
                                             int new_index) {
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   const BookmarkNode* node = new_parent->GetChild(new_index);
-  args->Append(new StringValue(base::Int64ToString(node->id())));
-  DictionaryValue* object_args = new DictionaryValue();
+  args->Append(new base::StringValue(base::Int64ToString(node->id())));
+  base::DictionaryValue* object_args = new base::DictionaryValue();
   object_args->SetString(keys::kParentIdKey,
                          base::Int64ToString(new_parent->id()));
   object_args->SetInteger(keys::kIndexKey, new_index);
   object_args->SetString(keys::kOldParentIdKey,
                          base::Int64ToString(old_parent->id()));
   object_args->SetInteger(keys::kOldIndexKey, old_index);
   args->Append(object_args);
 
   DispatchEvent(keys::kOnBookmarkMoved, args.Pass());
 }
 
 void BookmarkEventRouter::BookmarkNodeAdded(BookmarkModel* model,
                                             const BookmarkNode* parent,
                                             int index) {
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   const BookmarkNode* node = parent->GetChild(index);
-  args->Append(new StringValue(base::Int64ToString(node->id())));
+  args->Append(new base::StringValue(base::Int64ToString(node->id())));
   scoped_ptr<BookmarkTreeNode> tree_node(
       bookmark_api_helpers::GetBookmarkTreeNode(node, false, false));
   args->Append(tree_node->ToValue().release());
 
   DispatchEvent(keys::kOnBookmarkCreated, args.Pass());
 }
 
 void BookmarkEventRouter::BookmarkNodeRemoved(BookmarkModel* model,
                                               const BookmarkNode* parent,
                                               int index,
                                               const BookmarkNode* node) {
-  scoped_ptr<ListValue> args(new ListValue());
-  args->Append(new StringValue(base::Int64ToString(node->id())));
-  DictionaryValue* object_args = new DictionaryValue();
+  scoped_ptr<base::ListValue> args(new base::ListValue());
+  args->Append(new base::StringValue(base::Int64ToString(node->id())));
+  base::DictionaryValue* object_args = new base::DictionaryValue();
   object_args->SetString(keys::kParentIdKey,
                          base::Int64ToString(parent->id()));
   object_args->SetInteger(keys::kIndexKey, index);
   args->Append(object_args);
 
   DispatchEvent(keys::kOnBookmarkRemoved, args.Pass());
 }
 
 void BookmarkEventRouter::BookmarkAllNodesRemoved(BookmarkModel* model) {
   NOTREACHED();
   // TODO(shashishekhar) Currently this notification is only used on Android,
   // which does not support extensions. If Desktop needs to support this, add
   // a new event to the extensions api.
 }
 
 void BookmarkEventRouter::BookmarkNodeChanged(BookmarkModel* model,
                                               const BookmarkNode* node) {
-  scoped_ptr<ListValue> args(new ListValue());
-  args->Append(new StringValue(base::Int64ToString(node->id())));
+  scoped_ptr<base::ListValue> args(new base::ListValue());
+  args->Append(new base::StringValue(base::Int64ToString(node->id())));
 
   // TODO(erikkay) The only three things that BookmarkModel sends this
   // notification for are title, url and favicon.  Since we're currently
   // ignoring favicon and since the notification doesn't say which one anyway,
   // for now we only include title and url.  The ideal thing would be to change
   // BookmarkModel to indicate what changed.
-  DictionaryValue* object_args = new DictionaryValue();
+  base::DictionaryValue* object_args = new base::DictionaryValue();
   object_args->SetString(keys::kTitleKey, node->GetTitle());
   if (node->is_url())
     object_args->SetString(keys::kUrlKey, node->url().spec());
   args->Append(object_args);
 
   DispatchEvent(keys::kOnBookmarkChanged, args.Pass());
 }
 
 void BookmarkEventRouter::BookmarkNodeFaviconChanged(BookmarkModel* model,
                                                      const BookmarkNode* node) {
   // TODO(erikkay) anything we should do here?
 }
 
 void BookmarkEventRouter::BookmarkNodeChildrenReordered(
     BookmarkModel* model,
     const BookmarkNode* node) {
-  scoped_ptr<ListValue> args(new ListValue());
-  args->Append(new StringValue(base::Int64ToString(node->id())));
+  scoped_ptr<base::ListValue> args(new base::ListValue());
+  args->Append(new base::StringValue(base::Int64ToString(node->id())));
   int childCount = node->child_count();
-  ListValue* children = new ListValue();
+  base::ListValue* children = new base::ListValue();
   for (int i = 0; i < childCount; ++i) {
     const BookmarkNode* child = node->GetChild(i);
-    Value* child_id = new StringValue(base::Int64ToString(child->id()));
+    base::Value* child_id =
+        new base::StringValue(base::Int64ToString(child->id()));
     children->Append(child_id);
   }
-  DictionaryValue* reorder_info = new DictionaryValue();
+  base::DictionaryValue* reorder_info = new base::DictionaryValue();
   reorder_info->Set(keys::kChildIdsKey, children);
   args->Append(reorder_info);
 
   DispatchEvent(keys::kOnBookmarkChildrenReordered, args.Pass());
 }
 
 void BookmarkEventRouter::ExtensiveBookmarkChangesBeginning(
     BookmarkModel* model) {
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   DispatchEvent(keys::kOnBookmarkImportBegan, args.Pass());
 }
 
 void BookmarkEventRouter::ExtensiveBookmarkChangesEnded(BookmarkModel* model) {
-  scoped_ptr<ListValue> args(new ListValue());
+  scoped_ptr<base::ListValue> args(new base::ListValue());
   DispatchEvent(keys::kOnBookmarkImportEnded, args.Pass());
 }
 
 BookmarksAPI::BookmarksAPI(Profile* profile) : profile_(profile) {
   ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
       this, keys::kOnBookmarkCreated);
   ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
       this, keys::kOnBookmarkRemoved);
   ExtensionSystem::Get(profile_)->event_router()->RegisterObserver(
       this, keys::kOnBookmarkChanged);
@@ skipping 167 matching lines @@
   for (std::vector<const BookmarkNode*>::iterator node_iter = nodes.begin();
        node_iter != nodes.end(); ++node_iter) {
     bookmark_api_helpers::AddNode(*node_iter, &tree_nodes, false);
   }
 
   results_ = bookmarks::Search::Results::Create(tree_nodes);
   return true;
 }
 
 // static
-bool BookmarksRemoveFunction::ExtractIds(const ListValue* args,
+bool BookmarksRemoveFunction::ExtractIds(const base::ListValue* args,
                                          std::list<int64>* ids,
                                          bool* invalid_id) {
   std::string id_string;
   if (!args->GetString(0, &id_string))
     return false;
   int64 id;
   if (base::StringToInt64(id_string, &id))
     ids->push_back(id);
   else
     *invalid_id = true;
@@ skipping 90 matching lines @@
   }
 
   scoped_ptr<BookmarkTreeNode> ret(
       bookmark_api_helpers::GetBookmarkTreeNode(node, false, false));
   results_ = bookmarks::Create::Results::Create(*ret);
 
   return true;
 }
 
 // static
-bool BookmarksMoveFunction::ExtractIds(const ListValue* args,
+bool BookmarksMoveFunction::ExtractIds(const base::ListValue* args,
                                        std::list<int64>* ids,
                                        bool* invalid_id) {
   // For now, Move accepts ID parameters in the same way as an Update.
   return BookmarksUpdateFunction::ExtractIds(args, ids, invalid_id);
 }
 
 bool BookmarksMoveFunction::RunImpl() {
   if (!EditBookmarksEnabled())
     return false;
 
@@ skipping 53 matching lines @@
   model->Move(node, parent, index);
 
   scoped_ptr<BookmarkTreeNode> tree_node(
       bookmark_api_helpers::GetBookmarkTreeNode(node, false, false));
   results_ = bookmarks::Move::Results::Create(*tree_node);
 
   return true;
 }
 
 // static
-bool BookmarksUpdateFunction::ExtractIds(const ListValue* args,
+bool BookmarksUpdateFunction::ExtractIds(const base::ListValue* args,
                                          std::list<int64>* ids,
                                          bool* invalid_id) {
   // For now, Update accepts ID parameters in the same way as an Remove.
   return BookmarksRemoveFunction::ExtractIds(args, ids, invalid_id);
 }
 
 bool BookmarksUpdateFunction::RunImpl() {
   if (!EditBookmarksEnabled())
     return false;
 
@@ skipping 65 matching lines @@
   std::map<BucketIdType, Bucket*> buckets_;
 };
 
 // Mapper for 'bookmarks.create'.  Maps "same input to bookmarks.create" to a
 // unique bucket.
 class CreateBookmarkBucketMapper : public BookmarkBucketMapper<std::string> {
  public:
   explicit CreateBookmarkBucketMapper(Profile* profile) : profile_(profile) {}
   // TODO(tim): This should share code with BookmarksCreateFunction::RunImpl,
   // but I can't figure out a good way to do that with all the macros.
-  virtual void GetBucketsForArgs(const ListValue* args,
+  virtual void GetBucketsForArgs(const base::ListValue* args,
                                  BucketList* buckets) OVERRIDE {
-    const DictionaryValue* json;
+    const base::DictionaryValue* json;
     if (!args->GetDictionary(0, &json))
       return;
 
     std::string parent_id;
     if (json->HasKey(keys::kParentIdKey)) {
       if (!json->GetString(keys::kParentIdKey, &parent_id))
         return;
     }
     BookmarkModel* model = BookmarkModelFactory::GetForProfile(profile_);
 
@@ skipping 16 matching lines @@
     buckets->push_back(GetBucket(base::SHA1HashString(bucket_id)));
   }
  private:
   Profile* profile_;
 };
 
 // Mapper for 'bookmarks.remove'.
 class RemoveBookmarksBucketMapper : public BookmarkBucketMapper<std::string> {
  public:
   explicit RemoveBookmarksBucketMapper(Profile* profile) : profile_(profile) {}
-  virtual void GetBucketsForArgs(const ListValue* args,
+  virtual void GetBucketsForArgs(const base::ListValue* args,
                                  BucketList* buckets) OVERRIDE {
     typedef std::list<int64> IdList;
     IdList ids;
     bool invalid_id = false;
     if (!BookmarksRemoveFunction::ExtractIds(args, &ids, &invalid_id) ||
         invalid_id) {
       return;
     }
 
     for (IdList::iterator it = ids.begin(); it != ids.end(); ++it) {
@@ skipping 14 matching lines @@
 };
 
 // Mapper for any bookmark function accepting bookmark IDs as parameters, where
 // a distinct ID corresponds to a single item in terms of quota limiting.  This
 // is inappropriate for bookmarks.remove, for example, since repeated removals
 // of the same item will actually have a different ID each time.
 template <class FunctionType>
 class BookmarkIdMapper : public BookmarkBucketMapper<int64> {
  public:
   typedef std::list<int64> IdList;
-  virtual void GetBucketsForArgs(const ListValue* args, BucketList* buckets) {
+  virtual void GetBucketsForArgs(const base::ListValue* args,
+                                 BucketList* buckets) {
     IdList ids;
     bool invalid_id = false;
     if (!FunctionType::ExtractIds(args, &ids, &invalid_id) || invalid_id)
       return;
     for (IdList::iterator it = ids.begin(); it != ids.end(); ++it)
       buckets->push_back(GetBucket(*it));
   }
 };
 
 // Builds heuristics for all BookmarkFunctions using specialized BucketMappers.
@@ skipping 187 matching lines @@
 #if !defined(OS_ANDROID)
   // Android does not have support for the standard exporter.
   // TODO(jgreenwald): remove ifdef once extensions are no longer built on
   // Android.
   bookmark_html_writer::WriteBookmarks(profile(), path, NULL);
 #endif
   Release();  // Balanced in BookmarksIOFunction::SelectFile()
 }
 
 }  // namespace extensions