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

chrome/browser/accessibility/accessibility_events.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/accessibility/accessibility_events.h"
 
 #include "base/values.h"
 #include "chrome/browser/accessibility/accessibility_extension_api.h"
 #include "chrome/browser/accessibility/accessibility_extension_api_constants.h"
 #include "chrome/browser/chrome_notification_types.h"
@@ skipping 40 matching lines @@
 
 AccessibilityControlInfo::AccessibilityControlInfo(
     Profile* profile, const std::string& name)
     : AccessibilityEventInfo(profile),
       name_(name) {
 }
 
 AccessibilityControlInfo::~AccessibilityControlInfo() {
 }
 
-void AccessibilityControlInfo::SerializeToDict(DictionaryValue *dict) const {
+void AccessibilityControlInfo::SerializeToDict(
+    base::DictionaryValue *dict) const {
   dict->SetString(keys::kNameKey, name_);
   dict->SetString(keys::kTypeKey, type());
   if (!context_.empty())
     dict->SetString(keys::kContextKey, context_);
 }
 
 AccessibilityWindowInfo::AccessibilityWindowInfo(Profile* profile,
                                                  const std::string& window_name)
     : AccessibilityControlInfo(profile, window_name) {
 }
@@ skipping 36 matching lines @@
       item_index_(item_index),
       item_count_(item_count) {
   set_context(context);
 }
 
 const char* AccessibilityRadioButtonInfo::type() const {
   return keys::kTypeRadioButton;
 }
 
 void AccessibilityRadioButtonInfo::SerializeToDict(
-    DictionaryValue *dict) const {
+    base::DictionaryValue *dict) const {
   AccessibilityControlInfo::SerializeToDict(dict);
   dict->SetBoolean(keys::kCheckedKey, checked_);
   dict->SetInteger(keys::kItemIndexKey, item_index_);
   dict->SetInteger(keys::kItemCountKey, item_count_);
 }
 
 AccessibilityCheckboxInfo::AccessibilityCheckboxInfo(Profile* profile,
                                                      const std::string& name,
                                                      const std::string& context,
                                                      bool checked)
     : AccessibilityControlInfo(profile, name),
       checked_(checked) {
   set_context(context);
 }
 
 const char* AccessibilityCheckboxInfo::type() const {
   return keys::kTypeCheckbox;
 }
 
-void AccessibilityCheckboxInfo::SerializeToDict(DictionaryValue *dict) const {
+void AccessibilityCheckboxInfo::SerializeToDict(
+    base::DictionaryValue *dict) const {
   AccessibilityControlInfo::SerializeToDict(dict);
   dict->SetBoolean(keys::kCheckedKey, checked_);
 }
 
 AccessibilityTabInfo::AccessibilityTabInfo(Profile* profile,
                                            const std::string& tab_name,
                                            const std::string& context,
                                            int tab_index,
                                            int tab_count)
     : AccessibilityControlInfo(profile, tab_name),
       tab_index_(tab_index),
       tab_count_(tab_count) {
   set_context(context);
 }
 
 const char* AccessibilityTabInfo::type() const {
   return keys::kTypeTab;
 }
 
-void AccessibilityTabInfo::SerializeToDict(DictionaryValue *dict) const {
+void AccessibilityTabInfo::SerializeToDict(base::DictionaryValue *dict) const {
   AccessibilityControlInfo::SerializeToDict(dict);
   dict->SetInteger(keys::kItemIndexKey, tab_index_);
   dict->SetInteger(keys::kItemCountKey, tab_count_);
 }
 
 AccessibilityComboBoxInfo::AccessibilityComboBoxInfo(Profile* profile,
                                                      const std::string& name,
                                                      const std::string& context,
                                                      const std::string& value,
                                                      int item_index,
                                                      int item_count)
     : AccessibilityControlInfo(profile, name),
       value_(value),
       item_index_(item_index),
       item_count_(item_count) {
   set_context(context);
 }
 
 const char* AccessibilityComboBoxInfo::type() const {
   return keys::kTypeComboBox;
 }
 
-void AccessibilityComboBoxInfo::SerializeToDict(DictionaryValue *dict) const {
+void AccessibilityComboBoxInfo::SerializeToDict(
+    base::DictionaryValue *dict) const {
   AccessibilityControlInfo::SerializeToDict(dict);
   dict->SetString(keys::kValueKey, value_);
   dict->SetInteger(keys::kItemIndexKey, item_index_);
   dict->SetInteger(keys::kItemCountKey, item_count_);
 }
 
 AccessibilityTextBoxInfo::AccessibilityTextBoxInfo(Profile* profile,
                                                    const std::string& name,
                                                    const std::string& context,
                                                    bool password)
     : AccessibilityControlInfo(profile, name),
       password_(password),
       selection_start_(0),
       selection_end_(0) {
   set_context(context);
 }
 
 const char* AccessibilityTextBoxInfo::type() const {
   return keys::kTypeTextBox;
 }
 
-void AccessibilityTextBoxInfo::SerializeToDict(DictionaryValue *dict) const {
+void AccessibilityTextBoxInfo::SerializeToDict(
+    base::DictionaryValue *dict) const {
   AccessibilityControlInfo::SerializeToDict(dict);
   dict->SetString(keys::kValueKey, value_);
   dict->SetBoolean(keys::kPasswordKey, password_);
   dict->SetInteger(keys::kSelectionStartKey, selection_start_);
   dict->SetInteger(keys::kSelectionEndKey, selection_end_);
 }
 
 AccessibilityListBoxInfo::AccessibilityListBoxInfo(Profile* profile,
                                                    const std::string& name,
                                                    const std::string& context,
                                                    const std::string& value,
                                                    int item_index,
                                                    int item_count)
     : AccessibilityControlInfo(profile, name),
       value_(value),
       item_index_(item_index),
       item_count_(item_count) {
   set_context(context);
 }
 
 const char* AccessibilityListBoxInfo::type() const {
   return keys::kTypeListBox;
 }
 
-void AccessibilityListBoxInfo::SerializeToDict(DictionaryValue *dict) const {
+void AccessibilityListBoxInfo::SerializeToDict(
+    base::DictionaryValue *dict) const {
   AccessibilityControlInfo::SerializeToDict(dict);
   dict->SetString(keys::kValueKey, value_);
   dict->SetInteger(keys::kItemIndexKey, item_index_);
   dict->SetInteger(keys::kItemCountKey, item_count_);
 }
 
 AccessibilityMenuInfo::AccessibilityMenuInfo(Profile* profile,
                                              const std::string& menu_name)
     : AccessibilityControlInfo(profile, menu_name) {
 }
@@ skipping 12 matching lines @@
       has_submenu_(has_submenu),
       item_index_(item_index),
       item_count_(item_count) {
   set_context(context);
 }
 
 const char* AccessibilityMenuItemInfo::type() const {
   return keys::kTypeMenuItem;
 }
 
-void AccessibilityMenuItemInfo::SerializeToDict(DictionaryValue *dict) const {
+void AccessibilityMenuItemInfo::SerializeToDict(
+    base::DictionaryValue *dict) const {
   AccessibilityControlInfo::SerializeToDict(dict);
   dict->SetBoolean(keys::kHasSubmenuKey, has_submenu_);
   dict->SetInteger(keys::kItemIndexKey, item_index_);
   dict->SetInteger(keys::kItemCountKey, item_count_);
 }
 
 AccessibilityTreeInfo::AccessibilityTreeInfo(Profile* profile,
                                              const std::string& menu_name)
     : AccessibilityControlInfo(profile, menu_name) {
 }
@@ skipping 16 matching lines @@
       item_count_(item_count),
       children_count_(children_count),
       is_expanded_(is_expanded) {
   set_context(context);
 }
 
 const char* AccessibilityTreeItemInfo::type() const {
   return keys::kTypeTreeItem;
 }
 
-void AccessibilityTreeItemInfo::SerializeToDict(DictionaryValue *dict) const {
+void AccessibilityTreeItemInfo::SerializeToDict(
+    base::DictionaryValue *dict) const {
   AccessibilityControlInfo::SerializeToDict(dict);
   dict->SetInteger(keys::kItemDepthKey, item_depth_);
   dict->SetInteger(keys::kItemIndexKey, item_index_);
   dict->SetInteger(keys::kItemCountKey, item_count_);
   dict->SetInteger(keys::kChildrenCountKey, children_count_);
   dict->SetBoolean(keys::kItemExpandedKey, is_expanded_);
 }
 
 AccessibilitySliderInfo::AccessibilitySliderInfo(Profile* profile,
                                                  const std::string& name,
                                                  const std::string& context,
                                                  const std::string& value)
     : AccessibilityControlInfo(profile, name),
       value_(value) {
   set_context(context);
 }
 
 const char* AccessibilitySliderInfo::type() const {
   return keys::kTypeSlider;
 }
 
-void AccessibilitySliderInfo::SerializeToDict(DictionaryValue *dict) const {
+void AccessibilitySliderInfo::SerializeToDict(
+    base::DictionaryValue *dict) const {
   AccessibilityControlInfo::SerializeToDict(dict);
   dict->SetString(keys::kStringValueKey, value_);
 }
 
 AccessibilityAlertInfo::AccessibilityAlertInfo(Profile* profile,
                                                const std::string& name)
     : AccessibilityControlInfo(profile, name) {
 }
 
 const char* AccessibilityAlertInfo::type() const {
   return keys::kTypeAlert;
 }