# Copyright 2016 The Chromium Authors
# Use of this source code is governed by a BSD-style license that can be
# found in the LICENSE file.
"""Presubmit script for ui/accessibility."""
import json
import os
import re
AX_MOJOM = 'ui/accessibility/ax_enums.mojom'
AUTOMATION_IDL = 'extensions/common/api/automation.idl'
AX_TS_FILE = 'chrome/browser/resources/accessibility/accessibility.ts'
AX_MODE_HEADER = 'ui/accessibility/ax_mode.h'
def InitialLowerCamelCase(unix_name):
words = unix_name.split('_')
return words[0] + ''.join(word.capitalize() for word in words[1:])
def CamelToLowerHacker(str):
out = ''
for i in range(len(str)):
if str[i] >= 'A' and str[i] <= 'Z' and out:
out += '_'
out += str[i]
return out.lower()
# Given a full path to an IDL or MOJOM file containing enum definitions,
# parse the file for enums and return a dict mapping the enum name
# to a list of values for that enum.
def GetEnumsFromFile(fullpath, get_raw_enum_value=False):
enum_name = None
enums = {}
for line in open(fullpath, encoding='utf-8').readlines():
# Strip out comments
line = re.sub('//.*', '', line)
# Strip out mojo annotations.
line = re.sub('\[(.*)\]', '', line)
# Look for lines of the form "enum ENUM_NAME {" and get the enum_name
m = re.search('enum ([\w]+) {', line)
if m:
enum_name = m.group(1)
continue
# Look for a "}" character signifying the end of an enum
if line.find('}') >= 0:
enum_name = None
continue
if not enum_name:
continue
# We're now inside of a enum definition.
# First, if requested, add the raw line.
if get_raw_enum_value:
enums.setdefault(enum_name, [])
enums[enum_name].append(line)
continue
# Add the first string consisting of alphanumerics plus underscore ("\w") to
# the list of values for that enum.
m = re.search('([\w]+)', line)
if m:
enums.setdefault(enum_name, [])
enum_value = m.group(1)
if (enum_value[0] == 'k' and
enum_value[1] == enum_value[1].upper()):
enum_value = CamelToLowerHacker(enum_value[1:])
if enum_value == 'none' or enum_value == 'last':
continue
enums[enum_name].append(enum_value)
return enums
def CheckMatchingEnum(ax_enums,
ax_enum_name,
automation_enums,
automation_enum_name,
errs,
output_api,
strict_ordering=False,
allow_extra_destination_enums=False):
if ax_enum_name not in ax_enums:
errs.append(output_api.PresubmitError(
'Expected %s to have an enum named %s' % (AX_MOJOM, ax_enum_name)))
return
if automation_enum_name not in automation_enums:
errs.append(output_api.PresubmitError(
'Expected %s to have an enum named %s' % (
AUTOMATION_IDL, automation_enum_name)))
return
src = ax_enums[ax_enum_name]
dst = automation_enums[automation_enum_name]
if strict_ordering and len(src) != len(dst):
errs.append(output_api.PresubmitError(
'Expected %s to have the same number of items as %s' % (
automation_enum_name, ax_enum_name)))
return
if strict_ordering:
for index, value in enumerate(src):
lower_value = InitialLowerCamelCase(value)
if lower_value != dst[index]:
errs.append(output_api.PresubmitError(
('At index %s in enums, unexpected ordering around %s.%s ' +
'and %s.%s in %s and %s') % (
index, ax_enum_name, lower_value,
automation_enum_name, dst[index],
AX_MOJOM, AUTOMATION_IDL)))
return
return
for value in src:
lower_value = InitialLowerCamelCase(value)
if lower_value in dst:
dst.remove(lower_value) # Any remaining at end are extra and a mismatch.
else:
errs.append(output_api.PresubmitError(
'Found %s.%s in %s, but did not find %s.%s in %s' % (
ax_enum_name, value, AX_MOJOM,
automation_enum_name, InitialLowerCamelCase(value),
AUTOMATION_IDL)))
# Should be no remaining items
if not allow_extra_destination_enums:
for value in dst:
errs.append(output_api.PresubmitError(
'Found %s.%s in %s, but did not find %s.%s in %s' % (
automation_enum_name, value, AUTOMATION_IDL,
ax_enum_name, InitialLowerCamelCase(value),
AX_MOJOM)))
def CheckEnumsMatch(input_api, output_api):
repo_root = input_api.change.RepositoryRoot()
ax_enums = GetEnumsFromFile(os.path.join(repo_root, AX_MOJOM))
automation_enums = GetEnumsFromFile(os.path.join(repo_root, AUTOMATION_IDL))
# Focused state only exists in automation.
automation_enums['StateType'].remove('focused')
# Offscreen state only exists in automation.
automation_enums['StateType'].remove('offscreen')
errs = []
CheckMatchingEnum(ax_enums, 'Role', automation_enums, 'RoleType', errs,
output_api)
CheckMatchingEnum(ax_enums, 'State', automation_enums, 'StateType', errs,
output_api, strict_ordering=True)
CheckMatchingEnum(ax_enums, 'Action', automation_enums, 'ActionType', errs,
output_api, strict_ordering=True)
CheckMatchingEnum(ax_enums, 'Event', automation_enums, 'EventType', errs,
output_api, allow_extra_destination_enums=True)
CheckMatchingEnum(ax_enums, 'NameFrom', automation_enums, 'NameFromType',
errs, output_api)
CheckMatchingEnum(ax_enums, 'DescriptionFrom', automation_enums,
'DescriptionFromType', errs, output_api)
CheckMatchingEnum(ax_enums, 'Restriction', automation_enums,
'Restriction', errs, output_api)
CheckMatchingEnum(ax_enums, 'DefaultActionVerb', automation_enums,
'DefaultActionVerb', errs, output_api)
CheckMatchingEnum(ax_enums, 'MarkerType', automation_enums,
'MarkerType', errs, output_api)
CheckMatchingEnum(ax_enums, 'Command', automation_enums,
'IntentCommandType', errs, output_api)
CheckMatchingEnum(ax_enums, 'InputEventType', automation_enums,
'IntentInputEventType', errs, output_api)
CheckMatchingEnum(ax_enums, 'TextBoundary', automation_enums,
'IntentTextBoundaryType', errs, output_api)
CheckMatchingEnum(ax_enums, 'MoveDirection', automation_enums,
'IntentMoveDirectionType', errs, output_api)
CheckMatchingEnum(ax_enums, 'SortDirection', automation_enums,
'SortDirectionType', errs, output_api)
CheckMatchingEnum(ax_enums, 'HasPopup', automation_enums,
'HasPopup', errs, output_api)
CheckMatchingEnum(ax_enums, 'AriaCurrentState', automation_enums,
'AriaCurrentState', errs, output_api)
return errs
def CheckAXEnumsOrdinals(input_api, output_api):
repo_root = input_api.change.RepositoryRoot()
ax_enums = GetEnumsFromFile(
os.path.join(repo_root, AX_MOJOM), get_raw_enum_value=True)
# Find all enums containing enum values with ordinals and save each enum value
# as a pair e.g. (kEnumValue, 100).
enums_with_ordinal_values = {}
for enum_name in ax_enums:
for enum_value in ax_enums[enum_name]:
m = re.search("([\w]+) = ([\d]+)", enum_value)
if not m:
continue
enums_with_ordinal_values.setdefault(enum_name, [])
enums_with_ordinal_values[enum_name].append(m.groups(1))
# Now, do the validation for each enum.
errs = []
for enum_name in enums_with_ordinal_values:
# This is expected to not be continuous.
if enum_name == "MarkerType":
continue
enum = enums_with_ordinal_values[enum_name]
enum.sort(key = lambda item: int(item[1]))
index = 0
for enum_value in enum:
if index == int(enum_value[1]):
index += 1
continue
errs.append(output_api.PresubmitError(
"Unexpected enum %s ordinal: %s = %s. Expected %d." % (
enum_name, enum_value[0], enum_value[1], index)))
return errs
# Given a full path to c++ header, return an array of the first static
# constexpr defined. (Note there can be more than one defined in a C++
# header)
def GetConstexprFromFile(fullpath):
values = []
for line in open(fullpath, encoding='utf-8').readlines():
# Strip out comments
line = re.sub('//.*', '', line)
# Look for lines of the form "static constexpr <type> NAME "
m = re.search('static constexpr [\w]+ ([\w]+)', line)
if m:
value = m.group(1)
# Skip first/last sentinels
if (value in ['kNone', 'kFirstModeFlag', 'kLastModeFlag']):
continue
values.append(value)
return values
# Given a full path to js file, return the AXMode consts
# defined
def GetAccessibilityModesFromFile(fullpath):
values = []
inside = False
for line in open(fullpath, encoding='utf-8').readlines():
if not inside:
# Look for the block of code that defines the AXMode enum.
m = re.search('^enum AxMode {$', line)
if m:
inside = True
continue
# Look for a "}" character signifying the end of the enum.
m = re.search('^}$', line)
if m:
return values
m = re.search('([\w]+) = ', line)
if m:
values.append(m.group(1))
continue
return values
# Make sure that the modes defined in the C++ header match those defined in
# the js file. Note that this doesn't guarantee that the values are the same,
# but does make sure if we add or remove we can signal to the developer that
# they should be aware that this dependency exists.
def CheckModesMatch(input_api, output_api):
errs = []
repo_root = input_api.change.RepositoryRoot()
ax_modes_in_header = GetConstexprFromFile(
os.path.join(repo_root,AX_MODE_HEADER))
ax_modes_in_js = GetAccessibilityModesFromFile(
os.path.join(repo_root, AX_TS_FILE))
# In TypeScript enum values are NAMED_LIKE_THIS. Transform them to make them
# comparable to the C++ naming scheme.
ax_modes_in_js = list(
map(lambda s: ('k' + s.replace('_', '')).lower(), ax_modes_in_js))
# The following AxMode values are not used in the UI, and are purposefully
# omitted.
unused_ax_modes = [
'kAXModeBasic',
'kAXModeWebContentsOnly',
'kAXModeComplete',
'kAXModeCompleteNoHTML',
'kAXModeFormControls',
'kExperimentalFirstFlag',
'kExperimentalFormControls',
'kExperimentalLastFlag',
]
for value in ax_modes_in_header:
if value in unused_ax_modes:
continue
equivalent_value = value.lower()
if equivalent_value not in ax_modes_in_js:
errs.append(output_api.PresubmitError(
'Found %s in %s, but did not find an equivalent value in %s' % (
value, AX_MODE_HEADER, AX_TS_FILE)))
return errs
def CheckChangeOnUpload(input_api, output_api):
errs = []
for path in input_api.LocalPaths():
path = path.replace('\\', '/')
if AX_MOJOM == path:
errs.extend(CheckEnumsMatch(input_api, output_api))
errs.extend(CheckAXEnumsOrdinals(input_api, output_api))
if AX_MODE_HEADER == path:
errs.extend(CheckModesMatch(input_api, output_api))
return errs
def CheckChangeOnCommit(input_api, output_api):
errs = []
for path in input_api.LocalPaths():
path = path.replace('\\', '/')
if AX_MOJOM == path:
errs.extend(CheckEnumsMatch(input_api, output_api))
if AX_MODE_HEADER == path:
errs.extend(CheckModesMatch(input_api, output_api))
return errs
Codebase Browser
chromium