| // Copyright 2023 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <map> |
| |
| #include "base/base_paths.h" |
| #include "base/files/file_path.h" |
| #include "base/files/file_util.h" |
| #include "base/memory/raw_ptr.h" |
| #include "base/path_service.h" |
| #include "base/run_loop.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/test/bind.h" |
| #include "base/test/task_environment.h" |
| #include "build/build_config.h" |
| #include "services/accessibility/assistive_technology_controller_impl.h" |
| #include "services/accessibility/fake_service_client.h" |
| #include "services/accessibility/features/mojo/test/js_test_interface.h" |
| #include "services/accessibility/os_accessibility_service.h" |
| #include "services/accessibility/public/mojom/accessibility_service.mojom.h" |
| #include "services/accessibility/public/mojom/speech_recognition.mojom.h" |
| #include "services/accessibility/public/mojom/tts.mojom.h" |
| #include "services/accessibility/public/mojom/user_input.mojom.h" |
| #include "services/accessibility/public/mojom/user_interface.mojom-shared.h" |
| #include "services/accessibility/public/mojom/user_interface.mojom.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "ui/accessibility/ax_action_data.h" |
| #include "ui/accessibility/ax_tree_id.h" |
| #include "ui/events/event_constants.h" |
| #include "ui/events/keycodes/keyboard_codes.h" |
| #include "ui/events/mojom/event_constants.mojom-shared.h" |
| |
| namespace ax { |
| |
| // Parent test class for JS APIs implemented for ATP features to consume. |
| class AtpJSApiTest : public testing::Test { |
| public: |
| AtpJSApiTest() = default; |
| AtpJSApiTest(const AtpJSApiTest&) = delete; |
| AtpJSApiTest& operator=(const AtpJSApiTest&) = delete; |
| ~AtpJSApiTest() override = default; |
| |
| void SetUp() override { |
| mojo::PendingReceiver<mojom::AccessibilityService> receiver; |
| service_ = std::make_unique<OSAccessibilityService>(std::move(receiver)); |
| at_controller_ = service_->at_controller_.get(); |
| |
| client_ = std::make_unique<FakeServiceClient>(service_.get()); |
| client_->BindAccessibilityServiceClientForTest(); |
| ASSERT_TRUE(client_->AccessibilityServiceClientIsBound()); |
| |
| SetUpTestEnvironment(); |
| } |
| |
| void ExecuteJS(const std::string& script) { |
| base::RunLoop script_waiter; |
| at_controller_->RunScriptForTest(GetATTypeForTest(), script, |
| script_waiter.QuitClosure()); |
| script_waiter.Run(); |
| } |
| |
| void WaitForJSTestComplete() { |
| // Wait for the test mojom API testComplete method. |
| test_waiter_.Run(); |
| } |
| |
| void WaitAtCheckpoint(const std::string& checkpoint_identifier) { |
| checkpoint_loops_[checkpoint_identifier].Run(); |
| } |
| |
| void SynchronizeAfterMojoCalls() { |
| // TODO(b:332620645): Implement robust synchronization mechanism for atp js |
| // tests. This loop here is necessary because the mojo call above that |
| // dispatches events needs to send data to a different thread. If the JS |
| // code ahead runs without this, it uses the cached callback containing the |
| // desktop (which is already computed after a call to |
| // chrome.automation.getDesktop), which means it picks up the old tree |
| // values without this change. |
| base::RunLoop loop; |
| loop.RunUntilIdle(); |
| } |
| |
| protected: |
| base::test::TaskEnvironment task_environment_; |
| std::unique_ptr<FakeServiceClient> client_; |
| base::RunLoop test_waiter_; |
| std::map<std::string, base::RunLoop> checkpoint_loops_; |
| |
| private: |
| // The AT type to use, this will inform which APIs are added and available |
| // within V8. |
| virtual mojom::AssistiveTechnologyType GetATTypeForTest() const = 0; |
| |
| // Any additional JS files at these paths will be loaded during |
| // SetUpTestEnvironment. |
| // Note!!! This should not be alphabetical order, but import order. |
| virtual const std::vector<std::string> GetJSFilePathsToLoad() const = 0; |
| |
| std::string LoadScriptFromFile(const std::string& file_path) { |
| base::FilePath gen_test_data_root; |
| base::PathService::Get(base::DIR_GEN_TEST_DATA_ROOT, &gen_test_data_root); |
| base::FilePath source_path = |
| gen_test_data_root.Append(FILE_PATH_LITERAL(file_path)); |
| std::string script; |
| EXPECT_TRUE(ReadFileToString(source_path, &script)) |
| << "Could not load script from " << file_path; |
| return script; |
| } |
| |
| void SetUpTestEnvironment() { |
| // Turn on an AT. |
| std::vector<mojom::AssistiveTechnologyType> enabled_features; |
| enabled_features.emplace_back(GetATTypeForTest()); |
| at_controller_->EnableAssistiveTechnology(enabled_features); |
| |
| std::unique_ptr<JSTestInterface> test_interface = |
| std::make_unique<JSTestInterface>( |
| base::BindLambdaForTesting([this](bool success) { |
| EXPECT_TRUE(success) << "Mojo JS was not successful"; |
| test_waiter_.Quit(); |
| }), |
| base::BindLambdaForTesting( |
| [this](const std::string& checkpoint_identifier) { |
| const auto it = checkpoint_loops_.find(checkpoint_identifier); |
| ASSERT_NE(it, checkpoint_loops_.end()) |
| << "Javascript code reached a checkpoint: " |
| << checkpoint_identifier |
| << " that c++ is " |
| "not waiting on."; |
| it->second.Quit(); |
| })); |
| at_controller_->AddInterfaceForTest(GetATTypeForTest(), |
| std::move(test_interface)); |
| |
| for (const std::string& js_file_path : GetJSFilePathsToLoad()) { |
| base::RunLoop test_support_waiter; |
| at_controller_->RunScriptForTest(GetATTypeForTest(), |
| LoadScriptFromFile(js_file_path), |
| test_support_waiter.QuitClosure()); |
| test_support_waiter.Run(); |
| } |
| } |
| |
| raw_ptr<AssistiveTechnologyControllerImpl, DanglingUntriaged> at_controller_ = |
| nullptr; |
| std::unique_ptr<OSAccessibilityService> service_; |
| }; |
| |
| // Tests for generic ChromeEvents. |
| class ChromeEventTest : public AtpJSApiTest { |
| public: |
| ChromeEventTest() = default; |
| ChromeEventTest(const ChromeEventTest&) = delete; |
| ChromeEventTest& operator=(const ChromeEventTest&) = delete; |
| ~ChromeEventTest() override = default; |
| |
| mojom::AssistiveTechnologyType GetATTypeForTest() const override { |
| // Any type is fine. |
| return mojom::AssistiveTechnologyType::kChromeVox; |
| } |
| |
| const std::vector<std::string> GetJSFilePathsToLoad() const override { |
| // TODO(b:266856702): Eventually ATP will load its own JS instead of us |
| // doing it in the test. Right now the service doesn't have enough |
| // permissions so we load support JS within the test. |
| return std::vector<std::string>{ |
| "services/accessibility/features/mojo/test/mojom_test_support.js", |
| "services/accessibility/features/javascript/chrome_event.js", |
| }; |
| } |
| }; |
| |
| TEST_F(ChromeEventTest, AddsRemovesAndCallsListeners) { |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| let listenerAddedCallbackCount = 0; |
| const chromeEvent = new ChromeEvent(() => { |
| listenerAddedCallbackCount++; |
| }); |
| |
| let firstCallCount = 0; |
| const firstListener = (a, b) => { |
| if (a !== 'hello' && b !== 'world') { |
| remote.testComplete(/*success=*/false); |
| } |
| firstCallCount++; |
| }; |
| |
| // Add one listener and call it. |
| chromeEvent.addListener(firstListener); |
| if (listenerAddedCallbackCount !== 1) { |
| remote.testComplete(/*success=*/false); |
| } |
| chromeEvent.callListeners('hello', 'world'); |
| if (firstCallCount !== 1) { |
| remote.testComplete(/*success=*/false); |
| } |
| |
| let secondCallCount = 0; |
| const secondListener = (a, b) => { |
| if (a !== 'hello' && b !== 'world') { |
| remote.testComplete(/*success=*/false); |
| } |
| secondCallCount++; |
| }; |
| |
| // Add another listener and call all the listeners. |
| chromeEvent.addListener(secondListener); |
| if (listenerAddedCallbackCount !== 1) { |
| // Listener added callback should only be used once. |
| remote.testComplete(/*success=*/false); |
| } |
| chromeEvent.callListeners('hello', 'world'); |
| if (firstCallCount !== 2) { |
| remote.testComplete(/*success=*/false); |
| } |
| if (secondCallCount !== 1) { |
| remote.testComplete(/*success=*/false); |
| } |
| |
| // Remove a listener and call the listeners. |
| chromeEvent.removeListener(secondListener); |
| chromeEvent.callListeners('hello', 'world'); |
| if (firstCallCount !== 3) { |
| remote.testComplete(/*success=*/false); |
| } |
| if (secondCallCount !== 1) { |
| remote.testComplete(/*success=*/false); |
| } |
| |
| // Remove the first listener and call. |
| chromeEvent.removeListener(firstListener); |
| chromeEvent.callListeners('no one', 'is listening'); |
| if (firstCallCount !== 3) { |
| remote.testComplete(/*success=*/false); |
| } |
| if (secondCallCount !== 1) { |
| remote.testComplete(/*success=*/false); |
| } |
| |
| remote.testComplete(/*success=*/true); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| class TtsJSApiTest : public AtpJSApiTest { |
| public: |
| TtsJSApiTest() = default; |
| TtsJSApiTest(const TtsJSApiTest&) = delete; |
| TtsJSApiTest& operator=(const TtsJSApiTest&) = delete; |
| ~TtsJSApiTest() override = default; |
| |
| mojom::AssistiveTechnologyType GetATTypeForTest() const override { |
| return mojom::AssistiveTechnologyType::kChromeVox; |
| } |
| |
| const std::vector<std::string> GetJSFilePathsToLoad() const override { |
| // TODO(b:266856702): Eventually ATP will load its own JS instead of us |
| // doing it in the test. Right now the service doesn't have enough |
| // permissions so we load support JS within the test. |
| return std::vector<std::string>{ |
| "services/accessibility/features/mojo/test/mojom_test_support.js", |
| "services/accessibility/public/mojom/tts.mojom-lite.js", |
| "services/accessibility/features/javascript/tts.js", |
| }; |
| } |
| }; |
| |
| TEST_F(TtsJSApiTest, TtsGetVoices) { |
| // Note: voices are created in FakeServiceClient. |
| // TODO(b/266767386): Load test JS from files instead of as strings in C++. |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.tts.getVoices(voices => { |
| if (voices.length !== 2) { |
| remote.testComplete(/*success=*/false); |
| return; |
| } |
| expectedFirst = { |
| "voiceName": "Lyra", |
| "eventTypes": [ |
| "start", "end", "word", "sentence", "marker", "interrupted", |
| "cancelled", "error", "pause", "resume"], |
| "extensionId": "us_toddler", |
| "lang": "en-US", |
| "remote":false |
| }; |
| if (JSON.stringify(voices[0]) !== JSON.stringify(expectedFirst)) { |
| remote.testComplete(/*success=*/false); |
| return; |
| } |
| expectedSecond = { |
| "voiceName": "Juno", |
| "eventTypes": ["start", "end"], |
| "extensionId": "us_baby", |
| "lang": "en-GB", |
| "remote":true |
| }; |
| if (JSON.stringify(voices[1]) !== JSON.stringify(expectedSecond)) { |
| remote.testComplete(/*success=*/false); |
| return; |
| } |
| remote.testComplete(/*success=*/true); |
| }); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| // Tests chrome.tts.speak in JS ends up with a call to the |
| // TTS client in C++, and that callbacks from the TTS client in |
| // C++ are received as events in JS. Also ensures that ordering |
| // is consistent: if start is sent before end in C++, it should |
| // be received before end in JS. |
| TEST_F(TtsJSApiTest, TtsSpeakWithStartAndEndEvents) { |
| client_->SetTtsSpeakCallback(base::BindLambdaForTesting( |
| [this](const std::string& text, mojom::TtsOptionsPtr options) { |
| EXPECT_EQ(text, "Hello, world"); |
| auto start_event = ax::mojom::TtsEvent::New(); |
| start_event->type = mojom::TtsEventType::kStart; |
| auto end_event = ax::mojom::TtsEvent::New(); |
| end_event->type = mojom::TtsEventType::kEnd; |
| client_->SendTtsUtteranceEvent(std::move(start_event)); |
| client_->SendTtsUtteranceEvent(std::move(end_event)); |
| })); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| let receivedStart = false; |
| const onEvent = (ttsEvent) => { |
| if (ttsEvent.type === chrome.tts.EventType.END) { |
| remote.testComplete( |
| /*success=*/receivedStart); |
| } else if (ttsEvent.type === chrome.tts.EventType.START) { |
| receivedStart = true; |
| } |
| }; |
| const options = { onEvent }; |
| chrome.tts.speak('Hello, world', options); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| TEST_F(TtsJSApiTest, TtsSpeaksNumbers) { |
| base::RunLoop waiter; |
| client_->SetTtsSpeakCallback(base::BindLambdaForTesting( |
| [&waiter](const std::string& text, mojom::TtsOptionsPtr options) { |
| EXPECT_EQ(text, "42"); |
| waiter.Quit(); |
| })); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.tts.speak('42'); |
| )JS"); |
| waiter.Run(); |
| } |
| |
| TEST_F(TtsJSApiTest, TtsSpeakPauseResumeStopEvents) { |
| client_->SetTtsSpeakCallback(base::BindLambdaForTesting( |
| [this](const std::string& text, mojom::TtsOptionsPtr options) { |
| EXPECT_EQ(text, "Green is the loneliest color"); |
| auto start_event = ax::mojom::TtsEvent::New(); |
| start_event->type = mojom::TtsEventType::kStart; |
| client_->SendTtsUtteranceEvent(std::move(start_event)); |
| })); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| let receivedStart = false; |
| let receivedPause = false; |
| let receivedResume = false; |
| // Start creates a request to pause, |
| // pause creates a request to resume, |
| // resume creates a request to stop, |
| // stop causes interrupted, which ends the test. |
| const onEvent = (ttsEvent) => { |
| if (ttsEvent.type === chrome.tts.EventType.START) { |
| receivedStart = true; |
| chrome.tts.pause(); |
| } else if (ttsEvent.type === chrome.tts.EventType.PAUSE) { |
| receivedPause = true; |
| chrome.tts.resume(); |
| } else if (ttsEvent.type === chrome.tts.EventType.RESUME) { |
| receivedResume = true; |
| chrome.tts.stop(); |
| } else if (ttsEvent.type === chrome.tts.EventType.INTERRUPTED) { |
| remote.testComplete( |
| /*success=*/receivedStart && receivedPause && receivedResume); |
| } else { |
| console.error('Unexpected event type', ttsEvent.type); |
| remote.testComplete( |
| /*success=*/false); |
| } |
| }; |
| const options = { onEvent }; |
| chrome.tts.speak('Green is the loneliest color', options); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| // Test that parameters can be sent in an event. |
| TEST_F(TtsJSApiTest, TtsEventPassesParams) { |
| client_->SetTtsSpeakCallback(base::BindLambdaForTesting( |
| [this](const std::string& text, mojom::TtsOptionsPtr options) { |
| EXPECT_EQ(text, "Hello, world"); |
| auto start_event = ax::mojom::TtsEvent::New(); |
| start_event->type = mojom::TtsEventType::kStart; |
| start_event->error_message = "Off by one"; |
| start_event->length = 10; |
| start_event->char_index = 5; |
| client_->SendTtsUtteranceEvent(std::move(start_event)); |
| })); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| const onEvent = (ttsEvent) => { |
| if (ttsEvent.type === chrome.tts.EventType.START) { |
| let success = ttsEvent.charIndex === 5 && |
| ttsEvent.length === 10 && ttsEvent.errorMessage === 'Off by one'; |
| remote.testComplete(success); |
| } |
| }; |
| const options = { onEvent }; |
| chrome.tts.speak('Hello, world', options); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| TEST_F(TtsJSApiTest, TtsIsSpeaking) { |
| client_->SetTtsSpeakCallback(base::BindLambdaForTesting( |
| [this](const std::string& text, mojom::TtsOptionsPtr options) { |
| EXPECT_EQ(text, "Pie in the sky"); |
| auto start_event = ax::mojom::TtsEvent::New(); |
| start_event->type = mojom::TtsEventType::kStart; |
| client_->SendTtsUtteranceEvent(std::move(start_event)); |
| })); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| const onEvent = (ttsEvent) => { |
| // Now TTS should be speaking. |
| chrome.tts.isSpeaking(secondSpeaking => { |
| remote.testComplete(/*success=*/secondSpeaking); |
| }); |
| }; |
| const options = { onEvent }; |
| chrome.tts.isSpeaking(isSpeaking => { |
| // The first time, TTS should not be speaking. |
| if (isSpeaking) { |
| remote.testComplete(/*success=*/false); |
| } |
| chrome.tts.speak('Pie in the sky', options); |
| }); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| TEST_F(TtsJSApiTest, TtsUtteranceError) { |
| client_->SetTtsSpeakCallback(base::BindLambdaForTesting( |
| [this](const std::string& text, mojom::TtsOptionsPtr options) { |
| EXPECT_EQ(text, "No man can kill me"); |
| auto error_event = ax::mojom::TtsEvent::New(); |
| error_event->type = mojom::TtsEventType::kError; |
| error_event->error_message = "I am no man"; |
| client_->SendTtsUtteranceEvent(std::move(error_event)); |
| })); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| const onEvent = (ttsEvent) => { |
| const success = ttsEvent.type == chrome.tts.EventType.ERROR && |
| ttsEvent.errorMessage === 'I am no man'; |
| remote.testComplete(success); |
| }; |
| const options = { onEvent }; |
| chrome.tts.isSpeaking(isSpeaking => { |
| chrome.tts.speak('No man can kill me', options); |
| }); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| TEST_F(TtsJSApiTest, DefaultTtsOptions) { |
| base::RunLoop waiter; |
| client_->SetTtsSpeakCallback(base::BindLambdaForTesting( |
| [&waiter](const std::string& text, mojom::TtsOptionsPtr options) { |
| waiter.Quit(); |
| EXPECT_EQ(options->pitch, 1.0); |
| EXPECT_EQ(options->rate, 1.0); |
| EXPECT_EQ(options->volume, 1.0); |
| EXPECT_FALSE(options->enqueue); |
| EXPECT_FALSE(options->voice_name); |
| EXPECT_FALSE(options->engine_id); |
| EXPECT_FALSE(options->lang); |
| EXPECT_FALSE(options->on_event); |
| })); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.tts.speak('You have my ax'); |
| )JS"); |
| |
| waiter.Run(); |
| } |
| |
| TEST_F(TtsJSApiTest, TtsOptions) { |
| base::RunLoop waiter; |
| client_->SetTtsSpeakCallback(base::BindLambdaForTesting( |
| [&waiter](const std::string& text, mojom::TtsOptionsPtr options) { |
| waiter.Quit(); |
| EXPECT_EQ(options->pitch, 0.5); |
| EXPECT_EQ(options->rate, 1.5); |
| EXPECT_EQ(options->volume, 2.5); |
| EXPECT_TRUE(options->enqueue); |
| ASSERT_TRUE(options->voice_name); |
| EXPECT_EQ(options->voice_name.value(), "Gimli"); |
| ASSERT_TRUE(options->engine_id); |
| EXPECT_EQ(options->engine_id.value(), "us_dwarf"); |
| ASSERT_TRUE(options->lang); |
| EXPECT_EQ(options->lang.value(), "en-NZ"); |
| EXPECT_TRUE(options->on_event); |
| })); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| const options = { |
| pitch: .5, |
| rate: 1.5, |
| volume: 2.5, |
| enqueue: true, |
| engineId: 'us_dwarf', |
| lang: 'en-NZ', |
| voiceName: 'Gimli', |
| onEvent: (ttsEvent) => {}, |
| }; |
| chrome.tts.speak('You have my ax', options); |
| )JS"); |
| |
| waiter.Run(); |
| } |
| |
| class AccessibilityPrivateJSApiTest : public AtpJSApiTest { |
| public: |
| AccessibilityPrivateJSApiTest() = default; |
| AccessibilityPrivateJSApiTest(const AccessibilityPrivateJSApiTest&) = delete; |
| AccessibilityPrivateJSApiTest& operator=( |
| const AccessibilityPrivateJSApiTest&) = delete; |
| ~AccessibilityPrivateJSApiTest() override = default; |
| |
| mojom::AssistiveTechnologyType GetATTypeForTest() const override { |
| return mojom::AssistiveTechnologyType::kChromeVox; |
| } |
| |
| const std::vector<std::string> GetJSFilePathsToLoad() const override { |
| // TODO(b:266856702): Eventually ATP will load its own JS instead of us |
| // doing it in the test. Right now the service doesn't have enough |
| // permissions so we load support JS within the test. |
| return std::vector<std::string>{ |
| "services/accessibility/features/mojo/test/mojom_test_support.js", |
| "mojo/public/mojom/base/time.mojom-lite.js", |
| "skia/public/mojom/skcolor.mojom-lite.js", |
| "ui/gfx/geometry/mojom/geometry.mojom-lite.js", |
| "ui/latency/mojom/latency_info.mojom-lite.js", |
| "ui/events/mojom/event_constants.mojom-lite.js", |
| "ui/events/mojom/event.mojom-lite.js", |
| "services/accessibility/public/mojom/" |
| "assistive_technology_type.mojom-lite.js", |
| "services/accessibility/public/mojom/user_input.mojom-lite.js", |
| "services/accessibility/public/mojom/user_interface.mojom-lite.js", |
| "services/accessibility/features/javascript/chrome_event.js", |
| "services/accessibility/features/javascript/accessibility_private.js", |
| }; |
| } |
| }; |
| |
| TEST_F(AccessibilityPrivateJSApiTest, DarkenScreen) { |
| base::RunLoop waiter; |
| client_->SetDarkenScreenCallback( |
| base::BindLambdaForTesting([&waiter](bool darken) { |
| waiter.Quit(); |
| ASSERT_EQ(darken, true); |
| })); |
| ExecuteJS(R"JS( |
| chrome.accessibilityPrivate.darkenScreen(true); |
| )JS"); |
| waiter.Run(); |
| } |
| |
| TEST_F(AccessibilityPrivateJSApiTest, OpenSettingsSubpage) { |
| base::RunLoop waiter; |
| client_->SetOpenSettingsSubpageCallback( |
| base::BindLambdaForTesting([&waiter](const std::string& subpage) { |
| waiter.Quit(); |
| ASSERT_EQ(subpage, "manageAccessibility/tts"); |
| })); |
| ExecuteJS(R"JS( |
| chrome.accessibilityPrivate.openSettingsSubpage('manageAccessibility/tts'); |
| )JS"); |
| waiter.Run(); |
| } |
| |
| TEST_F(AccessibilityPrivateJSApiTest, ShowConfirmationDialog) { |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.accessibilityPrivate.showConfirmationDialog( |
| 'Confirm Order', |
| 'Your order is: Three samosas, two chai teas, and a side of naan bread', |
| 'Cancel please, I already ate', |
| success => remote.testComplete(success) |
| ); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| TEST_F(AccessibilityPrivateJSApiTest, SetFocusRings) { |
| base::RunLoop waiter; |
| client_->SetFocusRingsCallback(base::BindLambdaForTesting([&waiter, this]() { |
| waiter.Quit(); |
| const std::vector<mojom::FocusRingInfoPtr>& focus_rings = |
| client_->GetFocusRingsForType( |
| ax::mojom::AssistiveTechnologyType::kChromeVox); |
| ASSERT_EQ(focus_rings.size(), 1u); |
| auto& focus_ring = focus_rings[0]; |
| EXPECT_EQ(focus_ring->type, mojom::FocusType::kGlow); |
| EXPECT_EQ(focus_ring->color, SK_ColorRED); |
| ASSERT_EQ(focus_ring->rects.size(), 1u); |
| EXPECT_EQ(focus_ring->rects[0], gfx::Rect(50, 100, 200, 300)); |
| |
| // Optional fields are not set if not passed. |
| EXPECT_FALSE(focus_ring->stacking_order.has_value()); |
| EXPECT_FALSE(focus_ring->background_color.has_value()); |
| EXPECT_FALSE(focus_ring->secondary_color.has_value()); |
| EXPECT_FALSE(focus_ring->id.has_value()); |
| })); |
| ExecuteJS(R"JS( |
| const focusRingInfo = { |
| rects: [{left: 50, top: 100, width: 200, height: 300}], |
| type: 'glow', |
| color: '#ff0000', |
| }; |
| chrome.accessibilityPrivate.setFocusRings([focusRingInfo], |
| chrome.accessibilityPrivate.AssistiveTechnologyType.CHROME_VOX); |
| )JS"); |
| waiter.Run(); |
| } |
| |
| TEST_F(AccessibilityPrivateJSApiTest, EmptyFocusRings) { |
| base::RunLoop waiter; |
| client_->SetFocusRingsCallback(base::BindLambdaForTesting([&waiter, this]() { |
| waiter.Quit(); |
| const std::vector<mojom::FocusRingInfoPtr>& focus_rings = |
| client_->GetFocusRingsForType( |
| ax::mojom::AssistiveTechnologyType::kAutoClick); |
| EXPECT_EQ(focus_rings.size(), 0u); |
| })); |
| ExecuteJS(R"JS( |
| chrome.accessibilityPrivate.setFocusRings([], |
| chrome.accessibilityPrivate.AssistiveTechnologyType.AUTO_CLICK); |
| )JS"); |
| waiter.Run(); |
| } |
| |
| TEST_F(AccessibilityPrivateJSApiTest, SetFocusRingsOptionalValues) { |
| base::RunLoop waiter; |
| client_->SetFocusRingsCallback(base::BindLambdaForTesting([&waiter, this]() { |
| waiter.Quit(); |
| const std::vector<mojom::FocusRingInfoPtr>& focus_rings = |
| client_->GetFocusRingsForType( |
| ax::mojom::AssistiveTechnologyType::kSelectToSpeak); |
| ASSERT_EQ(focus_rings.size(), 2u); |
| auto& focus_ring1 = focus_rings[0]; |
| EXPECT_EQ(focus_ring1->type, mojom::FocusType::kSolid); |
| EXPECT_EQ(focus_ring1->color, SK_ColorWHITE); |
| ASSERT_EQ(focus_ring1->rects.size(), 2u); |
| EXPECT_EQ(focus_ring1->rects[0], gfx::Rect(150, 200, 300, 400)); |
| EXPECT_EQ(focus_ring1->rects[1], gfx::Rect(0, 50, 150, 250)); |
| ASSERT_TRUE(focus_ring1->stacking_order.has_value()); |
| EXPECT_EQ(focus_ring1->stacking_order.value(), |
| mojom::FocusRingStackingOrder::kAboveAccessibilityBubbles); |
| ASSERT_TRUE(focus_ring1->background_color.has_value()); |
| EXPECT_EQ(focus_ring1->background_color.value(), SK_ColorYELLOW); |
| ASSERT_TRUE(focus_ring1->secondary_color.has_value()); |
| EXPECT_EQ(focus_ring1->secondary_color.value(), SK_ColorMAGENTA); |
| ASSERT_TRUE(focus_ring1->id.has_value()); |
| EXPECT_EQ(focus_ring1->id.value(), "lovelace"); |
| |
| auto& focus_ring2 = focus_rings[1]; |
| EXPECT_EQ(focus_ring2->type, mojom::FocusType::kDashed); |
| EXPECT_EQ(focus_ring2->color, SK_ColorBLACK); |
| ASSERT_EQ(focus_ring2->rects.size(), 1u); |
| EXPECT_EQ(focus_ring2->rects[0], gfx::Rect(4, 3, 2, 1)); |
| ASSERT_TRUE(focus_ring2->stacking_order.has_value()); |
| EXPECT_EQ(focus_ring2->stacking_order.value(), |
| mojom::FocusRingStackingOrder::kBelowAccessibilityBubbles); |
| ASSERT_TRUE(focus_ring2->background_color.has_value()); |
| EXPECT_EQ(focus_ring2->background_color.value(), SK_ColorRED); |
| ASSERT_TRUE(focus_ring2->secondary_color.has_value()); |
| EXPECT_EQ(focus_ring2->secondary_color.value(), SK_ColorCYAN); |
| ASSERT_TRUE(focus_ring2->id.has_value()); |
| EXPECT_EQ(focus_ring2->id.value(), "curie"); |
| })); |
| ExecuteJS(R"JS( |
| const stackingOrder = chrome.accessibilityPrivate.FocusRingStackingOrder; |
| const focusRingInfo1 = { |
| rects: [ |
| {left: 150, top: 200, width: 300, height: 400}, |
| {left: 0, top: 50, width: 150, height: 250} |
| ], |
| type: 'solid', |
| color: '#ffffff', |
| backgroundColor: '#ffff00', |
| // Ensure capitalization doesn't matter. |
| secondaryColor: '#FF00ff', |
| stackingOrder: |
| stackingOrder.ABOVE_ACCESSIBILITY_BUBBLES, |
| id: 'lovelace', |
| }; |
| const focusRingInfo2 = { |
| rects: [{left: 4, top: 3, width: 2, height: 1}], |
| type: 'dashed', |
| color: '#000000', |
| backgroundColor: 'ff0000', |
| secondaryColor: '#00FFFF', |
| stackingOrder: |
| stackingOrder.BELOW_ACCESSIBILITY_BUBBLES, |
| id: 'curie', |
| } |
| chrome.accessibilityPrivate.setFocusRings( |
| [focusRingInfo1, focusRingInfo2], |
| chrome.accessibilityPrivate.AssistiveTechnologyType.SELECT_TO_SPEAK); |
| )JS"); |
| waiter.Run(); |
| } |
| |
| TEST_F(AccessibilityPrivateJSApiTest, SetHighlights) { |
| base::RunLoop waiter; |
| client_->SetHighlightsCallback(base::BindLambdaForTesting( |
| [&waiter](const std::vector<gfx::Rect>& rects, SkColor color) { |
| waiter.Quit(); |
| ASSERT_EQ(rects.size(), 2u); |
| EXPECT_EQ(rects[0], gfx::Rect(1, 22, 1973, 100)); |
| EXPECT_EQ(rects[1], gfx::Rect(2, 4, 6, 8)); |
| EXPECT_EQ(color, SK_ColorGREEN); |
| })); |
| ExecuteJS(R"JS( |
| const rects = [ |
| {left: 1, top: 22, width: 1973, height: 100}, |
| {left: 2, top: 4, width: 6, height: 8} |
| ]; |
| chrome.accessibilityPrivate.setHighlights(rects, '#00FF00'); |
| )JS"); |
| waiter.Run(); |
| } |
| |
| TEST_F(AccessibilityPrivateJSApiTest, SetHighlightsEmptyRects) { |
| base::RunLoop waiter; |
| client_->SetHighlightsCallback(base::BindLambdaForTesting( |
| [&waiter](const std::vector<gfx::Rect>& rects, SkColor color) { |
| waiter.Quit(); |
| ASSERT_EQ(rects.size(), 0u); |
| })); |
| ExecuteJS(R"JS( |
| chrome.accessibilityPrivate.setHighlights([], '#FF0000'); |
| )JS"); |
| waiter.Run(); |
| } |
| |
| class AutoclickA11yPrivateJSApiTest : public AtpJSApiTest { |
| public: |
| AutoclickA11yPrivateJSApiTest() = default; |
| AutoclickA11yPrivateJSApiTest(const AutoclickA11yPrivateJSApiTest&) = delete; |
| AutoclickA11yPrivateJSApiTest& operator=( |
| const AutoclickA11yPrivateJSApiTest&) = delete; |
| ~AutoclickA11yPrivateJSApiTest() override = default; |
| |
| mojom::AssistiveTechnologyType GetATTypeForTest() const override { |
| return mojom::AssistiveTechnologyType::kAutoClick; |
| } |
| |
| const std::vector<std::string> GetJSFilePathsToLoad() const override { |
| return std::vector<std::string>{ |
| "services/accessibility/features/mojo/test/mojom_test_support.js", |
| "ui/gfx/geometry/mojom/geometry.mojom-lite.js", |
| "services/accessibility/public/mojom/autoclick.mojom-lite.js", |
| "services/accessibility/features/javascript/chrome_event.js", |
| "services/accessibility/features/javascript/accessibility_private.js", |
| }; |
| } |
| }; |
| |
| TEST_F(AutoclickA11yPrivateJSApiTest, AutoclickApis) { |
| base::RunLoop waiter; |
| client_->SetScrollableBoundsForPointFoundCallback( |
| base::BindLambdaForTesting([&waiter](const gfx::Rect& rect) { |
| waiter.Quit(); |
| ASSERT_EQ(rect, gfx::Rect(2, 4, 6, 8)); |
| })); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.accessibilityPrivate.onScrollableBoundsForPointRequested.addListener( |
| (point) => { |
| if (point.x !== 42 || point.y !== 84) { |
| remote.testComplete(/*success=*/false); |
| } |
| const rect = {left: 2, top: 4, width: 6, height: 8}; |
| chrome.accessibilityPrivate.handleScrollableBoundsForPointFound(rect); |
| }); |
| // Exit the JS portion of the test; the callback created above will |
| // run after the test C++ executes RequestScrollableBoundsForPoint. |
| remote.testComplete(/*success=*/true); |
| )JS"); |
| WaitForJSTestComplete(); |
| client_->RequestScrollableBoundsForPoint(gfx::Point(42, 84)); |
| waiter.Run(); |
| } |
| |
| TEST_F(AccessibilityPrivateJSApiTest, SetVirtualKeyboardVisible) { |
| base::RunLoop waiter; |
| client_->SetVirtualKeyboardVisibleCallback( |
| base::BindLambdaForTesting([&waiter](bool is_visible) { |
| waiter.Quit(); |
| ASSERT_EQ(is_visible, true); |
| })); |
| ExecuteJS(R"JS( |
| chrome.accessibilityPrivate.setVirtualKeyboardVisible(true); |
| )JS"); |
| waiter.Run(); |
| } |
| |
| TEST_F(AccessibilityPrivateJSApiTest, SetVirtualKeyboardInvisible) { |
| base::RunLoop waiter; |
| client_->SetVirtualKeyboardVisibleCallback( |
| base::BindLambdaForTesting([&waiter](bool is_visible) { |
| waiter.Quit(); |
| ASSERT_EQ(is_visible, false); |
| })); |
| ExecuteJS(R"JS( |
| chrome.accessibilityPrivate.setVirtualKeyboardVisible(false); |
| )JS"); |
| waiter.Run(); |
| } |
| |
| TEST_F(AccessibilityPrivateJSApiTest, GetDisplayNameForLocale) { |
| ExecuteJS(R"JS( |
| const locale1 = 'en-US'; |
| const locale2 = 'es'; |
| const notreal = ''; |
| |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| |
| let displayName = chrome.accessibilityPrivate.getDisplayNameForLocale( |
| locale2, locale1); |
| if (displayName !== 'Spanish') { |
| remote.log('Expected "' + displayName + '" to equal "Spanish"'); |
| remote.testComplete(/*success=*/false); |
| } |
| displayName = chrome.accessibilityPrivate.getDisplayNameForLocale( |
| locale1, locale1); |
| if (!displayName.includes('English')) { |
| remote.log('Expected "' + displayName + '" to contain "English"'); |
| remote.testComplete(/*success=*/false); |
| } |
| displayName = chrome.accessibilityPrivate.getDisplayNameForLocale( |
| locale2, locale2); |
| if (displayName !== 'español') { |
| remote.log('Expected "' + displayName + '" to equal "español"'); |
| remote.testComplete(/*success=*/false); |
| } |
| displayName = chrome.accessibilityPrivate.getDisplayNameForLocale( |
| locale2, notreal); |
| if (displayName !== '') { |
| remote.log('Expected "' + displayName + '" to equal ""'); |
| remote.testComplete(/*success=*/false); |
| } |
| displayName = chrome.accessibilityPrivate.getDisplayNameForLocale( |
| notreal, locale1); |
| if (displayName !== '') { |
| remote.log('Expected "' + displayName + '" to equal ""'); |
| remote.testComplete(/*success=*/false); |
| } |
| |
| remote.testComplete(/*success=*/ true); |
| )JS"); |
| |
| WaitForJSTestComplete(); |
| } |
| |
| TEST_F(AccessibilityPrivateJSApiTest, |
| SendSyntheticKeyEventForShortcutOrNavigation) { |
| base::RunLoop waiter; |
| |
| client_->SetSyntheticKeyEventCallback( |
| base::BindLambdaForTesting([&waiter, this]() { |
| const std::vector<mojom::SyntheticKeyEventPtr>& events = |
| client_->GetKeyEvents(); |
| if (events.size() < 2) { |
| return; |
| } |
| |
| ASSERT_EQ(events.size(), 2u); |
| |
| auto& press_event = events[0]; |
| ASSERT_EQ(press_event->type, ui::mojom::EventType::KEY_PRESSED); |
| ASSERT_EQ(press_event->key_data->key_code, ui::VKEY_X); |
| // TODO(b/307553499): Update SyntheticKeyEvent to use dom_code and |
| // dom_key. |
| ASSERT_EQ(press_event->key_data->dom_code, 0u); |
| ASSERT_EQ(press_event->key_data->dom_key, 0); |
| ASSERT_FALSE(press_event->key_data->is_char); |
| ASSERT_EQ(press_event->flags, ui::EF_NONE); |
| |
| auto& release_event = events[1]; |
| ASSERT_EQ(release_event->type, ui::mojom::EventType::KEY_RELEASED); |
| ASSERT_EQ(release_event->key_data->key_code, ui::VKEY_X); |
| // TODO(b/307553499): Update SyntheticKeyEvent to use dom_code and |
| // dom_key. |
| ASSERT_EQ(release_event->key_data->dom_code, 0u); |
| ASSERT_EQ(release_event->key_data->dom_key, 0); |
| ASSERT_FALSE(release_event->key_data->is_char); |
| ASSERT_EQ(release_event->flags, ui::EF_NONE); |
| |
| waiter.Quit(); |
| })); |
| |
| ExecuteJS(R"JS( |
| chrome.accessibilityPrivate.sendSyntheticKeyEvent( |
| {type: 'keydown', keyCode: /*X=*/ 88}); |
| chrome.accessibilityPrivate.sendSyntheticKeyEvent( |
| {type: 'keyup', keyCode: /*X=*/ 88}); |
| )JS"); |
| waiter.Run(); |
| } |
| |
| TEST_F(AccessibilityPrivateJSApiTest, |
| SendSyntheticKeyEventForShortcutOrNavigationWithModifiers) { |
| base::RunLoop waiter; |
| |
| client_->SetSyntheticKeyEventCallback(base::BindLambdaForTesting([&waiter, |
| this]() { |
| const std::vector<mojom::SyntheticKeyEventPtr>& events = |
| client_->GetKeyEvents(); |
| if (events.size() < 2) { |
| return; |
| } |
| |
| ASSERT_EQ(events.size(), 2u); |
| |
| auto& press_event = events[0]; |
| ASSERT_EQ(press_event->type, ui::mojom::EventType::KEY_PRESSED); |
| ASSERT_EQ(press_event->key_data->key_code, ui::VKEY_ESCAPE); |
| // TODO(b/307553499): Update SyntheticKeyEvent to use dom_code and dom_key. |
| ASSERT_EQ(press_event->key_data->dom_code, 0u); |
| ASSERT_EQ(press_event->key_data->dom_key, 0); |
| ASSERT_FALSE(press_event->key_data->is_char); |
| ASSERT_EQ(press_event->flags, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | |
| ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN); |
| |
| auto& release_event = events[1]; |
| ASSERT_EQ(release_event->type, ui::mojom::EventType::KEY_RELEASED); |
| ASSERT_EQ(release_event->key_data->key_code, ui::VKEY_ESCAPE); |
| // TODO(b/307553499): Update SyntheticKeyEvent to use dom_code and dom_key. |
| ASSERT_EQ(release_event->key_data->dom_code, 0u); |
| ASSERT_EQ(release_event->key_data->dom_key, 0); |
| ASSERT_FALSE(release_event->key_data->is_char); |
| ASSERT_EQ(release_event->flags, ui::EF_SHIFT_DOWN | ui::EF_CONTROL_DOWN | |
| ui::EF_ALT_DOWN | ui::EF_COMMAND_DOWN); |
| |
| waiter.Quit(); |
| })); |
| |
| ExecuteJS(R"JS( |
| chrome.accessibilityPrivate.sendSyntheticKeyEvent({ |
| type: 'keydown', |
| keyCode: /*ESC=*/ 27, |
| modifiers: { |
| alt: true, |
| ctrl: true, |
| search: true, |
| shift: true, |
| }, |
| }); |
| |
| chrome.accessibilityPrivate.sendSyntheticKeyEvent({ |
| type: 'keyup', |
| keyCode: /*ESC=*/ 27, |
| modifiers: { |
| alt: true, |
| ctrl: true, |
| search: true, |
| shift: true, |
| }, |
| }); |
| )JS"); |
| |
| waiter.Run(); |
| } |
| |
| TEST_F(AccessibilityPrivateJSApiTest, SendSyntheticMouseEvent) { |
| base::RunLoop waiter; |
| client_->SetSyntheticMouseEventCallback(base::BindLambdaForTesting([&waiter, |
| this]() { |
| const auto& events = client_->GetMouseEvents(); |
| // Wait for all the events to be fired. |
| if (events.size() < 6) { |
| return; |
| } |
| |
| // Confirm there are no extra events. |
| ASSERT_EQ(events.size(), 6u); |
| |
| auto& press_event = events[0]; |
| EXPECT_EQ(press_event->type, ui::mojom::EventType::MOUSE_PRESSED_EVENT); |
| EXPECT_EQ(press_event->point.x(), 20); |
| EXPECT_EQ(press_event->point.y(), 30); |
| ASSERT_FALSE(press_event->touch_accessibility.has_value()); |
| ASSERT_TRUE(press_event->mouse_button.has_value()); |
| EXPECT_EQ(press_event->mouse_button.value(), |
| mojom::SyntheticMouseEventButton::kLeft); |
| |
| auto& release_event = events[1]; |
| EXPECT_EQ(release_event->type, ui::mojom::EventType::MOUSE_RELEASED_EVENT); |
| EXPECT_EQ(release_event->point.x(), 21); |
| EXPECT_EQ(release_event->point.y(), 31); |
| ASSERT_TRUE(release_event->touch_accessibility.has_value()); |
| EXPECT_FALSE(release_event->touch_accessibility.value()); |
| ASSERT_TRUE(release_event->mouse_button.has_value()); |
| EXPECT_EQ(release_event->mouse_button.value(), |
| mojom::SyntheticMouseEventButton::kMiddle); |
| |
| auto& drag_event = events[2]; |
| EXPECT_EQ(drag_event->type, ui::mojom::EventType::MOUSE_DRAGGED_EVENT); |
| EXPECT_EQ(drag_event->point.x(), 22); |
| EXPECT_EQ(drag_event->point.y(), 32); |
| ASSERT_TRUE(drag_event->touch_accessibility.has_value()); |
| EXPECT_TRUE(drag_event->touch_accessibility.value()); |
| ASSERT_TRUE(drag_event->mouse_button.has_value()); |
| EXPECT_EQ(drag_event->mouse_button.value(), |
| mojom::SyntheticMouseEventButton::kRight); |
| |
| auto& move_event = events[3]; |
| EXPECT_EQ(move_event->type, ui::mojom::EventType::MOUSE_MOVED_EVENT); |
| EXPECT_EQ(move_event->point.x(), 23); |
| EXPECT_EQ(move_event->point.y(), 33); |
| ASSERT_FALSE(move_event->touch_accessibility.has_value()); |
| ASSERT_FALSE(move_event->mouse_button.has_value()); |
| |
| auto& enter_event = events[4]; |
| EXPECT_EQ(enter_event->type, ui::mojom::EventType::MOUSE_ENTERED_EVENT); |
| EXPECT_EQ(enter_event->point.x(), 24); |
| EXPECT_EQ(enter_event->point.y(), 34); |
| ASSERT_FALSE(enter_event->touch_accessibility.has_value()); |
| ASSERT_TRUE(enter_event->mouse_button.has_value()); |
| EXPECT_EQ(enter_event->mouse_button.value(), |
| mojom::SyntheticMouseEventButton::kBack); |
| |
| auto& exit_event = events[5]; |
| EXPECT_EQ(exit_event->type, ui::mojom::EventType::MOUSE_EXITED_EVENT); |
| EXPECT_EQ(exit_event->point.x(), 25); |
| EXPECT_EQ(exit_event->point.y(), 35); |
| ASSERT_FALSE(exit_event->touch_accessibility.has_value()); |
| ASSERT_TRUE(exit_event->mouse_button.has_value()); |
| EXPECT_EQ(exit_event->mouse_button.value(), |
| mojom::SyntheticMouseEventButton::kForward); |
| |
| waiter.Quit(); |
| })); |
| |
| ExecuteJS(R"JS( |
| chrome.accessibilityPrivate.sendSyntheticMouseEvent({ |
| type: 'press', |
| x: 20, |
| y: 30, |
| mouseButton: 'left', |
| }); |
| chrome.accessibilityPrivate.sendSyntheticMouseEvent({ |
| type: 'release', |
| x: 21, |
| y: 31, |
| mouseButton: 'middle', |
| touchAccessibility: false, |
| }); |
| chrome.accessibilityPrivate.sendSyntheticMouseEvent({ |
| type: 'drag', |
| x: 22, |
| y: 32, |
| mouseButton: 'right', |
| touchAccessibility: true, |
| }); |
| chrome.accessibilityPrivate.sendSyntheticMouseEvent({ |
| type: 'move', |
| x: 23, |
| y: 33, |
| }); |
| chrome.accessibilityPrivate.sendSyntheticMouseEvent({ |
| type: 'enter', |
| x: 24, |
| y: 34, |
| mouseButton: 'back', |
| }); |
| chrome.accessibilityPrivate.sendSyntheticMouseEvent({ |
| type: 'exit', |
| x: 25, |
| y: 35, |
| mouseButton: 'forward', |
| }); |
| )JS"); |
| waiter.Run(); |
| } |
| |
| class SpeechRecognitionJSApiTest : public AtpJSApiTest { |
| public: |
| SpeechRecognitionJSApiTest() = default; |
| SpeechRecognitionJSApiTest(const SpeechRecognitionJSApiTest&) = delete; |
| SpeechRecognitionJSApiTest& operator=(const SpeechRecognitionJSApiTest&) = |
| delete; |
| ~SpeechRecognitionJSApiTest() override = default; |
| |
| mojom::AssistiveTechnologyType GetATTypeForTest() const override { |
| return mojom::AssistiveTechnologyType::kDictation; |
| } |
| |
| const std::vector<std::string> GetJSFilePathsToLoad() const override { |
| // TODO(b:266856702): Eventually ATP will load its own JS instead of us |
| // doing it in the test. Right now the service doesn't have enough |
| // permissions so we load support JS within the test. |
| return std::vector<std::string>{ |
| "services/accessibility/features/mojo/test/mojom_test_support.js", |
| "services/accessibility/public/mojom/" |
| "assistive_technology_type.mojom-lite.js", |
| "services/accessibility/public/mojom/speech_recognition.mojom-lite.js", |
| "services/accessibility/features/javascript/chrome_event.js", |
| "services/accessibility/features/javascript/speech_recognition.js", |
| }; |
| } |
| }; |
| |
| TEST_F(SpeechRecognitionJSApiTest, Start) { |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| const options = {}; |
| chrome.speechRecognitionPrivate.start(options, (type) => { |
| if (chrome.runtime.lastError) { |
| remote.testComplete(/*success=*/false); |
| } |
| if (type === 'network') { |
| remote.testComplete(/*success=*/true); |
| } else { |
| remote.testComplete(/*success=*/false); |
| } |
| }); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| TEST_F(SpeechRecognitionJSApiTest, StartAndStop) { |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| const options = {}; |
| chrome.speechRecognitionPrivate.start(options, (type) => { |
| if (type !== 'network') { |
| remote.testComplete(/*success=*/false); |
| return; |
| } |
| |
| chrome.speechRecognitionPrivate.stop(options, () => { |
| if (chrome.runtime.lastError) { |
| remote.testComplete(/*success=*/false); |
| } |
| remote.testComplete(/*success=*/true); |
| }); |
| }); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| TEST_F(SpeechRecognitionJSApiTest, StopEvent) { |
| client_->SetSpeechRecognitionStartCallback(base::BindLambdaForTesting( |
| [this]() { client_->SendSpeechRecognitionStopEvent(); })); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.speechRecognitionPrivate.onStop.addListener(() => { |
| remote.testComplete(/*success=*/true); |
| }); |
| |
| const options = {}; |
| chrome.speechRecognitionPrivate.start(options, (type) => {}); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| TEST_F(SpeechRecognitionJSApiTest, ResultEvent) { |
| client_->SetSpeechRecognitionStartCallback(base::BindLambdaForTesting( |
| [this]() { client_->SendSpeechRecognitionResultEvent(); })); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.speechRecognitionPrivate.onResult.addListener((event) => { |
| if (event.transcript === 'Hello world' && event.isFinal) { |
| remote.testComplete(/*success=*/true); |
| } |
| }); |
| |
| const options = {}; |
| chrome.speechRecognitionPrivate.start(options, (type) => {}); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| TEST_F(SpeechRecognitionJSApiTest, ErrorEvent) { |
| client_->SetSpeechRecognitionStartCallback(base::BindLambdaForTesting( |
| [this]() { client_->SendSpeechRecognitionErrorEvent(); })); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.speechRecognitionPrivate.onError.addListener((event) => { |
| if (event.message === 'Goodnight world') { |
| remote.testComplete(/*success=*/true); |
| } |
| }); |
| |
| const options = {}; |
| chrome.speechRecognitionPrivate.start(options, (type) => {}); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| TEST_F(SpeechRecognitionJSApiTest, StartError) { |
| client_->SetSpeechRecognitionStartError("Test start error"); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| const options = {}; |
| chrome.speechRecognitionPrivate.start(options, (type) => { |
| if (type !== 'network') { |
| remote.testComplete(/*success=*/false); |
| return; |
| } |
| |
| const lastError = chrome.runtime.lastError; |
| if (lastError && lastError.message === 'Test start error') { |
| remote.testComplete(/*success=*/true); |
| } |
| }); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| TEST_F(SpeechRecognitionJSApiTest, StopError) { |
| client_->SetSpeechRecognitionStopError("Test stop error"); |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| const options = {}; |
| chrome.speechRecognitionPrivate.stop(options, () => { |
| const lastError = chrome.runtime.lastError; |
| if (lastError && lastError.message === 'Test stop error') { |
| remote.testComplete(/*success=*/true); |
| } |
| }); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| class AutomationJSApiTest : public AtpJSApiTest { |
| public: |
| AutomationJSApiTest() = default; |
| AutomationJSApiTest(const AutomationJSApiTest&) = delete; |
| AutomationJSApiTest& operator=(const AutomationJSApiTest&) = delete; |
| ~AutomationJSApiTest() override = default; |
| |
| mojom::AssistiveTechnologyType GetATTypeForTest() const override { |
| return mojom::AssistiveTechnologyType::kAutoClick; |
| } |
| |
| const std::vector<std::string> GetJSFilePathsToLoad() const override { |
| // TODO(b:266856702): Eventually ATP will load its own JS instead of us |
| // doing it in the test. Right now the service doesn't have enough |
| // permissions so we load support JS within the test. |
| return std::vector<std::string>{ |
| "services/accessibility/features/mojo/test/mojom_test_support.js", |
| "ui/gfx/geometry/mojom/geometry.mojom-lite.js", |
| "mojo/public/mojom/base/unguessable_token.mojom-lite.js", |
| "ui/accessibility/ax_enums.mojom-lite.js", |
| "ui/accessibility/mojom/ax_tree_id.mojom-lite.js", |
| "ui/accessibility/mojom/ax_action_data.mojom-lite.js", |
| "services/accessibility/public/mojom/automation_client.mojom-lite.js", |
| "services/accessibility/features/javascript/event.js", |
| "services/accessibility/features/javascript/chrome_event.js", |
| "services/accessibility/features/javascript/automation_internal.js", |
| "services/accessibility/features/javascript/automation.js", |
| }; |
| } |
| }; |
| |
| // Ensures chrome.automation.getDesktop exists and returns something. |
| // Note that there are no tree updates so properties of the desktop object |
| // can't yet be calculated. |
| TEST_F(AutomationJSApiTest, GetDesktop) { |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.automation.getDesktop(desktop => { |
| remote.testComplete(/*success=*/desktop !== null && desktop.isRootNode); |
| }); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| // Ensures chrome.automation.getFocus|getAccessibilityFocus exist and gets the |
| // correct node. |
| TEST_F(AutomationJSApiTest, GetFocuses) { |
| std::vector<ui::AXTreeUpdate> updates; |
| updates.emplace_back(); |
| auto& tree_update = updates.back(); |
| tree_update.has_tree_data = true; |
| tree_update.root_id = 1; |
| auto& tree_data = tree_update.tree_data; |
| tree_data.tree_id = client_->desktop_tree_id(); |
| tree_data.focus_id = 2; |
| tree_update.nodes.emplace_back(); |
| auto& node_data1 = tree_update.nodes.back(); |
| node_data1.id = 1; |
| node_data1.role = ax::mojom::Role::kDesktop; |
| node_data1.child_ids.push_back(2); |
| tree_update.nodes.emplace_back(); |
| auto& node_data2 = tree_update.nodes.back(); |
| node_data2.id = 2; |
| node_data2.role = ax::mojom::Role::kButton; |
| std::vector<ui::AXEvent> events; |
| client_->SendAccessibilityEvents(tree_data.tree_id, updates, gfx::Point(), |
| events); |
| |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.automation.getDesktop(desktop => { |
| if (!desktop) { |
| remote.testComplete(/*success=*/false); |
| } |
| if (desktop.children.length !== 1 || |
| desktop.firstChild !== desktop.lastChild) { |
| remote.testComplete(/*success=*/false); |
| } |
| |
| // No accessibility focus at the time. |
| chrome.automation.getAccessibilityFocus(focus => { |
| if (focus) { |
| remote.testComplete(/*success=*/false); |
| } |
| }); |
| |
| const button = desktop.firstChild; |
| if (button.role !== 'button') { |
| remote.testComplete(/*success=*/false); |
| } |
| // Spot check button node. |
| if (button.parent !== desktop || button.root !== desktop || |
| button.indexInParent !== 0 || button.children.length !== 0) { |
| remote.testComplete(/*success=*/false); |
| } |
| button.setAccessibilityFocus(); |
| chrome.automation.getAccessibilityFocus(focus => { |
| if (!focus) { |
| remote.testComplete(/*success=*/false); |
| } |
| if (focus !== button) { |
| remote.testComplete(/*success=*/false); |
| } |
| chrome.automation.getFocus(focus => { |
| if (!focus) { |
| remote.testComplete(/*success=*/false); |
| } |
| remote.testComplete(/*success=*/focus === button); |
| }); |
| }); |
| }); |
| )JS"); |
| WaitForJSTestComplete(); |
| } |
| |
| // Ensures that chrome.automation.addTreeChangeObserver() receives updates. |
| // Note that this test is not to test all possible observer variants, but rather |
| // to confirm that atp dispatches event to observers. |
| TEST_F(AutomationJSApiTest, AutomationObservers) { |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| const observer = function(change) { |
| if (change.type == 'nodeCreated' && change.target.role == 'button') { |
| remote.checkpointReached('ObserverSawFirstTreeUpdate'); |
| } |
| |
| // If we see a textField here, it means that this observer wasn't removed |
| // correctly later on. |
| if (change.target.role == 'textField') { |
| remote.testComplete(/*success=*/false); |
| } |
| }; |
| chrome.automation.addTreeChangeObserver("allTreeChanges", observer); |
| )JS"); |
| |
| std::vector<ui::AXTreeUpdate> updates; |
| |
| { |
| updates.emplace_back(); |
| auto& tree_update = updates.back(); |
| tree_update.has_tree_data = true; |
| tree_update.root_id = 1; |
| auto& tree_data = tree_update.tree_data; |
| tree_data.tree_id = client_->desktop_tree_id(); |
| tree_data.focus_id = 2; |
| tree_update.nodes.emplace_back(); |
| auto& node_data1 = tree_update.nodes.back(); |
| node_data1.id = 1; |
| node_data1.role = ax::mojom::Role::kDesktop; |
| node_data1.child_ids.push_back(2); |
| tree_update.nodes.emplace_back(); |
| auto& node_data2 = tree_update.nodes.back(); |
| node_data2.id = 2; |
| node_data2.role = ax::mojom::Role::kButton; |
| |
| std::vector<ui::AXEvent> events; |
| client_->SendAccessibilityEvents(tree_data.tree_id, updates, gfx::Point(), |
| events); |
| } |
| |
| WaitAtCheckpoint("ObserverSawFirstTreeUpdate"); |
| |
| ExecuteJS(R"JS( |
| chrome.automation.getDesktop(desktop => { |
| const notAbutton = desktop.firstChild; |
| if (notAbutton.role !== 'button') { |
| remote.testComplete(/*success=*/false); |
| } |
| |
| chrome.automation.removeTreeChangeObserver(observer); |
| remote.checkpointReached('ObserverRemoved'); |
| }); |
| )JS"); |
| |
| WaitAtCheckpoint("ObserverRemoved"); |
| |
| updates.clear(); |
| |
| // Create a second update for the same tree that modifies a node. This update |
| // will be ignored by JS because there are no observers left. However, if |
| // there are still listeners, they will listen for the text field added node |
| // and make this test fail, defined above. |
| { |
| updates.emplace_back(); |
| auto& tree_update = updates.back(); |
| tree_update.has_tree_data = true; |
| tree_update.root_id = 1; |
| auto& tree_data = tree_update.tree_data; |
| tree_data.tree_id = client_->desktop_tree_id(); |
| tree_data.focus_id = 2; |
| tree_update.nodes.emplace_back(); |
| auto& node_data1 = tree_update.nodes.back(); |
| node_data1.id = 1; |
| node_data1.role = ax::mojom::Role::kDesktop; |
| node_data1.child_ids.push_back(2); |
| tree_update.nodes.emplace_back(); |
| auto& node_data2 = tree_update.nodes.back(); |
| node_data2.id = 2; |
| |
| // Only change from the first update. |
| node_data2.role = ax::mojom::Role::kTextField; |
| |
| std::vector<ui::AXEvent> events; |
| client_->SendAccessibilityEvents(tree_data.tree_id, updates, gfx::Point(), |
| events); |
| } |
| |
| ExecuteJS(R"JS( |
| remote.testComplete(/*success=*/true); |
| )JS"); |
| |
| WaitForJSTestComplete(); |
| } |
| |
| // Ensures chrome.automation.setDocumentSelection dispatches a call to the |
| // AutomationClient interface and the parameters of the action are the correct |
| // ones. |
| TEST_F(AutomationJSApiTest, SetDocumentSelection) { |
| std::vector<ui::AXTreeUpdate> updates; |
| updates.emplace_back(); |
| auto& tree_update = updates.back(); |
| tree_update.has_tree_data = true; |
| tree_update.root_id = 1; |
| auto& tree_data = tree_update.tree_data; |
| tree_data.tree_id = client_->desktop_tree_id(); |
| tree_data.focus_id = 2; |
| tree_update.nodes.emplace_back(); |
| auto& node_data1 = tree_update.nodes.back(); |
| node_data1.id = 1; |
| node_data1.role = ax::mojom::Role::kDesktop; |
| node_data1.child_ids.push_back(2); |
| node_data1.child_ids.push_back(3); |
| tree_update.nodes.emplace_back(); |
| auto& node_data2 = tree_update.nodes.back(); |
| node_data2.id = 2; |
| node_data2.role = ax::mojom::Role::kStaticText; |
| tree_update.nodes.emplace_back(); |
| auto& node_data3 = tree_update.nodes.back(); |
| node_data3.id = 3; |
| node_data3.role = ax::mojom::Role::kStaticText; |
| |
| std::vector<ui::AXEvent> events; |
| client_->SendAccessibilityEvents(tree_data.tree_id, updates, gfx::Point(), |
| events); |
| |
| bool perform_action_called = false; |
| client_->SetPerformActionCalledCallback(base::BindLambdaForTesting( |
| [this, &perform_action_called](const ui::AXActionData& data) { |
| perform_action_called = true; |
| EXPECT_EQ(data.target_tree_id, client_->desktop_tree_id()); |
| EXPECT_EQ(data.action, ax::mojom::Action::kSetSelection); |
| EXPECT_EQ(data.anchor_node_id, 2); |
| EXPECT_EQ(data.anchor_offset, 0); |
| EXPECT_EQ(data.focus_node_id, 2); |
| EXPECT_EQ(data.focus_offset, 3); |
| })); |
| |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.automation.getDesktop(desktop => { |
| const unselected_text = desktop.lastChild; |
| |
| // This call will not trigger a PerformAction because unselected_text |
| // is part of the desktop tree. |
| chrome.automation.setDocumentSelection({ |
| anchorObject: unselected_text, |
| focusObject: unselected_text, |
| anchorOffset: 1, |
| focusOffset: 4, |
| }); |
| |
| const text = desktop.firstChild; |
| |
| // TODO(b:330577726): Update test to point to a child tree once ATP |
| // supports them. |
| // Note: the correct way to call setDocumentSelection in a tree that is |
| // a desktop tree is via AutomationNode.setSelection. However, because |
| // the goal of this test is to check if the call to the |
| // AutomationClient interface is made with the correct parameters, we |
| // override the desktop tree ID here so that the API thinks it is not |
| // a desktop tree. |
| chrome.automation.desktopId_ = 'abcdef'; |
| chrome.automation.setDocumentSelection({ |
| anchorObject: text, |
| focusObject: text, |
| anchorOffset: 0, |
| focusOffset: 3, |
| }); |
| remote.testComplete(/*success=*/true); |
| }); |
| )JS"); |
| WaitForJSTestComplete(); |
| ASSERT_TRUE(perform_action_called); |
| } |
| |
| // Ensures that when a child tree is created, a event is fired on the parent |
| // tree to indicate that it is finished loading and is |
| // connected. |
| TEST_F(AutomationJSApiTest, OnChildTreeEvents) { |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.automation.getDesktop(desktop => { |
| // This event will trigger once the child tree is loaded. |
| desktop.addEventListener('childrenChanged', function() { |
| const mainTree = chrome.automation.desktopTree; |
| if (!mainTree) { |
| remote.testComplete(/*success=*/false); |
| } |
| const childTree = mainTree.childTree; |
| if (!childTree) { |
| remote.testComplete(/*success=*/false); |
| } |
| if (childTree.parent !== mainTree) { |
| remote.testComplete(/*success=*/false); |
| } |
| remote.testComplete(/*success=*/true); |
| }); |
| }); |
| )JS"); |
| |
| std::vector<ui::AXTreeUpdate> updates; |
| const ui::AXTreeID child_tree_id = ui::AXTreeID::CreateNewAXTreeID(); |
| |
| { |
| updates.emplace_back(); |
| auto& tree_update = updates.back(); |
| tree_update.has_tree_data = true; |
| tree_update.root_id = 1; |
| auto& tree_data = tree_update.tree_data; |
| tree_data.tree_id = client_->desktop_tree_id(); |
| tree_update.nodes.emplace_back(); |
| auto& node_data1 = tree_update.nodes.back(); |
| node_data1.id = 1; |
| node_data1.role = ax::mojom::Role::kDesktop; |
| node_data1.AddChildTreeId(child_tree_id); |
| |
| std::vector<ui::AXEvent> events; |
| client_->SendAccessibilityEvents(tree_data.tree_id, updates, gfx::Point(), |
| events); |
| } |
| updates.clear(); |
| |
| { |
| // Child tree data: |
| updates.emplace_back(); |
| auto& tree_update2 = updates.back(); |
| tree_update2.has_tree_data = true; |
| tree_update2.root_id = 1; |
| auto& tree_data2 = tree_update2.tree_data; |
| tree_data2.tree_id = child_tree_id; |
| tree_update2.nodes.emplace_back(); |
| auto& node_data2 = tree_update2.nodes.back(); |
| node_data2.id = 1; |
| node_data2.role = ax::mojom::Role::kWebView; |
| node_data2.child_ids.push_back(2); |
| tree_update2.nodes.emplace_back(); |
| auto& node_data3 = tree_update2.nodes.back(); |
| node_data3.id = 2; |
| node_data3.role = ax::mojom::Role::kButton; |
| |
| std::vector<ui::AXEvent> events; |
| client_->SendAccessibilityEvents(tree_data2.tree_id, updates, gfx::Point(), |
| events); |
| } |
| |
| WaitForJSTestComplete(); |
| } |
| |
| // Ensures that when nodes are deleted, the js objects are also removed. |
| TEST_F(AutomationJSApiTest, DeletedNodesAreRemovedFromTree) { |
| std::vector<ui::AXTreeUpdate> updates; |
| |
| { |
| updates.emplace_back(); |
| auto& tree_update = updates.back(); |
| tree_update.has_tree_data = true; |
| tree_update.root_id = 1; |
| auto& tree_data = tree_update.tree_data; |
| tree_data.tree_id = client_->desktop_tree_id(); |
| tree_update.nodes.emplace_back(); |
| auto& node_data1 = tree_update.nodes.back(); |
| node_data1.id = 1; |
| node_data1.role = ax::mojom::Role::kDesktop; |
| node_data1.child_ids.push_back(2); |
| tree_update.nodes.emplace_back(); |
| auto& node_data2 = tree_update.nodes.back(); |
| node_data2.id = 2; |
| node_data2.role = ax::mojom::Role::kStaticText; |
| |
| std::vector<ui::AXEvent> events; |
| client_->SendAccessibilityEvents(tree_data.tree_id, updates, gfx::Point(), |
| events); |
| } |
| |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.automation.getDesktop(desktop => { |
| if (desktop.children.length !== 1) { |
| remote.testComplete(/*success=*/false); |
| } |
| remote.checkpointReached('JSTreeHasOneChild'); |
| }); |
| )JS"); |
| |
| // Wait until javascript code says it has reached this checkpoint. |
| // This is important because there are two threads running here, and it can be |
| // the case that the test thread sends all tree updates before js has the |
| // chance to see that it had one child, and then later that the child is |
| // deleted. |
| WaitAtCheckpoint("JSTreeHasOneChild"); |
| |
| // Delete node: |
| { |
| updates.clear(); |
| updates.emplace_back(); |
| auto& tree_update = updates.back(); |
| tree_update.node_id_to_clear = 1; |
| tree_update.has_tree_data = true; |
| tree_update.root_id = 1; |
| auto& tree_data = tree_update.tree_data; |
| tree_data.tree_id = client_->desktop_tree_id(); |
| tree_update.nodes.emplace_back(); |
| auto& node_data1 = tree_update.nodes.back(); |
| node_data1.id = 1; |
| node_data1.role = ax::mojom::Role::kDesktop; |
| |
| std::vector<ui::AXEvent> events; |
| client_->SendAccessibilityEvents(tree_data.tree_id, updates, gfx::Point(), |
| events); |
| } |
| |
| SynchronizeAfterMojoCalls(); |
| |
| ExecuteJS(R"JS( |
| chrome.automation.getDesktop(desktop => { |
| if (desktop.children.length == 0) { |
| remote.testComplete(/*success=*/true); |
| } |
| }); |
| )JS"); |
| |
| WaitForJSTestComplete(); |
| } |
| |
| // Ensures that when event listeners are added, once the last one is removed, |
| // automation is disabled and js objects are destroyed. |
| TEST_F(AutomationJSApiTest, OnAllAutomationEventListenersRemoved) { |
| std::vector<ui::AXTreeUpdate> updates; |
| |
| { |
| updates.emplace_back(); |
| auto& tree_update = updates.back(); |
| tree_update.has_tree_data = true; |
| tree_update.root_id = 1; |
| auto& tree_data = tree_update.tree_data; |
| tree_data.tree_id = client_->desktop_tree_id(); |
| tree_update.nodes.emplace_back(); |
| auto& node_data1 = tree_update.nodes.back(); |
| node_data1.id = 1; |
| node_data1.role = ax::mojom::Role::kDesktop; |
| |
| std::vector<ui::AXEvent> events; |
| client_->SendAccessibilityEvents(tree_data.tree_id, updates, gfx::Point(), |
| events); |
| } |
| |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| const listener = function() {}; |
| chrome.automation.getDesktop(desktop => { |
| desktop.addEventListener('childrenChanged', listener); |
| remote.checkpointReached('EventListenerAdded'); |
| }); |
| )JS"); |
| |
| WaitAtCheckpoint("EventListenerAdded"); |
| |
| updates.clear(); |
| |
| { |
| updates.emplace_back(); |
| auto& tree_update = updates.back(); |
| tree_update.has_tree_data = true; |
| tree_update.root_id = 1; |
| auto& tree_data = tree_update.tree_data; |
| tree_data.tree_id = client_->desktop_tree_id(); |
| tree_update.nodes.emplace_back(); |
| auto& node_data = tree_update.nodes.back(); |
| node_data.id = 1; |
| node_data.role = ax::mojom::Role::kDesktop; |
| node_data.child_ids.push_back(2); |
| tree_update.nodes.emplace_back(); |
| auto& node_data2 = tree_update.nodes.back(); |
| node_data2.id = 2; |
| node_data2.role = ax::mojom::Role::kButton; |
| |
| std::vector<ui::AXEvent> events; |
| client_->SendAccessibilityEvents(tree_data.tree_id, updates, gfx::Point(), |
| events); |
| } |
| |
| SynchronizeAfterMojoCalls(); |
| |
| ExecuteJS(R"JS( |
| chrome.automation.getDesktop(desktop => { |
| desktop.removeEventListener('childrenChanged', listener); |
| }); |
| )JS"); |
| |
| // TODO(b:332620645): Implement robust synchronization mechanism for atp js |
| // This script runs separate from the one above so that the loop of the v8 |
| // thread runs and dispatches the mojo calls to disable automation (after the |
| // last listener is removed). This causes the automation js objects to be |
| // reset. |
| |
| ExecuteJS(R"JS( |
| if (chrome.automation.desktopTree === undefined) { |
| remote.testComplete(/*success=*/true); |
| } |
| )JS"); |
| |
| WaitForJSTestComplete(); |
| |
| EXPECT_EQ(client_->num_disable_called(), 1u); |
| } |
| |
| // Ensures that the tree is destroyed after a call to the automation |
| // DispatchTreeDestroyed. |
| TEST_F(AutomationJSApiTest, OnTreeDestroyedEvent) { |
| std::vector<ui::AXTreeUpdate> updates; |
| |
| { |
| updates.emplace_back(); |
| auto& tree_update = updates.back(); |
| tree_update.has_tree_data = true; |
| tree_update.root_id = 1; |
| auto& tree_data = tree_update.tree_data; |
| tree_data.tree_id = client_->desktop_tree_id(); |
| tree_update.nodes.emplace_back(); |
| auto& node_data1 = tree_update.nodes.back(); |
| node_data1.id = 1; |
| node_data1.role = ax::mojom::Role::kDesktop; |
| node_data1.child_ids.push_back(2); |
| tree_update.nodes.emplace_back(); |
| auto& node_data2 = tree_update.nodes.back(); |
| node_data2.id = 2; |
| node_data2.role = ax::mojom::Role::kButton; |
| |
| std::vector<ui::AXEvent> events; |
| client_->SendAccessibilityEvents(tree_data.tree_id, updates, gfx::Point(), |
| events); |
| } |
| |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| let tree_id = ''; |
| chrome.automation.getDesktop(desktop => { |
| // Save tree id for later. |
| tree_id = desktop.treeID; |
| remote.checkpointReached('TreeLoaded'); |
| }); |
| )JS"); |
| |
| WaitAtCheckpoint("TreeLoaded"); |
| |
| client_->SendTreeDestroyedEvent(client_->desktop_tree_id()); |
| |
| SynchronizeAfterMojoCalls(); |
| |
| ExecuteJS(R"JS( |
| const tree = AutomationRootNode.get(tree_id); |
| remote.testComplete(/*success=*/!tree); |
| )JS"); |
| |
| WaitForJSTestComplete(); |
| } |
| |
| // Ensures that automation is notified when an action result is available. |
| TEST_F(AutomationJSApiTest, OnActionResult) { |
| std::vector<ui::AXTreeUpdate> updates; |
| |
| { |
| updates.emplace_back(); |
| auto& tree_update = updates.back(); |
| tree_update.has_tree_data = true; |
| tree_update.root_id = 1; |
| auto& tree_data = tree_update.tree_data; |
| tree_data.tree_id = client_->desktop_tree_id(); |
| tree_update.nodes.emplace_back(); |
| auto& node_data1 = tree_update.nodes.back(); |
| node_data1.id = 1; |
| node_data1.role = ax::mojom::Role::kDesktop; |
| node_data1.child_ids.push_back(2); |
| tree_update.nodes.emplace_back(); |
| auto& node_data2 = tree_update.nodes.back(); |
| node_data2.id = 2; |
| node_data2.role = ax::mojom::Role::kButton; |
| |
| std::vector<ui::AXEvent> events; |
| client_->SendAccessibilityEvents(tree_data.tree_id, updates, gfx::Point(), |
| events); |
| } |
| |
| client_->SetPerformActionCalledCallback( |
| base::BindLambdaForTesting([this](const ui::AXActionData& data) { |
| EXPECT_EQ(data.action, ax::mojom::Action::kHitTest); |
| EXPECT_EQ(data.target_node_id, 2); |
| // TODO(b:333790806): Convert opt_args to AxActionData format. Once that |
| // is done, check x and y passed to perform action hit test logic. |
| client_->SendActionResult(data, /*result=*/true); |
| })); |
| |
| ExecuteJS(R"JS( |
| const remote = axtest.mojom.TestBindingInterface.getRemote(); |
| chrome.automation.getDesktop(desktop => { |
| const button = desktop.firstChild; |
| if (button.role !== 'button') { |
| remote.testComplete(/*success=*/false); |
| } |
| button.hitTestWithReply(10, 10, function() { |
| remote.testComplete(/*success=*/true); |
| }); |
| }); |
| )JS"); |
| |
| WaitForJSTestComplete(); |
| } |
| |
| } // namespace ax |
