// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "services/accessibility/features/automation_internal_bindings.h"
#include "base/functional/bind.h"
#include "base/memory/weak_ptr.h"
#include "base/values.h"
#include "gin/function_template.h"
#include "mojo/public/cpp/bindings/pending_associated_remote.h"
#include "services/accessibility/assistive_technology_controller_impl.h"
#include "services/accessibility/automation_impl.h"
#include "services/accessibility/features/bindings_isolate_holder.h"
#include "services/accessibility/features/v8_utils.h"
#include "services/accessibility/public/mojom/accessibility_service.mojom.h"
#include "ui/accessibility/ax_event_generator.h"
#include "ui/accessibility/ax_node_position.h"
#include "ui/accessibility/ax_tree_id.h"
#include "ui/accessibility/mojom/ax_event.mojom.h"
#include "ui/accessibility/platform/automation/automation_api_util.h"
#include "ui/accessibility/platform/automation/automation_v8_router.h"
#include "v8-function.h"
#include "v8-value.h"
#include "v8/include/v8-local-handle.h"
#include "v8/include/v8-template.h"
namespace ax {
namespace {
static const char kJSAutomationInternalV8Listeners[] =
"automationInternalV8Listeners";
static const char kJSCallListeners[] = "callListeners";
} // namespace
AutomationInternalBindings::AutomationInternalBindings(
BindingsIsolateHolder* isolate_holder,
mojo::PendingAssociatedReceiver<mojom::Automation> automation)
: isolate_holder_(isolate_holder),
automation_v8_bindings_(std::make_unique<ui::AutomationV8Bindings>(
/*AutomationTreeManagerOwner=*/this,
/*AutomationV8Router=*/this)) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
receiver_.Bind(std::move(automation));
}
AutomationInternalBindings::~AutomationInternalBindings() = default;
void AutomationInternalBindings::AddAutomationRoutesToTemplate(
v8::Local<v8::ObjectTemplate>* object_template) {
template_ = object_template;
automation_v8_bindings_->AddV8Routes();
template_ = nullptr;
}
ui::AutomationV8Bindings* AutomationInternalBindings::GetAutomationV8Bindings()
const {
DCHECK(automation_v8_bindings_);
return automation_v8_bindings_.get();
}
void AutomationInternalBindings::NotifyTreeEventListenersChanged() {
// This task is posted because we need to wait for any pending mutations
// to be processed before sending the event.
CHECK(base::SequencedTaskRunner::HasCurrentDefault());
auto& main_runner = base::SequencedTaskRunner::GetCurrentDefault();
// `this` is safe here because this object outlives
// AutomationTreeManagerOwner, which in turn generates this kind of event.
auto task = base::BindOnce(&AutomationInternalBindings::
MaybeSendOnAllAutomationEventListenersRemoved,
base::Unretained(this));
main_runner->PostTask(FROM_HERE, std::move(task));
}
void AutomationInternalBindings::ThrowInvalidArgumentsException(
bool is_fatal) const {
GetIsolate()->ThrowException(v8::String::NewFromUtf8Literal(
GetIsolate(),
"Invalid arguments to AutomationInternalBindings function"));
if (!is_fatal)
return;
LOG(FATAL) << "Invalid arguments to AutomationInternalBindings function";
// TODO(crbug.com/1357889): Could print a stack trace from JS, paralleling
// AutomationInternalCustomBindings.
}
v8::Isolate* AutomationInternalBindings::GetIsolate() const {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(isolate_holder_);
return isolate_holder_->GetIsolate();
}
v8::Local<v8::Context> AutomationInternalBindings::GetContext() const {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(isolate_holder_);
return isolate_holder_->GetContext();
}
void AutomationInternalBindings::RouteHandlerFunction(
const std::string& name,
scoped_refptr<ui::V8HandlerFunctionWrapper> handler_function_wrapper) {
DCHECK(template_);
(*template_)
->Set(GetIsolate(), name.c_str(),
gin::CreateFunctionTemplate(
GetIsolate(),
base::BindRepeating(&ui::V8HandlerFunctionWrapper::Run,
handler_function_wrapper)));
}
ui::TreeChangeObserverFilter
AutomationInternalBindings::ParseTreeChangeObserverFilter(
const std::string& filter) const {
// TODO(b:327258691): Share const strings between c++ and js for event names.
if (filter == "none") {
return ui::TreeChangeObserverFilter::kNone;
}
if (filter == "noTreeChanges") {
return ui::TreeChangeObserverFilter::kNoTreeChanges;
}
if (filter == "liveRegionTreeChanges") {
return ui::TreeChangeObserverFilter::kLiveRegionTreeChanges;
}
if (filter == "textMarkerChanges") {
return ui::TreeChangeObserverFilter::kTextMarkerChanges;
}
if (filter == "allTreeChanges") {
return ui::TreeChangeObserverFilter::kAllTreeChanges;
}
return ui::TreeChangeObserverFilter::kAllTreeChanges;
}
std::string AutomationInternalBindings::GetMarkerTypeString(
ax::mojom::MarkerType type) const {
// TODO(crbug.com/1357889): Implement based on Automation API.
return ui::ToString(type);
}
std::string AutomationInternalBindings::GetFocusedStateString() const {
// TODO(crbug.com/1357889): Implement based on Automation API.
return "focused";
}
std::string AutomationInternalBindings::GetOffscreenStateString() const {
// TODO(crbug.com/1357889): Implement based on Automation API.
return "offscreen";
}
std::string
AutomationInternalBindings::GetLocalizedStringForImageAnnotationStatus(
ax::mojom::ImageAnnotationStatus status) const {
// TODO(crbug.com/1357889): Implement based on Automation API.
return ui::ToString(status);
}
std::string AutomationInternalBindings::GetTreeChangeTypeString(
ax::mojom::Mutation change_type) const {
// TODO(b:327258691): Share const strings between c++ and js for event names.
switch (change_type) {
case ax::mojom::Mutation::kNone:
return "none";
case ax::mojom::Mutation::kNodeCreated:
return "nodeCreated";
case ax::mojom::Mutation::kSubtreeCreated:
return "subtreeCreated";
case ax::mojom::Mutation::kNodeChanged:
return "nodeChanged";
case ax::mojom::Mutation::kTextChanged:
return "textChanged";
case ax::mojom::Mutation::kNodeRemoved:
return "nodeRemoved";
case ax::mojom::Mutation::kSubtreeUpdateEnd:
return "subtreeUpdateEnd";
}
}
std::string AutomationInternalBindings::GetEventTypeString(
const std::tuple<ax::mojom::Event, ui::AXEventGenerator::Event>& event_type)
const {
// TODO(b:327258691): Share const strings between c++ and js for event names.
const ui::AXEventGenerator::Event& generated_event = std::get<1>(event_type);
// Resolve the proper event based on generated or non-generated event sources.
if (generated_event != ui::AXEventGenerator::Event::NONE &&
!ui::ShouldIgnoreGeneratedEventForAutomation(generated_event)) {
return ui::ToString(generated_event);
}
const ax::mojom::Event& event = std::get<0>(event_type);
if (event != ax::mojom::Event::kNone &&
!ui::ShouldIgnoreAXEventForAutomation(event)) {
return ui::ToString(event);
}
return "";
}
void AutomationInternalBindings::DispatchEvent(
const std::string& event_name,
const base::Value::List& event_args) const {
v8::HandleScope handle_scope(GetIsolate());
v8::Local<v8::Context> context = GetContext();
v8::Context::Scope context_scope(context);
// Here, a helper function defined in js is invoked to retrieve the event
// object that contains all the listeners. Then, we dispatch the event to all
// listeners.
v8::Local<v8::String> func_name =
v8::String::NewFromUtf8(GetIsolate(), kJSAutomationInternalV8Listeners)
.ToLocalChecked();
v8::Local<v8::Value> func_value =
context->Global()->Get(context, func_name).ToLocalChecked();
v8::Local<v8::Function> get_event_listeners_from_name_function =
v8::Local<v8::Function>::Cast(func_value);
// Prepare the argument for the 'getEventListenersFromName' call
v8::Local<v8::Value> args[] = {
v8::String::NewFromUtf8(GetIsolate(), event_name.c_str())
.ToLocalChecked()};
// Call the 'getEventListenersFromName' function using the event that needs to
// be dispatched. The return value is an object containing all listeners to
// that event.
v8::Local<v8::Value> result = get_event_listeners_from_name_function
->Call(context, context->Global(), 1, args)
.ToLocalChecked();
CHECK(result->IsObject()) << "Unknown event type: " << event_name;
v8::Local<v8::Object> event_listeners_object =
v8::Local<v8::Object>::Cast(result);
v8::Local<v8::String> method_name =
v8::String::NewFromUtf8(GetIsolate(), kJSCallListeners).ToLocalChecked();
v8::Local<v8::Value> method_value =
event_listeners_object->Get(context, method_name).ToLocalChecked();
v8::Local<v8::Function> method = v8::Local<v8::Function>::Cast(method_value);
std::vector<v8::Local<v8::Value>> js_event_args;
for (const base::Value& value : event_args) {
v8::Local<v8::Value> js_event_arg =
V8ValueConverter ::GetInstance()->ConvertToV8Value(value, context);
js_event_args.push_back(js_event_arg);
}
v8::MaybeLocal<v8::Value> unused_result =
method->Call(context, event_listeners_object, js_event_args.size(),
js_event_args.data());
CHECK(!unused_result.IsEmpty());
}
} // namespace ax
Codebase Browser
chromium