blob: 0bae7f803db8fbf16c91b768452870cd9ae5f1d7 [file] [log] [blame]
// Copyright 2019 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 "content/browser/accessibility/accessibility_tree_formatter_uia_win.h"
#include <math.h>
#include <oleacc.h>
#include <stddef.h>
#include <stdint.h>
#include <uiautomation.h>
#include <wrl/client.h>
#include <iostream>
#include <memory>
#include <string>
#include <utility>
#include "base/command_line.h"
#include "base/files/file_path.h"
#include "base/strings/string_number_conversions.h"
#include "base/strings/string_piece.h"
#include "base/strings/string_util.h"
#include "base/strings/stringprintf.h"
#include "base/strings/utf_string_conversions.h"
#include "base/values.h"
#include "base/win/com_init_util.h"
#include "base/win/scoped_bstr.h"
#include "base/win/scoped_variant.h"
#include "base/win/windows_version.h"
#include "content/browser/accessibility/accessibility_tree_formatter_utils_win.h"
#include "content/browser/accessibility/browser_accessibility_manager.h"
#include "ui/accessibility/accessibility_switches.h"
#include "ui/gfx/win/hwnd_util.h"
namespace {
base::string16 UiaIdentifierToCondensedString16(int32_t id) {
base::string16 identifier = content::UiaIdentifierToString(id);
if (id >= UIA_RuntimeIdPropertyId && id <= UIA_HeadingLevelPropertyId) {
// remove leading 'UIA_' and trailing 'PropertyId'
return identifier.substr(4, identifier.size() - 14);
}
return identifier;
}
std::string UiaIdentifierToCondensedString(int32_t id) {
return base::UTF16ToUTF8(UiaIdentifierToCondensedString16(id));
}
} // namespace
namespace content {
// This is the list of interesting properties to dump.
//
// Certain properties are skipped because they are known to cause crashes if the
// underlying pattern isn't implemented (e.g., LegacyIAccessibleSelection will
// crash on Win7 if the LegacyIAccessible pattern isn't implemented).
//
// Other properties aren't interesting in a tree-dump context (e.g., ProcessId).
//
// Finally, certain properties are dumped as part of a pattern, and don't need
// to be dumped a second time here (e.g., Grid*, GridItem*, RangeValue*, etc.).
// static
const long AccessibilityTreeFormatterUia::properties_[] = {
// UIA_RuntimeIdPropertyId // 30000
UIA_BoundingRectanglePropertyId, // 30001
// UIA_ProcessIdPropertyId // 30002
UIA_ControlTypePropertyId, // 30003
UIA_LocalizedControlTypePropertyId, // 30004
UIA_NamePropertyId, // 30005
UIA_AcceleratorKeyPropertyId, // 30006
UIA_AccessKeyPropertyId, // 30007
UIA_HasKeyboardFocusPropertyId, // 30008
UIA_IsKeyboardFocusablePropertyId, // 30009
UIA_IsEnabledPropertyId, // 30010
UIA_AutomationIdPropertyId, // 30011
UIA_ClassNamePropertyId, // 30012
UIA_HelpTextPropertyId, // 30013
UIA_ClickablePointPropertyId, // 30014
UIA_CulturePropertyId, // 30015
UIA_IsControlElementPropertyId, // 30016
UIA_IsContentElementPropertyId, // 30017
UIA_LabeledByPropertyId, // 30018
UIA_IsPasswordPropertyId, // 30019
// UIA_NativeWindowHandlePropertyId // 30020
UIA_ItemTypePropertyId, // 30021
UIA_IsOffscreenPropertyId, // 30022
UIA_OrientationPropertyId, // 30023
UIA_FrameworkIdPropertyId, // 30024
UIA_IsRequiredForFormPropertyId, // 30025
UIA_ItemStatusPropertyId, // 30026
UIA_IsDockPatternAvailablePropertyId, // 30027
UIA_IsExpandCollapsePatternAvailablePropertyId, // 30028
UIA_IsGridItemPatternAvailablePropertyId, // 30029
UIA_IsGridPatternAvailablePropertyId, // 30030
UIA_IsInvokePatternAvailablePropertyId, // 30031
UIA_IsMultipleViewPatternAvailablePropertyId, // 30032
UIA_IsRangeValuePatternAvailablePropertyId, // 30033
UIA_IsScrollPatternAvailablePropertyId, // 30034
UIA_IsScrollItemPatternAvailablePropertyId, // 30035
UIA_IsSelectionItemPatternAvailablePropertyId, // 30036
UIA_IsSelectionPatternAvailablePropertyId, // 30037
UIA_IsTablePatternAvailablePropertyId, // 30038
UIA_IsTableItemPatternAvailablePropertyId, // 30039
UIA_IsTextPatternAvailablePropertyId, // 30040
UIA_IsTogglePatternAvailablePropertyId, // 30041
UIA_IsTransformPatternAvailablePropertyId, // 30042
UIA_IsValuePatternAvailablePropertyId, // 30043
UIA_IsWindowPatternAvailablePropertyId, // 30044
// UIA_Value* // 30045-30046
// UIA_RangeValue* // 30047-30052
// UIA_Scroll* // 30053-30058
UIA_SelectionSelectionPropertyId, // 30059
// UIA_Selection* // 30060-30061
// UIA_Grid* // 30062-30068
UIA_DockDockPositionPropertyId, // 30069
UIA_ExpandCollapseExpandCollapseStatePropertyId, // 30070
UIA_MultipleViewCurrentViewPropertyId, // 30071
UIA_MultipleViewSupportedViewsPropertyId, // 30072
UIA_WindowCanMaximizePropertyId, // 30073
UIA_WindowCanMinimizePropertyId, // 30074
UIA_WindowWindowVisualStatePropertyId, // 30075
UIA_WindowWindowInteractionStatePropertyId, // 30076
// UIA_WindowIsModalPropertyId // 30077
UIA_WindowIsTopmostPropertyId, // 30078
// UIA_SelectionItem* // 30079-30080
UIA_TableRowHeadersPropertyId, // 30081
UIA_TableColumnHeadersPropertyId, // 30082
// UIA_TableRowOrColumnMajorPropertyId // 30083
UIA_TableItemRowHeaderItemsPropertyId, // 30084
UIA_TableItemColumnHeaderItemsPropertyId, // 30085
// UIA_ToggleToggleStatePropertyId // 30086
UIA_TransformCanMovePropertyId, // 30087
UIA_TransformCanResizePropertyId, // 30088
UIA_TransformCanRotatePropertyId, // 30089
UIA_IsLegacyIAccessiblePatternAvailablePropertyId, // 30090
// UIA_LegacyIAccessible* // 30091-30100
UIA_AriaRolePropertyId, // 30101
UIA_AriaPropertiesPropertyId, // 30102
UIA_IsDataValidForFormPropertyId, // 30103
UIA_ControllerForPropertyId, // 30104
UIA_DescribedByPropertyId, // 30105
UIA_FlowsToPropertyId, // 30106
// UIA_ProviderDescriptionPropertyId // 30107
UIA_IsItemContainerPatternAvailablePropertyId, // 30108
UIA_IsVirtualizedItemPatternAvailablePropertyId, // 30109
UIA_IsSynchronizedInputPatternAvailablePropertyId, // 30110
UIA_OptimizeForVisualContentPropertyId, // 30111
UIA_IsObjectModelPatternAvailablePropertyId, // 30112
UIA_AnnotationAnnotationTypeIdPropertyId, // 30113
UIA_AnnotationAnnotationTypeNamePropertyId, // 30114
UIA_AnnotationAuthorPropertyId, // 30115
UIA_AnnotationDateTimePropertyId, // 30116
UIA_AnnotationTargetPropertyId, // 30117
UIA_IsAnnotationPatternAvailablePropertyId, // 30118
UIA_IsTextPattern2AvailablePropertyId, // 30119
UIA_StylesStyleIdPropertyId, // 30120
UIA_StylesStyleNamePropertyId, // 30121
UIA_StylesFillColorPropertyId, // 30122
UIA_StylesFillPatternStylePropertyId, // 30123
UIA_StylesShapePropertyId, // 30124
UIA_StylesFillPatternColorPropertyId, // 30125
UIA_StylesExtendedPropertiesPropertyId, // 30126
UIA_IsStylesPatternAvailablePropertyId, // 30127
UIA_IsSpreadsheetPatternAvailablePropertyId, // 30128
UIA_SpreadsheetItemFormulaPropertyId, // 30129
UIA_SpreadsheetItemAnnotationObjectsPropertyId, // 30130
UIA_SpreadsheetItemAnnotationTypesPropertyId, // 30131
UIA_IsSpreadsheetItemPatternAvailablePropertyId, // 30132
UIA_Transform2CanZoomPropertyId, // 30133
UIA_IsTransformPattern2AvailablePropertyId, // 30134
UIA_LiveSettingPropertyId, // 30135
UIA_IsTextChildPatternAvailablePropertyId, // 30136
UIA_IsDragPatternAvailablePropertyId, // 30137
UIA_DragIsGrabbedPropertyId, // 30138
UIA_DragDropEffectPropertyId, // 30139
UIA_DragDropEffectsPropertyId, // 30140
UIA_IsDropTargetPatternAvailablePropertyId, // 30141
UIA_DropTargetDropTargetEffectPropertyId, // 30142
UIA_DropTargetDropTargetEffectsPropertyId, // 30143
UIA_DragGrabbedItemsPropertyId, // 30144
UIA_Transform2ZoomLevelPropertyId, // 30145
UIA_Transform2ZoomMinimumPropertyId, // 30146
UIA_Transform2ZoomMaximumPropertyId, // 30147
UIA_FlowsFromPropertyId, // 30148
UIA_IsTextEditPatternAvailablePropertyId, // 30149
UIA_IsPeripheralPropertyId, // 30150
UIA_IsCustomNavigationPatternAvailablePropertyId, // 30151
UIA_PositionInSetPropertyId, // 30152
UIA_SizeOfSetPropertyId, // 30153
UIA_LevelPropertyId, // 30154
UIA_AnnotationTypesPropertyId, // 30155
UIA_AnnotationObjectsPropertyId, // 30156
UIA_LandmarkTypePropertyId, // 30157
UIA_LocalizedLandmarkTypePropertyId, // 30158
UIA_FullDescriptionPropertyId, // 30159
UIA_FillColorPropertyId, // 30160
UIA_OutlineColorPropertyId, // 30161
UIA_FillTypePropertyId, // 30162
UIA_VisualEffectsPropertyId, // 30163
UIA_OutlineThicknessPropertyId, // 30164
UIA_CenterPointPropertyId, // 30165
UIA_RotationPropertyId, // 30166
UIA_SizePropertyId, // 30167
UIA_IsSelectionPattern2AvailablePropertyId, // 30168
UIA_Selection2FirstSelectedItemPropertyId, // 30169
UIA_Selection2LastSelectedItemPropertyId, // 30170
UIA_Selection2CurrentSelectedItemPropertyId, // 30171
UIA_Selection2ItemCountPropertyId, // 30172
UIA_HeadingLevelPropertyId, // 30173
};
// static
std::unique_ptr<AccessibilityTreeFormatter>
AccessibilityTreeFormatterUia::CreateUia() {
base::win::AssertComInitialized();
return std::make_unique<AccessibilityTreeFormatterUia>();
}
AccessibilityTreeFormatterUia::AccessibilityTreeFormatterUia() {
// Create an instance of the CUIAutomation class.
CoCreateInstance(CLSID_CUIAutomation, NULL, CLSCTX_INPROC_SERVER,
IID_IUIAutomation, &uia_);
CHECK(uia_.Get());
BuildCacheRequests();
}
AccessibilityTreeFormatterUia::~AccessibilityTreeFormatterUia() {}
void AccessibilityTreeFormatterUia::AddDefaultFilters(
std::vector<PropertyFilter>* property_filters) {
AddPropertyFilter(property_filters, "Name=*");
AddPropertyFilter(property_filters, "ItemStatus=*");
AddPropertyFilter(property_filters, "IsKeyboardFocusable=true");
AddPropertyFilter(property_filters, "Orientation=OrientationType_Horizontal");
AddPropertyFilter(property_filters, "IsPassword=true");
AddPropertyFilter(property_filters, "IsControlElement=false");
AddPropertyFilter(property_filters, "IsEnabled=false");
AddPropertyFilter(property_filters, "IsDataValidForForm=true");
AddPropertyFilter(property_filters, "IsRequiredForForm=true");
}
void AccessibilityTreeFormatterUia::SetUpCommandLineForTestPass(
base::CommandLine* command_line) {
base::CommandLine::ForCurrentProcess()->AppendSwitch(
::switches::kEnableExperimentalUIAutomation);
}
std::unique_ptr<base::DictionaryValue>
AccessibilityTreeFormatterUia::BuildAccessibilityTree(
BrowserAccessibility* start) {
// Find the root IUIAutomationElement for the content window.
HWND hwnd =
start->manager()->GetRoot()->GetTargetForNativeAccessibilityEvent();
return BuildAccessibilityTreeForWindow(hwnd);
}
std::unique_ptr<base::DictionaryValue>
AccessibilityTreeFormatterUia::BuildAccessibilityTreeForProcess(
base::ProcessId pid) {
std::unique_ptr<base::DictionaryValue> tree;
// Get HWND for process id.
HWND hwnd = GetHwndForProcess(pid);
return BuildAccessibilityTreeForWindow(hwnd);
}
std::unique_ptr<base::DictionaryValue>
AccessibilityTreeFormatterUia::BuildAccessibilityTreeForWindow(
gfx::AcceleratedWidget hwnd) {
CHECK(hwnd);
Microsoft::WRL::ComPtr<IUIAutomationElement> root;
uia_->ElementFromHandle(hwnd, &root);
CHECK(root.Get());
std::unique_ptr<base::DictionaryValue> tree =
std::make_unique<base::DictionaryValue>();
RecursiveBuildAccessibilityTree(root.Get(), tree.get());
return tree;
}
std::unique_ptr<base::DictionaryValue>
AccessibilityTreeFormatterUia::BuildAccessibilityTreeForPattern(
const base::StringPiece& pattern) {
LOG(ERROR) << "Windows does not yet support building accessibility trees for "
"patterns";
return nullptr;
}
void AccessibilityTreeFormatterUia::RecursiveBuildAccessibilityTree(
IUIAutomationElement* uncached_node,
base::DictionaryValue* dict) {
// Process this node.
AddProperties(uncached_node, dict);
// Update the cache to get children
Microsoft::WRL::ComPtr<IUIAutomationElement> parent;
uncached_node->BuildUpdatedCache(children_cache_request_.Get(), &parent);
Microsoft::WRL::ComPtr<IUIAutomationElementArray> children;
if (!SUCCEEDED(parent->GetCachedChildren(&children)) || !children)
return;
// Process children.
auto child_list = std::make_unique<base::ListValue>();
int child_count;
children->get_Length(&child_count);
for (int i = 0; i < child_count; i++) {
Microsoft::WRL::ComPtr<IUIAutomationElement> child;
std::unique_ptr<base::DictionaryValue> child_dict =
std::make_unique<base::DictionaryValue>();
if (SUCCEEDED(children->GetElement(i, &child))) {
RecursiveBuildAccessibilityTree(child.Get(), child_dict.get());
} else {
child_dict->SetString("error", L"[Error retrieving child]");
}
child_list->Append(std::move(child_dict));
}
dict->Set(kChildrenDictAttr, std::move(child_list));
}
void AccessibilityTreeFormatterUia::AddProperties(
IUIAutomationElement* uncached_node,
base::DictionaryValue* dict) {
// Update the cache for this node's information.
Microsoft::WRL::ComPtr<IUIAutomationElement> node;
uncached_node->BuildUpdatedCache(element_cache_request_.Get(), &node);
// Get all properties that may be on this node.
for (long i : properties_) {
base::win::ScopedVariant variant;
if (SUCCEEDED(node->GetCachedPropertyValue(i, variant.Receive()))) {
WriteProperty(i, variant, dict);
}
}
}
void AccessibilityTreeFormatterUia::WriteProperty(
long propertyId,
const base::win::ScopedVariant& var,
base::DictionaryValue* dict) {
switch (var.type()) {
case VT_EMPTY:
case VT_NULL:
break;
case VT_I2:
dict->SetInteger(UiaIdentifierToCondensedString(propertyId),
var.ptr()->iVal);
break;
case VT_I4:
WriteI4Property(propertyId, var.ptr()->lVal, dict);
break;
case VT_R4:
dict->SetDouble(UiaIdentifierToCondensedString(propertyId),
var.ptr()->fltVal);
break;
case VT_R8:
dict->SetDouble(UiaIdentifierToCondensedString(propertyId),
var.ptr()->dblVal);
break;
case VT_I1:
dict->SetInteger(UiaIdentifierToCondensedString(propertyId),
var.ptr()->cVal);
break;
case VT_UI1:
dict->SetInteger(UiaIdentifierToCondensedString(propertyId),
var.ptr()->bVal);
break;
case VT_UI2:
dict->SetInteger(UiaIdentifierToCondensedString(propertyId),
var.ptr()->uiVal);
break;
case VT_UI4:
dict->SetInteger(UiaIdentifierToCondensedString(propertyId),
var.ptr()->ulVal);
break;
break;
case VT_BSTR:
dict->SetString(UiaIdentifierToCondensedString(propertyId),
BstrToUTF8(var.ptr()->bstrVal));
break;
case VT_BOOL:
dict->SetBoolean(UiaIdentifierToCondensedString(propertyId),
var.ptr()->boolVal == VARIANT_TRUE ? true : false);
break;
case VT_UNKNOWN:
WriteUnknownProperty(propertyId, var.ptr()->punkVal, dict);
break;
case VT_DISPATCH:
case VT_ERROR:
case VT_CY:
case VT_DATE:
case VT_VARIANT:
case VT_DECIMAL:
case VT_INT:
case VT_UINT:
case VT_ARRAY:
case VT_BYREF:
default:
break;
}
}
void AccessibilityTreeFormatterUia::WriteI4Property(
long propertyId,
long lval,
base::DictionaryValue* dict) {
switch (propertyId) {
case UIA_ControlTypePropertyId:
dict->SetString(UiaIdentifierToCondensedString(propertyId),
UiaIdentifierToCondensedString16(lval));
break;
case UIA_OrientationPropertyId:
dict->SetString(UiaIdentifierToCondensedString(propertyId),
UiaOrientationToString(lval));
break;
case UIA_LiveSettingPropertyId:
dict->SetString(UiaIdentifierToCondensedString(propertyId),
UiaLiveSettingToString(lval));
break;
default:
dict->SetInteger(UiaIdentifierToCondensedString(propertyId), lval);
break;
}
}
void AccessibilityTreeFormatterUia::WriteUnknownProperty(
long propertyId,
IUnknown* unk,
base::DictionaryValue* dict) {
switch (propertyId) {
case UIA_ControllerForPropertyId:
case UIA_DescribedByPropertyId:
case UIA_FlowsFromPropertyId:
case UIA_FlowsToPropertyId: {
Microsoft::WRL::ComPtr<IUIAutomationElementArray> array;
if (unk && SUCCEEDED(unk->QueryInterface(IID_PPV_ARGS(&array))))
WriteElementArray(propertyId, array.Get(), dict);
break;
}
case UIA_LabeledByPropertyId: {
Microsoft::WRL::ComPtr<IUIAutomationElement> node;
if (unk && SUCCEEDED(unk->QueryInterface(IID_PPV_ARGS(&node)))) {
dict->SetString(UiaIdentifierToCondensedString(propertyId),
GetNodeName(node.Get()));
}
break;
}
default:
break;
}
}
void AccessibilityTreeFormatterUia::WriteElementArray(
long propertyId,
IUIAutomationElementArray* array,
base::DictionaryValue* dict) {
int count;
array->get_Length(&count);
base::string16 element_list = L"";
for (int i = 0; i < count; i++) {
Microsoft::WRL::ComPtr<IUIAutomationElement> element;
if (SUCCEEDED(array->GetElement(i, &element))) {
if (element_list != L"") {
element_list += L", ";
}
element_list += GetNodeName(element.Get());
}
}
dict->SetString(UiaIdentifierToCondensedString(propertyId), element_list);
}
base::string16 AccessibilityTreeFormatterUia::GetNodeName(
IUIAutomationElement* uncached_node) {
// Update the cache for this node.
Microsoft::WRL::ComPtr<IUIAutomationElement> node;
uncached_node->BuildUpdatedCache(element_cache_request_.Get(), &node);
base::win::ScopedBstr name;
base::win::ScopedVariant variant;
if (SUCCEEDED(node->GetCachedPropertyValue(UIA_NamePropertyId,
variant.Receive())) &&
variant.type() == VT_BSTR) {
return base::string16(variant.ptr()->bstrVal,
SysStringLen(variant.ptr()->bstrVal));
}
return L"";
}
void AccessibilityTreeFormatterUia::BuildCacheRequests() {
// Create cache request for requesting children of a node.
uia_->CreateCacheRequest(&children_cache_request_);
CHECK(children_cache_request_.Get());
children_cache_request_->put_TreeScope(TreeScope_Children);
// Create cache request for requesting information about a node.
uia_->CreateCacheRequest(&element_cache_request_);
CHECK(element_cache_request_.Get());
element_cache_request_->put_TreeScope(TreeScope_Element);
// Caching properties allows us to use GetCachedPropertyValue.
// The non-cached version (GetCurrentPropertyValue) may cross
// the process boundary for each call.
// Cache all properties.
for (long i : properties_) {
element_cache_request_->AddProperty(i);
}
}
base::string16 AccessibilityTreeFormatterUia::ProcessTreeForOutput(
const base::DictionaryValue& dict,
base::DictionaryValue* filtered_dict_result) {
std::unique_ptr<base::DictionaryValue> tree;
base::string16 line;
// Always show role, and show it first.
base::string16 role_value;
dict.GetString(UiaIdentifierToCondensedString(UIA_AriaRolePropertyId),
&role_value);
WriteAttribute(true, base::UTF16ToUTF8(role_value), &line);
if (filtered_dict_result) {
filtered_dict_result->SetString(
UiaIdentifierToStringUTF8(UIA_AriaRolePropertyId), role_value);
}
for (long i : properties_) {
const std::string attribute_name = UiaIdentifierToCondensedString(i);
const base::Value* value;
if (!dict.Get(attribute_name, &value))
continue;
switch (value->type()) {
case base::Value::Type::STRING: {
base::string16 string_value;
value->GetAsString(&string_value);
bool did_pass_filters = WriteAttribute(
false,
base::StringPrintf(L"%ls='%ls'",
base::UTF8ToUTF16(attribute_name).c_str(),
string_value.c_str()),
&line);
if (filtered_dict_result && did_pass_filters)
filtered_dict_result->SetString(attribute_name, string_value);
break;
}
case base::Value::Type::BOOLEAN: {
bool bool_value = 0;
value->GetAsBoolean(&bool_value);
bool did_pass_filters = WriteAttribute(
false,
base::StringPrintf(L"%ls=%ls",
base::UTF8ToUTF16(attribute_name).c_str(),
(bool_value ? L"true" : L"false")),
&line);
if (filtered_dict_result && did_pass_filters)
filtered_dict_result->SetBoolean(attribute_name, bool_value);
break;
}
case base::Value::Type::INTEGER: {
int int_value = 0;
value->GetAsInteger(&int_value);
bool did_pass_filters = WriteAttribute(
false,
base::StringPrintf(L"%ls=%d",
base::UTF8ToUTF16(attribute_name).c_str(),
int_value),
&line);
if (filtered_dict_result && did_pass_filters)
filtered_dict_result->SetInteger(attribute_name, int_value);
break;
}
case base::Value::Type::DOUBLE: {
double double_value = 0.0;
value->GetAsDouble(&double_value);
bool did_pass_filters = WriteAttribute(
false,
base::StringPrintf(L"%ls=%.2f",
base::UTF8ToUTF16(attribute_name).c_str(),
double_value),
&line);
if (filtered_dict_result && did_pass_filters)
filtered_dict_result->SetDouble(attribute_name, double_value);
break;
}
default:
NOTREACHED();
break;
}
}
return line;
}
const base::FilePath::StringType
AccessibilityTreeFormatterUia::GetExpectedFileSuffix() {
return FILE_PATH_LITERAL("-expected-uia-win.txt");
}
const base::FilePath::StringType
AccessibilityTreeFormatterUia::GetVersionSpecificExpectedFileSuffix() {
if (base::win::GetVersion() == base::win::Version::VERSION_WIN7) {
return FILE_PATH_LITERAL("-expected-uia-win7.txt");
}
return FILE_PATH_LITERAL("");
}
const std::string AccessibilityTreeFormatterUia::GetAllowEmptyString() {
return "@UIA-WIN-ALLOW-EMPTY:";
}
const std::string AccessibilityTreeFormatterUia::GetAllowString() {
return "@UIA-WIN-ALLOW:";
}
const std::string AccessibilityTreeFormatterUia::GetDenyString() {
return "@UIA-WIN-DENY:";
}
const std::string AccessibilityTreeFormatterUia::GetDenyNodeString() {
return "@UIA-WIN-DENY-NODE:";
}
} // namespace content