// Copyright 2014 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
// Custom bindings for the automation API.
const AutomationRootNode = require('automationNode').AutomationRootNode;
const automationInternal = getInternalApi('automationInternal');
const exceptionHandler = require('uncaught_exception_handler');
const logging = requireNative('logging');
const nativeAutomationInternal = requireNative('automationInternal');
const DestroyAccessibilityTree =
nativeAutomationInternal.DestroyAccessibilityTree;
const StartCachingAccessibilityTrees =
nativeAutomationInternal.StartCachingAccessibilityTrees;
const StopCachingAccessibilityTrees =
nativeAutomationInternal.StopCachingAccessibilityTrees;
const AddTreeChangeObserver = nativeAutomationInternal.AddTreeChangeObserver;
const RemoveTreeChangeObserver =
nativeAutomationInternal.RemoveTreeChangeObserver;
const GetFocusNative = nativeAutomationInternal.GetFocus;
const GetAccessibilityFocusNative =
nativeAutomationInternal.GetAccessibilityFocus;
const SetDesktopID = nativeAutomationInternal.SetDesktopID;
// A namespace to export utility functions to other files in automation.
const automationUtil = function() {};
// TODO(aboxhall): Look into using WeakMap
let idToCallback = {};
let desktopId;
let desktopTree;
automationUtil.storeTreeCallback = function(id, callback) {
if (!callback) {
return;
}
const targetTree = AutomationRootNode.get(id);
if (!targetTree) {
// If we haven't cached the tree, hold the callback until the tree is
// populated by the initial onAccessibilityEvent call.
if (id in idToCallback) {
idToCallback[id].push(callback);
} else {
idToCallback[id] = [callback];
}
} else {
callback(targetTree);
}
};
/**
* Global list of tree change observers.
* @type {Object<number, TreeChangeObserver>}
*/
automationUtil.treeChangeObserverMap = {};
/**
* The id of the next tree change observer.
* @type {number}
*/
automationUtil.nextTreeChangeObserverId = 1;
apiBridge.registerCustomHook(function(bindingsAPI) {
const apiFunctions = bindingsAPI.apiFunctions;
apiFunctions.setHandleRequest('getDesktop', function(callback) {
StartCachingAccessibilityTrees();
if (desktopId !== undefined) {
desktopTree = AutomationRootNode.get(desktopId);
}
if (!desktopTree) {
automationInternal.enableDesktop(function(treeId) {
if (bindingUtil.hasLastError()) {
AutomationRootNode.destroy(treeId);
desktopId = undefined;
SetDesktopID('');
callback();
return;
}
desktopId = treeId;
SetDesktopID(desktopId);
desktopTree = AutomationRootNode.getOrCreate(desktopId);
callback(desktopTree);
// TODO(dtseng): Disable desktop tree once desktop object goes out of
// scope.
});
} else {
callback(desktopTree);
}
});
apiFunctions.setHandleRequest('getFocus', function(callback) {
const focusedNodeInfo = GetFocusNative();
if (!focusedNodeInfo) {
callback(null);
return;
}
const tree = AutomationRootNode.getOrCreate(focusedNodeInfo.treeId);
if (tree) {
callback(privates(tree).impl.get(focusedNodeInfo.nodeId));
return;
}
});
apiFunctions.setHandleRequest('getAccessibilityFocus', function(callback) {
const focusedNodeInfo = GetAccessibilityFocusNative();
if (!focusedNodeInfo) {
callback(null);
return;
}
const tree = AutomationRootNode.getOrCreate(focusedNodeInfo.treeId);
if (tree) {
callback(privates(tree).impl.get(focusedNodeInfo.nodeId));
}
});
function removeTreeChangeObserver(observer) {
for (const id in automationUtil.treeChangeObserverMap) {
if (automationUtil.treeChangeObserverMap[id] == observer) {
RemoveTreeChangeObserver(id);
delete automationUtil.treeChangeObserverMap[id];
return;
}
}
}
apiFunctions.setHandleRequest('removeTreeChangeObserver', function(observer) {
removeTreeChangeObserver(observer);
});
function addTreeChangeObserver(filter, observer) {
removeTreeChangeObserver(observer);
const id = automationUtil.nextTreeChangeObserverId++;
AddTreeChangeObserver(id, filter);
automationUtil.treeChangeObserverMap[id] = observer;
}
apiFunctions.setHandleRequest('addTreeChangeObserver',
function(filter, observer) {
addTreeChangeObserver(filter, observer);
});
apiFunctions.setHandleRequest('setDocumentSelection', function(params) {
const anchorNodeImpl = privates(params.anchorObject).impl;
const focusNodeImpl = privates(params.focusObject).impl;
if (anchorNodeImpl.treeID !== focusNodeImpl.treeID) {
throw new Error('Selection anchor and focus must be in the same tree.');
}
if (anchorNodeImpl.treeID === desktopId) {
throw new Error('Use AutomationNode.setSelection to set the selection ' +
'in the desktop tree.');
}
automationInternal.performAction(
{
treeID: anchorNodeImpl.treeID,
automationNodeID: anchorNodeImpl.id,
actionType: 'setSelection',
},
{
focusNodeID: focusNodeImpl.id,
anchorOffset: params.anchorOffset,
focusOffset: params.focusOffset,
});
});
});
automationInternal.onChildTreeID.addListener(function(childTreeId) {
const targetTree = AutomationRootNode.get(childTreeId);
// If the tree is already loded, or if we previously requested it be loaded
// (i.e. have a callback for it), don't try to do so again.
if (targetTree || idToCallback[childTreeId]) {
return;
}
// A WebView in the desktop tree has a different AX tree as its child.
// When we encounter a WebView with a child AX tree id that we don't
// currently have cached, explicitly request that AX tree from the
// browser process and set up a callback when it loads to attach that
// tree as a child of this node and fire appropriate events.
automationUtil.storeTreeCallback(childTreeId, function(root) {
const rootImpl = privates(root).impl;
rootImpl.dispatchEvent('loadComplete', 'page');
if (rootImpl.parent) {
privates(rootImpl.parent).impl.dispatchEvent('childrenChanged');
}
}, true);
automationInternal.enableTree(childTreeId);
});
automationInternal.onTreeChange.addListener(function(
observerID, treeID, nodeID, changeType) {
const tree = AutomationRootNode.getOrCreate(treeID);
if (!tree) {
return;
}
const node = privates(tree).impl.get(nodeID);
if (!node) {
return;
}
const observer = automationUtil.treeChangeObserverMap[observerID];
if (!observer) {
return;
}
try {
observer({target: node, type: changeType});
} catch (e) {
exceptionHandler.handle('Error in tree change observer for ' +
changeType, e);
}
});
automationInternal.onNodesRemoved.addListener(function(treeID, nodeIDs) {
const tree = AutomationRootNode.getOrCreate(treeID);
if (!tree) {
return;
}
for (let i = 0; i < nodeIDs.length; i++) {
privates(tree).impl.remove(nodeIDs[i]);
}
});
automationInternal.onAllAutomationEventListenersRemoved.addListener(() => {
if (!desktopId) {
return;
}
automationInternal.disableDesktop(() => {
desktopId = undefined;
desktopTree = undefined;
idToCallback = {};
AutomationRootNode.destroyAll();
StopCachingAccessibilityTrees();
});
});
/**
* Dispatch accessibility events fired on individual nodes to its
* corresponding AutomationNode.
*/
automationInternal.onAccessibilityEvent.addListener(function(eventParams) {
const id = eventParams.treeID;
const targetTree = AutomationRootNode.getOrCreate(id);
if (eventParams.eventType == 'mediaStartedPlaying' ||
eventParams.eventType == 'mediaStoppedPlaying') {
// These events are global to the tree.
eventParams.targetID = privates(targetTree).impl.id;
}
privates(targetTree).impl.onAccessibilityEvent(eventParams);
// If we're not waiting on a callback, we can early out here.
if (!(id in idToCallback)) {
return;
}
// We usually get a 'placeholder' tree first, which doesn't have any url
// attribute or child nodes. If we've got that, wait for the full tree before
// calling the callback.
// TODO(dmazzoni): Don't send down placeholder (crbug.com/397553)
if (id != desktopId && !targetTree.url && targetTree.children.length == 0) {
return;
}
// If the tree wasn't available, the callback will have been cached in
// idToCallback, so call and delete it now that we have the complete tree.
for (let i = 0; i < idToCallback[id].length; i++) {
const callback = idToCallback[id][i];
callback(targetTree);
}
delete idToCallback[id];
});
automationInternal.onAccessibilityTreeDestroyed.addListener(function(id) {
// Destroy the AutomationRootNode.
const targetTree = AutomationRootNode.get(id);
if (targetTree) {
privates(targetTree).impl.destroy();
AutomationRootNode.destroy(id);
} else {
logging.WARNING('no targetTree to destroy');
}
// Destroy the native cache of the accessibility tree.
DestroyAccessibilityTree(id);
});
automationInternal.onAccessibilityTreeSerializationError.addListener(
function(id) {
automationInternal.enableTree(id);
});
automationInternal.onActionResult.addListener(function(
treeID, requestID, result) {
const targetTree = AutomationRootNode.get(treeID);
if (!targetTree) {
return;
}
privates(targetTree).impl.onActionResult(requestID, result);
});
automationInternal.onGetTextLocationResult.addListener(function(
textLocationParams) {
const targetTree = AutomationRootNode.get(textLocationParams.treeID);
if (!targetTree) {
return;
}
privates(targetTree).impl.onGetTextLocationResult(textLocationParams);
});
Codebase Browser
chromium