| // 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. |
| |
| #include <stddef.h> |
| |
| #include <string> |
| #include <vector> |
| |
| #include "ash/constants/ash_pref_names.h" |
| #include "base/json/json_writer.h" |
| #include "base/values.h" |
| #include "chrome/browser/ash/accessibility/accessibility_test_utils.h" |
| #include "chrome/browser/extensions/extension_apitest.h" |
| #include "chrome/browser/profiles/profile.h" |
| #include "chrome/browser/ui/browser.h" |
| #include "components/prefs/pref_service.h" |
| #include "content/public/test/browser_test.h" |
| #include "extensions/test/result_catcher.h" |
| |
| // API tests for chrome.accessibilityFeatures API. |
| // Note that the API is implemented using preference API infrastructure. |
| // See preference_api.cc for the list of accessibility features exposed by the |
| // API and the related preferences. |
| |
| namespace extensions { |
| |
| namespace { |
| |
| // Keys for data in the test config argument that will be set for the test app |
| // to use. |
| // The test that the app should run. |
| const char kTestNameKey[] = "testName"; |
| // Key for list of features enabled when the test is initialized. |
| const char kEnabledFeaturesKey[] = "enabled"; |
| // Key for list of features disabled when the test is initialized. |
| const char kDisabledFeaturesKey[] = "disabled"; |
| |
| // A test extension path. The extension has only |accessibilityFeatures.read| |
| // permission. |
| const char kTestExtensionPathReadPermission[] = |
| "accessibility_features/read_permission/"; |
| |
| // A test extension path. The extension has only |accessibilityFeatures.read| |
| // permission and has manifest v3. |
| const char kTestExtensionPathReadPermissionV3[] = |
| "accessibility_features/mv3/read_permission/"; |
| |
| // A test extension path. The extension has only |accessibilityFeatures.modify| |
| // permission. |
| const char kTestExtensionPathModifyPermission[] = |
| "accessibility_features/modify_permission/"; |
| |
| // A test extension path. The extension has only |accessibilityFeatures.modify| |
| // permission and has manifest v3. |
| const char kTestExtensionPathModifyPermissionV3[] = |
| "accessibility_features/mv3/modify_permission/"; |
| |
| using ManifestVersion = ash::ManifestVersion; |
| |
| enum class Permission { kWriteOnly, kReadOnly }; |
| |
| // A class used to define the parameters of a test case. |
| struct TestConfig { |
| Permission permission; |
| ManifestVersion version; |
| }; |
| |
| // Accessibility features API test. |
| // Tests are parameterized by the permission (write-only or read-only), as well |
| // as the manifest version (v2 or v3). |
| class AccessibilityFeaturesApiTest |
| : public ExtensionApiTest, |
| public testing::WithParamInterface<TestConfig> { |
| public: |
| AccessibilityFeaturesApiTest() = default; |
| virtual ~AccessibilityFeaturesApiTest() = default; |
| |
| protected: |
| // Returns pref service to be used to initialize and later verify |
| // accessibility preference values. |
| PrefService* GetPrefs() { return browser()->profile()->GetPrefs(); } |
| |
| // Returns the path of the extension that should be used in a parameterized |
| // test. |
| const char* GetTestExtensionPath() const { |
| Permission permission = GetParam().permission; |
| ManifestVersion version = GetParam().version; |
| if (version == ManifestVersion::kTwo && |
| permission == Permission::kWriteOnly) { |
| return kTestExtensionPathModifyPermission; |
| } else if (version == ManifestVersion::kTwo && |
| permission == Permission::kReadOnly) { |
| return kTestExtensionPathReadPermission; |
| } else if (version == ManifestVersion::kThree && |
| permission == Permission::kWriteOnly) { |
| return kTestExtensionPathModifyPermissionV3; |
| } else if (version == ManifestVersion::kThree && |
| permission == Permission::kReadOnly) { |
| return kTestExtensionPathReadPermissionV3; |
| } |
| |
| NOTREACHED(); |
| } |
| |
| // Whether a parameterized test should have been able to modify accessibility |
| // preferences (i.e. whether the test extension had modify permission). |
| bool ShouldModifyingFeatureSucceed() const { |
| return GetParam().permission == Permission::kWriteOnly; |
| } |
| |
| // Returns preference path for accessibility features as defined by the API. |
| const char* GetPrefForFeature(const std::string& feature) { |
| if (feature == "spokenFeedback") |
| return ash::prefs::kAccessibilitySpokenFeedbackEnabled; |
| if (feature == "largeCursor") |
| return ash::prefs::kAccessibilityLargeCursorEnabled; |
| if (feature == "stickyKeys") |
| return ash::prefs::kAccessibilityStickyKeysEnabled; |
| if (feature == "highContrast") |
| return ash::prefs::kAccessibilityHighContrastEnabled; |
| if (feature == "screenMagnifier") |
| return ash::prefs::kAccessibilityScreenMagnifierEnabled; |
| if (feature == "autoclick") |
| return ash::prefs::kAccessibilityAutoclickEnabled; |
| if (feature == "virtualKeyboard") |
| return ash::prefs::kAccessibilityVirtualKeyboardEnabled; |
| if (feature == "caretHighlight") |
| return ash::prefs::kAccessibilityCaretHighlightEnabled; |
| if (feature == "cursorHighlight") |
| return ash::prefs::kAccessibilityCursorHighlightEnabled; |
| if (feature == "focusHighlight") |
| return ash::prefs::kAccessibilityFocusHighlightEnabled; |
| if (feature == "selectToSpeak") |
| return ash::prefs::kAccessibilitySelectToSpeakEnabled; |
| if (feature == "switchAccess") |
| return ash::prefs::kAccessibilitySwitchAccessEnabled; |
| if (feature == "cursorColor") |
| return ash::prefs::kAccessibilityCursorColorEnabled; |
| if (feature == "dockedMagnifier") |
| return ash::prefs::kDockedMagnifierEnabled; |
| if (feature == "dictation") |
| return ash::prefs::kAccessibilityDictationEnabled; |
| return nullptr; |
| } |
| |
| // Initializes preferences before running the test extension. |
| // |prefs| Pref service which should be initialized. |
| // |enabled_features| List of boolean preference whose value should be set to |
| // true. |
| // |disabled_features| List of boolean preferences whose value should be set |
| // to false. |
| bool InitPrefServiceForTest( |
| PrefService* prefs, |
| const std::vector<std::string>& enabled_features, |
| const std::vector<std::string>& disabled_features) { |
| for (const auto& feature : enabled_features) { |
| const char* const pref_name = GetPrefForFeature(feature); |
| EXPECT_TRUE(pref_name) << "Invalid feature " << feature; |
| if (!pref_name) |
| return false; |
| prefs->SetBoolean(pref_name, true); |
| } |
| |
| for (const auto& feature : disabled_features) { |
| const char* const pref_name = GetPrefForFeature(feature); |
| EXPECT_TRUE(pref_name) << "Invalid feature " << feature; |
| if (!pref_name) |
| return false; |
| prefs->SetBoolean(pref_name, false); |
| } |
| return true; |
| } |
| |
| // Verifies that preferences have the expected value. |
| // |prefs| The pref service to be verified. |
| // |enabled_features| The list of boolean preferences whose value should be |
| // true. |
| // |disabled_features| The list of boolean preferences whose value should be |
| // false. |
| void VerifyPrefServiceState( |
| PrefService* prefs, |
| const std::vector<std::string>& enabled_features, |
| const std::vector<std::string>& disabled_features) { |
| for (const auto& feature : enabled_features) { |
| const char* const pref_name = GetPrefForFeature(feature); |
| ASSERT_TRUE(pref_name) << "Invalid feature " << feature; |
| ASSERT_TRUE(prefs->GetBoolean(pref_name)); |
| } |
| |
| for (const auto& feature : disabled_features) { |
| const char* const pref_name = GetPrefForFeature(feature); |
| ASSERT_TRUE(pref_name) << "Invalid feature " << feature; |
| ASSERT_FALSE(prefs->GetBoolean(pref_name)); |
| } |
| } |
| |
| // Given the test name and list of enabled and disabled features, generates |
| // and sets the JSON string that should be given to the test extension as |
| // test configuration. |
| // The result is saved to |result|. The return value is whether the test |
| // argument was successfully generated. |
| bool GenerateTestArg(const std::string& test_name, |
| const std::vector<std::string>& enabled_features, |
| const std::vector<std::string>& disabled_features, |
| std::string* result) { |
| base::Value::Dict test_arg; |
| test_arg.Set(kTestNameKey, test_name); |
| |
| base::Value::List enabled_list; |
| for (const auto& feature : enabled_features) |
| enabled_list.Append(feature); |
| test_arg.Set(kEnabledFeaturesKey, std::move(enabled_list)); |
| |
| base::Value::List disabled_list; |
| for (const auto& feature : disabled_features) |
| disabled_list.Append(feature); |
| test_arg.Set(kDisabledFeaturesKey, std::move(disabled_list)); |
| |
| return base::JSONWriter::Write(test_arg, result); |
| } |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(AccessibilityFeaturesApiTestWritePermission, |
| AccessibilityFeaturesApiTest, |
| ::testing::Values(TestConfig{Permission::kWriteOnly, |
| ManifestVersion::kTwo})); |
| |
| INSTANTIATE_TEST_SUITE_P(AccessibilityFeaturesApiTestReadPermission, |
| AccessibilityFeaturesApiTest, |
| ::testing::Values(TestConfig{Permission::kReadOnly, |
| ManifestVersion::kTwo})); |
| |
| INSTANTIATE_TEST_SUITE_P(AccessibilityFeaturesApiTestWritePermissionV3, |
| AccessibilityFeaturesApiTest, |
| ::testing::Values(TestConfig{ |
| Permission::kWriteOnly, ManifestVersion::kThree})); |
| |
| INSTANTIATE_TEST_SUITE_P(AccessibilityFeaturesApiTestReadPermissionV3, |
| AccessibilityFeaturesApiTest, |
| ::testing::Values(TestConfig{ |
| Permission::kReadOnly, ManifestVersion::kThree})); |
| |
| // Tests that an extension with read permission can read accessibility features |
| // state, while an extension that doesn't have the permission cannot. |
| IN_PROC_BROWSER_TEST_P(AccessibilityFeaturesApiTest, Get) { |
| // WARNING: Make sure that features which load Chrome extension are not among |
| // enabled_features (see |Set| test for the reason). |
| std::vector<std::string> enabled_features = { |
| "cursorColor", "cursorHighlight", "highContrast", |
| "largeCursor", "stickyKeys", |
| }; |
| |
| std::vector<std::string> disabled_features = { |
| "autoclick", |
| "caretHighlight", |
| "dockedMagnifier", |
| "focusHighlight", |
| "screenMagnifier", |
| "selectToSpeak", |
| "spokenFeedback", |
| "switchAccess", |
| "virtualKeyboard", |
| }; |
| |
| ASSERT_TRUE( |
| InitPrefServiceForTest(GetPrefs(), enabled_features, disabled_features)); |
| |
| std::string test_arg; |
| ASSERT_TRUE(GenerateTestArg("getterTest", enabled_features, disabled_features, |
| &test_arg)); |
| |
| bool is_mv2 = GetParam().version == ManifestVersion::kTwo; |
| EXPECT_TRUE(RunExtensionTest( |
| GetTestExtensionPath(), |
| {.custom_arg = test_arg.c_str(), .launch_as_platform_app = is_mv2})) |
| << message_; |
| } |
| |
| IN_PROC_BROWSER_TEST_P(AccessibilityFeaturesApiTest, PRE_Get_ComponentApp) { |
| bool is_mv2 = GetParam().version == ManifestVersion::kTwo; |
| EXPECT_FALSE( |
| RunExtensionTest(GetTestExtensionPath(), |
| {.custom_arg = "{}", .launch_as_platform_app = is_mv2}, |
| {.load_as_component = is_mv2})) |
| << message_; |
| } |
| |
| // A regression test for https://crbug.com/454513. Ensure that loading a |
| // component extension with the same version as has previously loaded, correctly |
| // sets up access to accessibility prefs. Otherwise,this is the same as the |
| // |Get| test. |
| IN_PROC_BROWSER_TEST_P(AccessibilityFeaturesApiTest, Get_ComponentApp) { |
| // WARNING: Make sure that features which load Chrome extension are not among |
| // enabled_features (see |Set| test for the reason). |
| std::vector<std::string> enabled_features = { |
| "cursorHighlight", |
| "dockedMagnifier", |
| "highContrast", |
| "largeCursor", |
| "stickyKeys", |
| }; |
| |
| std::vector<std::string> disabled_features = { |
| "autoclick", "caretHighlight", "cursorColor", |
| "focusHighlight", "screenMagnifier", "selectToSpeak", |
| "spokenFeedback", "switchAccess", "virtualKeyboard", |
| }; |
| |
| ASSERT_TRUE( |
| InitPrefServiceForTest(GetPrefs(), enabled_features, disabled_features)); |
| |
| std::string test_arg; |
| ASSERT_TRUE(GenerateTestArg("getterTest", enabled_features, disabled_features, |
| &test_arg)); |
| |
| bool is_mv2 = GetParam().version == ManifestVersion::kTwo; |
| EXPECT_TRUE(RunExtensionTest( |
| GetTestExtensionPath(), |
| {.custom_arg = test_arg.c_str(), .launch_as_platform_app = is_mv2}, |
| {.load_as_component = is_mv2})) |
| << message_; |
| } |
| |
| // Tests that an extension with modify permission can modify accessibility |
| // features, while an extension that doesn't have the permission can't. |
| IN_PROC_BROWSER_TEST_P(AccessibilityFeaturesApiTest, Set) { |
| // WARNING: Make sure that features which load Chrome extension are not |
| // enabled at this point (before the test app is loaded), as that may break |
| // the test: |
| // |RunPlatformAppTestWithArg| waits for the test extension to load by |
| // waiting for EXTENSION_LOADED notification to be observed. It also assumes |
| // that there is only one extension being loaded during this time (it finishes |
| // when the first notification is seen). Enabling spoken feedback, select to |
| // speak, autoclick, or switch access here would break this assumption as it |
| // would induce loading of Chrome extension. |
| std::vector<std::string> enabled_features = { |
| "caretHighlight", |
| "cursorColor", |
| "focusHighlight", |
| "stickyKeys", |
| }; |
| |
| std::vector<std::string> disabled_features = { |
| "autoclick", |
| "cursorHighlight", |
| "dockedMagnifier", |
| "highContrast", |
| "largeCursor", |
| "screenMagnifier", |
| "selectToSpeak", |
| "spokenFeedback", |
| "switchAccess", |
| "virtualKeyboard", |
| }; |
| |
| ASSERT_TRUE( |
| InitPrefServiceForTest(GetPrefs(), enabled_features, disabled_features)); |
| |
| std::string test_arg; |
| ASSERT_TRUE(GenerateTestArg("setterTest", enabled_features, disabled_features, |
| &test_arg)); |
| bool is_mv2 = GetParam().version == ManifestVersion::kTwo; |
| // The test extension attempts to flip all feature values. |
| ASSERT_TRUE(RunExtensionTest( |
| GetTestExtensionPath(), |
| {.custom_arg = test_arg.c_str(), .launch_as_platform_app = is_mv2})) |
| << message_; |
| |
| // The test tries to flip the feature states. |
| if (ShouldModifyingFeatureSucceed()) { |
| VerifyPrefServiceState(GetPrefs(), disabled_features, enabled_features); |
| } else { |
| VerifyPrefServiceState(GetPrefs(), enabled_features, disabled_features); |
| } |
| } |
| |
| // Tests that an extension with read permission is notified when accessibility |
| // features change. |
| IN_PROC_BROWSER_TEST_P(AccessibilityFeaturesApiTest, ObserveFeatures) { |
| // WARNING: Make sure that features which load Chrome extension are not among |
| // enabled_features (see |Set| test for the reason). |
| std::vector<std::string> enabled_features = { |
| "caretHighlight", |
| "cursorColor", |
| "focusHighlight", |
| "stickyKeys", |
| }; |
| |
| std::vector<std::string> disabled_features = { |
| "autoclick", |
| "cursorHighlight", |
| "dockedMagnifier", |
| "highContrast", |
| "largeCursor", |
| "screenMagnifier", |
| "selectToSpeak", |
| "spokenFeedback", |
| "switchAccess", |
| "virtualKeyboard", |
| }; |
| |
| ASSERT_TRUE( |
| InitPrefServiceForTest(GetPrefs(), enabled_features, disabled_features)); |
| |
| std::string test_arg; |
| ASSERT_TRUE(GenerateTestArg("observerTest", enabled_features, |
| disabled_features, &test_arg)); |
| |
| // The test extension is supposed to report result twice when running this |
| // test. First time when in initializes it's feature listeners, and second |
| // time, when gets all expected events. This is done so the extension is |
| // running when the accessibility features are flipped; otherwise, the |
| // extension may not see events. |
| |
| bool is_mv2 = GetParam().version == ManifestVersion::kTwo; |
| const char* extension_path = is_mv2 ? kTestExtensionPathReadPermission |
| : kTestExtensionPathReadPermissionV3; |
| ASSERT_TRUE(RunExtensionTest( |
| extension_path, |
| {.custom_arg = test_arg.c_str(), .launch_as_platform_app = is_mv2})) |
| << message_; |
| |
| // This should flip all features. |
| ASSERT_TRUE( |
| InitPrefServiceForTest(GetPrefs(), disabled_features, enabled_features)); |
| |
| // Catch the second result notification sent by the test extension. |
| ResultCatcher result_catcher; |
| ASSERT_TRUE(result_catcher.GetNextResult()) << result_catcher.message(); |
| } |
| |
| } // namespace |
| |
| } // namespace extensions |
