This source file includes following definitions.
- Initialize
- AddProperties
- ToString
- GetActualFileSuffix
- GetExpectedFileSuffix
- GetAllowEmptyString
- GetAllowString
- GetDenyString
#include "content/browser/accessibility/accessibility_tree_formatter.h"
#include <oleacc.h>
#include <string>
#include "base/files/file_path.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "content/browser/accessibility/accessibility_tree_formatter_utils_win.h"
#include "content/browser/accessibility/browser_accessibility_manager.h"
#include "content/browser/accessibility/browser_accessibility_win.h"
#include "third_party/iaccessible2/ia2_api_all.h"
#include "ui/base/win/atl_module.h"
using base::StringPrintf;
namespace content {
const char* ALL_ATTRIBUTES[] = {
"name",
"value",
"states",
"attributes",
"role_name",
"currentValue",
"minimumValue",
"maximumValue",
"description",
"default_action",
"keyboard_shortcut",
"location",
"size",
"index_in_parent",
"n_relations",
"group_level",
"similar_items_in_group",
"position_in_group",
"table_rows",
"table_columns",
"row_index",
"column_index",
"n_characters",
"caret_offset",
"n_selections",
"selection_start",
"selection_end"
};
void AccessibilityTreeFormatter::Initialize() {
ui::win::CreateATLModuleIfNeeded();
}
void AccessibilityTreeFormatter::AddProperties(
const BrowserAccessibility& node, base::DictionaryValue* dict) {
BrowserAccessibilityWin* acc_obj =
const_cast<BrowserAccessibility*>(&node)->ToBrowserAccessibilityWin();
VARIANT variant_self;
variant_self.vt = VT_I4;
variant_self.lVal = CHILDID_SELF;
dict->SetString("role", IAccessible2RoleToString(acc_obj->ia2_role()));
CComBSTR msaa_variant;
HRESULT hresult = acc_obj->get_accName(variant_self, &msaa_variant);
if (hresult == S_OK)
dict->SetString("name", msaa_variant.m_str);
hresult = acc_obj->get_accValue(variant_self, &msaa_variant);
if (hresult == S_OK)
dict->SetString("value", msaa_variant.m_str);
std::vector<base::string16> state_strings;
int32 ia_state = acc_obj->ia_state();
ia_state &= ~STATE_SYSTEM_HOTTRACKED;
ia_state &= ~STATE_SYSTEM_OFFSCREEN;
IAccessibleStateToStringVector(ia_state, &state_strings);
IAccessible2StateToStringVector(acc_obj->ia2_state(), &state_strings);
base::ListValue* states = new base::ListValue;
for (std::vector<base::string16>::const_iterator it = state_strings.begin();
it != state_strings.end();
++it) {
states->AppendString(base::UTF16ToUTF8(*it));
}
dict->Set("states", states);
const std::vector<base::string16>& ia2_attributes = acc_obj->ia2_attributes();
base::ListValue* attributes = new base::ListValue;
for (std::vector<base::string16>::const_iterator it = ia2_attributes.begin();
it != ia2_attributes.end();
++it) {
attributes->AppendString(base::UTF16ToUTF8(*it));
}
dict->Set("attributes", attributes);
dict->SetString("role_name", acc_obj->role_name());
VARIANT currentValue;
if (acc_obj->get_currentValue(¤tValue) == S_OK)
dict->SetDouble("currentValue", V_R8(¤tValue));
VARIANT minimumValue;
if (acc_obj->get_minimumValue(&minimumValue) == S_OK)
dict->SetDouble("minimumValue", V_R8(&minimumValue));
VARIANT maximumValue;
if (acc_obj->get_maximumValue(&maximumValue) == S_OK)
dict->SetDouble("maximumValue", V_R8(&maximumValue));
hresult = acc_obj->get_accDescription(variant_self, &msaa_variant);
if (hresult == S_OK)
dict->SetString("description", msaa_variant.m_str);
hresult = acc_obj->get_accDefaultAction(variant_self, &msaa_variant);
if (hresult == S_OK)
dict->SetString("default_action", msaa_variant.m_str);
hresult = acc_obj->get_accKeyboardShortcut(variant_self, &msaa_variant);
if (hresult == S_OK)
dict->SetString("keyboard_shortcut", msaa_variant.m_str);
hresult = acc_obj->get_accHelp(variant_self, &msaa_variant);
if (S_OK == hresult)
dict->SetString("help", msaa_variant.m_str);
BrowserAccessibility* root = node.manager()->GetRoot();
LONG left, top, width, height;
LONG root_left, root_top, root_width, root_height;
if (acc_obj->accLocation(&left, &top, &width, &height, variant_self)
!= S_FALSE
&& root->ToBrowserAccessibilityWin()->accLocation(
&root_left, &root_top, &root_width, &root_height, variant_self)
!= S_FALSE) {
base::DictionaryValue* location = new base::DictionaryValue;
location->SetInteger("x", left - root_left);
location->SetInteger("y", top - root_top);
dict->Set("location", location);
base::DictionaryValue* size = new base::DictionaryValue;
size->SetInteger("width", width);
size->SetInteger("height", height);
dict->Set("size", size);
}
LONG index_in_parent;
if (acc_obj->get_indexInParent(&index_in_parent) == S_OK)
dict->SetInteger("index_in_parent", index_in_parent);
LONG n_relations;
if (acc_obj->get_nRelations(&n_relations) == S_OK)
dict->SetInteger("n_relations", n_relations);
LONG group_level, similar_items_in_group, position_in_group;
if (acc_obj->get_groupPosition(&group_level,
&similar_items_in_group,
&position_in_group) == S_OK) {
dict->SetInteger("group_level", group_level);
dict->SetInteger("similar_items_in_group", similar_items_in_group);
dict->SetInteger("position_in_group", position_in_group);
}
LONG table_rows;
if (acc_obj->get_nRows(&table_rows) == S_OK)
dict->SetInteger("table_rows", table_rows);
LONG table_columns;
if (acc_obj->get_nRows(&table_columns) == S_OK)
dict->SetInteger("table_columns", table_columns);
LONG row_index;
if (acc_obj->get_rowIndex(&row_index) == S_OK)
dict->SetInteger("row_index", row_index);
LONG column_index;
if (acc_obj->get_columnIndex(&column_index) == S_OK)
dict->SetInteger("column_index", column_index);
LONG n_characters;
if (acc_obj->get_nCharacters(&n_characters) == S_OK)
dict->SetInteger("n_characters", n_characters);
LONG caret_offset;
if (acc_obj->get_caretOffset(&caret_offset) == S_OK)
dict->SetInteger("caret_offset", caret_offset);
LONG n_selections;
if (acc_obj->get_nSelections(&n_selections) == S_OK) {
dict->SetInteger("n_selections", n_selections);
if (n_selections > 0) {
LONG start, end;
if (acc_obj->get_selection(0, &start, &end) == S_OK) {
dict->SetInteger("selection_start", start);
dict->SetInteger("selection_end", end);
}
}
}
}
base::string16 AccessibilityTreeFormatter::ToString(
const base::DictionaryValue& dict,
const base::string16& indent) {
base::string16 line;
base::string16 role_value;
dict.GetString("role", &role_value);
WriteAttribute(true, base::UTF16ToUTF8(role_value), &line);
base::string16 name_value;
dict.GetString("name", &name_value);
WriteAttribute(true, base::StringPrintf(L"name='%ls'", name_value.c_str()),
&line);
for (int i = 0; i < arraysize(ALL_ATTRIBUTES); i++) {
const char* attribute_name = ALL_ATTRIBUTES[i];
const base::Value* value;
if (!dict.Get(attribute_name, &value))
continue;
switch (value->GetType()) {
case base::Value::TYPE_STRING: {
base::string16 string_value;
value->GetAsString(&string_value);
WriteAttribute(false,
StringPrintf(L"%ls='%ls'",
base::UTF8ToUTF16(attribute_name).c_str(),
string_value.c_str()),
&line);
break;
}
case base::Value::TYPE_INTEGER: {
int int_value;
value->GetAsInteger(&int_value);
WriteAttribute(false,
base::StringPrintf(L"%ls=%d",
base::UTF8ToUTF16(
attribute_name).c_str(),
int_value),
&line);
break;
}
case base::Value::TYPE_DOUBLE: {
double double_value;
value->GetAsDouble(&double_value);
WriteAttribute(false,
base::StringPrintf(L"%ls=%.2f",
base::UTF8ToUTF16(
attribute_name).c_str(),
double_value),
&line);
break;
}
case base::Value::TYPE_LIST: {
const base::ListValue* list_value;
value->GetAsList(&list_value);
for (base::ListValue::const_iterator it = list_value->begin();
it != list_value->end();
++it) {
base::string16 string_value;
if ((*it)->GetAsString(&string_value))
WriteAttribute(false, string_value, &line);
}
break;
}
case base::Value::TYPE_DICTIONARY: {
const base::DictionaryValue* dict_value;
value->GetAsDictionary(&dict_value);
if (strcmp(attribute_name, "size") == 0) {
WriteAttribute(false,
FormatCoordinates("size", "width", "height",
*dict_value),
&line);
} else if (strcmp(attribute_name, "location") == 0) {
WriteAttribute(false,
FormatCoordinates("location", "x", "y", *dict_value),
&line);
}
break;
}
default:
NOTREACHED();
break;
}
}
return indent + line + base::ASCIIToUTF16("\n");
}
const base::FilePath::StringType
AccessibilityTreeFormatter::GetActualFileSuffix() {
return FILE_PATH_LITERAL("-actual-win.txt");
}
const base::FilePath::StringType
AccessibilityTreeFormatter::GetExpectedFileSuffix() {
return FILE_PATH_LITERAL("-expected-win.txt");
}
const std::string AccessibilityTreeFormatter::GetAllowEmptyString() {
return "@WIN-ALLOW-EMPTY:";
}
const std::string AccessibilityTreeFormatter::GetAllowString() {
return "@WIN-ALLOW:";
}
const std::string AccessibilityTreeFormatter::GetDenyString() {
return "@WIN-DENY:";
}
}