| // Copyright 2025 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "chrome/test/interaction/interactive_browser_window_test.h" |
| |
| #include <sstream> |
| #include <string> |
| #include <utility> |
| #include <variant> |
| |
| #include "base/check.h" |
| #include "base/command_line.h" |
| #include "base/functional/bind.h" |
| #include "base/strings/strcat.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/strings/to_string.h" |
| #include "base/task/single_thread_task_runner.h" |
| #include "base/test/bind.h" |
| #include "base/test/test_switches.h" |
| #include "base/values.h" |
| #include "build/build_config.h" |
| #include "chrome/browser/ui/browser_navigator.h" |
| #include "chrome/browser/ui/browser_window/public/browser_window_interface.h" |
| #include "chrome/browser/ui/browser_window/public/browser_window_interface_iterator.h" |
| #include "chrome/browser/ui/interaction/browser_elements.h" |
| #include "chrome/test/base/in_process_browser_test.h" |
| #include "chrome/test/interaction/interaction_test_util_browser.h" |
| #include "chrome/test/interaction/interactive_browser_test_internal.h" |
| #include "chrome/test/interaction/tracked_element_webcontents.h" |
| #include "chrome/test/interaction/webcontents_interaction_test_util.h" |
| #include "components/tabs/public/tab_interface.h" |
| #include "content/public/browser/visibility.h" |
| #include "content/public/browser/web_contents.h" |
| #include "content/public/test/browser_test_utils.h" |
| #include "content/public/test/update_user_activation_state_interceptor.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/abseil-cpp/absl/functional/overload.h" |
| #include "third_party/blink/public/mojom/frame/user_activation_notification_type.mojom-shared.h" |
| #include "third_party/blink/public/mojom/frame/user_activation_update_types.mojom-shared.h" |
| #include "ui/base/interaction/element_identifier.h" |
| #include "ui/base/interaction/element_tracker.h" |
| #include "ui/base/interaction/interaction_sequence.h" |
| #include "ui/base/interaction/interaction_test_util.h" |
| #include "ui/base/interaction/interactive_test_internal.h" |
| #include "ui/base/test/ui_controls.h" |
| |
| namespace { |
| |
| // Checks that an element is visible in a non-empty region of the viewport. |
| // Perhaps look into using checkVisibility() in the future, but this approach |
| // seems most robust. |
| constexpr char kElementVisibilityQuery[] = |
| R"( |
| function(el) { |
| const rect = el.getBoundingClientRect(); |
| const left = Math.max(0, rect.x); |
| const top = Math.max(0, rect.y); |
| const right = Math.min(rect.x + rect.width, window.innerWidth); |
| const bottom = Math.min(rect.y + rect.height, window.innerHeight); |
| return right > left && bottom > top; |
| } |
| )"; |
| |
| // Returns the intersection rectangle between a Web UI element `where`, and the |
| // tracked WebContents `el` it resides in. The web element must reside (at least |
| // partially) within the web container's bounds and be visible on screen, or |
| // this will CHECK() fail. |
| gfx::Rect GetWebElementIntersection( |
| ui::TrackedElement* el, |
| const WebContentsInteractionTestUtil::DeepQuery& where) { |
| auto* const contents = el->AsA<TrackedElementWebContents>(); |
| CHECK(contents) << "Containing element is not a WebContents"; |
| const gfx::Rect container_bounds = contents->GetScreenBounds(); |
| gfx::Rect element_bounds = contents->owner()->GetElementBoundsInScreen(where); |
| CHECK(!element_bounds.IsEmpty()) |
| << "Cannot target DOM element at " << where << " in " << el->identifier() |
| << " because its screen bounds are emtpy."; |
| gfx::Rect intersect_bounds = element_bounds; |
| intersect_bounds.Intersect(container_bounds); |
| CHECK(!intersect_bounds.IsEmpty()) |
| << "Cannot target DOM element at " << where << " in " << el->identifier() |
| << " because its screen bounds " << element_bounds.ToString() |
| << " are outside the screen bounds of the containing frame, " |
| << container_bounds.ToString() |
| << ". Did you forget to scroll the element into view? See " |
| "ScrollIntoView()."; |
| return intersect_bounds; |
| } |
| |
| // Returns the location of Web UI element `where`, relative to the tracked |
| // WebContents `el` it resides in. The web element must reside (at least |
| // partially) within the web container's bounds and be visible on screen, or |
| // this will CHECK() fail. |
| gfx::Rect GetRegionInWebContents( |
| ui::TrackedElement* el, |
| const WebContentsInteractionTestUtil::DeepQuery& where) { |
| gfx::Rect intersect_bounds = GetWebElementIntersection(el, where); |
| |
| // Compute the sub-region relative to the webcontents. |
| auto* const contents = el->AsA<TrackedElementWebContents>(); |
| CHECK(contents) << "Containing element is not a WebContents"; |
| const gfx::Rect container_bounds = contents->GetScreenBounds(); |
| intersect_bounds.Offset(-container_bounds.OffsetFromOrigin()); |
| return intersect_bounds; |
| } |
| |
| // Returns the browser window that `web_contents` is a tab in, or nullptr if it |
| // is not in a known tab. |
| BrowserWindowInterface* MaybeGetForWebContentsInTab( |
| content::WebContents* web_contents) { |
| if (auto* tab = tabs::TabInterface::MaybeGetFromContents(web_contents)) { |
| return tab->GetBrowserWindowInterface(); |
| } |
| return nullptr; |
| } |
| |
| } // namespace |
| |
| DEFINE_CLASS_CUSTOM_ELEMENT_EVENT_TYPE(InteractiveBrowserWindowTestApi, |
| kDefaultWaitForJsResultEvent); |
| DEFINE_CLASS_CUSTOM_ELEMENT_EVENT_TYPE(InteractiveBrowserWindowTestApi, |
| kDefaultWaitForJsResultAtEvent); |
| |
| InteractiveBrowserWindowTestApi::InteractiveBrowserWindowTestApi() |
| : test_impl_(private_test_impl() |
| .MaybeRegisterFrameworkImpl< |
| internal::InteractiveBrowserTestPrivate>()) {} |
| |
| InteractiveBrowserWindowTestApi::~InteractiveBrowserWindowTestApi() = default; |
| |
| // static |
| WebContentsInteractionTestUtil* |
| InteractiveBrowserWindowTestApi::AsInstrumentedWebContents( |
| ui::TrackedElement* el) { |
| auto* const web_el = el->AsA<TrackedElementWebContents>(); |
| CHECK(web_el); |
| return web_el->owner(); |
| } |
| |
| void InteractiveBrowserWindowTestApi::EnableWebUICodeCoverage() { |
| test_impl_->MaybeStartWebUICodeCoverage(); |
| } |
| |
| InteractiveBrowserWindowTestApi::MultiStep |
| InteractiveBrowserWindowTestApi::ScreenshotWebUi( |
| ElementSpecifier element, |
| const DeepQuery& where, |
| const std::string& screenshot_name, |
| const std::string& baseline_cl) { |
| StepBuilder builder; |
| builder.SetDescription("Compare WebUI Element Screenshot"); |
| builder.SetElement(element); |
| builder.SetStartCallback(base::BindOnce( |
| [](InteractiveBrowserWindowTestApi* test, std::string screenshot_name, |
| std::string baseline_cl, const DeepQuery& where, |
| ui::InteractionSequence* seq, ui::TrackedElement* el) { |
| // Locate the element within the bounds of the WebContents. |
| const auto window_rect = GetRegionInWebContents(el, where); |
| ScreenshotOptions options; |
| options.region = window_rect; |
| options.focus = ScreenshotFocusMode::kLeaveFocusWhereItIs; |
| const auto result = InteractionTestUtilBrowser::CompareScreenshot( |
| el, screenshot_name, baseline_cl, options); |
| test->private_test_impl().HandleActionResult(seq, el, "Screenshot", |
| result); |
| }, |
| base::Unretained(this), screenshot_name, baseline_cl, where)); |
| |
| auto steps = Steps(MaybeWaitForPaint(element), std::move(builder), |
| MaybeWaitForUserToDismiss(element)); |
| AddDescriptionPrefix( |
| steps, base::StrCat({"ScreenshotWebUi( ", "", screenshot_name, ", ", "", |
| baseline_cl, ""})); |
| return steps; |
| } |
| |
| InteractiveBrowserWindowTestApi::MultiStep |
| InteractiveBrowserWindowTestApi::ScreenshotSurface( |
| ElementSpecifier element_in_surface, |
| const std::string& screenshot_name, |
| const std::string& baseline_cl) { |
| StepBuilder builder; |
| builder.SetDescription("Compare Surface Screenshot"); |
| builder.SetElement(element_in_surface); |
| builder.SetStartCallback(base::BindOnce( |
| [](InteractiveBrowserWindowTestApi* test, std::string screenshot_name, |
| std::string baseline_cl, ui::InteractionSequence* seq, |
| ui::TrackedElement* el) { |
| const auto result = |
| InteractionTestUtilBrowser::CompareSurfaceScreenshot( |
| el, screenshot_name, baseline_cl); |
| test->private_test_impl().HandleActionResult(seq, el, "Screenshot", |
| result); |
| }, |
| base::Unretained(this), screenshot_name, baseline_cl)); |
| |
| auto steps = Steps(MaybeWaitForPaint(element_in_surface), std::move(builder), |
| MaybeWaitForUserToDismiss(element_in_surface)); |
| AddDescriptionPrefix( |
| steps, base::StrCat({"ScreenshotSurface( \"", screenshot_name, "\", \"", |
| baseline_cl, "\" )"})); |
| return steps; |
| } |
| |
| InteractiveBrowserWindowTestApi::MultiStep |
| InteractiveBrowserWindowTestApi::InstrumentTab(ui::ElementIdentifier id, |
| std::optional<int> tab_index, |
| BrowserSpecifier in_browser, |
| bool wait_for_ready) { |
| auto steps = Steps(WithElement( |
| ui::test::internal::kInteractiveTestPivotElementId, |
| base::BindLambdaForTesting([this, id, tab_index, |
| in_browser](ui::TrackedElement* el) { |
| auto* const browser = GetBrowserWindowFor(el->context(), in_browser); |
| CHECK(browser) << "InstrumentTab(): a specific browser is required."; |
| test_impl_->AddInstrumentedWebContents( |
| WebContentsInteractionTestUtil::ForExistingTabInBrowser(browser, id, |
| tab_index)); |
| }))); |
| if (wait_for_ready) { |
| steps.push_back(WaitForWebContentsReady(id)); |
| } |
| AddDescriptionPrefix( |
| steps, |
| base::StringPrintf("InstrumentTab( %s, %d, %d )", id.GetName().c_str(), |
| tab_index.value_or(-1), wait_for_ready)); |
| return steps; |
| } |
| |
| ui::InteractionSequence::StepBuilder |
| InteractiveBrowserWindowTestApi::InstrumentNextTab( |
| ui::ElementIdentifier id, |
| BrowserSpecifier in_browser) { |
| return WithElement( |
| ui::test::internal::kInteractiveTestPivotElementId, |
| [this, id, in_browser](ui::TrackedElement* el) { |
| auto* const browser = |
| GetBrowserWindowFor(el->context(), in_browser); |
| test_impl_->AddInstrumentedWebContents( |
| browser |
| ? WebContentsInteractionTestUtil::ForNextTabInBrowser( |
| browser, id) |
| : WebContentsInteractionTestUtil::ForNextTabInAnyBrowser( |
| id)); |
| }) |
| .AddDescriptionPrefix( |
| base::StrCat({"InstrumentTab( ", id.GetName(), " )"})); |
| } |
| |
| InteractiveBrowserWindowTestApi::MultiStep |
| InteractiveBrowserWindowTestApi::AddInstrumentedTab( |
| ui::ElementIdentifier id, |
| GURL url, |
| std::optional<int> at_index, |
| BrowserSpecifier in_browser) { |
| auto steps = Steps( |
| InstrumentNextTab(id, in_browser), |
| WithElement( |
| ui::test::internal::kInteractiveTestPivotElementId, |
| base::BindLambdaForTesting([this, url, at_index, |
| in_browser](ui::TrackedElement* el) { |
| auto* const browser = |
| GetBrowserWindowFor(el->context(), in_browser); |
| CHECK(browser) << "AddInstrumentedTab(): a browser is required."; |
| NavigateParams navigate_params( |
| browser, url, ui::PageTransition::PAGE_TRANSITION_TYPED); |
| navigate_params.tabstrip_index = at_index.value_or(-1); |
| navigate_params.disposition = |
| WindowOpenDisposition::NEW_FOREGROUND_TAB; |
| CHECK(Navigate(&navigate_params)); |
| })), |
| WaitForWebContentsReady(id)); |
| AddDescriptionPrefix( |
| steps, base::StringPrintf("AddInstrumentedTab( %s, %s, %d, )", |
| id.GetName().c_str(), url.spec().c_str(), |
| at_index.value_or(-1))); |
| return steps; |
| } |
| |
| InteractiveBrowserWindowTestApi::MultiStep |
| InteractiveBrowserWindowTestApi::InstrumentInnerWebContents( |
| ui::ElementIdentifier inner_id, |
| ui::ElementIdentifier outer_id, |
| size_t inner_contents_index, |
| bool wait_for_ready) { |
| MultiStep steps; |
| steps.emplace_back(Do([this, inner_id, outer_id, inner_contents_index]() { |
| test_impl_->AddInstrumentedWebContents( |
| WebContentsInteractionTestUtil::ForInnerWebContents( |
| outer_id, inner_contents_index, inner_id)); |
| })); |
| if (wait_for_ready) { |
| steps.push_back(WaitForWebContentsReady(inner_id)); |
| } |
| AddDescriptionPrefix( |
| steps, base::StringPrintf("InstrumentInnerWebContents( %s, %s, %u, %d )", |
| inner_id.GetName(), outer_id.GetName(), |
| inner_contents_index, wait_for_ready)); |
| return steps; |
| } |
| |
| InteractiveBrowserWindowTestApi::StepBuilder |
| InteractiveBrowserWindowTestApi::UninstrumentWebContents( |
| ui::ElementIdentifier id, |
| bool fail_if_not_instrumented) { |
| return std::move( |
| (fail_if_not_instrumented |
| ? Check([this, id]() { |
| return test_impl_->UninstrumentWebContents(id); |
| }) |
| : Do([this, id]() { test_impl_->UninstrumentWebContents(id); })) |
| .SetDescription( |
| base::StringPrintf("UninstrumentWebContents(%s)", id.GetName()))); |
| } |
| |
| // static |
| ui::InteractionSequence::StepBuilder |
| InteractiveBrowserWindowTestApi::WaitForWebContentsReady( |
| ui::ElementIdentifier webcontents_id, |
| std::optional<GURL> expected_url) { |
| StepBuilder builder; |
| builder.SetDescription( |
| base::StringPrintf("WaitForWebContentsReady( %s )", |
| expected_url.value_or(GURL()).spec().c_str())); |
| builder.SetElementID(webcontents_id); |
| builder.SetContext(kDefaultWebContentsContextMode); |
| // Because we're checking the current specific state of the contents, this |
| // avoids further navigations breaking the test. |
| builder.SetStepStartMode(ui::InteractionSequence::StepStartMode::kImmediate); |
| if (expected_url.has_value()) { |
| builder.SetStartCallback(base::BindOnce( |
| [](GURL expected_url, ui::InteractionSequence* seq, |
| ui::TrackedElement* el) { |
| auto* const contents = |
| el->AsA<TrackedElementWebContents>()->owner()->web_contents(); |
| if (expected_url != contents->GetURL()) { |
| LOG(ERROR) << "Loaded wrong URL; got " << contents->GetURL() |
| << " but expected " << expected_url; |
| seq->FailForTesting(); |
| } |
| }, |
| expected_url.value())); |
| } |
| return builder; |
| } |
| |
| // static |
| ui::InteractionSequence::StepBuilder |
| InteractiveBrowserWindowTestApi::WaitForWebContentsNavigation( |
| ui::ElementIdentifier webcontents_id, |
| std::optional<GURL> expected_url) { |
| StepBuilder builder; |
| builder.SetDescription( |
| base::StringPrintf("WaitForWebContentsNavigation( %s )", |
| expected_url.value_or(GURL()).spec().c_str())); |
| builder.SetElementID(webcontents_id); |
| builder.SetContext(kDefaultWebContentsContextMode); |
| builder.SetTransitionOnlyOnEvent(true); |
| if (expected_url.has_value()) { |
| builder.SetStartCallback(base::BindOnce( |
| [](GURL expected_url, ui::InteractionSequence* seq, |
| ui::TrackedElement* el) { |
| auto* const contents = |
| el->AsA<TrackedElementWebContents>()->owner()->web_contents(); |
| if (expected_url != contents->GetURL()) { |
| LOG(ERROR) << "Loaded wrong URL; got " << contents->GetURL() |
| << " but expected " << expected_url; |
| seq->FailForTesting(); |
| } |
| }, |
| expected_url.value())); |
| } |
| return builder; |
| } |
| |
| // There is a bug that causes WebContents::CompletedFirstVisuallyNonEmptyPaint() |
| // to occasionally fail to ever become true. This sometimes manifests when |
| // running tests on Mac builders. In order to prevent tests from hanging when |
| // trying to ensure a non-empty paint, then, a workaround is required. |
| // |
| // See https://crbug.com/332895669 and https://crbug.com/334747109 for more |
| // information. |
| |
| namespace { |
| |
| // Warning message so people aren't surprised when something else in their test |
| // flakes after this step due to the bug. |
| constexpr char kPaintWorkaroundWarning[] = |
| "\n\nIMPORTANT NOTE FOR TESTERS AND CHROMIUM GARDENERS:\n\n" |
| "There is a known issue (crbug.com/332895669, crbug.com/334747109) on Mac " |
| "and Win where sometimes WebContents::CompletedFirstVisuallyNonEmptyPaint()" |
| " can return false even for a WebContents that is visible and painted, " |
| "especially in secondary UI.\n\n" |
| "Unfortunately, this has happened. In order to prevent this test from " |
| "timing out, we will be ensuring that the page is visible and renders at " |
| "least one frame and then continuing the test.\n\n" |
| "In most cases, this will only result in a slight delay. However, in a " |
| "handful of cases the test may hang or fail because some other code relies " |
| "on the page reporting as painted, which we have no direct control over. " |
| "If this happens, you may need to disable the test until the lower-level " |
| "bug is fixed.\n"; |
| |
| // CheckJsResult() can handle promises, so queue a promise that only succeeds |
| // after the contents have been rendered. |
| constexpr char kPaintWorkaroundFunction[] = |
| "() => new Promise(resolve => requestAnimationFrame(() => resolve(true)))"; |
| |
| // Event sent on a delay to bypass the "was this WebContents painted?" check on |
| // platforms where the check is flaky; see comments above. |
| DEFINE_LOCAL_CUSTOM_ELEMENT_EVENT_TYPE(kPaintWorkaroundEvent); |
| |
| void MaybePostPaintWorkaroundEvent(ui::TrackedElement* el) { |
| // Only secondary web contents are affected. |
| if (MaybeGetForWebContentsInTab( |
| el->AsA<TrackedElementWebContents>()->owner()->web_contents())) { |
| return; |
| } |
| base::SingleThreadTaskRunner::GetCurrentDefault()->PostDelayedTask( |
| FROM_HERE, |
| base::BindOnce( |
| [](ui::ElementIdentifier id) { |
| if (auto* const el = ui::ElementTracker::GetElementTracker() |
| ->GetElementInAnyContext(id)) { |
| ui::ElementTracker::GetFrameworkDelegate()->NotifyCustomEvent( |
| el, kPaintWorkaroundEvent); |
| } |
| }, |
| el->identifier()), |
| base::Seconds(1)); |
| } |
| |
| } // namespace |
| |
| // static |
| ui::InteractionSequence::StepBuilder |
| InteractiveBrowserWindowTestApi::WaitForWebContentsPainted( |
| ui::ElementIdentifier webcontents_id) { |
| auto wait_step = WaitForEvent(webcontents_id, |
| TrackedElementWebContents::kFirstNonEmptyPaint); |
| wait_step.SetContext(kDefaultWebContentsContextMode); |
| wait_step.SetMustBeVisibleAtStart(false); |
| wait_step.AddDescriptionPrefix("WaitForWebContentsPainted()"); |
| |
| #if BUILDFLAG(IS_MAC) || BUILDFLAG(IS_WIN) |
| const bool requires_workaround = true; |
| #else |
| const bool requires_workaround = false; |
| #endif |
| |
| if (requires_workaround) { |
| // Workaround for https://crbug.com/332895669 and |
| // https://crbug.com/334747109: |
| // |
| // In parallel with waiting for the WebContents to report as painted, post a |
| // delayed event, verify the contents are visible, and ensure at least one |
| // frame has rendered. This doesn't fix the problem of the WebContents not |
| // reporting as painted, but it does prevent tests that want to ensure that |
| // the contents *are* painted from hanging. |
| wait_step = AnyOf( |
| // Ideally this finishes pretty quickly and we can move on. |
| RunSubsequence(std::move(wait_step)), |
| // Otherwise, create a timeout after the WebContents is shown. |
| RunSubsequence( |
| // Ensure that the contents are loaded, then wait a short time. |
| InAnyContext( |
| AfterShow(webcontents_id, &MaybePostPaintWorkaroundEvent)), |
| // After the timeout, first post a verbose warning describing the |
| // known issue so that test maintainers are not surprised if |
| // something later in the test breaks because paint status is still |
| // being reported incorrectly. |
| InSameContext( |
| AfterEvent(webcontents_id, kPaintWorkaroundEvent, |
| []() { LOG(WARNING) << kPaintWorkaroundWarning; }), |
| // Ensure that the WebContents actually believes it's visible. |
| CheckElement( |
| webcontents_id, |
| [](ui::TrackedElement* el) { |
| return AsInstrumentedWebContents(el) |
| ->web_contents() |
| ->GetVisibility(); |
| }, |
| content::Visibility::VISIBLE), |
| // Force a frame to render before proceeding. |
| // After this is done, we at least known that the contents have |
| // been painted - even if the WebContents object itself doesn't! |
| CheckJsResult(webcontents_id, kPaintWorkaroundFunction)))); |
| } |
| |
| // If the element is already painted, there is no reason to actually wait (and |
| // in fact that will cause a timeout). So only execute the wait step if the |
| // WebContents is not ready or not painted. |
| // |
| // Note: this could also be done with a custom `StateObserver` and |
| // `WaitForState()` but this approach requires the fewest steps. |
| return IfElement( |
| webcontents_id, |
| [](const ui::TrackedElement* el) { |
| // If the page is not ready (i.e. no element) or not |
| // painted, execute the wait step; otherwise skip it. |
| return !el || !el->AsA<TrackedElementWebContents>() |
| ->owner() |
| ->HasPageBeenPainted(); |
| }, |
| Then(std::move(wait_step))) |
| .SetContext(kDefaultWebContentsContextMode) |
| .AddDescriptionPrefix("WaitForWebContentsPainted()"); |
| } |
| |
| // static |
| InteractiveBrowserWindowTestApi::MultiStep |
| InteractiveBrowserWindowTestApi::NavigateWebContents( |
| ui::ElementIdentifier webcontents_id, |
| GURL target_url) { |
| auto steps = Steps( |
| std::move(StepBuilder() |
| .SetDescription("Navigate") |
| .SetElementID(webcontents_id) |
| .SetContext(kDefaultWebContentsContextMode) |
| .SetStartCallback(base::BindOnce( |
| [](GURL url, ui::InteractionSequence* seq, |
| ui::TrackedElement* el) { |
| auto* const owner = |
| el->AsA<TrackedElementWebContents>()->owner(); |
| if (url.EqualsIgnoringRef( |
| owner->web_contents()->GetURL())) { |
| LOG(ERROR) << "Trying to load URL " << url |
| << " but WebContents URL is already " |
| << owner->web_contents()->GetURL(); |
| seq->FailForTesting(); |
| } |
| owner->LoadPage(url); |
| }, |
| target_url))), |
| WaitForWebContentsNavigation(webcontents_id, target_url)); |
| AddDescriptionPrefix( |
| steps, base::StrCat({"NavigateWebContents( ", target_url.spec(), " )"})); |
| return steps; |
| } |
| |
| InteractiveBrowserWindowTestApi::MultiStep |
| InteractiveBrowserWindowTestApi::FocusWebContents( |
| ui::ElementIdentifier webcontents_id) { |
| auto steps = InAnyContext(WaitForWebContentsPainted(webcontents_id), |
| ActivateSurface(webcontents_id), |
| FocusElement(webcontents_id)); |
| AddDescriptionPrefix(steps, "FocusWebContents()"); |
| return steps; |
| } |
| |
| // static |
| InteractiveBrowserWindowTestApi::MultiStep |
| InteractiveBrowserWindowTestApi::WaitForStateChange( |
| ui::ElementIdentifier webcontents_id, |
| const StateChange& state_change, |
| bool expect_timeout) { |
| ui::CustomElementEventType event_type = |
| expect_timeout ? state_change.timeout_event : state_change.event; |
| CHECK(event_type); |
| const bool fail_on_close = !state_change.continue_across_navigation; |
| StepBuilder step1; |
| step1.SetDescription("Queue Event") |
| .SetElementID(webcontents_id) |
| .SetContext(kDefaultWebContentsContextMode) |
| .SetMustRemainVisible(fail_on_close) |
| .SetStartCallback(base::BindOnce( |
| [](StateChange state_change, ui::TrackedElement* el) { |
| el->AsA<TrackedElementWebContents>() |
| ->owner() |
| ->SendEventOnStateChange(state_change); |
| }, |
| state_change)); |
| if (state_change.continue_across_navigation) { |
| // This is required to prevent failing if the element would otherwise be |
| // hidden due to a navigation between trigger and step start. |
| step1.SetStepStartMode(ui::InteractionSequence::StepStartMode::kImmediate); |
| } |
| |
| auto steps = Steps( |
| std::move(step1), |
| std::move(StepBuilder() |
| .SetDescription("Wait For Event") |
| .SetElementID(webcontents_id) |
| .SetContext( |
| ui::InteractionSequence::ContextMode::kFromPreviousStep) |
| .SetType(ui::InteractionSequence::StepType::kCustomEvent, |
| event_type) |
| .SetMustBeVisibleAtStart(fail_on_close))); |
| AddDescriptionPrefix( |
| steps, base::StrCat({"WaitForStateChange( ", base::ToString(state_change), |
| ", ", base::ToString(expect_timeout), " )"})); |
| return steps; |
| } |
| |
| // static |
| ui::InteractionSequence::StepBuilder |
| InteractiveBrowserWindowTestApi::EnsurePresent( |
| ui::ElementIdentifier webcontents_id, |
| const DeepQuery& where) { |
| StepBuilder builder; |
| builder.SetDescription(base::StringPrintf( |
| "EnsurePresent( %s, %s )", webcontents_id.GetName().c_str(), |
| internal::InteractiveBrowserTestPrivate::DeepQueryToString(where) |
| .c_str())); |
| builder.SetElementID(webcontents_id); |
| builder.SetContext(kDefaultWebContentsContextMode); |
| builder.SetStartCallback(base::BindOnce( |
| [](DeepQuery where, ui::InteractionSequence* seq, |
| ui::TrackedElement* el) { |
| if (!AsInstrumentedWebContents(el)->Exists(where)) { |
| LOG(ERROR) << "Expected DOM element to be present: " << where; |
| seq->FailForTesting(); |
| } |
| }, |
| where)); |
| return builder; |
| } |
| |
| // static |
| ui::InteractionSequence::StepBuilder |
| InteractiveBrowserWindowTestApi::EnsureNotPresent( |
| ui::ElementIdentifier webcontents_id, |
| const DeepQuery& where) { |
| StepBuilder builder; |
| builder.SetDescription(base::StringPrintf( |
| "EnsureNotPresent( %s, %s )", webcontents_id.GetName().c_str(), |
| internal::InteractiveBrowserTestPrivate::DeepQueryToString(where) |
| .c_str())); |
| builder.SetElementID(webcontents_id); |
| builder.SetContext(kDefaultWebContentsContextMode); |
| builder.SetStartCallback(base::BindOnce( |
| [](DeepQuery where, ui::InteractionSequence* seq, |
| ui::TrackedElement* el) { |
| if (AsInstrumentedWebContents(el)->Exists(where)) { |
| LOG(ERROR) << "Expected DOM element not to be present: " << where; |
| seq->FailForTesting(); |
| } |
| }, |
| where)); |
| return builder; |
| } |
| |
| ui::InteractionSequence::StepBuilder |
| InteractiveBrowserWindowTestApi::EnsureNotVisible( |
| ui::ElementIdentifier webcontents_id, |
| const DeepQuery& where) { |
| return IfElement( |
| webcontents_id, |
| [where](const ui::TrackedElement* el) { |
| return el->AsA<TrackedElementWebContents>()->owner()->Exists(where); |
| }, |
| Then(CheckJsResultAt(webcontents_id, where, kElementVisibilityQuery, |
| false))); |
| } |
| |
| // static |
| ui::InteractionSequence::StepBuilder InteractiveBrowserWindowTestApi::ExecuteJs( |
| ui::ElementIdentifier webcontents_id, |
| const std::string& function, |
| ExecuteJsMode mode) { |
| StepBuilder builder; |
| builder.SetDescription( |
| base::StringPrintf("ExecuteJs(\"\n%s\n\")", function.c_str())); |
| builder.SetElementID(webcontents_id); |
| builder.SetContext(kDefaultWebContentsContextMode); |
| switch (mode) { |
| case ExecuteJsMode::kFireAndForget: |
| builder.SetMustRemainVisible(false); |
| builder.SetStartCallback(base::BindOnce( |
| [](std::string function, ui::TrackedElement* el) { |
| AsInstrumentedWebContents(el)->Execute(function); |
| }, |
| function)); |
| break; |
| case ExecuteJsMode::kWaitForCompletion: |
| builder.SetStartCallback(base::BindOnce( |
| [](std::string function, ui::InteractionSequence* seq, |
| ui::TrackedElement* el) { |
| const auto full_function = base::StringPrintf( |
| "() => { (%s)(); return false; }", function.c_str()); |
| std::string error_msg; |
| AsInstrumentedWebContents(el)->Evaluate(full_function, &error_msg); |
| if (!error_msg.empty()) { |
| LOG(ERROR) << "ExecuteJsAt() failed: " << error_msg; |
| seq->FailForTesting(); |
| } |
| }, |
| function)); |
| break; |
| } |
| return builder; |
| } |
| |
| // static |
| ui::InteractionSequence::StepBuilder |
| InteractiveBrowserWindowTestApi::ExecuteJsAt( |
| ui::ElementIdentifier webcontents_id, |
| const DeepQuery& where, |
| const std::string& function, |
| ExecuteJsMode mode) { |
| StepBuilder builder; |
| builder.SetDescription(base::StringPrintf( |
| "ExecuteJsAt( %s, \"\n%s\n\")", |
| internal::InteractiveBrowserTestPrivate::DeepQueryToString(where).c_str(), |
| function.c_str())); |
| builder.SetElementID(webcontents_id); |
| builder.SetContext(kDefaultWebContentsContextMode); |
| switch (mode) { |
| case ExecuteJsMode::kFireAndForget: |
| builder.SetMustRemainVisible(false); |
| builder.SetStartCallback(base::BindOnce( |
| [](DeepQuery where, std::string function, ui::TrackedElement* el) { |
| AsInstrumentedWebContents(el)->ExecuteAt(where, function); |
| }, |
| where, function)); |
| break; |
| case ExecuteJsMode::kWaitForCompletion: |
| builder.SetStartCallback(base::BindOnce( |
| [](DeepQuery where, std::string function, |
| ui::InteractionSequence* seq, ui::TrackedElement* el) { |
| const auto full_function = base::StringPrintf( |
| R"( |
| (el, err) => { |
| if (err) { |
| throw err; |
| } |
| (%s)(el); |
| return false; |
| } |
| )", |
| function.c_str()); |
| std::string error_msg; |
| AsInstrumentedWebContents(el)->EvaluateAt(where, full_function, |
| &error_msg); |
| if (!error_msg.empty()) { |
| LOG(ERROR) << "ExecuteJsAt() failed: " << error_msg; |
| seq->FailForTesting(); |
| } |
| }, |
| where, function)); |
| break; |
| } |
| return builder; |
| } |
| |
| // static |
| ui::InteractionSequence::StepBuilder |
| InteractiveBrowserWindowTestApi::CheckJsResult( |
| ui::ElementIdentifier webcontents_id, |
| const std::string& function) { |
| return CheckJsResult(webcontents_id, function, internal::IsTruthyMatcher()); |
| } |
| |
| // static |
| ui::InteractionSequence::StepBuilder |
| InteractiveBrowserWindowTestApi::CheckJsResultAt( |
| ui::ElementIdentifier webcontents_id, |
| const DeepQuery& where, |
| const std::string& function) { |
| return CheckJsResultAt(webcontents_id, where, function, |
| internal::IsTruthyMatcher()); |
| } |
| |
| InteractiveBrowserWindowTestApi::MultiStep |
| InteractiveBrowserWindowTestApi::WaitForJsResult( |
| ui::ElementIdentifier webcontents_id, |
| const std::string& function) { |
| return WaitForJsResult(webcontents_id, function, IsTruthy()); |
| } |
| |
| InteractiveBrowserWindowTestApi::MultiStep |
| InteractiveBrowserWindowTestApi::WaitForJsResultAt( |
| ui::ElementIdentifier webcontents_id, |
| const DeepQuery& where, |
| const std::string& function) { |
| return WaitForJsResultAt(webcontents_id, where, function, IsTruthy()); |
| } |
| |
| ui::InteractionSequence::StepBuilder |
| InteractiveBrowserWindowTestApi::ScrollIntoView( |
| ui::ElementIdentifier web_contents, |
| const DeepQuery& where) { |
| return std::move( |
| ExecuteJsAt(web_contents, where, |
| "(el) => { el.scrollIntoView({ behavior: 'instant' }); }") |
| .SetDescription("ScrollIntoView()")); |
| } |
| |
| InteractiveBrowserWindowTestApi::MultiStep |
| InteractiveBrowserWindowTestApi::WaitForElementVisible( |
| ui::ElementIdentifier web_contents, |
| const DeepQuery& where) { |
| DEFINE_LOCAL_CUSTOM_ELEMENT_EVENT_TYPE(kWaitforElementVisibleCompleteEvent); |
| |
| StateChange change; |
| change.event = kWaitforElementVisibleCompleteEvent; |
| change.test_function = kElementVisibilityQuery; |
| change.type = StateChange::Type::kExistsAndConditionTrue; |
| change.where = where; |
| |
| auto steps = WaitForStateChange(web_contents, change); |
| AddDescriptionPrefix(steps, "WaitForElementVisible()"); |
| return steps; |
| } |
| |
| ui::InteractionSequence::StepBuilder |
| InteractiveBrowserWindowTestApi::ClickElement( |
| ui::ElementIdentifier web_contents, |
| const DeepQuery& where, |
| ui_controls::MouseButton button, |
| ui_controls::AcceleratorState modifiers, |
| ExecuteJsMode execute_mode) { |
| int js_button; |
| switch (button) { |
| case ui_controls::LEFT: |
| js_button = 0; |
| break; |
| case ui_controls::MIDDLE: |
| js_button = 1; |
| break; |
| case ui_controls::RIGHT: |
| js_button = 2; |
| break; |
| } |
| |
| const bool shift = modifiers & ui_controls::kShift; |
| const bool alt = modifiers & ui_controls::kAlt; |
| const bool ctrl = modifiers & ui_controls::kControl; |
| const bool meta = modifiers & ui_controls::kCommand; |
| |
| auto b2s = [](bool b) { return base::ToString(b); }; |
| |
| const std::string command = base::StringPrintf( |
| R"( |
| function(el) { |
| const rect = el.getBoundingClientRect(); |
| const left = Math.max(0, rect.x); |
| const top = Math.max(0, rect.y); |
| const right = Math.min(rect.x + rect.width, window.innerWidth); |
| const bottom = Math.min(rect.y + rect.height, window.innerHeight); |
| if (right <= left || bottom <= top) { |
| throw new Error( |
| 'Target element is zero size or ' + |
| 'has empty intersection with the viewport.'); |
| } |
| const x = (left + right) / 2; |
| const y = (top + bottom) / 2; |
| |
| const event = new MouseEvent( |
| 'click', |
| { |
| bubbles: true, |
| cancelable: true, |
| clientX: x, |
| clientY: y, |
| button: %d, |
| shiftKey: %s, |
| altKey: %s, |
| ctrlKey: %s, |
| metaKey: %s |
| } |
| ); |
| el.dispatchEvent(event); |
| } |
| )", |
| js_button, b2s(shift), b2s(alt), b2s(ctrl), b2s(meta)); |
| |
| return ExecuteJsAt(web_contents, where, command, execute_mode) |
| .SetDescription("ClickElement()"); |
| } |
| |
| // static |
| InteractiveBrowserWindowTestApi::RelativePositionCallback |
| InteractiveBrowserWindowTestApi::DeepQueryToRelativePosition( |
| const DeepQuery& where) { |
| return base::BindOnce( |
| [](DeepQuery q, ui::TrackedElement* el) { |
| gfx::Rect intersect_bounds = GetWebElementIntersection(el, q); |
| return intersect_bounds.CenterPoint(); |
| }, |
| where); |
| } |
| |
| InteractiveBrowserWindowTestApi::MultiStep |
| InteractiveBrowserWindowTestApi::MaybeWaitForPaint(ElementSpecifier element) { |
| // Only wait if `element` is actually a `WebContents`. |
| // |
| // WebContents are typically only referred to via their assigned IDs. |
| // TODO(dfried): possibly handle (rare) cases where a name has been assigned. |
| if (!element.is_identifier()) { |
| return MultiStep(); |
| } |
| const auto element_id = element.identifier(); |
| |
| // Do a `WaitForWebContentsPainted()`, but only if the ID has been assigned to |
| // an instrumented `WebContents`. |
| return Steps(If( |
| [this, element_id]() { |
| return test_impl_->IsInstrumentedWebContents(element_id); |
| }, |
| Then(WaitForWebContentsPainted(element_id)))); |
| } |
| |
| // static |
| InteractiveBrowserWindowTestApi::StepBuilder |
| InteractiveBrowserWindowTestApi::MaybeWaitForUserToDismiss( |
| ElementSpecifier element) { |
| // In interactive mode (--test-launcher-interactive) the behavior for pixel |
| // tests is to wait until the user closes/hides the surface that has the |
| // element to screenshot. This may break the rest of the test, but it's fine |
| // because the purpose of interactive mode is for a human user to observe |
| // what the test sees during the screenshot step. |
| return If( |
| []() { |
| return base::CommandLine::ForCurrentProcess()->HasSwitch( |
| switches::kTestLauncherInteractive); |
| }, |
| Then(Log( |
| R"( |
| |
| ------------------ |
| |
| Since --test-launcher-interactive is specified, this test will now wait for you |
| to dismiss the element that is being screenshot: |
| |
| )", |
| " ", element, |
| R"( |
| |
| Note that This may cause the remainder of the test to fail or crash, if the test |
| does not expect the surface to be dismissed. |
| |
| ------------------ |
| )"), |
| WaitForHide(element))); |
| } |
| |
| BrowserWindowInterface* InteractiveBrowserWindowTestApi::GetBrowserWindowFor( |
| ui::ElementContext current_context, |
| BrowserSpecifier spec) { |
| return std::visit( |
| absl::Overload{ |
| [](AnyBrowser) -> BrowserWindowInterface* { return nullptr; }, |
| [current_context](CurrentBrowser) { |
| BrowserWindowInterface* const browser = |
| InteractionTestUtilBrowser::GetBrowserFromContext( |
| current_context); |
| CHECK(browser) << "Current context is not a browser window."; |
| return browser; |
| }, |
| [](BrowserWindowInterface* browser) { |
| CHECK(browser) << "BrowserSpecifier: browser window is null."; |
| return browser; |
| }, |
| [](std::reference_wrapper<BrowserWindowInterface*> browser) { |
| CHECK(browser.get()) << "BrowserSpecifier: browser window is null."; |
| return browser.get(); |
| }}, |
| spec); |
| } |
