| // Copyright 2012 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <memory> |
| |
| #include "ash/ambient/ambient_ui_settings.h" |
| #include "ash/app_list/app_list_public_test_util.h" |
| #include "ash/app_list/views/search_box_view.h" |
| #include "ash/public/cpp/ambient/ambient_prefs.h" |
| #include "ash/public/cpp/app_list/app_list_types.h" |
| #include "ash/public/cpp/holding_space/holding_space_prefs.h" |
| #include "ash/public/cpp/overview_test_api.h" |
| #include "ash/public/cpp/test/app_list_test_api.h" |
| #include "ash/public/cpp/test/shell_test_api.h" |
| #include "base/json/json_writer.h" |
| #include "base/memory/raw_ptr.h" |
| #include "base/task/single_thread_task_runner.h" |
| #include "base/test/bind.h" |
| #include "base/test/scoped_command_line.h" |
| #include "base/test/scoped_feature_list.h" |
| #include "base/values.h" |
| #include "build/build_config.h" |
| #include "chrome/browser/ash/app_list/arc/arc_app_list_prefs.h" |
| #include "chrome/browser/ash/app_list/search/search_provider.h" |
| #include "chrome/browser/ash/app_list/search/test/app_list_search_test_helper.h" |
| #include "chrome/browser/ash/app_list/search/test/search_results_changed_waiter.h" |
| #include "chrome/browser/ash/app_list/search/test/test_result.h" |
| #include "chrome/browser/ash/arc/arc_util.h" |
| #include "chrome/browser/ash/arc/session/arc_session_manager.h" |
| #include "chrome/browser/ash/arc/tracing/arc_app_performance_tracing.h" |
| #include "chrome/browser/ash/arc/tracing/arc_app_performance_tracing_session.h" |
| #include "chrome/browser/ash/arc/tracing/test/arc_app_performance_tracing_test_helper.h" |
| #include "chrome/browser/ash/extensions/autotest_private/autotest_private_api.h" |
| #include "chrome/browser/ash/system_web_apps/test_support/test_system_web_app_installation.h" |
| #include "chrome/browser/browser_process.h" |
| #include "chrome/browser/extensions/extension_apitest.h" |
| #include "chrome/browser/profiles/profile_manager.h" |
| #include "chrome/browser/ui/ash/shelf/chrome_shelf_prefs.h" |
| #include "chrome/browser/ui/browser_window.h" |
| #include "chromeos/ash/experiences/arc/arc_prefs.h" |
| #include "chromeos/ash/experiences/arc/session/arc_bridge_service.h" |
| #include "chromeos/ash/experiences/arc/session/arc_service_manager.h" |
| #include "chromeos/ash/experiences/arc/session/connection_holder.h" |
| #include "chromeos/ash/experiences/arc/test/arc_task_window_builder.h" |
| #include "chromeos/ash/experiences/arc/test/arc_util_test_support.h" |
| #include "chromeos/ash/experiences/arc/test/connection_holder_util.h" |
| #include "chromeos/ash/experiences/arc/test/fake_app_instance.h" |
| #include "chromeos/ash/experiences/arc/test/fake_arc_session.h" |
| #include "chromeos/ash/experiences/arc/test/fake_process_instance.h" |
| #include "components/device_event_log/device_event_log.h" |
| #include "components/feature_engagement/public/feature_constants.h" |
| #include "components/language/core/browser/pref_names.h" |
| #include "components/policy/core/browser/browser_policy_connector.h" |
| #include "components/policy/core/common/mock_configuration_policy_provider.h" |
| #include "components/policy/core/common/policy_map.h" |
| #include "components/policy/core/common/policy_types.h" |
| #include "components/policy/policy_constants.h" |
| #include "components/prefs/pref_service.h" |
| #include "content/public/browser/render_frame_host.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/test/browser_test.h" |
| #include "content/public/test/test_navigation_observer.h" |
| #include "content/public/test/test_utils.h" |
| #include "services/viz/privileged/mojom/compositing/features.mojom-features.h" |
| #include "ui/aura/window.h" |
| #include "ui/events/event_utils.h" |
| #include "ui/events/test/event_generator.h" |
| #include "ui/views/widget/widget.h" |
| |
| using testing::_; |
| using testing::Return; |
| |
| namespace extensions { |
| |
| namespace { |
| |
| class TestSearchProvider : public app_list::SearchProvider { |
| public: |
| explicit TestSearchProvider(ash::AppListSearchResultType result_type) |
| : SearchProvider(app_list::SearchCategory::kTest), |
| result_type_(result_type) {} |
| |
| ~TestSearchProvider() override = default; |
| |
| void SetNextResults( |
| std::vector<std::unique_ptr<ChromeSearchResult>> results) { |
| results_ = std::move(results); |
| } |
| |
| ash::AppListSearchResultType ResultType() const override { |
| return result_type_; |
| } |
| |
| void Start(const std::u16string& query) override { |
| DCHECK(!ash::IsZeroStateResultType(result_type_)); |
| base::SingleThreadTaskRunner::GetCurrentDefault()->PostTask( |
| FROM_HERE, base::BindOnce(&TestSearchProvider::SetResults, |
| query_weak_factory_.GetWeakPtr())); |
| } |
| |
| void StopQuery() override { query_weak_factory_.InvalidateWeakPtrs(); } |
| |
| void StartZeroState() override {} |
| |
| private: |
| void SetResults() { SwapResults(&results_); } |
| |
| std::vector<std::unique_ptr<ChromeSearchResult>> results_; |
| ash::AppListSearchResultType result_type_; |
| base::WeakPtrFactory<TestSearchProvider> query_weak_factory_{this}; |
| }; |
| |
| } // namespace |
| |
| using ContextType = ExtensionBrowserTest::ContextType; |
| |
| class AutotestPrivateApiTest : public ExtensionApiTest { |
| public: |
| explicit AutotestPrivateApiTest(ContextType context_type) |
| : context_type_(context_type) { |
| feature_list_.InitAndEnableFeature(viz::mojom::EnableVizTestApis); |
| } |
| |
| AutotestPrivateApiTest(const AutotestPrivateApiTest&) = delete; |
| AutotestPrivateApiTest& operator=(const AutotestPrivateApiTest&) = delete; |
| |
| ~AutotestPrivateApiTest() override = default; |
| void SetUpCommandLine(base::CommandLine* command_line) override { |
| ExtensionApiTest::SetUpCommandLine(command_line); |
| // Make ARC enabled for tests. |
| arc::SetArcAvailableCommandLineForTesting(command_line); |
| } |
| |
| void SetUpInProcessBrowserTestFixture() override { |
| ExtensionApiTest::SetUpInProcessBrowserTestFixture(); |
| arc::ArcSessionManager::SetUiEnabledForTesting(false); |
| } |
| |
| void SetUpOnMainThread() override { |
| ExtensionApiTest::SetUpOnMainThread(); |
| // Turn on testing mode so we don't kill the browser. |
| AutotestPrivateAPI::GetFactoryInstance() |
| ->Get(browser()->profile()) |
| ->set_test_mode(true); |
| } |
| |
| bool RunAutotestPrivateExtensionTest( |
| const std::string& test_suite, |
| base::Value::List suite_args = base::Value::List()) { |
| base::Value::Dict custom_args; |
| custom_args.Set("testSuite", test_suite); |
| custom_args.Set("args", std::move(suite_args)); |
| |
| std::string json; |
| if (!base::JSONWriter::Write(custom_args, &json)) { |
| LOG(ERROR) << "Failed to parse custom args into json."; |
| return false; |
| } |
| |
| return RunExtensionTest( |
| "autotest_private", {.custom_arg = json.c_str()}, |
| {.load_as_component = true, .context_type = context_type_}); |
| } |
| |
| base::test::ScopedFeatureList feature_list_; |
| ContextType context_type_; |
| }; |
| |
| class AutotestPrivateApiTestWithContextType |
| : public AutotestPrivateApiTest, |
| public ::testing::WithParamInterface<ContextType> { |
| public: |
| AutotestPrivateApiTestWithContextType() |
| : AutotestPrivateApiTest(GetParam()) {} |
| ~AutotestPrivateApiTestWithContextType() override = default; |
| AutotestPrivateApiTestWithContextType( |
| const AutotestPrivateApiTestWithContextType&) = delete; |
| AutotestPrivateApiTestWithContextType& operator=( |
| const AutotestPrivateApiTestWithContextType&) = delete; |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(EventPage, |
| AutotestPrivateApiTestWithContextType, |
| ::testing::Values(ContextType::kEventPage)); |
| INSTANTIATE_TEST_SUITE_P(ServiceWorker, |
| AutotestPrivateApiTestWithContextType, |
| ::testing::Values(ContextType::kServiceWorker)); |
| |
| // TODO(crbug.com/356369542): Fix flakiness on sanitizer bots. |
| |
| #if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) || \ |
| BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) |
| #define MAYBE_AutotestPrivate DISABLED_AutotestPrivate |
| #else |
| #define MAYBE_AutotestPrivate AutotestPrivate |
| #endif |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateApiTestWithContextType, |
| MAYBE_AutotestPrivate) { |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("default")) << message_; |
| } |
| |
| // Set of tests where ARC is enabled and test apps and packages are registered. |
| // TODO(crbug.com/41486987): re-enable the following test. |
| #if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) |
| #define MAYBE_AutotestPrivateArcEnabled DISABLED_AutotestPrivateArcEnabled |
| #else |
| #define MAYBE_AutotestPrivateArcEnabled AutotestPrivateArcEnabled |
| #endif |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateApiTestWithContextType, |
| MAYBE_AutotestPrivateArcEnabled) { |
| ArcAppListPrefs* const prefs = ArcAppListPrefs::Get(browser()->profile()); |
| ASSERT_TRUE(prefs); |
| |
| arc::ArcSessionManager::Get()->SetArcSessionRunnerForTesting( |
| std::make_unique<arc::ArcSessionRunner>( |
| base::BindRepeating(arc::FakeArcSession::Create))); |
| |
| // Having ARC Terms accepted automatically bypasses TOS stage. |
| // Set it before |arc::SetArcPlayStoreEnabledForProfile| |
| browser()->profile()->GetPrefs()->SetBoolean(arc::prefs::kArcTermsAccepted, |
| true); |
| arc::SetArcPlayStoreEnabledForProfile(profile(), true); |
| // Provisioning is completed. |
| browser()->profile()->GetPrefs()->SetBoolean(arc::prefs::kArcSignedIn, true); |
| // Start ARC |
| arc::ArcSessionManager::Get()->StartArcForTesting(); |
| |
| auto app_instance = std::make_unique<arc::FakeAppInstance>(prefs); |
| prefs->app_connection_holder()->SetInstance(app_instance.get()); |
| arc::WaitForInstanceReady(prefs->app_connection_holder()); |
| |
| std::vector<arc::mojom::AppInfoPtr> fake_apps; |
| fake_apps.emplace_back(arc::mojom::AppInfo::New("Fake App", "fake.package", |
| "fake.package.activity")); |
| app_instance->SendRefreshAppList(fake_apps); |
| |
| std::vector<arc::mojom::ArcPackageInfoPtr> packages; |
| packages.emplace_back(arc::mojom::ArcPackageInfo::New( |
| fake_apps[0]->package_name, 10 /* package_version */, |
| 100 /* last_backup_android_id */, |
| base::Time::Now() |
| .ToDeltaSinceWindowsEpoch() |
| .InMicroseconds() /* last_backup_time */, |
| true /* sync */)); |
| app_instance->SendRefreshPackageList(std::move(packages)); |
| |
| arc::FakeProcessInstance fake_process_instance; |
| arc::ArcServiceManager::Get()->arc_bridge_service()->process()->SetInstance( |
| &fake_process_instance); |
| fake_process_instance.set_request_low_memory_kill_counts_response( |
| arc::mojom::LowMemoryKillCounts::New(1, // oom. |
| 2, // lmkd_foreground. |
| 3, // lmkd_perceptible. |
| 4, // lmkd_cached. |
| 5, // pressure_foreground. |
| 6, // pressure_perceptible. |
| 7)); // pressure_cached. |
| |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("arcEnabled")) << message_; |
| |
| arc::SetArcPlayStoreEnabledForProfile(profile(), false); |
| } |
| |
| // TODO(crbug.com/331532893): Flaky on ASan/LSan. |
| #if defined(ADDRESS_SANITIZER) || defined(LEAK_SANITIZER) |
| #define MAYBE_AutotestPrivateArcProcess DISABLED_AutotestPrivateArcProcess |
| #else |
| #define MAYBE_AutotestPrivateArcProcess AutotestPrivateArcProcess |
| #endif |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateApiTestWithContextType, |
| MAYBE_AutotestPrivateArcProcess) { |
| arc::FakeProcessInstance fake_process_instance; |
| arc::ArcServiceManager::Get()->arc_bridge_service()->process()->SetInstance( |
| &fake_process_instance); |
| fake_process_instance.set_request_low_memory_kill_counts_response( |
| arc::mojom::LowMemoryKillCounts::New(1, // oom. |
| 2, // lmkd_foreground. |
| 3, // lmkd_perceptible. |
| 4, // lmkd_cached. |
| 5, // pressure_foreground. |
| 6, // pressure_perceptible. |
| 7)); // pressure_cached. |
| |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("arcProcess")) << message_; |
| } |
| |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateApiTestWithContextType, |
| ScrollableShelfAPITest) { |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("scrollableShelf")) << message_; |
| } |
| |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateApiTestWithContextType, ShelfAPITest) { |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("shelf")) << message_; |
| } |
| |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateApiTestWithContextType, |
| IsFeatureEnabled) { |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("isFeatureEnabled")) << message_; |
| } |
| |
| struct HoldingSpaceParams { |
| ContextType context_type = ContextType::kNone; |
| bool mark_time_of_first_add = false; |
| }; |
| |
| class AutotestPrivateHoldingSpaceApiTest |
| : public AutotestPrivateApiTest, |
| public ::testing::WithParamInterface<HoldingSpaceParams> { |
| public: |
| AutotestPrivateHoldingSpaceApiTest() |
| : AutotestPrivateApiTest(GetParam().context_type) {} |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P( |
| EventPageAndTrue, |
| AutotestPrivateHoldingSpaceApiTest, |
| ::testing::Values(HoldingSpaceParams(ContextType::kEventPage, true))); |
| INSTANTIATE_TEST_SUITE_P( |
| EventPageAndFalse, |
| AutotestPrivateHoldingSpaceApiTest, |
| ::testing::Values(HoldingSpaceParams(ContextType::kEventPage, false))); |
| INSTANTIATE_TEST_SUITE_P( |
| ServiceWorkerAndTrue, |
| AutotestPrivateHoldingSpaceApiTest, |
| ::testing::Values(HoldingSpaceParams(ContextType::kServiceWorker, true))); |
| INSTANTIATE_TEST_SUITE_P( |
| ServiceWorkerAndFalse, |
| AutotestPrivateHoldingSpaceApiTest, |
| ::testing::Values(HoldingSpaceParams(ContextType::kServiceWorker, false))); |
| |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateHoldingSpaceApiTest, |
| HoldingSpaceAPITest) { |
| auto* prefs = browser()->profile()->GetPrefs(); |
| |
| ash::holding_space_prefs::SetPreviewsEnabled(prefs, false); |
| ash::holding_space_prefs::MarkTimeOfFirstAdd(prefs); |
| ash::holding_space_prefs::MarkTimeOfFirstAvailability(prefs); |
| ash::holding_space_prefs::MarkTimeOfFirstEntry(prefs); |
| ash::holding_space_prefs::MarkTimeOfFirstFilesAppChipPress(prefs); |
| ash::holding_space_prefs::MarkTimeOfFirstPin(prefs); |
| |
| const bool mark_time_of_first_add = GetParam().mark_time_of_first_add; |
| |
| base::Value::Dict options; |
| options.Set("markTimeOfFirstAdd", mark_time_of_first_add); |
| base::Value::List suite_args; |
| suite_args.Append(std::move(options)); |
| |
| ASSERT_TRUE( |
| RunAutotestPrivateExtensionTest("holdingSpace", std::move(suite_args))) |
| << message_; |
| |
| std::optional<base::Time> timeOfFirstAdd = |
| ash::holding_space_prefs::GetTimeOfFirstAdd(prefs); |
| std::optional<base::Time> timeOfFirstAvailability = |
| ash::holding_space_prefs::GetTimeOfFirstAvailability(prefs); |
| |
| ASSERT_TRUE(ash::holding_space_prefs::IsPreviewsEnabled(prefs)); |
| ASSERT_EQ(timeOfFirstAdd.has_value(), mark_time_of_first_add); |
| ASSERT_NE(timeOfFirstAvailability, std::nullopt); |
| ASSERT_EQ(ash::holding_space_prefs::GetTimeOfFirstEntry(prefs), std::nullopt); |
| ASSERT_EQ(ash::holding_space_prefs::GetTimeOfFirstFilesAppChipPress(prefs), |
| std::nullopt); |
| ASSERT_EQ(ash::holding_space_prefs::GetTimeOfFirstPin(prefs), std::nullopt); |
| |
| if (timeOfFirstAdd) { |
| ASSERT_GT(timeOfFirstAdd, timeOfFirstAvailability); |
| } |
| } |
| |
| class AutotestPrivateApiOverviewTest |
| : public AutotestPrivateApiTestWithContextType { |
| public: |
| AutotestPrivateApiOverviewTest() = default; |
| |
| // AutotestPrivateApiTest: |
| void SetUpOnMainThread() override { |
| AutotestPrivateApiTest::SetUpOnMainThread(); |
| |
| // Create one additional browser window to make total of 2 windows. |
| CreateBrowser(browser()->profile()); |
| |
| // Enters tablet overview mode. |
| ash::ShellTestApi().SetTabletModeEnabledForTest(true); |
| base::RunLoop run_loop; |
| ash::OverviewTestApi().SetOverviewMode( |
| /*start=*/true, base::BindLambdaForTesting([&run_loop](bool finished) { |
| if (!finished) { |
| ADD_FAILURE() << "Failed to enter overview."; |
| } |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| |
| // We should get 2 overview items from the 2 browser windows. |
| ASSERT_EQ(2u, ash::OverviewTestApi().GetOverviewInfo()->size()); |
| } |
| |
| gfx::NativeWindow GetRootWindow() const { |
| return browser()->window()->GetNativeWindow()->GetRootWindow(); |
| } |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(EventPage, |
| AutotestPrivateApiOverviewTest, |
| ::testing::Values(ContextType::kEventPage)); |
| INSTANTIATE_TEST_SUITE_P(ServiceWorker, |
| AutotestPrivateApiOverviewTest, |
| ::testing::Values(ContextType::kServiceWorker)); |
| |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateApiOverviewTest, Default) { |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("overviewDefault")) << message_; |
| } |
| |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateApiOverviewTest, Drag) { |
| const ash::OverviewInfo info = |
| ash::OverviewTestApi().GetOverviewInfo().value(); |
| const gfx::Point start_point = |
| info.begin()->second.bounds_in_screen.CenterPoint(); |
| |
| // Long press to pick up an overview item and drag it a bit. |
| ui::test::EventGenerator generator(GetRootWindow()); |
| |
| generator.set_current_screen_location(start_point); |
| generator.PressTouch(); |
| |
| ui::GestureEvent long_press( |
| start_point.x(), start_point.y(), 0, ui::EventTimeForNow(), |
| ui::GestureEventDetails(ui::EventType::kGestureLongPress)); |
| generator.Dispatch(&long_press); |
| |
| // 50 is arbitrary number of dip to move a bit to ensure the item is being |
| // dragged. |
| const gfx::Point end_point(start_point.x() + 50, start_point.y()); |
| generator.MoveTouch(end_point); |
| |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("overviewDrag")) << message_; |
| } |
| |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateApiOverviewTest, PrimarySnapped) { |
| const ash::OverviewInfo info = |
| ash::OverviewTestApi().GetOverviewInfo().value(); |
| const gfx::Point start_point = |
| info.begin()->second.bounds_in_screen.CenterPoint(); |
| const gfx::Point end_point(0, start_point.y()); |
| |
| // Long press to pick up an overview item, drag all the way to the left |
| // to snap it on left. |
| ui::test::EventGenerator generator(GetRootWindow()); |
| |
| generator.set_current_screen_location(start_point); |
| generator.PressTouch(); |
| |
| ui::GestureEvent long_press( |
| start_point.x(), start_point.y(), 0, ui::EventTimeForNow(), |
| ui::GestureEventDetails(ui::EventType::kGestureLongPress)); |
| generator.Dispatch(&long_press); |
| |
| generator.MoveTouch(end_point); |
| generator.ReleaseTouch(); |
| |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("splitviewPrimarySnapped")) |
| << message_; |
| } |
| |
| class AutotestPrivateWithPolicyApiTest |
| : public AutotestPrivateApiTestWithContextType { |
| public: |
| AutotestPrivateWithPolicyApiTest() = default; |
| |
| AutotestPrivateWithPolicyApiTest(const AutotestPrivateWithPolicyApiTest&) = |
| delete; |
| AutotestPrivateWithPolicyApiTest& operator=( |
| const AutotestPrivateWithPolicyApiTest&) = delete; |
| |
| void SetUpInProcessBrowserTestFixture() override { |
| provider_.SetDefaultReturns( |
| /*is_initialization_complete_return=*/true, |
| /*is_first_policy_load_complete_return=*/true); |
| policy::BrowserPolicyConnector::SetPolicyProviderForTesting(&provider_); |
| AutotestPrivateApiTest::SetUpInProcessBrowserTestFixture(); |
| } |
| |
| void SetUpOnMainThread() override { |
| AutotestPrivateApiTest::SetUpOnMainThread(); |
| // Set a fake policy |
| policy::PolicyMap policy; |
| policy.Set(policy::key::kAllowDinosaurEasterEgg, |
| policy::POLICY_LEVEL_MANDATORY, policy::POLICY_SCOPE_USER, |
| policy::POLICY_SOURCE_CLOUD, base::Value(true), nullptr); |
| provider_.UpdateChromePolicy(policy); |
| base::RunLoop().RunUntilIdle(); |
| } |
| |
| protected: |
| testing::NiceMock<policy::MockConfigurationPolicyProvider> provider_; |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(EventPage, |
| AutotestPrivateWithPolicyApiTest, |
| ::testing::Values(ContextType::kEventPage)); |
| INSTANTIATE_TEST_SUITE_P(ServiceWorker, |
| AutotestPrivateWithPolicyApiTest, |
| ::testing::Values(ContextType::kServiceWorker)); |
| |
| // GetAllEnterprisePolicies Sanity check. |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateWithPolicyApiTest, PolicyAPITest) { |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("enterprisePolicies")) |
| << message_; |
| } |
| |
| class AutotestPrivateArcPerformanceTracing |
| : public AutotestPrivateApiTestWithContextType { |
| public: |
| AutotestPrivateArcPerformanceTracing() = default; |
| |
| AutotestPrivateArcPerformanceTracing( |
| const AutotestPrivateArcPerformanceTracing&) = delete; |
| AutotestPrivateArcPerformanceTracing& operator=( |
| const AutotestPrivateArcPerformanceTracing&) = delete; |
| |
| ~AutotestPrivateArcPerformanceTracing() override = default; |
| |
| protected: |
| // AutotestPrivateApiTest: |
| void SetUpOnMainThread() override { |
| AutotestPrivateApiTest::SetUpOnMainThread(); |
| |
| tracing_helper_.SetUp(profile()); |
| root_surface_ = std::make_unique<exo::Surface>(); |
| performance_tracing()->SetCustomSessionReadyCallbackForTesting( |
| base::BindRepeating( |
| &arc::ArcAppPerformanceTracingTestHelper::PlayDefaultSequence, |
| base::Unretained(&tracing_helper_), root_surface_.get())); |
| } |
| |
| void TearDownOnMainThread() override { |
| root_surface_.reset(); |
| performance_tracing()->SetCustomSessionReadyCallbackForTesting( |
| arc::ArcAppPerformanceTracing::CustomSessionReadyCallback()); |
| tracing_helper_.TearDown(); |
| |
| AutotestPrivateApiTest::TearDownOnMainThread(); |
| } |
| |
| arc::ArcAppPerformanceTracingTestHelper& tracing_helper() { |
| return tracing_helper_; |
| } |
| |
| arc::ArcAppPerformanceTracing* performance_tracing() { |
| return tracing_helper_.GetTracing(); |
| } |
| |
| std::unique_ptr<exo::Surface> root_surface_; |
| |
| private: |
| arc::ArcAppPerformanceTracingTestHelper tracing_helper_; |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(EventPage, |
| AutotestPrivateArcPerformanceTracing, |
| ::testing::Values(ContextType::kEventPage)); |
| INSTANTIATE_TEST_SUITE_P(ServiceWorker, |
| AutotestPrivateArcPerformanceTracing, |
| ::testing::Values(ContextType::kServiceWorker)); |
| |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateArcPerformanceTracing, Basic) { |
| const auto arc_widget = arc::ArcTaskWindowBuilder() |
| .SetShellRootSurface(root_surface_.get()) |
| .BuildOwnsNativeWidget(); |
| |
| performance_tracing()->OnWindowActivated( |
| wm::ActivationChangeObserver::ActivationReason::ACTIVATION_CLIENT, |
| arc_widget->GetNativeWindow(), nullptr); |
| |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("arcPerformanceTracing")) |
| << message_; |
| |
| performance_tracing()->OnWindowActivated( |
| wm::ActivationChangeObserver::ActivationReason::ACTIVATION_CLIENT, |
| nullptr, arc_widget->GetNativeWindow()); |
| } |
| |
| class AutotestPrivateSystemWebAppsTest : public AutotestPrivateApiTest { |
| public: |
| AutotestPrivateSystemWebAppsTest() |
| : AutotestPrivateApiTest(ContextType::kNone) { |
| installation_ = |
| ash::TestSystemWebAppInstallation::SetUpStandaloneSingleWindowApp(); |
| } |
| ~AutotestPrivateSystemWebAppsTest() override = default; |
| |
| private: |
| std::unique_ptr<ash::TestSystemWebAppInstallation> installation_; |
| }; |
| |
| IN_PROC_BROWSER_TEST_F(AutotestPrivateSystemWebAppsTest, SystemWebApps) { |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("systemWebApps")) << message_; |
| } |
| |
| struct SearchParams { |
| ContextType context_type = ContextType::kNone; |
| bool tablet_mode = false; |
| }; |
| |
| class AutotestPrivateSearchTest |
| : public AutotestPrivateApiTest, |
| public ::testing::WithParamInterface<SearchParams> { |
| public: |
| AutotestPrivateSearchTest() |
| : AutotestPrivateApiTest(GetParam().context_type) {} |
| |
| ~AutotestPrivateSearchTest() override = default; |
| AutotestPrivateSearchTest(const AutotestPrivateSearchTest&) = delete; |
| AutotestPrivateSearchTest& operator=(const AutotestPrivateSearchTest&) = |
| delete; |
| |
| std::vector<raw_ptr<ChromeSearchResult, VectorExperimental>> |
| PublishedResults() { |
| return AppListClientImpl::GetInstance() |
| ->GetModelUpdaterForTest() |
| ->GetPublishedSearchResultsForTest(); |
| } |
| |
| void SetUpSearchResults() { |
| auto search_provider_ = std::make_unique<TestSearchProvider>( |
| ash::AppListSearchResultType::kOmnibox); |
| search_provider_->SetNextResults( |
| MakeResults({"youtube"}, {ash::SearchResultDisplayType::kList}, |
| {ash::AppListSearchResultCategory::kWeb}, {1}, {0.8})); |
| |
| app_list::SearchController* search_controller = |
| AppListClientImpl::GetInstance()->search_controller(); |
| EXPECT_EQ(1u, search_controller->ReplaceProvidersForResultTypeForTest( |
| ash::AppListSearchResultType::kOmnibox, |
| std::move(search_provider_))); |
| } |
| |
| protected: |
| std::vector<std::unique_ptr<ChromeSearchResult>> MakeResults( |
| const std::vector<std::string>& ids, |
| const std::vector<ash::SearchResultDisplayType>& display_types, |
| const std::vector<ash::AppListSearchResultCategory>& categories, |
| const std::vector<int>& best_match_ranks, |
| const std::vector<double>& scores) { |
| std::vector<std::unique_ptr<ChromeSearchResult>> results; |
| for (size_t i = 0; i < ids.size(); ++i) { |
| std::unique_ptr<app_list::TestResult> test_result = |
| std::make_unique<app_list::TestResult>( |
| ids[i], display_types[i], categories[i], best_match_ranks[i], |
| /*relevance=*/scores[i], /*ftrl_result_score=*/scores[i]); |
| test_result->scoring().override_filter_for_test(true); |
| results.emplace_back(std::move(test_result)); |
| } |
| return results; |
| } |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(EventPageAndEnabled, |
| AutotestPrivateSearchTest, |
| ::testing::Values(SearchParams(ContextType::kEventPage, |
| true))); |
| INSTANTIATE_TEST_SUITE_P(EventPageAndDisabled, |
| AutotestPrivateSearchTest, |
| ::testing::Values(SearchParams(ContextType::kEventPage, |
| false))); |
| |
| INSTANTIATE_TEST_SUITE_P( |
| ServiceWorkerAndEnabled, |
| AutotestPrivateSearchTest, |
| ::testing::Values(SearchParams(ContextType::kServiceWorker, true))); |
| INSTANTIATE_TEST_SUITE_P( |
| ServiceWorkerAndDisabled, |
| AutotestPrivateSearchTest, |
| ::testing::Values(SearchParams(ContextType::kServiceWorker, false))); |
| |
| #if BUILDFLAG(IS_LINUX) || BUILDFLAG(IS_CHROMEOS) |
| #define MAYBE_LauncherSearchBoxStateAPITest \ |
| DISABLED_LauncherSearchBoxStateAPITest |
| #else |
| #define MAYBE_LauncherSearchBoxStateAPITest LauncherSearchBoxStateAPITest |
| #endif |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateSearchTest, |
| MAYBE_LauncherSearchBoxStateAPITest) { |
| ash::ShellTestApi().SetTabletModeEnabledForTest(GetParam().tablet_mode); |
| test::GetAppListClient()->ShowAppList(ash::AppListShowSource::kSearchKey); |
| if (!GetParam().tablet_mode) { |
| ash::AppListTestApi().WaitForBubbleWindow( |
| /*wait_for_opening_animation=*/false); |
| } |
| |
| ui::test::EventGenerator generator( |
| browser()->window()->GetNativeWindow()->GetRootWindow()); |
| generator.GestureTapAt( |
| ash::GetSearchBoxView()->GetBoundsInScreen().CenterPoint()); |
| |
| app_list::SearchResultsChangedWaiter results_changed_waiter( |
| AppListClientImpl::GetInstance()->search_controller(), |
| {app_list::ResultType::kOmnibox}); |
| app_list::ResultsWaiter results_waiter(u"outube"); |
| |
| SetUpSearchResults(); |
| ash::AppListTestApi().SimulateSearch(u"outube"); |
| |
| results_changed_waiter.Wait(); |
| results_waiter.Wait(); |
| |
| std::vector<ChromeSearchResult*> results; |
| for (ChromeSearchResult* result : PublishedResults()) { |
| // There may be zero state results that are also published, but not visible |
| // in the UI. This test should only check search list results. |
| if (result->display_type() != ash::SearchResultDisplayType::kList) { |
| continue; |
| } |
| |
| results.push_back(result); |
| } |
| |
| ASSERT_EQ(results.size(), 1u); |
| ASSERT_TRUE(results[0]); |
| EXPECT_EQ(base::UTF16ToASCII(results[0]->title()), "youtube"); |
| |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("launcherSearchBoxState")) |
| << message_; |
| } |
| |
| class AutotestPrivateIsFieldTrialActiveApiTest |
| : public AutotestPrivateApiTestWithContextType { |
| public: |
| AutotestPrivateIsFieldTrialActiveApiTest() { |
| base::FieldTrial* trial = base::FieldTrialList::CreateFieldTrial( |
| "ActiveTrialForTest", "GroupForTest"); |
| trial->Activate(); |
| } |
| }; |
| |
| INSTANTIATE_TEST_SUITE_P(EventPage, |
| AutotestPrivateIsFieldTrialActiveApiTest, |
| ::testing::Values(ContextType::kEventPage)); |
| INSTANTIATE_TEST_SUITE_P(ServiceWorker, |
| AutotestPrivateIsFieldTrialActiveApiTest, |
| ::testing::Values(ContextType::kServiceWorker)); |
| |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateIsFieldTrialActiveApiTest, |
| IsFieldTrialActive) { |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("isFieldTrialActive")) |
| << message_; |
| } |
| |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateApiTestWithContextType, |
| ClearAllowedPref) { |
| static constexpr auto kTestTheme = |
| ash::personalization_app::mojom::AmbientTheme::kFloatOnBy; |
| ash::personalization_app::mojom::AmbientTheme default_theme = |
| ash::AmbientUiSettings::ReadFromPrefService( |
| *browser()->profile()->GetPrefs()) |
| .theme(); |
| ASSERT_NE(kTestTheme, default_theme); |
| ash::AmbientUiSettings(kTestTheme) |
| .WriteToPrefService(*browser()->profile()->GetPrefs()); |
| |
| base::Value::List suite_args; |
| suite_args.Append(base::Value(ash::ambient::prefs::kAmbientUiSettings)); |
| |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("clearAllowedPref", |
| std::move(suite_args))) |
| << message_; |
| // Value read back should be the default. |
| EXPECT_EQ(ash::AmbientUiSettings::ReadFromPrefService( |
| *browser()->profile()->GetPrefs()) |
| .theme(), |
| default_theme); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateApiTestWithContextType, |
| SetDeviceLanguage) { |
| std::string target_locale = "ja-JP"; |
| base::Value::List args; |
| args.Append(base::Value(target_locale)); |
| ASSERT_TRUE( |
| RunAutotestPrivateExtensionTest("setDeviceLanguage", std::move(args))) |
| << message_; |
| std::string cur_locale = browser()->profile()->GetPrefs()->GetString( |
| language::prefs::kApplicationLocale); |
| EXPECT_EQ(cur_locale, target_locale); |
| } |
| |
| IN_PROC_BROWSER_TEST_P(AutotestPrivateApiTestWithContextType, |
| GetDeviceEventLog) { |
| device_event_log::ClearAll(); |
| PRINTER_LOG(DEBUG) << "PrinterTestLog"; |
| NET_LOG(DEBUG) << "NetworkTestLog"; |
| USB_LOG(DEBUG) << "USBTestLog"; |
| ASSERT_TRUE(RunAutotestPrivateExtensionTest("getDeviceEventLog")) << message_; |
| } |
| |
| } // namespace extensions |
