Add a context field to the accessibility extension API.

chrome/browser/accessibility/accessibility_events.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/accessibility/accessibility_events.h"
 
 #include "base/values.h"
 
 #include "chrome/browser/accessibility/accessibility_extension_api_constants.h"
 #include "chrome/browser/profiles/profile.h"
@@ skipping 15 matching lines @@
 }
 
 void SendAccessibilityVolumeNotification(double volume, bool is_muted) {
   Profile* profile = ProfileManager::GetDefaultProfile();
   AccessibilityVolumeInfo info(profile, volume, is_muted);
   SendAccessibilityNotification(
       chrome::NOTIFICATION_ACCESSIBILITY_VOLUME_CHANGED, &info);
 }
 
 AccessibilityControlInfo::AccessibilityControlInfo(
-    Profile* profile, const std::string& control_name)
-    : AccessibilityEventInfo(profile), name_(control_name) {
+    Profile* profile, const std::string& name, const std::string& context)
+    : AccessibilityEventInfo(profile),
+      name_(name),
+      context_(context) {
 }
 
 AccessibilityControlInfo::~AccessibilityControlInfo() {
 }
 
 void AccessibilityControlInfo::SerializeToDict(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) {
+    : AccessibilityControlInfo(profile, window_name, std::string()) {
 }
 
 const char* AccessibilityWindowInfo::type() const {
   return keys::kTypeWindow;
 }
 
 AccessibilityButtonInfo::AccessibilityButtonInfo(Profile* profile,
-                                                 const std::string& button_name)
-    : AccessibilityControlInfo(profile, button_name) {
+                                                 const std::string& button_name,
+                                                 const std::string& context)
+    : AccessibilityControlInfo(profile, button_name, context) {
 }
 
 const char* AccessibilityButtonInfo::type() const {
   return keys::kTypeButton;
 }
 
 AccessibilityLinkInfo::AccessibilityLinkInfo(Profile* profile,
-                                             const std::string& link_name)
-      : AccessibilityControlInfo(profile, link_name) { }
+                                             const std::string& link_name,
+                                             const std::string& context)
+    : AccessibilityControlInfo(profile, link_name, context) { }
 
 const char* AccessibilityLinkInfo::type() const {
   return keys::kTypeLink;
 }
 
 AccessibilityRadioButtonInfo::AccessibilityRadioButtonInfo(
     Profile* profile,
     const std::string& name,
+    const std::string& context,
     bool checked,
     int item_index,
     int item_count)
-    : AccessibilityControlInfo(profile, name),
+    : AccessibilityControlInfo(profile, name, context),
       checked_(checked),
       item_index_(item_index),
       item_count_(item_count) {
 }
 
 const char* AccessibilityRadioButtonInfo::type() const {
   return keys::kTypeRadioButton;
 }
 
 void AccessibilityRadioButtonInfo::SerializeToDict(
     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),
+    : AccessibilityControlInfo(profile, name, context),
       checked_(checked) {
 }
 
 const char* AccessibilityCheckboxInfo::type() const {
   return keys::kTypeCheckbox;
 }
 
 void AccessibilityCheckboxInfo::SerializeToDict(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),
+    : AccessibilityControlInfo(profile, tab_name, context),
       tab_index_(tab_index),
       tab_count_(tab_count) {
 }
 
 const char* AccessibilityTabInfo::type() const {
   return keys::kTypeTab;
 }
 
 void AccessibilityTabInfo::SerializeToDict(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),
+    : AccessibilityControlInfo(profile, name, context),
       value_(value),
       item_index_(item_index),
       item_count_(item_count) {
 }
 
 const char* AccessibilityComboBoxInfo::type() const {
   return keys::kTypeComboBox;
 }
 
 void AccessibilityComboBoxInfo::SerializeToDict(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),
+    : AccessibilityControlInfo(profile, name, context),
       value_(""),
       password_(password),
       selection_start_(0),
       selection_end_(0) {
 }
 
 const char* AccessibilityTextBoxInfo::type() const {
   return keys::kTypeTextBox;
 }
 
 void AccessibilityTextBoxInfo::SerializeToDict(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),
+    : AccessibilityControlInfo(profile, name, context),
       value_(value),
       item_index_(item_index),
       item_count_(item_count) {
 }
 
 const char* AccessibilityListBoxInfo::type() const {
   return keys::kTypeListBox;
 }
 
 void AccessibilityListBoxInfo::SerializeToDict(DictionaryValue *dict) const {
@@ skipping 28 matching lines @@
 
 WokeUpEventInfo::WokeUpEventInfo(Profile* profile)
     : AccessibilityEventInfo(profile) {
 }
 
 void WokeUpEventInfo::SerializeToDict(DictionaryValue *dict) const {
 }
 
 AccessibilityMenuInfo::AccessibilityMenuInfo(Profile* profile,
                                              const std::string& menu_name)
-    : AccessibilityControlInfo(profile, menu_name) {
+    : AccessibilityControlInfo(profile, menu_name, std::string()) {
 }
 
 const char* AccessibilityMenuInfo::type() const {
   return keys::kTypeMenu;
 }
 
 AccessibilityMenuItemInfo::AccessibilityMenuItemInfo(Profile* profile,
                                                      const std::string& name,
+                                                     const std::string& context,
                                                      bool has_submenu,
                                                      int item_index,
                                                      int item_count)
-    : AccessibilityControlInfo(profile, name),
+    : AccessibilityControlInfo(profile, name, context),
       has_submenu_(has_submenu),
       item_index_(item_index),
       item_count_(item_count) {
 }
 
 const char* AccessibilityMenuItemInfo::type() const {
   return keys::kTypeMenuItem;
 }
 
 void AccessibilityMenuItemInfo::SerializeToDict(DictionaryValue *dict) const {
   AccessibilityControlInfo::SerializeToDict(dict);
   dict->SetBoolean(keys::kHasSubmenuKey, has_submenu_);
   dict->SetInteger(keys::kItemIndexKey, item_index_);
   dict->SetInteger(keys::kItemCountKey, item_count_);
 }