| // Copyright 2024 The Chromium Authors |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "third_party/blink/renderer/modules/content_extraction/ai_page_content_agent.h" |
| |
| #include <cstddef> |
| #include <initializer_list> |
| #include <limits> |
| #include <optional> |
| #include <string> |
| |
| #include "base/functional/bind.h" |
| #include "base/logging.h" |
| #include "base/run_loop.h" |
| #include "base/strings/stringprintf.h" |
| #include "base/test/bind.h" |
| #include "base/test/metrics/histogram_tester.h" |
| #include "base/test/mock_log.h" |
| #include "base/trace_event/trace_event.h" |
| #include "mojo/public/cpp/base/big_buffer.h" |
| #include "mojo/public/cpp/test_support/test_utils.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "third_party/blink/public/common/frame/frame_ad_evidence.h" |
| #include "third_party/blink/public/common/input/web_mouse_event.h" |
| #include "third_party/blink/public/mojom/content_extraction/ai_page_content.mojom.h" |
| #include "third_party/blink/public/web/web_script_source.h" |
| #include "third_party/blink/renderer/bindings/core/v8/v8_binding_for_testing.h" |
| #include "third_party/blink/renderer/core/accessibility/ax_context.h" |
| #include "third_party/blink/renderer/core/accessibility/ax_object_cache.h" |
| #include "third_party/blink/renderer/core/css/style_engine.h" |
| #include "third_party/blink/renderer/core/dom/document.h" |
| #include "third_party/blink/renderer/core/dom/document_lifecycle.h" |
| #include "third_party/blink/renderer/core/dom/dom_node_ids.h" |
| #include "third_party/blink/renderer/core/editing/editing_utilities.h" |
| #include "third_party/blink/renderer/core/frame/frame_test_helpers.h" |
| #include "third_party/blink/renderer/core/frame/local_frame.h" |
| #include "third_party/blink/renderer/core/frame/local_frame_view.h" |
| #include "third_party/blink/renderer/core/frame/settings.h" |
| #include "third_party/blink/renderer/core/frame/visual_viewport.h" |
| #include "third_party/blink/renderer/core/html/forms/html_input_element.h" |
| #include "third_party/blink/renderer/core/html/html_collection.h" |
| #include "third_party/blink/renderer/core/html/html_iframe_element.h" |
| #include "third_party/blink/renderer/core/html/html_image_element.h" |
| #include "third_party/blink/renderer/core/input/event_handler.h" |
| #include "third_party/blink/renderer/core/layout/hit_test_location.h" |
| #include "third_party/blink/renderer/core/layout/hit_test_request.h" |
| #include "third_party/blink/renderer/core/layout/hit_test_result.h" |
| #include "third_party/blink/renderer/core/layout/layout_box_model_object.h" |
| #include "third_party/blink/renderer/core/layout/layout_object.h" |
| #include "third_party/blink/renderer/core/layout/layout_view.h" |
| #include "third_party/blink/renderer/core/layout/map_coordinates_flags.h" |
| #include "third_party/blink/renderer/core/page/chrome_client.h" |
| #include "third_party/blink/renderer/core/scroll/scrollable_area.h" |
| #include "third_party/blink/renderer/core/style/computed_style.h" |
| #include "third_party/blink/renderer/core/testing/page_test_base.h" |
| #include "third_party/blink/renderer/core/view_transition/view_transition_supplement.h" |
| #include "third_party/blink/renderer/modules/accessibility/ax_object_cache_impl.h" |
| #include "third_party/blink/renderer/platform/bindings/exception_state.h" |
| #include "third_party/blink/renderer/platform/bindings/script_state.h" |
| #include "third_party/blink/renderer/platform/geometry/physical_offset.h" |
| #include "third_party/blink/renderer/platform/graphics/visual_rect_flags.h" |
| #include "third_party/blink/renderer/platform/testing/runtime_enabled_features_test_helpers.h" |
| #include "third_party/blink/renderer/platform/testing/task_environment.h" |
| #include "third_party/blink/renderer/platform/testing/unit_test_helpers.h" |
| #include "third_party/blink/renderer/platform/testing/url_test_helpers.h" |
| #include "third_party/blink/renderer/platform/wtf/text/atomic_string.h" |
| #include "third_party/blink/renderer/platform/wtf/vector.h" |
| #include "ui/accessibility/ax_action_data.h" |
| #include "ui/accessibility/ax_mode.h" |
| #include "ui/display/screen_info.h" |
| #include "ui/gfx/geometry/point_f.h" |
| #include "ui/gfx/geometry/quad_f.h" |
| #include "ui/gfx/geometry/rect_conversions.h" |
| |
| namespace blink { |
| using ClickabilityReason = mojom::blink::AIPageContentClickabilityReason; |
| using InteractionDisabledReason = |
| mojom::blink::AIPageContentInteractionDisabledReason; |
| |
| namespace { |
| |
| constexpr gfx::Size kWindowSize{1000, 1000}; |
| constexpr char kSmallImage[] = |
| "data:image/jpeg;base64,/9j/4AAQSkZJRgABAQAAAQABAAD/" |
| "2wBDAAMCAgICAgMCAgIDAwMDBAYEBAQEBAgGBgUGCQgKCgkICQkKDA8MCgsOCwkJDRENDg8QEB" |
| "EQCgwSExIQEw8QEBD/" |
| "2wBDAQMDAwQDBAgEBAgQCwkLEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEBAQEB" |
| "AQEBAQEBAQEBAQEBD/wAARCAABAAEDASIAAhEBAxEB/" |
| "8QAHwAAAQUBAQEBAQEAAAAAAAAAAAECAwQFBgcICQoL/" |
| "8QAtRAAAgEDAwIEAwUFBAQAAAF9AQIDAAQRBRIhMUEGE1FhByJxFDKBkaEII0KxwRVS0fAkM2J" |
| "yggkKFhcYGRolJicoKSo0NTY3ODk6Q0RFRkdISUpTVFVWV1hZWmNkZWZnaGlqc3R1dnd4eXqDh" |
| "IWGh4iJipKTlJWWl5iZmqKjpKWmp6ipqrKztLW2t7i5usLDxMXGx8jJytLT1NXW19jZ2uHi4+" |
| "Tl5ufo6erx8vP09fb3+Pn6/8QAHwEAAwEBAQEBAQEBAQAAAAAAAAECAwQFBgcICQoL/" |
| "8QAtREAAgECBAQDBAcFBAQAAQJ3AAECAxEEBSExBhJBUQdhcRMiMoEIFEKRobHBCSMzUvAVYnL" |
| "RChYkNOEl8RcYGRomJygpKjU2Nzg5OkNERUZHSElKU1RVVldYWVpjZGVmZ2hpanN0dXZ3eHl6g" |
| "oOEhYaHiImKkpOUlZaXmJmaoqOkpaanqKmqsrO0tba3uLm6wsPExcbHyMnK0tPU1dbX2Nna4uP" |
| "k5ebn6Onq8vP09fb3+Pn6/9oADAMBAAIRAxEAPwD+/iiiigD/2Q=="; |
| |
| class AIPageContentAgentTest : public testing::Test { |
| public: |
| AIPageContentAgentTest() = default; |
| ~AIPageContentAgentTest() override = default; |
| |
| void SetUp() override { |
| helper_.InitializeWithSettings(&UpdateWebSettings); |
| helper_.Resize(kWindowSize); |
| helper_.LoadAhem(); |
| ASSERT_TRUE(helper_.LocalMainFrame()); |
| } |
| |
| void TearDown() override { |
| url_test_helpers::UnregisterAllURLsAndClearMemoryCache(); |
| } |
| |
| void LoadAhem() { |
| helper_.LoadAhem(); |
| test::RunPendingTasks(); |
| helper_.LocalMainFrame() |
| ->GetFrame() |
| ->GetDocument() |
| ->View() |
| ->UpdateAllLifecyclePhasesForTest(); |
| } |
| |
| void CheckListItemWithText(const mojom::blink::AIPageContentNode& node, |
| const String& expected_text) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kListItem); |
| EXPECT_EQ(node.children_nodes.size(), 1u); |
| CheckTextNode(*node.children_nodes[0], expected_text); |
| } |
| |
| void CheckTextNode(const mojom::blink::AIPageContentNode& node, |
| const String& expected_text) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kText); |
| ASSERT_TRUE(attributes.text_info); |
| EXPECT_EQ(attributes.text_info->text_content, expected_text); |
| } |
| |
| bool TreeContainsTextSubstring(const mojom::blink::AIPageContentNode& node, |
| const String& substring) { |
| // Many tests only care that sensitive content does (or does not) appear |
| // anywhere in the extracted tree. Implement a small recursive helper to |
| // reduce coupling to the exact tree structure. |
| // |
| // Note: we intentionally check substrings rather than exact matches because |
| // extracted text nodes sometimes include newlines inserted by layout. |
| const auto& attributes = *node.content_attributes; |
| if (attributes.attribute_type == |
| mojom::blink::AIPageContentAttributeType::kText && |
| attributes.text_info && |
| attributes.text_info->text_content.contains(substring)) { |
| return true; |
| } |
| |
| for (const auto& child : node.children_nodes) { |
| if (TreeContainsTextSubstring(*child, substring)) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| const mojom::blink::AIPageContentNode* FindFormControlNodeWithTextSubstring( |
| const mojom::blink::AIPageContentNode& node, |
| const String& substring) { |
| const auto& attributes = *node.content_attributes; |
| if (attributes.attribute_type == |
| mojom::blink::AIPageContentAttributeType::kFormControl && |
| TreeContainsTextSubstring(node, substring)) { |
| return &node; |
| } |
| |
| for (const auto& child : node.children_nodes) { |
| if (const auto* match = |
| FindFormControlNodeWithTextSubstring(*child, substring)) { |
| return match; |
| } |
| } |
| return nullptr; |
| } |
| |
| void CheckTextSize(const mojom::blink::AIPageContentNode& node, |
| mojom::blink::AIPageContentTextSize expected_text_size) { |
| const auto& attributes = *node.content_attributes; |
| ASSERT_TRUE(attributes.text_info); |
| EXPECT_EQ(attributes.text_info->text_style->text_size, expected_text_size); |
| } |
| |
| void CheckTextEmphasis(const mojom::blink::AIPageContentNode& node, |
| bool expected_has_emphasis) { |
| const auto& attributes = *node.content_attributes; |
| ASSERT_TRUE(attributes.text_info); |
| EXPECT_EQ(attributes.text_info->text_style->has_emphasis, |
| expected_has_emphasis); |
| } |
| |
| void CheckTextColor(const mojom::blink::AIPageContentNode& node, |
| RGBA32 expected_color) { |
| const auto& attributes = *node.content_attributes; |
| ASSERT_TRUE(attributes.text_info); |
| EXPECT_EQ(attributes.text_info->text_style->color, expected_color); |
| } |
| |
| void CheckImageNode(const mojom::blink::AIPageContentNode& node, |
| const String& expected_caption, |
| const KURL& expected_url) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kImage); |
| ASSERT_TRUE(attributes.image_info); |
| EXPECT_EQ(attributes.image_info->image_caption, expected_caption); |
| EXPECT_EQ(attributes.image_info->url, expected_url); |
| } |
| |
| void CheckAnchorNode( |
| const mojom::blink::AIPageContentNode& node, |
| const blink::KURL& expected_url, |
| const Vector<mojom::blink::AIPageContentAnchorRel>& expected_rels) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kAnchor); |
| ASSERT_TRUE(attributes.anchor_data); |
| EXPECT_EQ(attributes.anchor_data->url, expected_url); |
| ASSERT_EQ(attributes.anchor_data->rel.size(), expected_rels.size()); |
| for (wtf_size_t i = 0; i < expected_rels.size(); ++i) { |
| EXPECT_EQ(attributes.anchor_data->rel[i], expected_rels[i]); |
| } |
| } |
| |
| void CheckTableNode(const mojom::blink::AIPageContentNode& node, |
| String expected_table_name = String()) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kTable); |
| ASSERT_TRUE(attributes.table_data); |
| if (!expected_table_name.IsNull()) { |
| EXPECT_EQ(attributes.table_data->table_name, expected_table_name); |
| } |
| } |
| |
| void CheckTableCellNode(const mojom::blink::AIPageContentNode& node) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kTableCell); |
| } |
| |
| void CheckTableRowNode( |
| const mojom::blink::AIPageContentNode& node, |
| const mojom::blink::AIPageContentTableRowType& expected_row_type) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kTableRow); |
| ASSERT_TRUE(attributes.table_row_data); |
| EXPECT_EQ(attributes.table_row_data->row_type, expected_row_type); |
| } |
| |
| void CheckContainerNode(const mojom::blink::AIPageContentNode& node) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kContainer); |
| } |
| |
| void CheckModalDialogNode(const mojom::blink::AIPageContentNode& node) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kDialogModal); |
| } |
| |
| void CheckModelessDialogNode(const mojom::blink::AIPageContentNode& node) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kDialogModeless); |
| } |
| |
| void CheckHeadingNode(const mojom::blink::AIPageContentNode& node) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kHeading); |
| } |
| |
| void CheckParagraphNode(const mojom::blink::AIPageContentNode& node) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kParagraph); |
| } |
| |
| void CheckUnorderedListNode(const mojom::blink::AIPageContentNode& node) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kUnorderedList); |
| } |
| |
| void CheckOrderedListNode(const mojom::blink::AIPageContentNode& node) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kOrderedList); |
| } |
| |
| void CheckAnnotatedRole( |
| const mojom::blink::AIPageContentNode& node, |
| const mojom::blink::AIPageContentAnnotatedRole& expected_role) { |
| const auto& attributes = *node.content_attributes; |
| ASSERT_EQ(attributes.annotated_roles.size(), 1u); |
| EXPECT_EQ(attributes.annotated_roles[0], expected_role); |
| } |
| |
| void CheckAnnotatedRoles( |
| const mojom::blink::AIPageContentNode& node, |
| const std::vector<mojom::blink::AIPageContentAnnotatedRole>& |
| expected_roles) { |
| const auto& attributes = *node.content_attributes; |
| ASSERT_EQ(attributes.annotated_roles.size(), expected_roles.size()); |
| EXPECT_THAT(attributes.annotated_roles, |
| testing::UnorderedElementsAreArray(expected_roles)); |
| } |
| |
| void CheckGeometry(const mojom::blink::AIPageContentNode& node, |
| const gfx::Rect& expected_outer_bounding_box, |
| const gfx::Rect& expected_visible_bounding_box) { |
| const auto& geometry = *node.content_attributes->geometry; |
| EXPECT_EQ(geometry.outer_bounding_box, expected_outer_bounding_box); |
| EXPECT_EQ(geometry.visible_bounding_box, expected_visible_bounding_box); |
| } |
| |
| void CheckFormControlNode( |
| const mojom::blink::AIPageContentNode& node, |
| const mojom::blink::FormControlType& expected_form_control_type) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kFormControl); |
| EXPECT_EQ(attributes.form_control_data->form_control_type, |
| expected_form_control_type); |
| } |
| |
| const mojom::blink::AIPageContentNode& GetSingleTableCell( |
| const mojom::blink::AIPageContentNode& table) { |
| CheckTableNode(table); |
| EXPECT_EQ(table.children_nodes.size(), 1u); |
| |
| const auto& table_row = *table.children_nodes[0]; |
| CheckTableRowNode(table_row, |
| mojom::blink::AIPageContentTableRowType::kBody); |
| EXPECT_EQ(table_row.children_nodes.size(), 1u); |
| |
| const auto& table_cell = *table_row.children_nodes[0]; |
| CheckTableCellNode(table_cell); |
| return table_cell; |
| } |
| |
| void CheckIframeNode(const mojom::blink::AIPageContentNode& node) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kIframe); |
| } |
| |
| void CheckRootNode(const mojom::blink::AIPageContentNode& node) { |
| const auto& attributes = *node.content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kRoot); |
| } |
| |
| void CheckAlmostEquals(const gfx::Point& actual, const gfx::Point& expected) { |
| // Allow 1px difference for rounding. |
| const int kTolerance = 1; |
| EXPECT_LE(abs(actual.x() - expected.x()), kTolerance) |
| << "actual : " << actual.ToString() |
| << ", expected: " << expected.ToString(); |
| EXPECT_LE(abs(actual.y() - expected.y()), kTolerance) |
| << "actual : " << actual.ToString() |
| << ", expected: " << expected.ToString(); |
| } |
| |
| void GetAIPageContentWithActionableElements() { |
| auto options = GetAIPageContentOptionsForTest(); |
| options->mode = mojom::blink::AIPageContentMode::kActionableElements; |
| GetAIPageContent(std::move(options)); |
| } |
| |
| static mojom::blink::AIPageContentOptionsPtr |
| GetAIPageContentOptionsForTest() { |
| auto options = mojom::blink::AIPageContentOptions::New(); |
| options->on_critical_path = true; |
| options->mode = mojom::blink::AIPageContentMode::kDefault; |
| return options; |
| } |
| |
| static void SetNodeIdAllowlistForTest( |
| mojom::blink::AIPageContentOptionsPtr& options, |
| std::initializer_list<mojom::blink::AIPageContentAttributeType> |
| allowlisted_attribute_types) { |
| // Centralize node-id options setup so test bodies focus on policy intent. |
| // `emplace()` means the policy is explicitly requested for this test. |
| options->node_id_allowlist.emplace(); |
| for (const auto attribute_type : allowlisted_attribute_types) { |
| options->node_id_allowlist->push_back(attribute_type); |
| } |
| } |
| |
| static mojom::blink::AIPageContentOptionsPtr CreateNodeIdPolicyOptionsForTest( |
| std::initializer_list<mojom::blink::AIPageContentAttributeType> |
| allowlisted_attribute_types = {}, |
| mojom::blink::AIPageContentMode mode = |
| mojom::blink::AIPageContentMode::kDefault) { |
| auto options = GetAIPageContentOptionsForTest(); |
| options->mode = mode; |
| SetNodeIdAllowlistForTest(options, allowlisted_attribute_types); |
| return options; |
| } |
| |
| static mojom::blink::AIPageContentOptionsPtr CreateNodeIdPolicyOptionsForTest( |
| mojom::blink::AIPageContentMode mode) { |
| return CreateNodeIdPolicyOptionsForTest( |
| /*allowlisted_attribute_types=*/{}, mode); |
| } |
| |
| void LoadNodeIdPolicyParagraphFixture() { |
| // Shared fixture for default-mode type-policy tests. Keeping this in one |
| // helper makes test intent clearer and avoids repeated HTML boilerplate. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p id='paragraph'>visible paragraph text</p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| } |
| |
| void GetAIPageContent( |
| mojom::blink::AIPageContentOptionsPtr options = nullptr) { |
| auto* agent = AIPageContentAgent::GetOrCreateForTesting( |
| *helper_.LocalMainFrame()->GetFrame()->GetDocument()); |
| EXPECT_TRUE(agent); |
| |
| last_options_ = options ? std::move(options) : default_options_->Clone(); |
| auto content = agent->GetAIPageContentInternal(*last_options_); |
| CHECK(content); |
| CHECK(content->root_node); |
| |
| // Always validate serialization. |
| mojom::blink::AIPageContentPtr output; |
| EXPECT_TRUE( |
| mojo::test::SerializeAndDeserialize<mojom::blink::AIPageContent>( |
| content, output)); |
| |
| last_content_ = std::move(content); |
| } |
| |
| void FireMouseMoveEvent(const gfx::PointF& point) { |
| EventHandler& event_handler = |
| helper_.LocalMainFrame()->GetFrame()->GetEventHandler(); |
| WebMouseEvent event(WebInputEvent::Type::kMouseMove, point, point, |
| WebPointerProperties::Button::kLeft, 0, |
| WebInputEvent::kLeftButtonDown, |
| WebInputEvent::GetStaticTimeStampForTests()); |
| event.SetFrameScale(1); |
| event_handler.HandleMouseMoveEvent(event, Vector<WebMouseEvent>(), |
| Vector<WebMouseEvent>()); |
| } |
| |
| const mojom::blink::AIPageContentNode& ContentRootNode() { |
| CHECK(last_content_); |
| |
| EXPECT_TRUE(last_content_->root_node); |
| if (last_options_->mode != |
| mojom::blink::AIPageContentMode::kActionableElements) { |
| return *last_content_->root_node; |
| } |
| |
| EXPECT_EQ(last_content_->root_node->children_nodes.size(), 1u); |
| const auto& html = *last_content_->root_node->children_nodes[0]; |
| |
| EXPECT_EQ(html.children_nodes.size(), 1u); |
| return *html.children_nodes[0]; |
| } |
| |
| const mojom::blink::AIPageContentNode* FindNodeByDomNodeId( |
| const mojom::blink::AIPageContentNode& root, |
| DOMNodeId dom_node_id) { |
| Vector<const mojom::blink::AIPageContentNode*> stack; |
| stack.push_back(&root); |
| while (!stack.empty()) { |
| const auto* node = stack.back(); |
| stack.pop_back(); |
| if (node->content_attributes && |
| node->content_attributes->dom_node_id.has_value() && |
| *node->content_attributes->dom_node_id == dom_node_id) { |
| return node; |
| } |
| for (wtf_size_t i = node->children_nodes.size(); i > 0; --i) { |
| stack.push_back(node->children_nodes[i - 1].get()); |
| } |
| } |
| return nullptr; |
| } |
| |
| const mojom::blink::AIPageContentNode* FindNodeByDomNodeId( |
| DOMNodeId dom_node_id) { |
| return FindNodeByDomNodeId(ContentRootNode(), dom_node_id); |
| } |
| |
| DOMNodeId GetDomNodeIdForSelector(String selector) { |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| EXPECT_TRUE(document); |
| if (!document) { |
| return kInvalidDOMNodeId; |
| } |
| |
| Element* element = document->QuerySelector(AtomicString(selector)); |
| EXPECT_TRUE(element) << "Couldn't find element with selector = " |
| << selector; |
| if (!element) { |
| return kInvalidDOMNodeId; |
| } |
| |
| DOMNodeId dom_node_id = DOMNodeIds::IdForNode(element); |
| EXPECT_GT(dom_node_id, kInvalidDOMNodeId); |
| return dom_node_id; |
| } |
| |
| const mojom::blink::AIPageContentNode* FindNodeBySelector(String selector) { |
| const DOMNodeId dom_node_id = GetDomNodeIdForSelector(selector); |
| if (dom_node_id == kInvalidDOMNodeId) { |
| return nullptr; |
| } |
| return FindNodeByDomNodeId(dom_node_id); |
| } |
| |
| void ExpectSelectorNotInApcOutput(String selector) { |
| // Validate that the selector resolves in the live DOM and has a valid |
| // DOMNodeId, then assert that APC output intentionally omitted it. |
| const DOMNodeId dom_node_id = GetDomNodeIdForSelector(selector); |
| ASSERT_GT(dom_node_id, kInvalidDOMNodeId); |
| EXPECT_FALSE(FindNodeByDomNodeId(dom_node_id)); |
| } |
| |
| void CheckHitTestableButNotInteractive( |
| const mojom::blink::AIPageContentNode& node) { |
| CHECK(node.content_attributes->node_interaction_info); |
| EXPECT_TRUE(node.content_attributes->node_interaction_info |
| ->document_scoped_z_order); |
| EXPECT_TRUE(node.content_attributes->node_interaction_info |
| ->clickability_reasons.empty()); |
| } |
| |
| void CheckHitTestableAndInteractive( |
| const mojom::blink::AIPageContentNode& node, |
| base::span<const ClickabilityReason> expected_reasons) { |
| CHECK(node.content_attributes->node_interaction_info); |
| EXPECT_TRUE(node.content_attributes->node_interaction_info |
| ->document_scoped_z_order); |
| EXPECT_THAT( |
| node.content_attributes->node_interaction_info->clickability_reasons, |
| testing::UnorderedElementsAreArray(expected_reasons)); |
| } |
| |
| const mojom::blink::AIPageContentPtr& Content() { return last_content_; } |
| |
| protected: |
| const mojom::blink::AIPageContentOptionsPtr default_options_ = |
| GetAIPageContentOptionsForTest(); |
| test::TaskEnvironment task_environment_; |
| frame_test_helpers::WebViewHelper helper_; |
| |
| private: |
| static void UpdateWebSettings(WebSettings* settings) { |
| settings->SetTextAreasAreResizable(true); |
| } |
| |
| mojom::blink::AIPageContentPtr last_content_; |
| mojom::blink::AIPageContentOptionsPtr last_options_; |
| }; |
| |
| TEST_F(AIPageContentAgentTest, Basic) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " div {" |
| " position: absolute;" |
| " top: -10px;" |
| " left: -20px;" |
| " }" |
| " </style>" |
| " <div>text</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = *Content()->root_node; |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& attributes = *root.content_attributes; |
| EXPECT_TRUE(attributes.dom_node_id.has_value()); |
| |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kRoot); |
| |
| CheckGeometry(root, gfx::Rect(kWindowSize), gfx::Rect(kWindowSize)); |
| |
| const auto& text_node = *ContentRootNode().children_nodes[0]; |
| CheckTextNode(text_node, "text"); |
| |
| const auto& text_attributes = *text_node.content_attributes; |
| ASSERT_TRUE(text_attributes.geometry); |
| EXPECT_FALSE(text_attributes.node_interaction_info); |
| EXPECT_EQ(text_attributes.geometry->outer_bounding_box.x(), -20); |
| EXPECT_EQ(text_attributes.geometry->outer_bounding_box.y(), -10); |
| } |
| |
| TEST_F(AIPageContentAgentTest, VisibleBoundingBoxClampsToVisualViewport) { |
| // Keep this regression test pinned to the runtime-flagged clamp behavior. |
| ScopedAIPageContentVisualViewportClampForTest enable_viewport_clamp(true); |
| |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " body {" |
| " background-color: cornflowerblue;" |
| " margin: 0;" |
| " }" |
| " #wideElement {" |
| " position: absolute;" |
| " top: 20px;" |
| " left: 0;" |
| " width: 800px;" |
| " height: 100px;" |
| " background-color: limegreen;" |
| " }" |
| " .corner {" |
| " position: fixed;" |
| " width: 100px;" |
| " height: 100px;" |
| " background-color: coral;" |
| " }" |
| " ::view-transition-group(*)," |
| " ::view-transition-new(*)," |
| " ::view-transition-old(*) {" |
| " animation-play-state: paused;" |
| " }" |
| " ::view-transition-old(*) {" |
| " display: none;" |
| " }" |
| " ::view-transition-new(*) {" |
| " animation-name: none;" |
| " opacity: 1;" |
| " }" |
| " </style>" |
| " <div class='corner'" |
| " style='top: 0; right: 0; view-transition-name: topright;'></div>" |
| " <div id='wideElement'></div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| LocalFrameView* view = document->View(); |
| ASSERT_TRUE(view); |
| |
| // Establish a stable layout baseline before moving the visual viewport. This |
| // keeps the test focused on viewport coordinate mapping rather than pending |
| // layout or style work. |
| view->UpdateAllLifecyclePhasesForTest(); |
| |
| Page* page = document->GetPage(); |
| ASSERT_TRUE(page); |
| |
| // Simulate a visual viewport offset via browser controls. On mobile, the |
| // top controls can partially hide/show to reclaim screen space; that shifts |
| // the visual viewport origin without changing layout viewport coordinates. |
| // View transitions create a view-transition root layer that is positioned |
| // relative to the visual viewport, which is the same setup as the failing |
| // web test. |
| // |
| // Simple mental model (not to scale): |
| // |
| // Layout viewport coordinates (used for layout): |
| // y=0 +----------------------+ |
| // | <div id=target> | |
| // | height=50 | |
| // +----------------------+ |
| // |
| // Visual viewport (what is actually visible): |
| // y=0 +----------------------+ |
| // | (starts 20px lower) | |
| // | so top 20px hidden | |
| // +----------------------+ |
| // |
| // The browser-controls adjustment is a renderer-side representation of that |
| // shift. It should result in negative visual-viewport coordinates after |
| // mapping, which we clamp. |
| const int kVisualViewportOffset = 20; |
| document->GetPage()->GetChromeClient().SetBrowserControlsState( |
| kVisualViewportOffset, 0, /*shrinks_layout=*/true); |
| |
| ScriptState* script_state = |
| ToScriptStateForMainWorld(helper_.LocalMainFrame()->GetFrame()); |
| ScriptState::Scope scope(script_state); |
| ViewTransitionSupplement::startViewTransition(script_state, *document, |
| IGNORE_EXCEPTION_FOR_TESTING); |
| test::RunPendingTasks(); |
| auto* view_transitions = document->GetViewTransitionsIfExists(); |
| ASSERT_TRUE(view_transitions); |
| ASSERT_TRUE(view_transitions->GetTransition()); |
| |
| // Recompute layout and paint properties with the new visual viewport state |
| // so the geometry mapping observes the updated visual-viewport transform. |
| view->UpdateAllLifecyclePhasesForTest(); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| int min_visible_y = std::numeric_limits<int>::max(); |
| bool saw_geometry = false; |
| auto visit_nodes = [&](auto& self, |
| const mojom::blink::AIPageContentNode* node) -> void { |
| if (!node) { |
| return; |
| } |
| if (node->content_attributes && node->content_attributes->geometry) { |
| const auto& geometry = *node->content_attributes->geometry; |
| if (!geometry.visible_bounding_box.IsEmpty()) { |
| min_visible_y = |
| std::min(min_visible_y, geometry.visible_bounding_box.y()); |
| saw_geometry = true; |
| } |
| } |
| for (const auto& child : node->children_nodes) { |
| self(self, child.get()); |
| } |
| }; |
| visit_nodes(visit_nodes, Content()->root_node.get()); |
| ASSERT_TRUE(saw_geometry); |
| EXPECT_EQ(min_visible_y, 0); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| VisibleBoundingBoxClampUsesConsistentUnitsOnHighDPI) { |
| // Keep this regression test pinned to the runtime-flagged clamp behavior. |
| ScopedAIPageContentVisualViewportClampForTest enable_viewport_clamp(true); |
| |
| // This is a regression test for a subtle unit mismatch in |
| // ComputeVisibleBoundingBox(). |
| // |
| // Background: |
| // - APC's visible_bounding_box is consumed by browser-side hit-testing |
| // (e.g. Actor TOCTOU validation) in device pixels (BlinkSpace). |
| // - The visible-bounding-box calculation maps LayoutObject geometry using |
| // MapToVisualRectInAncestorSpace(), which produces values in the same |
| // coordinate space that the browser expects (BlinkSpace/device pixels). |
| // |
| // The geo-fixes branch introduced a clamp intended to normalize negative |
| // coordinates that can occur when the visual viewport is offset relative to |
| // the layout viewport (browser controls, pinch zoom). That clamp must use a |
| // viewport rect in the *same* coordinate space as the mapped object rect. |
| // |
| // If the clamp instead uses unscaled CSS/layout pixels (DIPs), HighDPI pages |
| // (device_scale_factor > 1) will have their geometry truncated by ~DSF. This |
| // makes APC look DIP-bounded and causes browser-side hit-testing at scaled |
| // points to miss. |
| |
| // Configure the test WebView to behave like a HighDPI display. |
| // |
| // Important: The widget's ScreenInfo must be set during widget creation, not |
| // after initialization. Many coordinate conversions (including |
| // DIPsToBlinkSpace) cache the screen info early, and updating it late won't |
| // affect geometry computations. |
| frame_test_helpers::WebViewHelper high_dpi_helper(base::BindRepeating( |
| [](base::PassKey<WebLocalFrame> pass_key, |
| CrossVariantMojoAssociatedRemote< |
| mojom::blink::FrameWidgetHostInterfaceBase> frame_widget_host, |
| CrossVariantMojoAssociatedReceiver< |
| mojom::blink::FrameWidgetInterfaceBase> frame_widget, |
| CrossVariantMojoAssociatedRemote<mojom::blink::WidgetHostInterfaceBase> |
| widget_host, |
| CrossVariantMojoAssociatedReceiver<mojom::blink::WidgetInterfaceBase> |
| widget, |
| scoped_refptr<base::SingleThreadTaskRunner> task_runner, |
| const viz::FrameSinkId& frame_sink_id, bool hidden, |
| bool never_composited, bool is_for_child_local_root, |
| bool is_for_nested_main_frame, |
| bool is_for_scalable_page) -> frame_test_helpers::TestWebFrameWidget* { |
| auto* test_web_frame_widget = |
| MakeGarbageCollected<frame_test_helpers::TestWebFrameWidget>( |
| std::move(pass_key), std::move(frame_widget_host), |
| std::move(frame_widget), std::move(widget_host), |
| std::move(widget), std::move(task_runner), frame_sink_id, |
| hidden, never_composited, is_for_child_local_root, |
| is_for_nested_main_frame, is_for_scalable_page); |
| display::ScreenInfo screen_info; |
| screen_info.device_scale_factor = 2.f; |
| test_web_frame_widget->SetInitialScreenInfo(screen_info); |
| return test_web_frame_widget; |
| })); |
| // Keep WebSettings consistent with the main fixture's setup. We can't reuse |
| // AIPageContentAgentTest::UpdateWebSettings here because it's private to the |
| // fixture base class. |
| high_dpi_helper.InitializeWithSettings( |
| [](WebSettings* settings) { settings->SetTextAreasAreResizable(true); }); |
| high_dpi_helper.LoadAhem(); |
| ASSERT_TRUE(high_dpi_helper.LocalMainFrame()); |
| |
| // Use a small viewport size to make it easy to see clamping errors in the |
| // resulting bounding boxes. |
| // |
| // Note: WebViewHelper::Resize() takes the widget size in *device pixels*. |
| // With device_scale_factor=2, a 464x828 DIP viewport corresponds to a |
| // 928x1656 device-pixel widget size. |
| constexpr gfx::Size kDipViewportSize{464, 828}; |
| constexpr int kDeviceScaleFactor = 2; |
| high_dpi_helper.Resize( |
| gfx::Size(kDipViewportSize.width() * kDeviceScaleFactor, |
| kDipViewportSize.height() * kDeviceScaleFactor)); |
| |
| frame_test_helpers::LoadHTMLString( |
| high_dpi_helper.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " body {" |
| " margin: 0;" |
| " padding: 0;" |
| " }" |
| " #target {" |
| " position: absolute;" |
| " left: 0;" |
| " top: 0;" |
| " width: 100%;" |
| " height: 100%;" |
| " background: limegreen;" |
| " }" |
| " ::view-transition-group(*)," |
| " ::view-transition-new(*)," |
| " ::view-transition-old(*) {" |
| " animation-play-state: paused;" |
| " }" |
| " ::view-transition-old(*) {" |
| " display: none;" |
| " }" |
| " ::view-transition-new(*) {" |
| " animation-name: none;" |
| " opacity: 1;" |
| " }" |
| " </style>" |
| " <div id='target'></div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| Document* document = |
| high_dpi_helper.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| LocalFrameView* view = document->View(); |
| ASSERT_TRUE(view); |
| |
| // Establish a stable baseline before applying the visual viewport shift. |
| view->UpdateAllLifecyclePhasesForTest(); |
| |
| // Create a visual-viewport offset (same mechanism as the clamp test above). |
| constexpr int kVisualViewportOffsetDip = 20; |
| document->GetPage()->GetChromeClient().SetBrowserControlsState( |
| kVisualViewportOffsetDip, 0, /*shrinks_layout=*/true); |
| |
| ScriptState* script_state = |
| ToScriptStateForMainWorld(high_dpi_helper.LocalMainFrame()->GetFrame()); |
| ScriptState::Scope scope(script_state); |
| ViewTransitionSupplement::startViewTransition(script_state, *document, |
| IGNORE_EXCEPTION_FOR_TESTING); |
| test::RunPendingTasks(); |
| |
| // Recompute layout and paint properties so mapping sees the new viewport |
| // transform. |
| view->UpdateAllLifecyclePhasesForTest(); |
| |
| // Extract APC using the HighDPI document. We intentionally don't use the |
| // AIPageContentAgentTest fixture helpers here because those are wired to the |
| // fixture's `helper_` WebView, not the HighDPI helper created above. |
| mojom::blink::AIPageContentOptionsPtr options = |
| AIPageContentAgentTest::GetAIPageContentOptionsForTest(); |
| options->mode = mojom::blink::AIPageContentMode::kActionableElements; |
| auto* agent = AIPageContentAgent::GetOrCreateForTesting(*document); |
| ASSERT_TRUE(agent); |
| auto content = agent->GetAIPageContentInternal(*options); |
| ASSERT_TRUE(content); |
| ASSERT_TRUE(content->root_node); |
| |
| // We don't rely on a specific node ordering here. Instead, collect the |
| // maximum extents over all visible_bounding_box values and verify they match |
| // the device-pixel viewport size (BlinkSpace), not the DIP viewport size. |
| int max_right = 0; |
| int max_bottom = 0; |
| bool saw_geometry = false; |
| |
| auto visit_nodes = [&](auto& self, |
| const mojom::blink::AIPageContentNode* node) -> void { |
| if (!node) { |
| return; |
| } |
| if (node->content_attributes && node->content_attributes->geometry) { |
| const auto& geometry = *node->content_attributes->geometry; |
| if (!geometry.visible_bounding_box.IsEmpty()) { |
| saw_geometry = true; |
| max_right = std::max(max_right, geometry.visible_bounding_box.right()); |
| max_bottom = |
| std::max(max_bottom, geometry.visible_bounding_box.bottom()); |
| } |
| } |
| for (const auto& child : node->children_nodes) { |
| self(self, child.get()); |
| } |
| }; |
| visit_nodes(visit_nodes, content->root_node.get()); |
| |
| ASSERT_TRUE(saw_geometry); |
| |
| // On HighDPI, the device-pixel viewport should be (layout viewport in CSS |
| // pixels) * DSF. |
| // |
| // Note: When browser controls are involved, the layout viewport height can be |
| // reduced by an implementation-defined amount (it is *not* guaranteed to be |
| // exactly kVisualViewportOffsetDip). Use LocalFrameView's post-adjustment |
| // viewport size to compute the expected BlinkSpace/device-pixel extents. |
| EXPECT_EQ(max_right, view->ViewportWidth() * kDeviceScaleFactor); |
| EXPECT_EQ(max_bottom, view->ViewportHeight() * kDeviceScaleFactor); |
| } |
| |
| TEST_F(AIPageContentAgentTest, Image) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " img {" |
| " position: absolute;" |
| " top: -10px;" |
| " left: -20px;" |
| " width: 30px;" |
| " height: 40px;" |
| " }" |
| " </style>" |
| " <img alt=missing></img>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| auto& document = *helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| document.getElementsByTagName(AtomicString("img")) |
| ->item(0) |
| ->setAttribute(html_names::kSrcAttr, AtomicString(kSmallImage)); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| auto& image_node = *root.children_nodes[0]; |
| CheckImageNode(image_node, "missing", KURL()); |
| CheckGeometry(image_node, gfx::Rect(-20, -10, 30, 40), |
| gfx::Rect(0, 0, 10, 30)); |
| ASSERT_TRUE(image_node.content_attributes->image_info); |
| ASSERT_TRUE(image_node.content_attributes->image_info->source_origin); |
| EXPECT_TRUE( |
| image_node.content_attributes->image_info->source_origin->IsOpaque()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ImageWithUrl) { |
| url_test_helpers::RegisterMockedURLLoad( |
| url_test_helpers::ToKURL("https://example.com/image.jpg"), |
| test::CoreTestDataPath("white-1x1.png"), "image/png"); |
| |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <img id='img' src='https://example.com/image.jpg' alt='hello alt " |
| "text'></img>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| auto& image_node = *root.children_nodes[0]; |
| CheckImageNode(image_node, "hello alt text", |
| blink::KURL("https://example.com/image.jpg")); |
| ASSERT_TRUE(image_node.content_attributes->image_info); |
| ASSERT_TRUE(image_node.content_attributes->image_info->source_origin); |
| EXPECT_EQ( |
| image_node.content_attributes->image_info->source_origin->ToString(), |
| "https://example.com"); |
| |
| url_test_helpers::RegisterMockedURLUnregister( |
| url_test_helpers::ToKURL("https://example.com/image.jpg")); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ImageWithAriaLabel) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <img aria-label='hello'></img>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| auto& image_node = *root.children_nodes[0]; |
| EXPECT_EQ("hello", image_node.content_attributes->label); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ImageIsAdRelated) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <img id='ads'></img>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto& document = *helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| To<HTMLImageElement>(document.getElementById(AtomicString("ads"))) |
| ->SetIsAdRelated(AdProvenance{}); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| auto& image_node = *root.children_nodes[0]; |
| EXPECT_TRUE(image_node.content_attributes->is_ad_related); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ImageIsAdRelatedExcluded) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <img id='ads'></img>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto& document = *helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| To<HTMLImageElement>(document.getElementById(AtomicString("ads"))) |
| ->SetIsAdRelated(AdProvenance{}); |
| |
| auto options = GetAIPageContentOptionsForTest(); |
| options->non_salient_content_config = |
| mojom::blink::NonSalientContentConfig::New(); |
| options->non_salient_content_config->exclude_ad_related = true; |
| GetAIPageContent(std::move(options)); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 0u); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ImageNoAltText) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| base::StringPrintf("<body>" |
| " <style>" |
| " div::before {" |
| " content: url(%s);" |
| " }" |
| " </style>" |
| " <div>text</div>" |
| "</body>", |
| kSmallImage), |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| } |
| |
| TEST_F(AIPageContentAgentTest, Video) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <video src='https://example.com/video.mp4'></video>" |
| " <video " |
| "src='https://example.com/video.mp4?param1=value1¶m2=value2'></video>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& video1 = *root.children_nodes[0]; |
| EXPECT_EQ(video1.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kVideo); |
| ASSERT_TRUE(video1.content_attributes->video_data); |
| EXPECT_EQ(video1.content_attributes->video_data->url, |
| blink::KURL("https://example.com/video.mp4")); |
| ASSERT_TRUE(video1.content_attributes->video_data->source_origin); |
| EXPECT_EQ(video1.content_attributes->video_data->source_origin->ToString(), |
| "https://example.com"); |
| |
| const auto& video2 = *root.children_nodes[1]; |
| EXPECT_EQ(video2.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kVideo); |
| ASSERT_TRUE(video2.content_attributes->video_data); |
| EXPECT_EQ( |
| video2.content_attributes->video_data->url, |
| blink::KURL("https://example.com/video.mp4?param1=value1¶m2=value2")); |
| ASSERT_TRUE(video2.content_attributes->video_data->source_origin); |
| EXPECT_EQ(video2.content_attributes->video_data->source_origin->ToString(), |
| "https://example.com"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, Headings) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <h1>Heading 1</h1>" |
| " <h2>Heading 2</h2>" |
| " <h3>Heading 3</h3>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 3u); |
| |
| const auto& heading1 = *root.children_nodes[0]; |
| CheckHeadingNode(heading1); |
| ASSERT_EQ(heading1.children_nodes.size(), 1u); |
| const auto& heading1_text_node = *heading1.children_nodes[0]; |
| CheckTextNode(heading1_text_node, "Heading 1"); |
| |
| const auto& heading2 = *root.children_nodes[1]; |
| CheckHeadingNode(heading2); |
| ASSERT_EQ(heading2.children_nodes.size(), 1u); |
| const auto& heading2_text_node = *heading2.children_nodes[0]; |
| CheckTextNode(heading2_text_node, "Heading 2"); |
| |
| const auto& heading3 = *root.children_nodes[2]; |
| CheckHeadingNode(heading3); |
| ASSERT_EQ(heading3.children_nodes.size(), 1u); |
| const auto& heading3_text_node = *heading3.children_nodes[0]; |
| CheckTextNode(heading3_text_node, "Heading 3"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, Paragraph) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " p {" |
| " position: fixed;" |
| " top: -10px;" |
| " left: -20px;" |
| " width: 200px;" |
| " height: 40px;" |
| " margin: 0;" |
| " }" |
| " </style>" |
| " <p>text inside paragraph</p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& paragraph = *root.children_nodes[0]; |
| CheckParagraphNode(paragraph); |
| CheckGeometry(paragraph, gfx::Rect(-20, -10, 200, 40), |
| gfx::Rect(0, 0, 180, 30)); |
| |
| ASSERT_EQ(paragraph.children_nodes.size(), 1u); |
| const auto& paragraph_text_node = *paragraph.children_nodes[0]; |
| CheckTextNode(paragraph_text_node, "text inside paragraph"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, Lists) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <ul>" |
| " <li>Item 1</li>" |
| " <li>Item 2</li>" |
| " </ul>" |
| " <ol>" |
| " <li>Step 1</li>" |
| " <li>Step 2</li>" |
| " </ol>" |
| " <dl>" |
| " <dt>Detail 1 title</dt>" |
| " <dd>Detail 1 description</dd>" |
| " <dt>Detail 2 title</dt>" |
| " <dd>Detail 2 description</dd>" |
| " </dl>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 3u); |
| |
| const auto& ul = *root.children_nodes[0]; |
| CheckUnorderedListNode(ul); |
| ASSERT_EQ(ul.children_nodes.size(), 2u); |
| CheckListItemWithText(*ul.children_nodes[0], "Item 1"); |
| CheckListItemWithText(*ul.children_nodes[1], "Item 2"); |
| |
| const auto& ol = *root.children_nodes[1]; |
| CheckOrderedListNode(ol); |
| ASSERT_EQ(ol.children_nodes.size(), 2u); |
| CheckListItemWithText(*ol.children_nodes[0], "Step 1"); |
| CheckListItemWithText(*ol.children_nodes[1], "Step 2"); |
| |
| const auto& dl = *root.children_nodes[2]; |
| CheckUnorderedListNode(dl); |
| ASSERT_EQ(dl.children_nodes.size(), 4u); |
| CheckListItemWithText(*dl.children_nodes[0], "Detail 1 title"); |
| CheckListItemWithText(*dl.children_nodes[1], "Detail 1 description"); |
| CheckListItemWithText(*dl.children_nodes[2], "Detail 2 title"); |
| CheckListItemWithText(*dl.children_nodes[3], "Detail 2 description"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, IFrameWithContent) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <iframe src='about:blank'></iframe>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto* iframe_element = |
| To<HTMLIFrameElement>(helper_.LocalMainFrame() |
| ->GetFrame() |
| ->GetDocument() |
| ->getElementsByTagName(AtomicString("iframe")) |
| ->item(0)); |
| ASSERT_TRUE(iframe_element); |
| |
| // Access the iframe's document and set some content |
| auto* iframe_doc = iframe_element->contentDocument(); |
| ASSERT_TRUE(iframe_doc); |
| |
| iframe_doc->body()->SetInnerHTMLWithoutTrustedTypes( |
| "<body>inside iframe</body>"); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& iframe = *root.children_nodes[0]; |
| const auto& iframe_attributes = *iframe.content_attributes; |
| |
| EXPECT_EQ(iframe_attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kIframe); |
| EXPECT_FALSE(iframe_attributes.is_ad_related); |
| |
| const auto& iframe_root = *iframe.children_nodes[0]; |
| CheckTextNode(*iframe_root.children_nodes[0], "inside iframe"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, IFrameAds) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <iframe src='about:blank'></iframe>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto* iframe_element = |
| To<HTMLIFrameElement>(helper_.LocalMainFrame() |
| ->GetFrame() |
| ->GetDocument() |
| ->getElementsByTagName(AtomicString("iframe")) |
| ->item(0)); |
| ASSERT_TRUE(iframe_element); |
| |
| // Mark iframe's ad evidence. |
| blink::FrameAdEvidence ad_evidence; |
| ad_evidence.set_created_by_ad_script( |
| blink::mojom::FrameCreationStackEvidence::kCreatedByAdScript); |
| ad_evidence.set_is_complete(); |
| To<LocalFrame>(iframe_element->ContentFrame())->SetAdEvidence(ad_evidence); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& iframe = *root.children_nodes[0]; |
| const auto& iframe_attributes = *iframe.content_attributes; |
| |
| EXPECT_EQ(iframe_attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kIframe); |
| EXPECT_TRUE(iframe_attributes.is_ad_related); |
| } |
| |
| TEST_F(AIPageContentAgentTest, IFrameAdsExcluded) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <iframe src='about:blank'></iframe>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto* iframe_element = |
| To<HTMLIFrameElement>(helper_.LocalMainFrame() |
| ->GetFrame() |
| ->GetDocument() |
| ->getElementsByTagName(AtomicString("iframe")) |
| ->item(0)); |
| ASSERT_TRUE(iframe_element); |
| |
| // Mark iframe's ad evidence. |
| blink::FrameAdEvidence ad_evidence; |
| ad_evidence.set_created_by_ad_script( |
| blink::mojom::FrameCreationStackEvidence::kCreatedByAdScript); |
| ad_evidence.set_is_complete(); |
| To<LocalFrame>(iframe_element->ContentFrame())->SetAdEvidence(ad_evidence); |
| |
| auto options = GetAIPageContentOptionsForTest(); |
| options->non_salient_content_config = |
| mojom::blink::NonSalientContentConfig::New(); |
| options->non_salient_content_config->exclude_ad_related = true; |
| GetAIPageContent(std::move(options)); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 0u); |
| } |
| |
| TEST_F(AIPageContentAgentTest, RootFrameAdExcluded) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <iframe src='about:blank'></iframe>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto* iframe_element = |
| To<HTMLIFrameElement>(helper_.LocalMainFrame() |
| ->GetFrame() |
| ->GetDocument() |
| ->getElementsByTagName(AtomicString("iframe")) |
| ->item(0)); |
| ASSERT_TRUE(iframe_element); |
| |
| // Mark iframe's ad evidence. |
| blink::FrameAdEvidence ad_evidence; |
| ad_evidence.set_created_by_ad_script( |
| blink::mojom::FrameCreationStackEvidence::kCreatedByAdScript); |
| ad_evidence.set_is_complete(); |
| auto* child_frame = To<LocalFrame>(iframe_element->ContentFrame()); |
| child_frame->SetAdEvidence(ad_evidence); |
| ASSERT_TRUE(child_frame->IsAdFrame()); |
| |
| auto* agent = |
| AIPageContentAgent::GetOrCreateForTesting(*child_frame->GetDocument()); |
| ASSERT_TRUE(agent); |
| |
| auto options = GetAIPageContentOptionsForTest(); |
| options->non_salient_content_config = |
| mojom::blink::NonSalientContentConfig::New(); |
| options->non_salient_content_config->exclude_ad_related = true; |
| auto content = agent->GetAIPageContentInternal(*options); |
| |
| // The entire content should be null because the frame is an ad. |
| ASSERT_FALSE(content); |
| } |
| |
| TEST_F(AIPageContentAgentTest, CrossSiteIframeIncluded) { |
| KURL main_url = url_test_helpers::ToKURL("http://example.com/main.html"); |
| KURL cross_origin_url = |
| url_test_helpers::ToKURL("http://www.example.com/frame.html"); |
| KURL cross_site_url = |
| url_test_helpers::ToKURL("http://altostrat.com/frame_another.html"); |
| |
| // Mock the cross origin, same-site iframe's content. |
| url_test_helpers::RegisterMockedURLLoadFromBase( |
| WebString("http://www.example.com/"), test::CoreTestDataPath(), |
| WebString("frame.html")); |
| |
| // Mock the cross-site iframe's content. |
| url_test_helpers::RegisterMockedURLLoadFromBase( |
| WebString("http://altostrat.com/"), test::CoreTestDataPath(), |
| WebString("frame_another.html")); |
| |
| // Load the main page which contains the same-site iframe and the cross-origin |
| // iframe. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| "<iframe src='http://www.example.com/frame.html'></iframe>" |
| "<iframe src='http://altostrat.com/frame_another.html'></iframe>" |
| "</body>", |
| main_url); |
| |
| // Let the iframe load. |
| test::RunPendingTasks(); |
| |
| auto options = GetAIPageContentOptionsForTest(); |
| |
| options->include_same_site_only = false; |
| GetAIPageContent(std::move(options)); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 2u); |
| |
| // Both nodes should be present. |
| const auto& same_site_iframe_node = *root.children_nodes[0]; |
| const auto& cross_site_iframe_node = *root.children_nodes[1]; |
| CheckIframeNode(same_site_iframe_node); |
| CheckIframeNode(cross_site_iframe_node); |
| |
| // The contents of both nodes should be present as well. |
| ASSERT_EQ(same_site_iframe_node.children_nodes.size(), 1u); |
| ASSERT_EQ(cross_site_iframe_node.children_nodes.size(), 1u); |
| |
| const auto& same_site_iframe_root = *same_site_iframe_node.children_nodes[0]; |
| const auto& cross_site_iframe_root = |
| *cross_site_iframe_node.children_nodes[0]; |
| |
| CheckRootNode(same_site_iframe_root); |
| CheckRootNode(cross_site_iframe_root); |
| ASSERT_EQ(same_site_iframe_root.children_nodes.size(), 1u); |
| ASSERT_EQ(cross_site_iframe_root.children_nodes.size(), 1u); |
| |
| CheckTextNode(*same_site_iframe_root.children_nodes[0], "I am an iframe\n"); |
| CheckTextNode(*cross_site_iframe_root.children_nodes[0], |
| "I am another iframe\n"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, CrossSiteIframeExcluded) { |
| KURL main_url = url_test_helpers::ToKURL("http://example.com/main.html"); |
| KURL cross_origin_url = |
| url_test_helpers::ToKURL("http://www.example.com/frame.html"); |
| KURL cross_site_url = |
| url_test_helpers::ToKURL("http://altostrat.com/frame_another.html"); |
| |
| // Mock the cross origin, same-site iframe's content. |
| url_test_helpers::RegisterMockedURLLoadFromBase( |
| WebString("http://www.example.com/"), test::CoreTestDataPath(), |
| WebString("frame.html")); |
| |
| // Mock the cross-site iframe's content. |
| url_test_helpers::RegisterMockedURLLoadFromBase( |
| WebString("http://altostrat.com/"), test::CoreTestDataPath(), |
| WebString("frame_another.html")); |
| |
| // Load the main page which contains the same-site iframe and the cross-origin |
| // iframe. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| "<iframe src='http://www.example.com/frame.html'></iframe>" |
| "<iframe src='http://altostrat.com/frame_another.html'></iframe>" |
| "</body>", |
| main_url); |
| |
| // Let the iframe load. |
| test::RunPendingTasks(); |
| |
| auto options = GetAIPageContentOptionsForTest(); |
| |
| options->include_same_site_only = true; |
| GetAIPageContent(std::move(options)); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 2u); |
| |
| // Both nodes should be present. |
| const auto& same_site_iframe_node = *root.children_nodes[0]; |
| const auto& cross_site_iframe_node = *root.children_nodes[1]; |
| CheckIframeNode(same_site_iframe_node); |
| CheckIframeNode(cross_site_iframe_node); |
| |
| // Only the contents of the same-site iframe should be present. |
| ASSERT_EQ(same_site_iframe_node.children_nodes.size(), 1u); |
| ASSERT_TRUE(cross_site_iframe_node.children_nodes.empty()); |
| ASSERT_EQ(cross_site_iframe_node.content_attributes->iframe_data->content |
| ->get_redacted_frame_metadata() |
| ->reason, |
| blink::mojom::RedactedFrameMetadata_Reason::kCrossSite); |
| |
| const auto& same_site_iframe_root = *same_site_iframe_node.children_nodes[0]; |
| |
| CheckRootNode(same_site_iframe_root); |
| ASSERT_EQ(same_site_iframe_root.children_nodes.size(), 1u); |
| |
| CheckTextNode(*same_site_iframe_root.children_nodes[0], "I am an iframe\n"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, NoLayoutElement) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div style='display: none;'>Hidden Content</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_TRUE(root.children_nodes.empty()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, VisibilityHidden) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div style='visibility: hidden;'>Hidden Content</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_TRUE(root.children_nodes.empty()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, TextSize) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <h1>Extra large text</h1>" |
| " <h2>Large text</h2>" |
| " <p>Regular text</p>" |
| " <h6>Small text</h6>" |
| " <p style='font-size: 0.25em;'>Extra small text</p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 5u); |
| |
| const auto& xl_text = *root.children_nodes[0]; |
| CheckHeadingNode(xl_text); |
| CheckTextNode(*xl_text.children_nodes[0], "Extra large text"); |
| CheckTextSize(*xl_text.children_nodes[0], |
| mojom::blink::AIPageContentTextSize::kXL); |
| |
| const auto& l_text = *root.children_nodes[1]; |
| CheckHeadingNode(l_text); |
| CheckTextNode(*l_text.children_nodes[0], "Large text"); |
| CheckTextSize(*l_text.children_nodes[0], |
| mojom::blink::AIPageContentTextSize::kL); |
| |
| const auto& m_text = *root.children_nodes[2]; |
| CheckParagraphNode(m_text); |
| CheckTextNode(*m_text.children_nodes[0], "Regular text"); |
| CheckTextSize(*m_text.children_nodes[0], |
| mojom::blink::AIPageContentTextSize::kM); |
| |
| const auto& s_text = *root.children_nodes[3]; |
| CheckHeadingNode(s_text); |
| CheckTextNode(*s_text.children_nodes[0], "Small text"); |
| CheckTextSize(*s_text.children_nodes[0], |
| mojom::blink::AIPageContentTextSize::kS); |
| |
| const auto& xs_text = *root.children_nodes[4]; |
| CheckParagraphNode(xs_text); |
| CheckTextNode(*xs_text.children_nodes[0], "Extra small text"); |
| CheckTextSize(*xs_text.children_nodes[0], |
| mojom::blink::AIPageContentTextSize::kXS); |
| } |
| |
| TEST_F(AIPageContentAgentTest, TextEmphasis) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| "<p>Regular text" |
| "<b>Bolded text</b>" |
| "<i>Italicized text</i>" |
| "<u>Underlined text</u>" |
| "<sub>Subscript text</sub>" |
| "<sup>Superscript text</sup>" |
| "<em>Emphasized text</em>" |
| "<strong>Strong text</strong>" |
| "</p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& paragraph = *root.children_nodes[0]; |
| CheckParagraphNode(paragraph); |
| ASSERT_EQ(paragraph.children_nodes.size(), 8u); |
| |
| const auto& regular_text = *paragraph.children_nodes[0]; |
| CheckTextNode(regular_text, "Regular text"); |
| CheckTextEmphasis(regular_text, false); |
| |
| const auto& bolded_text = *paragraph.children_nodes[1]; |
| CheckTextNode(bolded_text, "Bolded text"); |
| CheckTextEmphasis(bolded_text, true); |
| |
| const auto& italicized_text = *paragraph.children_nodes[2]; |
| CheckTextNode(italicized_text, "Italicized text"); |
| CheckTextEmphasis(italicized_text, true); |
| |
| const auto& underlined_text = *paragraph.children_nodes[3]; |
| CheckTextNode(underlined_text, "Underlined text"); |
| CheckTextEmphasis(underlined_text, true); |
| |
| const auto& subscript_text = *paragraph.children_nodes[4]; |
| CheckTextNode(subscript_text, "Subscript text"); |
| CheckTextEmphasis(subscript_text, true); |
| |
| const auto& superscript_text = *paragraph.children_nodes[5]; |
| CheckTextNode(superscript_text, "Superscript text"); |
| CheckTextEmphasis(superscript_text, true); |
| |
| const auto& emphasized_text = *paragraph.children_nodes[6]; |
| CheckTextNode(emphasized_text, "Emphasized text"); |
| CheckTextEmphasis(emphasized_text, true); |
| |
| const auto& strong_text = *paragraph.children_nodes[7]; |
| CheckTextNode(strong_text, "Strong text"); |
| CheckTextEmphasis(strong_text, true); |
| } |
| |
| TEST_F(AIPageContentAgentTest, TextColor) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| "<p>Regular text</p>" |
| "<p style='color: red'>Red text</p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& paragraph = *root.children_nodes[0]; |
| CheckParagraphNode(paragraph); |
| ASSERT_EQ(paragraph.children_nodes.size(), 1u); |
| |
| const auto& regular_text = *paragraph.children_nodes[0]; |
| CheckTextNode(regular_text, "Regular text"); |
| CheckTextColor(regular_text, Color(0, 0, 0).Rgb()); |
| |
| const auto& red_paragraph = *root.children_nodes[1]; |
| CheckParagraphNode(paragraph); |
| ASSERT_EQ(paragraph.children_nodes.size(), 1u); |
| |
| const auto& bolded_text = *red_paragraph.children_nodes[0]; |
| CheckTextNode(bolded_text, "Red text"); |
| CheckTextColor(bolded_text, Color(255, 0, 0).Rgb()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, Table) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <table>" |
| " <caption>Table caption</caption>" |
| " <thead>" |
| " <th colspan='2'>Header</th>" |
| " </thead>" |
| " <tr>" |
| " <td>Row 1 Column 1</td>" |
| " <td>Row 1 Column 2</td>" |
| " </tr>" |
| " <tr>" |
| " <td>Row 2 Column 1</td>" |
| " <td>Row 2 Column 2</td>" |
| " </tr>" |
| " <tfoot>" |
| " <td>Footer 1</td>" |
| " <td>Footer 2</td>" |
| " </tfoot>" |
| " </table>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& table = *root.children_nodes[0]; |
| CheckTableNode(table, "Table caption"); |
| ASSERT_EQ(table.children_nodes.size(), 5u); |
| |
| const auto& caption_text = *table.children_nodes[0]; |
| CheckTextNode(caption_text, "Table caption"); |
| |
| const auto& header1 = *table.children_nodes[1]; |
| CheckTableRowNode(header1, mojom::blink::AIPageContentTableRowType::kHeader); |
| ASSERT_EQ(header1.children_nodes.size(), 1u); |
| |
| const auto& header1_cell1 = *header1.children_nodes[0]; |
| CheckTableCellNode(header1_cell1); |
| CheckTextNode(*header1_cell1.children_nodes[0], "Header"); |
| |
| const auto& row1 = *table.children_nodes[2]; |
| CheckTableRowNode(row1, mojom::blink::AIPageContentTableRowType::kBody); |
| ASSERT_EQ(row1.children_nodes.size(), 2u); |
| |
| const auto& row1_cell1 = *row1.children_nodes[0]; |
| CheckTableCellNode(row1_cell1); |
| CheckTextNode(*row1_cell1.children_nodes[0], "Row 1 Column 1"); |
| |
| const auto& row1_cell2 = *row1.children_nodes[1]; |
| CheckTableCellNode(row1_cell2); |
| CheckTextNode(*row1_cell2.children_nodes[0], "Row 1 Column 2"); |
| |
| const auto& row2 = *table.children_nodes[3]; |
| CheckTableRowNode(row2, mojom::blink::AIPageContentTableRowType::kBody); |
| ASSERT_EQ(row2.children_nodes.size(), 2u); |
| |
| const auto& row2_cell1 = *row2.children_nodes[0]; |
| CheckTableCellNode(row2_cell1); |
| CheckTextNode(*row2_cell1.children_nodes[0], "Row 2 Column 1"); |
| |
| const auto& row2_cell2 = *row2.children_nodes[1]; |
| CheckTableCellNode(row2_cell2); |
| CheckTextNode(*row2_cell2.children_nodes[0], "Row 2 Column 2"); |
| |
| const auto& footer = *table.children_nodes[4]; |
| CheckTableRowNode(footer, mojom::blink::AIPageContentTableRowType::kFooter); |
| ASSERT_EQ(footer.children_nodes.size(), 2u); |
| |
| const auto& footer_cell1 = *footer.children_nodes[0]; |
| CheckTableCellNode(footer_cell1); |
| CheckTextNode(*footer_cell1.children_nodes[0], "Footer 1"); |
| |
| const auto& footer_cell2 = *footer.children_nodes[1]; |
| CheckTableCellNode(footer_cell2); |
| CheckTextNode(*footer_cell2.children_nodes[0], "Footer 2"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, TableMadeWithCss) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " .table {" |
| " display: table;" |
| " border-collapse: collapse;" |
| " width: 100%;" |
| " }" |
| " .row {" |
| " display: table-row;" |
| " }" |
| " .cell {" |
| " display: table-cell;" |
| " border: 1px solid #000;" |
| " padding: 8px;" |
| " text-align: center;" |
| " }" |
| " .header {" |
| " background-color: #f4f4f4;" |
| " font-weight: bold;" |
| " }" |
| " </style>" |
| " <div class='table'>" |
| // Header Rows |
| " <div class='row header'>" |
| " <div class='cell' colspan='2'>Personal Info</div>" |
| " <div class='cell' colspan='2'>Contact Info</div>" |
| " </div>" |
| " <div class='row header'>" |
| " <div class='cell'>Name</div>" |
| " <div class='cell'>Age</div>" |
| " <div class='cell'>Email</div>" |
| " <div class='cell'>Phone</div>" |
| " </div>" |
| // Body Rows |
| " <div class='row'>" |
| " <div class='cell'>John Doe</div>" |
| " <div class='cell'>30</div>" |
| " <div class='cell'>john.doe@example.com</div>" |
| " <div class='cell'>123-456-7890</div>" |
| " </div>" |
| " <div class='row'>" |
| " <div class='cell'>Jane Smith</div>" |
| " <div class='cell'>28</div>" |
| " <div class='cell'>jane.smith@example.com</div>" |
| " <div class='cell'>987-654-3210</div>" |
| " </div>" |
| " </div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& table = *root.children_nodes[0]; |
| CheckTableNode(table); |
| ASSERT_EQ(table.children_nodes.size(), 4u); |
| |
| const auto& row1 = *table.children_nodes[0]; |
| CheckTableRowNode(row1, mojom::blink::AIPageContentTableRowType::kBody); |
| ASSERT_EQ(row1.children_nodes.size(), 2u); |
| |
| const auto& row1_cell1 = *row1.children_nodes[0]; |
| CheckTableCellNode(row1_cell1); |
| CheckTextNode(*row1_cell1.children_nodes[0], "Personal Info"); |
| |
| const auto& row1_cell2 = *row1.children_nodes[1]; |
| CheckTableCellNode(row1_cell2); |
| CheckTextNode(*row1_cell2.children_nodes[0], "Contact Info"); |
| |
| const auto& row2 = *table.children_nodes[1]; |
| CheckTableRowNode(row2, mojom::blink::AIPageContentTableRowType::kBody); |
| ASSERT_EQ(row2.children_nodes.size(), 4u); |
| |
| const auto& row2_cell1 = *row2.children_nodes[0]; |
| CheckTableCellNode(row2_cell1); |
| CheckTextNode(*row2_cell1.children_nodes[0], "Name"); |
| |
| const auto& row2_cell2 = *row2.children_nodes[1]; |
| CheckTableCellNode(row2_cell2); |
| CheckTextNode(*row2_cell2.children_nodes[0], "Age"); |
| |
| const auto& row2_cell3 = *row2.children_nodes[2]; |
| CheckTableCellNode(row2_cell3); |
| CheckTextNode(*row2_cell3.children_nodes[0], "Email"); |
| |
| const auto& row2_cell4 = *row2.children_nodes[3]; |
| CheckTableCellNode(row2_cell4); |
| CheckTextNode(*row2_cell4.children_nodes[0], "Phone"); |
| |
| const auto& row3 = *table.children_nodes[2]; |
| CheckTableRowNode(row3, mojom::blink::AIPageContentTableRowType::kBody); |
| ASSERT_EQ(row3.children_nodes.size(), 4u); |
| |
| const auto& row3_cell1 = *row3.children_nodes[0]; |
| CheckTableCellNode(row3_cell1); |
| CheckTextNode(*row3_cell1.children_nodes[0], "John Doe"); |
| |
| const auto& row3_cell2 = *row3.children_nodes[1]; |
| CheckTableCellNode(row3_cell2); |
| CheckTextNode(*row3_cell2.children_nodes[0], "30"); |
| |
| const auto& row3_cell3 = *row3.children_nodes[2]; |
| CheckTableCellNode(row3_cell3); |
| CheckTextNode(*row3_cell3.children_nodes[0], "john.doe@example.com"); |
| |
| const auto& row3_cell4 = *row3.children_nodes[3]; |
| CheckTableCellNode(row3_cell4); |
| CheckTextNode(*row3_cell4.children_nodes[0], "123-456-7890"); |
| |
| const auto& row4 = *table.children_nodes[3]; |
| CheckTableRowNode(row4, mojom::blink::AIPageContentTableRowType::kBody); |
| ASSERT_EQ(row4.children_nodes.size(), 4u); |
| |
| const auto& row4_cell1 = *row4.children_nodes[0]; |
| CheckTableCellNode(row4_cell1); |
| CheckTextNode(*row4_cell1.children_nodes[0], "Jane Smith"); |
| |
| const auto& row4_cell2 = *row4.children_nodes[1]; |
| CheckTableCellNode(row4_cell2); |
| CheckTextNode(*row4_cell2.children_nodes[0], "28"); |
| |
| const auto& row4_cell3 = *row4.children_nodes[2]; |
| CheckTableCellNode(row4_cell3); |
| CheckTextNode(*row4_cell3.children_nodes[0], "jane.smith@example.com"); |
| |
| const auto& row4_cell4 = *row4.children_nodes[3]; |
| CheckTableCellNode(row4_cell4); |
| CheckTextNode(*row4_cell4.children_nodes[0], "987-654-3210"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, FigureCaptionDisplayAsTableCaption) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <figure style='display:table'> |
| <figcaption style='display:table-caption'> |
| <a href='https://www.youtube.com/'>Youtube</a> |
| </figcaption> |
| </figure> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& figure = *root.children_nodes.at(0); |
| ASSERT_TRUE(figure.content_attributes->node_interaction_info); |
| EXPECT_EQ(figure.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kTable); |
| |
| ASSERT_EQ(figure.children_nodes.size(), 1u); |
| const auto& fig_caption = *figure.children_nodes.at(0); |
| ASSERT_TRUE(fig_caption.content_attributes->node_interaction_info); |
| EXPECT_EQ(fig_caption.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kContainer); |
| |
| ASSERT_EQ(fig_caption.children_nodes.size(), 1u); |
| const auto& anchor = *fig_caption.children_nodes.at(0); |
| CheckAnchorNode(anchor, blink::KURL("https://www.youtube.com/"), {}); |
| } |
| |
| TEST_F(AIPageContentAgentTest, LandmarkSections) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <header>Header</header>" |
| " <nav>Navigation</nav>" |
| " <search>Search</search>" |
| " <main>Main content</main>" |
| " <article>Article</article>" |
| " <section>Section</section>" |
| " <aside>Aside</aside>" |
| " <footer>Footer</footer>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 8u); |
| |
| const auto& header = *root.children_nodes[0]; |
| CheckContainerNode(header); |
| CheckAnnotatedRole(header, mojom::blink::AIPageContentAnnotatedRole::kHeader); |
| CheckTextNode(*header.children_nodes[0], "Header"); |
| |
| const auto& nav = *root.children_nodes[1]; |
| CheckContainerNode(nav); |
| CheckAnnotatedRole(nav, mojom::blink::AIPageContentAnnotatedRole::kNav); |
| CheckTextNode(*nav.children_nodes[0], "Navigation"); |
| |
| const auto& search = *root.children_nodes[2]; |
| CheckContainerNode(search); |
| CheckAnnotatedRole(search, mojom::blink::AIPageContentAnnotatedRole::kSearch); |
| CheckTextNode(*search.children_nodes[0], "Search"); |
| |
| const auto& main = *root.children_nodes[3]; |
| CheckContainerNode(main); |
| CheckAnnotatedRole(main, mojom::blink::AIPageContentAnnotatedRole::kMain); |
| CheckTextNode(*main.children_nodes[0], "Main content"); |
| |
| const auto& article = *root.children_nodes[4]; |
| CheckContainerNode(article); |
| CheckAnnotatedRole(article, |
| mojom::blink::AIPageContentAnnotatedRole::kArticle); |
| CheckTextNode(*article.children_nodes[0], "Article"); |
| |
| const auto& section = *root.children_nodes[5]; |
| CheckContainerNode(section); |
| CheckAnnotatedRole(section, |
| mojom::blink::AIPageContentAnnotatedRole::kSection); |
| CheckTextNode(*section.children_nodes[0], "Section"); |
| |
| const auto& aside = *root.children_nodes[6]; |
| CheckContainerNode(aside); |
| CheckAnnotatedRole(aside, mojom::blink::AIPageContentAnnotatedRole::kAside); |
| CheckTextNode(*aside.children_nodes[0], "Aside"); |
| |
| const auto& footer = *root.children_nodes[7]; |
| CheckContainerNode(footer); |
| CheckAnnotatedRole(footer, mojom::blink::AIPageContentAnnotatedRole::kFooter); |
| CheckTextNode(*footer.children_nodes[0], "Footer"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, LandmarkSectionsWithAriaRoles) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div role='banner'>Header</div>" |
| " <div role='navigation'>Navigation</div>" |
| " <div role='search'>Search</div>" |
| " <div role='main'>Main content</div>" |
| " <div role='article'>Article</div>" |
| " <div role='region'>Section</div>" |
| " <div role='complementary'>Aside</div>" |
| " <div role='contentinfo'>Footer</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 8u); |
| |
| const auto& header = *root.children_nodes[0]; |
| CheckContainerNode(header); |
| CheckAnnotatedRole(header, mojom::blink::AIPageContentAnnotatedRole::kHeader); |
| CheckTextNode(*header.children_nodes[0], "Header"); |
| |
| const auto& nav = *root.children_nodes[1]; |
| CheckContainerNode(nav); |
| CheckAnnotatedRole(nav, mojom::blink::AIPageContentAnnotatedRole::kNav); |
| CheckTextNode(*nav.children_nodes[0], "Navigation"); |
| |
| const auto& search = *root.children_nodes[2]; |
| CheckContainerNode(search); |
| CheckAnnotatedRole(search, mojom::blink::AIPageContentAnnotatedRole::kSearch); |
| CheckTextNode(*search.children_nodes[0], "Search"); |
| |
| const auto& main = *root.children_nodes[3]; |
| CheckContainerNode(main); |
| CheckAnnotatedRole(main, mojom::blink::AIPageContentAnnotatedRole::kMain); |
| CheckTextNode(*main.children_nodes[0], "Main content"); |
| |
| const auto& article = *root.children_nodes[4]; |
| CheckContainerNode(article); |
| CheckAnnotatedRole(article, |
| mojom::blink::AIPageContentAnnotatedRole::kArticle); |
| CheckTextNode(*article.children_nodes[0], "Article"); |
| |
| const auto& section = *root.children_nodes[5]; |
| CheckContainerNode(section); |
| CheckAnnotatedRole(section, |
| mojom::blink::AIPageContentAnnotatedRole::kSection); |
| CheckTextNode(*section.children_nodes[0], "Section"); |
| |
| const auto& aside = *root.children_nodes[6]; |
| CheckContainerNode(aside); |
| CheckAnnotatedRole(aside, mojom::blink::AIPageContentAnnotatedRole::kAside); |
| CheckTextNode(*aside.children_nodes[0], "Aside"); |
| |
| const auto& footer = *root.children_nodes[7]; |
| CheckContainerNode(footer); |
| CheckAnnotatedRole(footer, mojom::blink::AIPageContentAnnotatedRole::kFooter); |
| CheckTextNode(*footer.children_nodes[0], "Footer"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, LandmarkSectionsWithUppercaseAriaRoles) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='banner' role='BANNER'>Header</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // ARIA role tokens are ASCII case-insensitive; APC should still annotate the |
| // landmark role even if authors use uppercase role names. |
| GetAIPageContent(); |
| |
| const auto* banner = FindNodeBySelector("#banner"); |
| ASSERT_TRUE(banner); |
| CheckAnnotatedRoles(*banner, |
| {mojom::blink::AIPageContentAnnotatedRole::kHeader}); |
| } |
| |
| TEST_F(AIPageContentAgentTest, RootScroller) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style='margin: 0px;'> |
| <div style='width: 200vw; height: 300vh; background: grey;'></div> |
| <script> |
| document.scrollingElement.scrollTop=100; |
| document.scrollingElement.scrollLeft=200; |
| </script> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_TRUE(root.content_attributes->node_interaction_info); |
| ASSERT_TRUE(root.content_attributes->node_interaction_info->scroller_info); |
| |
| const auto& root_scroller = |
| *root.content_attributes->node_interaction_info->scroller_info; |
| EXPECT_EQ(root_scroller.scrolling_bounds.width(), 2 * kWindowSize.width()); |
| EXPECT_EQ(root_scroller.scrolling_bounds.height(), 3 * kWindowSize.height()); |
| |
| EXPECT_EQ(root_scroller.visible_area, |
| gfx::Rect(200, 100, kWindowSize.width(), kWindowSize.height())); |
| } |
| |
| class AIPageContentAgentTestWithSubScroller |
| : public AIPageContentAgentTest, |
| public testing::WithParamInterface<std::string> {}; |
| |
| TEST_P(AIPageContentAgentTestWithSubScroller, Overflow) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| base::StringPrintf( |
| R"HTML( |
| <body style='margin: 0px;'> |
| <style> |
| #scroller { |
| overflow:%s; width: 100vw; height:100vh; |
| position:relative; top: 30px; left:50px; |
| } |
| </style> |
| <div id='scroller'> |
| <div style='width: 200vw; height: 300vh; background: grey;'></div> |
| </div> |
| <script> |
| let scroller = document.getElementById('scroller'); |
| scroller.scrollTop=100; |
| scroller.scrollLeft=200; |
| </script> |
| </body> |
| )HTML", |
| GetParam()), |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_TRUE(root.content_attributes->node_interaction_info); |
| ASSERT_TRUE(root.content_attributes->node_interaction_info->scroller_info); |
| |
| const auto& root_scroller = |
| *root.content_attributes->node_interaction_info->scroller_info; |
| EXPECT_EQ(root_scroller.scrolling_bounds.width(), kWindowSize.width() + 50); |
| EXPECT_EQ(root_scroller.scrolling_bounds.height(), kWindowSize.height() + 30); |
| EXPECT_EQ(root_scroller.visible_area, gfx::Rect(kWindowSize)); |
| |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& child = *root.children_nodes.at(0); |
| ASSERT_TRUE(child.content_attributes->node_interaction_info); |
| ASSERT_TRUE(child.content_attributes->node_interaction_info->scroller_info); |
| |
| const auto& sub_scroller = |
| *child.content_attributes->node_interaction_info->scroller_info; |
| EXPECT_EQ(sub_scroller.scrolling_bounds.width(), 2 * kWindowSize.width()); |
| EXPECT_EQ(sub_scroller.scrolling_bounds.height(), 3 * kWindowSize.height()); |
| |
| EXPECT_EQ(sub_scroller.visible_area, |
| gfx::Rect(200, 100, kWindowSize.width(), kWindowSize.height())); |
| |
| bool user_scrollable = GetParam() != "hidden"; |
| EXPECT_EQ(sub_scroller.user_scrollable_horizontal, user_scrollable); |
| EXPECT_EQ(sub_scroller.user_scrollable_vertical, user_scrollable); |
| } |
| |
| INSTANTIATE_TEST_SUITE_P(AIPageContentAgentTestWithSubScroller, |
| AIPageContentAgentTestWithSubScroller, |
| ::testing::Values("auto", "scroll", "hidden")); |
| |
| TEST_F(AIPageContentAgentTest, OverflowVisible) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style='margin: 0px;'> |
| <style> |
| #scroller { |
| overflow:visible; width: 100vw; height:100vh; |
| position:relative; top: 30px; left:50px; |
| } |
| </style> |
| <div id='scroller'> |
| <div style='width: 200vw; height: 300vh; background: grey;'></div> |
| </div> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_TRUE(root.content_attributes->node_interaction_info); |
| ASSERT_TRUE(root.content_attributes->node_interaction_info->scroller_info); |
| |
| const auto& root_scroller = |
| *root.content_attributes->node_interaction_info->scroller_info; |
| EXPECT_EQ(root_scroller.scrolling_bounds.width(), |
| kWindowSize.width() * 2 + 50); |
| EXPECT_EQ(root_scroller.scrolling_bounds.height(), |
| kWindowSize.height() * 3 + 30); |
| EXPECT_EQ(root_scroller.visible_area, gfx::Rect(kWindowSize)); |
| |
| EXPECT_EQ(root.children_nodes.size(), 0u); |
| } |
| |
| TEST_F(AIPageContentAgentTest, OverflowClip) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style='margin: 0px;'> |
| <style> |
| #scroller { |
| overflow:clip; width: 100vw; height:100vh; |
| position:relative; top: 30px; left:50px; |
| } |
| </style> |
| <div id='scroller'> |
| <div style='width: 200vw; height: 300vh; background: grey;'></div> |
| </div> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_TRUE(root.content_attributes->node_interaction_info); |
| ASSERT_TRUE(root.content_attributes->node_interaction_info->scroller_info); |
| |
| const auto& root_scroller = |
| *root.content_attributes->node_interaction_info->scroller_info; |
| EXPECT_EQ(root_scroller.scrolling_bounds.width(), kWindowSize.width() + 50); |
| EXPECT_EQ(root_scroller.scrolling_bounds.height(), kWindowSize.height() + 30); |
| EXPECT_EQ(root_scroller.visible_area, gfx::Rect(kWindowSize)); |
| |
| EXPECT_EQ(root.children_nodes.size(), 0u); |
| } |
| |
| TEST_F(AIPageContentAgentTest, Anchors) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <a href='https://www.google.com'>Google</a>" |
| " <a href='https://www.youtube.com' rel='noopener " |
| "noreferrer'>YouTube</a>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& link = *root.children_nodes[0]; |
| CheckAnchorNode(link, blink::KURL("https://www.google.com/"), {}); |
| const auto& link_text = *link.children_nodes[0]; |
| CheckTextNode(link_text, "Google"); |
| |
| const auto& link_with_rel = *root.children_nodes[1]; |
| CheckAnchorNode(link_with_rel, blink::KURL("https://www.youtube.com/"), |
| {mojom::blink::AIPageContentAnchorRel::kRelationNoOpener, |
| mojom::blink::AIPageContentAnchorRel::kRelationNoReferrer}); |
| const auto& link_with_rel_text = *link_with_rel.children_nodes[0]; |
| CheckTextNode(link_with_rel_text, "YouTube"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, NativeModalDialog) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <dialog id='welcomeDialog' style='position: absolute; overflow: " |
| "visible;'>This is a dialog.</dialog>" |
| " <script>" |
| " const dialog = document.getElementById('welcomeDialog');" |
| " dialog.showModal();" |
| " </script>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| // Two nodes: the dialog and its backdrop. |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& backdrop = *root.children_nodes[0]; |
| CheckContainerNode(backdrop); |
| |
| const auto& dialog = *root.children_nodes[1]; |
| CheckModalDialogNode(dialog); |
| |
| ASSERT_EQ(dialog.children_nodes.size(), 1u); |
| const auto& dialog_text = *dialog.children_nodes[0]; |
| CheckTextNode(dialog_text, "This is a dialog."); |
| } |
| |
| TEST_F(AIPageContentAgentTest, NativeModelessDialog) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <dialog id='welcomeDialog'>This is a modeless dialog.</dialog>" |
| " <script>" |
| " const dialog = document.getElementById('welcomeDialog');" |
| " dialog.show();" |
| " </script>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& dialog = *root.children_nodes[0]; |
| CheckModelessDialogNode(dialog); |
| |
| ASSERT_EQ(dialog.children_nodes.size(), 1u); |
| const auto& dialog_text = *dialog.children_nodes[0]; |
| CheckTextNode(dialog_text, "This is a modeless dialog."); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaModalDialog) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div role='dialog' aria-modal='true'>This is an ARIA modal dialog." |
| "</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& dialog = *root.children_nodes[0]; |
| CheckModalDialogNode(dialog); |
| |
| ASSERT_EQ(dialog.children_nodes.size(), 1u); |
| const auto& dialog_text = *dialog.children_nodes[0]; |
| CheckTextNode(dialog_text, "This is an ARIA modal dialog."); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaModelessDialog) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div role='dialog'>This is an ARIA modeless dialog.</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& dialog = *root.children_nodes[0]; |
| CheckModelessDialogNode(dialog); |
| |
| ASSERT_EQ(dialog.children_nodes.size(), 1u); |
| const auto& dialog_text = *dialog.children_nodes[0]; |
| CheckTextNode(dialog_text, "This is an ARIA modeless dialog."); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaAlertDialogDefaultsToModal) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div role='alertdialog'>This is an ARIA alert dialog.</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& dialog = *root.children_nodes[0]; |
| CheckModalDialogNode(dialog); |
| |
| ASSERT_EQ(dialog.children_nodes.size(), 1u); |
| const auto& dialog_text = *dialog.children_nodes[0]; |
| CheckTextNode(dialog_text, "This is an ARIA alert dialog."); |
| } |
| |
| TEST_F(AIPageContentAgentTest, TableWithAnonymousCells) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<html>" |
| " <style>" |
| " #target {" |
| " display: table;" |
| " }" |
| "" |
| " #target::before {" |
| " content: 'BEFORE';" |
| " display: table;" |
| " }" |
| " </style>" |
| " <div id='target'></div>" |
| "</html>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& outer_table = *root.children_nodes[0]; |
| const auto& outer_table_cell = GetSingleTableCell(outer_table); |
| ASSERT_EQ(outer_table_cell.children_nodes.size(), 1u); |
| |
| const auto& inner_table = *outer_table_cell.children_nodes[0]; |
| const auto& inner_table_cell = GetSingleTableCell(inner_table); |
| |
| EXPECT_EQ(inner_table_cell.children_nodes.size(), 1u); |
| CheckTextNode(*inner_table_cell.children_nodes[0], "BEFORE"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ContentVisibilityHidden) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " div {" |
| " content-visibility: hidden" |
| " }" |
| " </style>" |
| " <div>text</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& hidden_container = *root.children_nodes[0]; |
| CheckContainerNode(hidden_container); |
| CheckAnnotatedRole(hidden_container, |
| mojom::blink::AIPageContentAnnotatedRole::kContentHidden); |
| EXPECT_TRUE(hidden_container.children_nodes.empty()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ContentVisibilityHiddenActionable) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " #hidden {" |
| " content-visibility: hidden" |
| " }" |
| " </style>" |
| " <div id=hidden>hidden text</div>visible text" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // Actionable mode exercises geometry and hit-testing paths used in |
| // production APC requests. |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& hidden_container = *root.children_nodes[0]; |
| CheckContainerNode(hidden_container); |
| CheckAnnotatedRole(hidden_container, |
| mojom::blink::AIPageContentAnnotatedRole::kContentHidden); |
| // Content-visibility hidden subtrees are represented but not expanded. |
| EXPECT_TRUE(hidden_container.children_nodes.empty()); |
| // The container itself is laid out; actionable mode should capture its |
| // geometry without forcing layout on descendants. |
| EXPECT_TRUE(hidden_container.content_attributes->geometry); |
| |
| const auto& visible_text_node = *root.children_nodes[1]; |
| CheckTextNode(visible_text_node, "visible text"); |
| ASSERT_TRUE(visible_text_node.content_attributes->geometry); |
| EXPECT_FALSE(visible_text_node.content_attributes->geometry |
| ->visible_bounding_box.IsEmpty()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ContentVisibilityHiddenIframeActionable) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body><style>iframe { content-visibility: hidden }</style>" |
| "<iframe srcdoc='<div>hidden iframe text</div>'></iframe>" |
| " visible text</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // Actionable mode exercises iframe geometry and traversal paths. |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& iframe_node = *root.children_nodes[0]; |
| CheckIframeNode(iframe_node); |
| CheckAnnotatedRole(iframe_node, |
| mojom::blink::AIPageContentAnnotatedRole::kContentHidden); |
| // The iframe container is laid out, but its subtree should not be traversed |
| // when display locks block layout/prepaint on children. |
| EXPECT_TRUE(iframe_node.children_nodes.empty()); |
| ASSERT_TRUE(iframe_node.content_attributes->geometry); |
| ASSERT_TRUE(iframe_node.content_attributes->iframe_data->content); |
| EXPECT_TRUE(iframe_node.content_attributes->iframe_data->content |
| ->is_local_frame_data()); |
| // Display-locked iframes still provide frame data for browser conversion. |
| EXPECT_GT(iframe_node.content_attributes->iframe_data->content |
| ->get_local_frame_data() |
| ->default_line_height_px, |
| 0u); |
| |
| const auto& visible_text_node = *root.children_nodes[1]; |
| CheckTextNode(visible_text_node, " visible text"); |
| ASSERT_TRUE(visible_text_node.content_attributes->geometry); |
| EXPECT_FALSE(visible_text_node.content_attributes->geometry |
| ->visible_bounding_box.IsEmpty()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ContentVisibilityAuto) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " #foo {" |
| " position: relative;" |
| " top: 8000px;" |
| " content-visibility: auto" |
| " }" |
| " </style>" |
| " <div id=foo><div>far text</div></div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& text_node = *root.children_nodes[0]; |
| CheckTextNode(text_node, "far text"); |
| |
| const auto& attributes = *text_node.content_attributes; |
| EXPECT_TRUE(attributes.dom_node_id.has_value()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, HiddenUntilFound) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " body {" |
| " margin: 0; font-size: 100px;" |
| " }" |
| " </style>" |
| " <header hidden=until-found>hidden text</header><div>visible text</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& hidden_container = *root.children_nodes[0]; |
| CheckContainerNode(hidden_container); |
| CheckAnnotatedRoles( |
| hidden_container, |
| {mojom::blink::AIPageContentAnnotatedRole::kHeader, |
| mojom::blink::AIPageContentAnnotatedRole::kContentHidden}); |
| EXPECT_EQ(hidden_container.children_nodes.size(), 1u); |
| |
| const auto& hidden_text_node = *hidden_container.children_nodes[0]; |
| CheckTextNode(hidden_text_node, "hidden text"); |
| |
| const auto& visible_text_node = *root.children_nodes[1]; |
| CheckTextNode(visible_text_node, "visible text"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, HiddenUntilFoundNoInvalidationAllowed) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <style> |
| body { |
| margin: 0; font-size: 100px; |
| } |
| </style> |
| <header hidden=until-found>hidden text</header><div>visible text</div> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| LocalFrameView::InvalidationDisallowedScope disallow( |
| *helper_.LocalMainFrame()->GetFrame()->View()); |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& hidden_container = *root.children_nodes[0]; |
| CheckContainerNode(hidden_container); |
| CheckAnnotatedRoles( |
| hidden_container, |
| {mojom::blink::AIPageContentAnnotatedRole::kHeader, |
| mojom::blink::AIPageContentAnnotatedRole::kContentHidden}); |
| EXPECT_TRUE(hidden_container.children_nodes.empty()); |
| |
| const auto& visible_text_node = *root.children_nodes[1]; |
| CheckTextNode(visible_text_node, "visible text"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, HiddenUntilFoundGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " body {" |
| " margin: 0; font-size: 100px;" |
| " }" |
| " </style>" |
| " <header hidden=until-found>hidden text</header>visible text" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& hidden_container = *root.children_nodes[0]; |
| CheckContainerNode(hidden_container); |
| CheckAnnotatedRoles( |
| hidden_container, |
| {mojom::blink::AIPageContentAnnotatedRole::kHeader, |
| mojom::blink::AIPageContentAnnotatedRole::kContentHidden}); |
| EXPECT_EQ(hidden_container.children_nodes.size(), 1u); |
| |
| ASSERT_TRUE(hidden_container.content_attributes->geometry); |
| const auto& hidden_container_geometry = |
| *hidden_container.content_attributes->geometry; |
| |
| const auto& hidden_text_node = *hidden_container.children_nodes[0]; |
| CheckTextNode(hidden_text_node, "hidden text"); |
| ASSERT_TRUE(hidden_text_node.content_attributes->geometry); |
| const auto& hidden_text_geometry = |
| *hidden_text_node.content_attributes->geometry; |
| CheckAlmostEquals(hidden_text_geometry.outer_bounding_box.origin(), |
| gfx::Point(0, 0)); |
| EXPECT_FALSE(hidden_text_geometry.outer_bounding_box.IsEmpty()); |
| EXPECT_TRUE(hidden_text_geometry.visible_bounding_box.IsEmpty()); |
| |
| // The container's own layout size is empty. APC repairs its outer box from |
| // the hidden descendant, but does not give it visible geometry or fragments. |
| EXPECT_EQ(hidden_container_geometry.outer_bounding_box, |
| hidden_text_geometry.outer_bounding_box); |
| EXPECT_TRUE(hidden_container_geometry.visible_bounding_box.IsEmpty()); |
| EXPECT_TRUE( |
| hidden_container_geometry.fragment_visible_bounding_boxes.empty()); |
| |
| const auto& visible_text_node = *root.children_nodes[1]; |
| CheckTextNode(visible_text_node, "visible text"); |
| EXPECT_TRUE(visible_text_node.content_attributes->geometry); |
| const auto& visible_text_geometry = |
| *visible_text_node.content_attributes->geometry; |
| CheckAlmostEquals(visible_text_geometry.outer_bounding_box.origin(), |
| gfx::Point(0, 0)); |
| EXPECT_FALSE(visible_text_geometry.outer_bounding_box.IsEmpty()); |
| EXPECT_EQ(visible_text_geometry.outer_bounding_box, |
| visible_text_geometry.visible_bounding_box); |
| } |
| |
| TEST_F(AIPageContentAgentTest, HiddenUntilFoundInsideIframe) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " body {" |
| " margin: 0;" |
| " font-size: 100px;" |
| " }" |
| " </style>" |
| " <iframe srcdoc='<div hidden=until-found>hidden " |
| "text</div>'></iframe>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& iframe_node = *root.children_nodes[0]; |
| EXPECT_EQ(iframe_node.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kIframe); |
| EXPECT_EQ(iframe_node.children_nodes.size(), 1u); |
| const auto& iframe_root = *iframe_node.children_nodes[0]; |
| |
| EXPECT_EQ(iframe_root.children_nodes.size(), 1u); |
| const auto& hidden_container = *iframe_root.children_nodes[0]; |
| CheckContainerNode(hidden_container); |
| CheckAnnotatedRole(hidden_container, |
| mojom::blink::AIPageContentAnnotatedRole::kContentHidden); |
| EXPECT_EQ(hidden_container.children_nodes.size(), 1u); |
| |
| const auto& hidden_text_node = *hidden_container.children_nodes[0]; |
| CheckTextNode(hidden_text_node, "hidden text"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, HiddenUntilFoundOnIframe) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " body {" |
| " margin: 0;" |
| " font-size: 100px;" |
| " }" |
| " </style>" |
| " <iframe hidden=until-found srcdoc='<div>hidden " |
| "text</div>'></iframe>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& iframe_node = *root.children_nodes[0]; |
| EXPECT_EQ(iframe_node.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kIframe); |
| EXPECT_EQ(iframe_node.children_nodes.size(), 1u); |
| const auto& iframe_root = *iframe_node.children_nodes[0]; |
| |
| const auto& hidden_text_node = *iframe_root.children_nodes[0]; |
| CheckTextNode(hidden_text_node, "hidden text"); |
| } |
| |
| #if DCHECK_IS_ON() |
| TEST_F(AIPageContentAgentTest, AutoBuildRunsDuringDOMContentLoadedDispatch) { |
| base::test::MockLog log; |
| // Allow unrelated INFO logs; we only assert on the auto-build dump below. |
| EXPECT_CALL(log, Log(logging::LOGGING_INFO, testing::_, testing::_, |
| testing::_, testing::Not(testing::HasSubstr("<Root>")))) |
| .Times(testing::AnyNumber()); |
| // Start capturing early so we can assert that no auto-build dump appears |
| // until we invoke RunAutoBuildAfterDOMContentLoadedForTesting(). |
| log.StartCapturingLogs(); |
| |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), "<body><div>Auto build content</div></body>", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| LocalFrameView* view = document->View(); |
| ASSERT_TRUE(view); |
| |
| // Establish a stable lifecycle baseline so the auto-build checks are not |
| // influenced by unrelated pending layout or style updates. |
| view->UpdateAllLifecyclePhasesForTest(); |
| |
| auto* agent = AIPageContentAgent::GetOrCreateForTesting(*document); |
| ASSERT_TRUE(agent); |
| EXPECT_EQ(AIPageContentAgent::From(*document), agent); |
| |
| // Simulate DOMContentLoaded dispatch still being in progress by forcing the |
| // parsing state to "in DCL". |
| document->SetParsingState(Document::kInDOMContentLoaded); |
| |
| // Auto-build should not run until we explicitly invoke it below. This |
| // enforces that the unit-test guard in ListenForDOMContentLoadedForAutoBuild |
| // keeps auto-build from being scheduled implicitly in blink_unittests. |
| EXPECT_CALL(log, Log(logging::LOGGING_INFO, testing::_, testing::_, |
| testing::_, testing::HasSubstr("<Root>"))) |
| .Times(0); |
| test::RunPendingTasks(); |
| log.StopCapturingLogs(); |
| testing::Mock::VerifyAndClearExpectations(&log); |
| EXPECT_CALL(log, Log(logging::LOGGING_INFO, testing::_, testing::_, |
| testing::_, testing::Not(testing::HasSubstr("<Root>")))) |
| .Times(testing::AnyNumber()); |
| |
| // Invoke the auto-build entry point directly to keep the test deterministic; |
| // it should run while DOMContentLoaded dispatch is in progress. |
| EXPECT_CALL(log, Log(logging::LOGGING_INFO, testing::_, testing::_, |
| testing::_, testing::HasSubstr("<Root>"))) |
| .Times(1); |
| log.StartCapturingLogs(); |
| agent->RunAutoBuildAfterDOMContentLoadedForTesting(); |
| test::RunPendingTasks(); |
| log.StopCapturingLogs(); |
| testing::Mock::VerifyAndClearExpectations(&log); |
| |
| // Auto-build runs while parsing is still in the DOMContentLoaded phase. |
| |
| // Once parsing is finished and lifecycle updates complete, auto-build should |
| // still run without triggering lifecycle DCHECKs. |
| document->SetParsingState(Document::kFinishedParsing); |
| view->UpdateAllLifecyclePhasesForTest(); |
| test::RunPendingTasks(); |
| WebViewImpl* web_view = document->GetPage()->GetChromeClient().GetWebView(); |
| ASSERT_TRUE(web_view); |
| EXPECT_FALSE(web_view->GetPagePopup()); |
| |
| // Re-run the auto-build entry point now that parsing is finished. This should |
| // synchronously execute the auto-build path without crashing. |
| EXPECT_CALL(log, Log(logging::LOGGING_INFO, testing::_, testing::_, |
| testing::_, testing::HasSubstr("<Root>"))) |
| .Times(1); |
| log.StartCapturingLogs(); |
| agent->RunAutoBuildAfterDOMContentLoadedForTesting(); |
| test::RunPendingTasks(); |
| log.StopCapturingLogs(); |
| } |
| #endif // #if DCHECK_IS_ON() |
| |
| TEST_F(AIPageContentAgentTest, LineBreak) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| "<div style=\"width: 100px; height:100px\">" |
| "Lorem Ipsum is simply dummy text of the printing and " |
| "typesetting industry.<br>Lorem Ipsum has been the " |
| "industry's standard dummy text ever since the 1500s, " |
| "when an unknown printer took a galley of type and " |
| "scrambled it to make a type specimen book. It has " |
| "survived not only five centuries, but also the leap " |
| "into electronic typesetting, remaining essentially " |
| "unchanged. It was popularised in the 1960s with the " |
| "release of Letraset sheets containing Lorem Ipsum " |
| "passages, and more recently with desktop publishing " |
| "software like Aldus PageMaker including versions of " |
| "Lorem Ipsum." |
| "</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 2u); |
| CheckTextNode(*root.children_nodes[0], |
| "Lorem Ipsum is simply dummy text of the printing and " |
| "typesetting industry."); |
| CheckTextNode( |
| *root.children_nodes[1], |
| "Lorem Ipsum has been the industry's standard dummy text ever since the " |
| "1500s, when an unknown printer took a galley of type and scrambled it " |
| "to make a type specimen book. It has survived not only five centuries, " |
| "but also the leap into electronic typesetting, remaining essentially " |
| "unchanged. It was popularised in the 1960s with the release of Letraset " |
| "sheets containing Lorem Ipsum passages, and more recently with desktop " |
| "publishing software like Aldus PageMaker including versions of Lorem " |
| "Ipsum."); |
| } |
| |
| TEST_F(AIPageContentAgentTest, VisibilityHiddenOnSubtree) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " header {" |
| " visibility: hidden" |
| " }" |
| " </style>" |
| " <header>text</header>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 0u); |
| } |
| |
| TEST_F(AIPageContentAgentTest, VisibilityHiddenOnParentOnly) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " #parent {" |
| " visibility: hidden" |
| " }" |
| " #child {" |
| " visibility: visible" |
| " }" |
| " </style>" |
| " <header id=parent><div id=child>text</div></header>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& container = *root.children_nodes[0]; |
| CheckContainerNode(container); |
| EXPECT_EQ(container.children_nodes.size(), 1u); |
| |
| const auto& text_node = *container.children_nodes[0]; |
| CheckTextNode(text_node, "text"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, VisibilityHiddenOnIframe) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " iframe {" |
| " visibility: hidden;" |
| " }" |
| " </style>" |
| " <iframe srcdoc='<div style='visibility: visible'>hidden " |
| "text</div>'></iframe>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 0u); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| SkipUnclickableFixedOverlaysRespectsFeatureFlag) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <div id="unclickable" |
| style="position: fixed; inset: 0; pointer-events: none;"> |
| Readable text |
| </div> |
| <div id="clickable" style="position: fixed;"></div> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| { |
| ScopedAIPageContentSkipUnclickableFixedOverlaysForTest disable_feature( |
| false); |
| GetAIPageContentWithActionableElements(); |
| |
| // Preserve the legacy output while the feature is off. |
| EXPECT_TRUE(FindNodeBySelector("#unclickable")); |
| } |
| |
| { |
| ScopedAIPageContentSkipUnclickableFixedOverlaysForTest enable_feature(true); |
| GetAIPageContentWithActionableElements(); |
| |
| // Flatten the pointer-transparent wrapper without dropping its text. |
| ExpectSelectorNotInApcOutput("#unclickable"); |
| EXPECT_TRUE(TreeContainsTextSubstring(ContentRootNode(), "Readable text")); |
| EXPECT_TRUE(FindNodeBySelector("#clickable")); |
| } |
| } |
| |
| TEST_F(AIPageContentAgentTest, NoGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div>text</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_FALSE(root.content_attributes->geometry); |
| |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| const auto& text_node = *root.children_nodes[0]; |
| CheckTextNode(text_node, "text"); |
| EXPECT_FALSE(text_node.content_attributes->geometry); |
| } |
| |
| TEST_F(AIPageContentAgentTest, FormWithTextInput) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form name='myform' action='https://example.com/submit'>" |
| " <label for='input1'>Lorem Ipsum</label>" |
| " <input type='text' id='input1' name='LI' value='Lorem'>" |
| " <label for='input2'>Ipsum Dolor</label>" |
| " <input type='text' id='input2' name='ID' value='Ipsum' required>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto* agent = AIPageContentAgent::GetOrCreateForTesting( |
| *helper_.LocalMainFrame()->GetFrame()->GetDocument()); |
| ASSERT_TRUE(agent); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& form = *root.children_nodes[0]; |
| EXPECT_EQ(form.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kForm); |
| EXPECT_EQ(form.content_attributes->form_data->form_name, "myform"); |
| // The form metadata must expose the normalized action URL so callers can |
| // surface the submit destination. |
| EXPECT_EQ(form.content_attributes->form_data->action_url, |
| url_test_helpers::ToKURL("https://example.com/submit")); |
| EXPECT_EQ(form.children_nodes.size(), 4u); |
| |
| CheckTextNode(*form.children_nodes[0], "Lorem Ipsum"); |
| |
| const auto& text_input1 = *form.children_nodes[1]; |
| CheckFormControlNode(text_input1, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(text_input1.content_attributes->form_control_data->field_name, |
| "LI"); |
| EXPECT_EQ(text_input1.content_attributes->form_control_data->field_value, |
| "Lorem"); |
| EXPECT_EQ(text_input1.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kNoRedactionNecessary); |
| EXPECT_FALSE(text_input1.content_attributes->form_control_data->is_required); |
| EXPECT_EQ(text_input1.children_nodes.size(), 1u); |
| CheckContainerNode(*text_input1.children_nodes[0]); |
| EXPECT_EQ(text_input1.children_nodes[0]->children_nodes.size(), 1u); |
| CheckTextNode(*text_input1.children_nodes[0]->children_nodes[0], "Lorem"); |
| |
| CheckTextNode(*form.children_nodes[2], "Ipsum Dolor"); |
| |
| const auto& text_input2 = *form.children_nodes[3]; |
| CheckFormControlNode(text_input2, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(text_input2.content_attributes->form_control_data->field_name, |
| "ID"); |
| EXPECT_EQ(text_input2.content_attributes->form_control_data->field_value, |
| "Ipsum"); |
| EXPECT_EQ(text_input2.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kNoRedactionNecessary); |
| EXPECT_TRUE(text_input2.content_attributes->form_control_data->is_required); |
| EXPECT_EQ(text_input2.children_nodes.size(), 1u); |
| CheckContainerNode(*text_input2.children_nodes[0]); |
| EXPECT_EQ(text_input2.children_nodes[0]->children_nodes.size(), 1u); |
| CheckTextNode(*text_input2.children_nodes[0]->children_nodes[0], "Ipsum"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaRequiredAndPlaceholderOnTextInput) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <input id='input' type='text' aria-required='true' " |
| "aria-placeholder='Type here'>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // ARIA required/placeholder should be surfaced for native text inputs when |
| // the native attributes are not present, so we pick up author-provided ARIA |
| // metadata without overriding native semantics. |
| GetAIPageContent(); |
| |
| const auto* input = FindNodeBySelector("#input"); |
| ASSERT_TRUE(input); |
| CheckFormControlNode(*input, mojom::blink::FormControlType::kInputText); |
| EXPECT_TRUE(input->content_attributes->form_control_data->is_required); |
| EXPECT_EQ(input->content_attributes->form_control_data->placeholder, |
| "Type here"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaCheckedOnRoleCheckbox) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='checkbox' role='checkbox' aria-checked='true'>" |
| " ARIA Checkbox" |
| " </div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // ARIA-based controls should produce form control data when aria-checked is |
| // provided, enabling actionable extraction for custom widgets. |
| GetAIPageContent(); |
| |
| const auto* checkbox = FindNodeBySelector("#checkbox"); |
| ASSERT_TRUE(checkbox); |
| CheckFormControlNode(*checkbox, |
| mojom::blink::FormControlType::kInputCheckbox); |
| EXPECT_TRUE(checkbox->content_attributes->form_control_data->is_checked); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaRoleCheckboxWithoutProperties) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='checkbox' role='checkbox'>" |
| " ARIA Checkbox" |
| " </div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // An explicit ARIA role should be enough to surface form control metadata, |
| // even when no other ARIA state or property is provided. |
| GetAIPageContent(); |
| |
| const auto* checkbox = FindNodeBySelector("#checkbox"); |
| ASSERT_TRUE(checkbox); |
| CheckFormControlNode(*checkbox, |
| mojom::blink::FormControlType::kInputCheckbox); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaCheckedMixedOnRoleCheckbox) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='checkbox' role='checkbox' aria-checked='mixed'>" |
| " ARIA Checkbox" |
| " </div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // Keep aria-checked handling simple by treating "mixed" as a truthy state |
| // when the attribute is present, matching IsAriaAttributeTrue semantics. |
| GetAIPageContent(); |
| |
| const auto* checkbox = FindNodeBySelector("#checkbox"); |
| ASSERT_TRUE(checkbox); |
| CheckFormControlNode(*checkbox, |
| mojom::blink::FormControlType::kInputCheckbox); |
| EXPECT_TRUE(checkbox->content_attributes->form_control_data->is_checked); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaReadOnlyOnRoleTextbox) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='textbox' role='textbox' aria-readonly='true'>" |
| " ARIA Textbox" |
| " </div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // Readonly state should be exposed for ARIA-based textboxes so consumers can |
| // avoid actions which would try to edit locked content. |
| GetAIPageContent(); |
| |
| const auto* textbox = FindNodeBySelector("#textbox"); |
| ASSERT_TRUE(textbox); |
| CheckFormControlNode(*textbox, mojom::blink::FormControlType::kInputText); |
| EXPECT_TRUE(textbox->content_attributes->form_control_data->is_readonly); |
| } |
| |
| TEST_F(AIPageContentAgentTest, NativeReadOnlyTextInput) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <input id='input' type='text' readonly>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // Native readonly must be surfaced so consumers can avoid editing. |
| GetAIPageContent(); |
| |
| const auto* input = FindNodeBySelector("#input"); |
| ASSERT_TRUE(input); |
| CheckFormControlNode(*input, mojom::blink::FormControlType::kInputText); |
| EXPECT_TRUE(input->content_attributes->form_control_data->is_readonly); |
| } |
| |
| TEST_F(AIPageContentAgentTest, FrameDefaultLineHeightUsesCssPixels) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<html style='font-size: 10px; line-height: 24px; zoom: 2'>" |
| "<body>" |
| // CSS zoom scales layout values internally, so this verifies APC reports |
| // the author-facing CSS px value rather than the zoomed layout value. |
| " <input id='input' type='text' " |
| "style='font-size: 10px'>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto* input = FindNodeBySelector("#input"); |
| ASSERT_TRUE(input); |
| CheckFormControlNode(*input, mojom::blink::FormControlType::kInputText); |
| // The default line height is frame data because popups are frame-owned. |
| EXPECT_EQ(Content()->frame_data->default_line_height_px, 24u); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| FrameDefaultLineHeightFallsBackWithoutDocumentElementLayoutObject) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<html style='display: none'>" |
| "<body>" |
| // The <html> element has no LayoutObject when it is display:none. |
| // APC should still emit frame data instead of crashing the renderer. |
| " <input id='input' type='text'>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| ASSERT_TRUE(Content()->frame_data); |
| // Without a <html> LayoutObject, APC uses a fixed fallback row size. |
| EXPECT_EQ(Content()->frame_data->default_line_height_px, 12u); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| FrameDefaultLineHeightFallsBackWithoutDocumentElement) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<html>" |
| "<body>" |
| " <input id='input' type='text'>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| ASSERT_TRUE(document->documentElement()); |
| // APC can still serialize from the frame LayoutView after script removes |
| // the document element, but no author line-height source remains. |
| document->documentElement()->remove(); |
| |
| GetAIPageContent(); |
| |
| ASSERT_TRUE(Content()->frame_data); |
| EXPECT_EQ(Content()->frame_data->default_line_height_px, 12u); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaCheckedDoesNotOverrideNativeCheckbox) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <input id='native' type='checkbox' checked aria-checked='false'>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // Native checked state must remain authoritative over aria-checked, matching |
| // the HTML-AAM rule that ARIA must not override strong native semantics. |
| GetAIPageContent(); |
| |
| const auto* native_checkbox = FindNodeBySelector("#native"); |
| ASSERT_TRUE(native_checkbox); |
| CheckFormControlNode(*native_checkbox, |
| mojom::blink::FormControlType::kInputCheckbox); |
| EXPECT_TRUE( |
| native_checkbox->content_attributes->form_control_data->is_checked); |
| } |
| |
| TEST_F(AIPageContentAgentTest, FormWithSelect) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form name='myform'>" |
| " <select name='LI'>" |
| " <option value='Lorem'>Lorem Text</option>" |
| " <option value='Ipsum'>Ipsum Text</option>" |
| " </select>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto* agent = AIPageContentAgent::GetOrCreateForTesting( |
| *helper_.LocalMainFrame()->GetFrame()->GetDocument()); |
| ASSERT_TRUE(agent); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& form = *root.children_nodes[0]; |
| EXPECT_EQ(form.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kForm); |
| EXPECT_EQ(form.content_attributes->form_data->form_name, "myform"); |
| EXPECT_EQ(form.children_nodes.size(), 1u); |
| |
| const auto& select = *form.children_nodes[0]; |
| CheckFormControlNode(select, mojom::blink::FormControlType::kSelectOne); |
| EXPECT_EQ(select.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kNoRedactionNecessary); |
| |
| const auto& select_options = |
| select.content_attributes->form_control_data->select_options; |
| ASSERT_EQ(select_options.size(), 2u); |
| |
| EXPECT_EQ(select_options[0]->value, "Lorem"); |
| EXPECT_EQ(select_options[0]->text, "Lorem Text"); |
| EXPECT_TRUE(select_options[0]->is_selected); |
| |
| EXPECT_EQ(select_options[1]->value, "Ipsum"); |
| EXPECT_EQ(select_options[1]->text, "Ipsum Text"); |
| EXPECT_FALSE(select_options[1]->is_selected); |
| |
| EXPECT_EQ(select.children_nodes.size(), 1u); |
| CheckTextNode(*select.children_nodes[0], "Lorem Text"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, FormWithCheckbox) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form name='vehicles'>" |
| " <input type='checkbox' id='vehicle1' name='vehicle1' value='Bike'>" |
| " <label for='vehicle1'>I have a bike</label><br>" |
| " <input type='checkbox' id='vehicle2' name='vehicle2' value='Car' " |
| " checked>" |
| " <label for='vehicle2'>I have a car</label><br>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto* agent = AIPageContentAgent::GetOrCreateForTesting( |
| *helper_.LocalMainFrame()->GetFrame()->GetDocument()); |
| ASSERT_TRUE(agent); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& form = *root.children_nodes[0]; |
| EXPECT_EQ(form.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kForm); |
| EXPECT_EQ(form.content_attributes->form_data->form_name, "vehicles"); |
| EXPECT_EQ(form.children_nodes.size(), 4u); |
| |
| const auto& checkbox1 = *form.children_nodes[0]; |
| CheckFormControlNode(checkbox1, |
| mojom::blink::FormControlType::kInputCheckbox); |
| EXPECT_EQ(checkbox1.content_attributes->form_control_data->field_name, |
| "vehicle1"); |
| EXPECT_EQ(checkbox1.content_attributes->form_control_data->field_value, |
| "Bike"); |
| EXPECT_FALSE(checkbox1.content_attributes->form_control_data->is_checked); |
| EXPECT_EQ(checkbox1.children_nodes.size(), 0u); |
| |
| CheckTextNode(*form.children_nodes[1], "I have a bike"); |
| |
| const auto& checkbox2 = *form.children_nodes[2]; |
| CheckFormControlNode(checkbox2, |
| mojom::blink::FormControlType::kInputCheckbox); |
| EXPECT_EQ(checkbox2.content_attributes->form_control_data->field_name, |
| "vehicle2"); |
| EXPECT_EQ(checkbox2.content_attributes->form_control_data->field_value, |
| "Car"); |
| EXPECT_TRUE(checkbox2.content_attributes->form_control_data->is_checked); |
| EXPECT_EQ(checkbox2.children_nodes.size(), 0u); |
| |
| CheckTextNode(*form.children_nodes[3], "I have a car"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, FormWithRadio) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form name='vehicles'>" |
| " <input type='radio' id='vehicle1' name='vehicle1' value='Bike'>" |
| " <label for='vehicle1'>I have a bike</label><br>" |
| " <input type='radio' id='vehicle2' name='vehicle2' value='Car' " |
| " checked>" |
| " <label for='vehicle2'>I have a car</label><br>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto* agent = AIPageContentAgent::GetOrCreateForTesting( |
| *helper_.LocalMainFrame()->GetFrame()->GetDocument()); |
| ASSERT_TRUE(agent); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& form = *root.children_nodes[0]; |
| EXPECT_EQ(form.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kForm); |
| EXPECT_EQ(form.content_attributes->form_data->form_name, "vehicles"); |
| EXPECT_EQ(form.children_nodes.size(), 4u); |
| |
| const auto& radio1 = *form.children_nodes[0]; |
| CheckFormControlNode(radio1, mojom::blink::FormControlType::kInputRadio); |
| EXPECT_EQ(radio1.content_attributes->form_control_data->field_name, |
| "vehicle1"); |
| EXPECT_EQ(radio1.content_attributes->form_control_data->field_value, "Bike"); |
| EXPECT_EQ(radio1.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kNoRedactionNecessary); |
| EXPECT_FALSE(radio1.content_attributes->form_control_data->is_checked); |
| EXPECT_EQ(radio1.children_nodes.size(), 0u); |
| |
| CheckTextNode(*form.children_nodes[1], "I have a bike"); |
| |
| const auto& radio2 = *form.children_nodes[2]; |
| CheckFormControlNode(radio2, mojom::blink::FormControlType::kInputRadio); |
| EXPECT_EQ(radio2.content_attributes->form_control_data->field_name, |
| "vehicle2"); |
| EXPECT_EQ(radio2.content_attributes->form_control_data->field_value, "Car"); |
| EXPECT_TRUE(radio2.content_attributes->form_control_data->is_checked); |
| EXPECT_EQ(radio2.children_nodes.size(), 0u); |
| |
| CheckTextNode(*form.children_nodes[3], "I have a car"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, FormWithPassword) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='pwd' type='password' name='Enter password' " |
| "value='mypassword'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto* agent = AIPageContentAgent::GetOrCreateForTesting( |
| *helper_.LocalMainFrame()->GetFrame()->GetDocument()); |
| ASSERT_TRUE(agent); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& form = *root.children_nodes[0]; |
| EXPECT_EQ(form.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kForm); |
| EXPECT_EQ(form.children_nodes.size(), 1u); |
| |
| const auto& password = *form.children_nodes[0]; |
| CheckFormControlNode(password, mojom::blink::FormControlType::kInputPassword); |
| EXPECT_EQ(password.content_attributes->form_control_data->field_name, |
| "Enter password"); |
| EXPECT_EQ(password.content_attributes->form_control_data->field_value, |
| nullptr); |
| EXPECT_EQ(password.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_HasBeenPassword); |
| EXPECT_EQ(password.children_nodes.size(), 0u); |
| |
| // Now reveal the password (simulating clicking the eye icon) |
| // This mimics JavaScript: passwordInput.type = 'text'; |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* input_element = |
| To<HTMLInputElement>(document->getElementById(AtomicString("pwd"))); |
| ASSERT_TRUE(input_element); |
| input_element->setType(AtomicString("text")); |
| |
| // Ensure the DOM is updated |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| // Get AI page content again - password should still be hidden |
| GetAIPageContent(); |
| |
| const auto& root2 = ContentRootNode(); |
| EXPECT_EQ(root2.children_nodes.size(), 1u); |
| |
| const auto& form2 = *root2.children_nodes[0]; |
| EXPECT_EQ(form2.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kForm); |
| EXPECT_EQ(form2.children_nodes.size(), 1u); |
| |
| const auto& revealed_password = *form2.children_nodes[0]; |
| CheckFormControlNode(revealed_password, |
| mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(revealed_password.content_attributes->form_control_data->field_name, |
| "Enter password"); |
| // Even though the password is revealed, the value should still be hidden |
| // because HasBeenBeenPasswordField() is true. |
| EXPECT_EQ( |
| revealed_password.content_attributes->form_control_data->field_value, |
| nullptr); |
| EXPECT_EQ(revealed_password.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_HasBeenPassword); |
| EXPECT_EQ(revealed_password.children_nodes.size(), 0u); |
| |
| input_element->SetValue(""); |
| |
| // Ensure the DOM is updated |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| // Get AI page content again - empty passwords are unredacted. |
| GetAIPageContent(); |
| |
| const auto& root3 = ContentRootNode(); |
| EXPECT_EQ(root3.children_nodes.size(), 1u); |
| |
| const auto& form3 = *root3.children_nodes[0]; |
| EXPECT_EQ(form3.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kForm); |
| EXPECT_EQ(form3.children_nodes.size(), 1u); |
| |
| const auto& empty_password = *form3.children_nodes[0]; |
| CheckFormControlNode(empty_password, |
| mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(empty_password.content_attributes->form_control_data->field_name, |
| "Enter password"); |
| EXPECT_EQ(empty_password.content_attributes->form_control_data->field_value, |
| ""); |
| EXPECT_EQ(empty_password.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kUnredacted_EmptyPassword); |
| EXPECT_EQ(empty_password.children_nodes.size(), 1u); |
| } |
| |
| TEST_F(AIPageContentAgentTest, FormWithWebkitTextSecurityRedactsAndPersists) { |
| // This test covers a common custom-password pattern where authors use |
| // `-webkit-text-security` on a normal <input type="text"> to visually mask |
| // the value without using <input type="password">. |
| // |
| // Acceptance criteria: |
| // - The value is redacted when `-webkit-text-security` is not `none`. |
| // - After the style is removed (simulating JS toggling the masking), the |
| // value remains redacted for subsequent extractions. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='masked' type='text' name='Enter secret' " |
| "style='-webkit-text-security: disc;' value='supersecret'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& form = *root.children_nodes[0]; |
| ASSERT_EQ(form.children_nodes.size(), 1u); |
| |
| const auto& field = *form.children_nodes[0]; |
| CheckFormControlNode(field, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field.content_attributes->form_control_data->field_name, |
| "Enter secret"); |
| EXPECT_EQ(field.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ( |
| field.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_CSS); |
| |
| // Now remove the masking style (simulating a "show password" eye icon). |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* input_element = |
| To<HTMLInputElement>(document->getElementById(AtomicString("masked"))); |
| ASSERT_TRUE(input_element); |
| input_element->setAttribute(html_names::kStyleAttr, |
| AtomicString("-webkit-text-security: none;")); |
| |
| // Ensure the DOM is updated. |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| // Extract again: the field should remain redacted since it was previously |
| // classified as password-like. |
| GetAIPageContent(); |
| |
| const auto& root2 = ContentRootNode(); |
| ASSERT_EQ(root2.children_nodes.size(), 1u); |
| const auto& form2 = *root2.children_nodes[0]; |
| ASSERT_EQ(form2.children_nodes.size(), 1u); |
| const auto& field2 = *form2.children_nodes[0]; |
| CheckFormControlNode(field2, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field2.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ( |
| field2.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_CSS); |
| } |
| |
| TEST_F(AIPageContentAgentTest, FormWithMaskedValuePatternRedactsAndPersists) { |
| // Some custom controls implement password-style masking in JavaScript by |
| // writing a value that contains mostly mask characters (e.g. bullets) while |
| // revealing the last typed character. |
| // |
| // Acceptance criteria: |
| // - A masked-value pattern is treated as password-like and redacted. |
| // - After the value is changed to an unmasked string, the field remains |
| // redacted for subsequent extractions. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='jsmasked' type='text' name='Enter secret' " |
| "value='••••a'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& form = *root.children_nodes[0]; |
| ASSERT_EQ(form.children_nodes.size(), 1u); |
| |
| const auto& field = *form.children_nodes[0]; |
| CheckFormControlNode(field, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ(field.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_JS); |
| |
| // Now set an unmasked value; the field should remain redacted since it was |
| // previously classified as password-like. |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* input_element = |
| To<HTMLInputElement>(document->getElementById(AtomicString("jsmasked"))); |
| ASSERT_TRUE(input_element); |
| input_element->SetValue("notmaskedanymore"); |
| |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| GetAIPageContent(); |
| const auto& root2 = ContentRootNode(); |
| ASSERT_EQ(root2.children_nodes.size(), 1u); |
| const auto& form2 = *root2.children_nodes[0]; |
| ASSERT_EQ(form2.children_nodes.size(), 1u); |
| const auto& field2 = *form2.children_nodes[0]; |
| CheckFormControlNode(field2, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field2.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ(field2.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_JS); |
| } |
| |
| TEST_F(AIPageContentAgentTest, FormWithAllMaskCharactersRedacts) { |
| // Some custom controls always fully mask the value, never revealing a |
| // character (e.g. "•••••"). This should still be treated as password-like. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='jsmasked' type='text' name='Enter secret' " |
| "value='•••••'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& form = *root.children_nodes[0]; |
| ASSERT_EQ(form.children_nodes.size(), 1u); |
| |
| const auto& field = *form.children_nodes[0]; |
| CheckFormControlNode(field, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ(field.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_JS); |
| } |
| |
| TEST_F(AIPageContentAgentTest, FormWithMaskedValuePatternWithSpaceNotRedacted) { |
| // Guardrail: if the value contains whitespace, treat it as non-password-like. |
| // A common rich-text pattern is a bullet used as a list marker. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='maybe' type='text' name='Enter secret' " |
| "value='•• secret'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& form = *root.children_nodes[0]; |
| ASSERT_EQ(form.children_nodes.size(), 1u); |
| |
| const auto& field = *form.children_nodes[0]; |
| CheckFormControlNode(field, mojom::blink::FormControlType::kInputText); |
| EXPECT_NE(field.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ(field.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kNoRedactionNecessary); |
| } |
| |
| TEST_F(AIPageContentAgentTest, FormWithEarlyJSMaskedValueRedacts) { |
| // Guard against leaking initial characters as the user types into a custom |
| // JS-masked password field. Some implementations show "•b" for a 2-character |
| // password while the last typed character remains visible. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='early' type='text' name='Enter secret' value='•b'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& form = *root.children_nodes[0]; |
| ASSERT_EQ(form.children_nodes.size(), 1u); |
| |
| const auto& field = *form.children_nodes[0]; |
| CheckFormControlNode(field, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ(field.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_JS); |
| } |
| |
| TEST_F(AIPageContentAgentTest, CustomPasswordJSBecomesEmptyThenRedactsAgain) { |
| // Regression coverage: once a field is classified as a JS custom password |
| // field, it stays classified even if the value becomes empty and later |
| // becomes non-empty again. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='js' type='text' name='Enter secret' " |
| "value='••••a'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& form = *root.children_nodes[0]; |
| ASSERT_EQ(form.children_nodes.size(), 1u); |
| const auto& field = *form.children_nodes[0]; |
| CheckFormControlNode(field, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ(field.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_JS); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* input_element = |
| To<HTMLInputElement>(document->getElementById(AtomicString("js"))); |
| ASSERT_TRUE(input_element); |
| input_element->SetValue(""); |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| GetAIPageContent(); |
| const auto& root2 = ContentRootNode(); |
| ASSERT_EQ(root2.children_nodes.size(), 1u); |
| const auto& form2 = *root2.children_nodes[0]; |
| ASSERT_EQ(form2.children_nodes.size(), 1u); |
| const auto& field2 = *form2.children_nodes[0]; |
| CheckFormControlNode(field2, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field2.content_attributes->form_control_data->field_value, ""); |
| EXPECT_EQ( |
| field2.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kUnredacted_EmptyCustomPassword); |
| |
| input_element->SetValue("notmaskedanymore"); |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| GetAIPageContent(); |
| const auto& root3 = ContentRootNode(); |
| ASSERT_EQ(root3.children_nodes.size(), 1u); |
| const auto& form3 = *root3.children_nodes[0]; |
| ASSERT_EQ(form3.children_nodes.size(), 1u); |
| const auto& field3 = *form3.children_nodes[0]; |
| CheckFormControlNode(field3, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field3.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ(field3.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_JS); |
| } |
| |
| TEST_F(AIPageContentAgentTest, CustomPasswordJSPlainTextThenMaskedAgain) { |
| // Regression coverage: a JS custom password field may temporarily replace its |
| // value with plain text (e.g. "show password") and later resume masking. The |
| // value must remain redacted throughout. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='js' type='text' name='Enter secret' " |
| "value='••••a'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* input_element = |
| To<HTMLInputElement>(document->getElementById(AtomicString("js"))); |
| ASSERT_TRUE(input_element); |
| |
| GetAIPageContent(); |
| |
| input_element->SetValue("plain-text-temporary"); |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| GetAIPageContent(); |
| const auto& root2 = ContentRootNode(); |
| ASSERT_EQ(root2.children_nodes.size(), 1u); |
| const auto& form2 = *root2.children_nodes[0]; |
| ASSERT_EQ(form2.children_nodes.size(), 1u); |
| const auto& field2 = *form2.children_nodes[0]; |
| CheckFormControlNode(field2, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field2.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ(field2.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_JS); |
| |
| input_element->SetValue(String::FromUtf8("••••z")); |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| GetAIPageContent(); |
| const auto& root3 = ContentRootNode(); |
| ASSERT_EQ(root3.children_nodes.size(), 1u); |
| const auto& form3 = *root3.children_nodes[0]; |
| ASSERT_EQ(form3.children_nodes.size(), 1u); |
| const auto& field3 = *form3.children_nodes[0]; |
| CheckFormControlNode(field3, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field3.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ(field3.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_JS); |
| } |
| |
| TEST_F(AIPageContentAgentTest, CustomPasswordCSSBecomesEmptyThenRedactsAgain) { |
| // Regression coverage: once a field is classified as a CSS custom password |
| // field, it stays classified even if the value becomes empty and later |
| // becomes non-empty again. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='css' type='text' name='Enter secret' " |
| "style='-webkit-text-security: disc;' value='supersecret'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& form = *root.children_nodes[0]; |
| ASSERT_EQ(form.children_nodes.size(), 1u); |
| const auto& field = *form.children_nodes[0]; |
| CheckFormControlNode(field, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ( |
| field.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_CSS); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* input_element = |
| To<HTMLInputElement>(document->getElementById(AtomicString("css"))); |
| ASSERT_TRUE(input_element); |
| input_element->SetValue(""); |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| GetAIPageContent(); |
| const auto& root2 = ContentRootNode(); |
| ASSERT_EQ(root2.children_nodes.size(), 1u); |
| const auto& form2 = *root2.children_nodes[0]; |
| ASSERT_EQ(form2.children_nodes.size(), 1u); |
| const auto& field2 = *form2.children_nodes[0]; |
| CheckFormControlNode(field2, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field2.content_attributes->form_control_data->field_value, ""); |
| EXPECT_EQ( |
| field2.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kUnredacted_EmptyCustomPassword); |
| |
| input_element->setAttribute(html_names::kStyleAttr, |
| AtomicString("-webkit-text-security: none;")); |
| input_element->SetValue("plain-text-temporary"); |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| GetAIPageContent(); |
| const auto& root3 = ContentRootNode(); |
| ASSERT_EQ(root3.children_nodes.size(), 1u); |
| const auto& form3 = *root3.children_nodes[0]; |
| ASSERT_EQ(form3.children_nodes.size(), 1u); |
| const auto& field3 = *form3.children_nodes[0]; |
| CheckFormControlNode(field3, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field3.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ( |
| field3.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_CSS); |
| } |
| |
| TEST_F(AIPageContentAgentTest, CustomPasswordCSSPlainTextThenMaskedAgain) { |
| // Regression coverage: a CSS custom password field may temporarily disable |
| // masking (e.g. "show password") and later re-enable it. The value must |
| // remain redacted throughout. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='css' type='text' name='Enter secret' " |
| "style='-webkit-text-security: disc;' value='supersecret'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* input_element = |
| To<HTMLInputElement>(document->getElementById(AtomicString("css"))); |
| ASSERT_TRUE(input_element); |
| |
| GetAIPageContent(); |
| |
| input_element->setAttribute(html_names::kStyleAttr, |
| AtomicString("-webkit-text-security: none;")); |
| input_element->SetValue("plain-text-temporary"); |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| GetAIPageContent(); |
| const auto& root2 = ContentRootNode(); |
| ASSERT_EQ(root2.children_nodes.size(), 1u); |
| const auto& form2 = *root2.children_nodes[0]; |
| ASSERT_EQ(form2.children_nodes.size(), 1u); |
| const auto& field2 = *form2.children_nodes[0]; |
| CheckFormControlNode(field2, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field2.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ( |
| field2.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_CSS); |
| |
| input_element->setAttribute(html_names::kStyleAttr, |
| AtomicString("-webkit-text-security: disc;")); |
| input_element->SetValue("supersecret2"); |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| GetAIPageContent(); |
| const auto& root3 = ContentRootNode(); |
| ASSERT_EQ(root3.children_nodes.size(), 1u); |
| const auto& form3 = *root3.children_nodes[0]; |
| ASSERT_EQ(form3.children_nodes.size(), 1u); |
| const auto& field3 = *form3.children_nodes[0]; |
| CheckFormControlNode(field3, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field3.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ( |
| field3.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_CSS); |
| } |
| |
| TEST_F( |
| AIPageContentAgentTest, |
| DISABLED_ContentEditableWithMaskedValuePatternSingleLineRedactsAndPersists) { |
| // TODO(crbug.com/480179556): Treat contenteditable as a form control (or add |
| // a first-class editable field node) so we can attach structured redaction |
| // decisions and consistently skip editor/shadow subtrees for password-like |
| // contenteditables. This test covers a custom password control implemented |
| // with a contenteditable element. A common JS approach is to write mask |
| // characters (e.g. bullets) and reveal only the most recently typed |
| // character. |
| // |
| // Acceptance criteria: |
| // - The extracted content does not include the masked string. |
| // - After the field has been classified as password-like, it stays redacted |
| // even if the page later writes an unmasked value. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='ce' " |
| "contenteditable='true'>••••a</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* editable = |
| To<HTMLElement>(document->getElementById(AtomicString("ce"))); |
| ASSERT_TRUE(editable); |
| ASSERT_TRUE(IsRichlyEditable(*editable)); |
| ASSERT_EQ(RootEditableElement(*editable), editable); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_FALSE(TreeContainsTextSubstring(root, "a")); |
| |
| editable->setInnerText("notmaskedanymore"); |
| |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| GetAIPageContent(); |
| const auto& root2 = ContentRootNode(); |
| EXPECT_FALSE(TreeContainsTextSubstring(root2, "notmaskedanymore")); |
| } |
| |
| TEST_F( |
| AIPageContentAgentTest, |
| DISABLED_ContentEditableMultilineWithBulletIsNotClassifiedAsCustomPassword) { |
| // TODO(crbug.com/480179556): When adding contenteditable custom password |
| // redaction, keep a single-line guardrail to avoid false positives for rich |
| // text editors. Guardrail against false positives: rich text editors often |
| // use bullet characters (•) as list markers in normal prose, and we must not |
| // treat these as password-like fields. We require contenteditable masking |
| // heuristics to apply only to single-line fields. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='editor' contenteditable='true'>" |
| " <div>• item</div>" |
| " <div>more</div>" |
| " </div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_TRUE(TreeContainsTextSubstring(root, "item")); |
| EXPECT_TRUE(TreeContainsTextSubstring(root, "more")); |
| } |
| |
| TEST_F(AIPageContentAgentTest, InteractiveElementsTextArea) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <textarea>text</textarea>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& text_area = *root.children_nodes[0]; |
| CheckFormControlNode(text_area, mojom::blink::FormControlType::kTextArea); |
| EXPECT_EQ(text_area.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kNoRedactionNecessary); |
| CheckHitTestableAndInteractive(text_area, |
| {ClickabilityReason::kClickableControl}); |
| |
| // Text area uses a UA shadow DOM internally to create an editable box. |
| const auto& shadow_div = *text_area.children_nodes[0]; |
| EXPECT_EQ(shadow_div.children_nodes.size(), 1u); |
| CheckContainerNode(shadow_div); |
| CheckHitTestableAndInteractive(shadow_div, {ClickabilityReason::kEditable}); |
| |
| EXPECT_EQ(shadow_div.children_nodes.size(), 1u); |
| const auto& text_area_text = *shadow_div.children_nodes[0]; |
| CheckTextNode(text_area_text, "text"); |
| CheckHitTestableButNotInteractive(text_area_text); |
| } |
| |
| TEST_F(AIPageContentAgentTest, InteractiveElementsButton) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <button>button</button>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& button = *root.children_nodes[0]; |
| CheckFormControlNode(button, mojom::blink::FormControlType::kButtonSubmit); |
| EXPECT_EQ(button.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kNoRedactionNecessary); |
| CheckHitTestableAndInteractive(button, |
| {ClickabilityReason::kClickableControl, |
| ClickabilityReason::kHoverPseudoClass}); |
| EXPECT_TRUE(button.content_attributes->node_interaction_info->is_focusable); |
| |
| ASSERT_EQ(button.children_nodes.size(), 1u); |
| const auto& button_text = *button.children_nodes[0]; |
| CheckTextNode(button_text, "button"); |
| EXPECT_TRUE(button_text.content_attributes->node_interaction_info); |
| CheckHitTestableButNotInteractive(button_text); |
| } |
| |
| TEST_F(AIPageContentAgentTest, InteractiveElementsResizableDiv) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " div {" |
| " resize: both;" |
| " overflow: auto;" |
| " border: 1px solid black;" |
| " width: 200px;" |
| " }" |
| " </style>" |
| " <div>resize</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& resize = *ContentRootNode().children_nodes[0]; |
| CheckContainerNode(resize); |
| ASSERT_TRUE(resize.content_attributes->node_interaction_info); |
| EXPECT_FALSE(resize.content_attributes->node_interaction_info->scroller_info); |
| CheckHitTestableButNotInteractive(resize); |
| |
| ASSERT_EQ(resize.children_nodes.size(), 1u); |
| const auto& resize_text = *resize.children_nodes[0]; |
| CheckTextNode(resize_text, "resize"); |
| EXPECT_TRUE(resize_text.content_attributes->node_interaction_info); |
| CheckHitTestableButNotInteractive(resize_text); |
| } |
| |
| TEST_F(AIPageContentAgentTest, Selection) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p id='p1'>Paragraph 1</p>" |
| " <p id='p2'>Paragraph 2</p>" |
| " <p id='p3'>Paragraph 3</p>" |
| " <script>" |
| " const p1 = document.getElementById('p1');" |
| " const p2 = document.getElementById('p2');" |
| " const range = new Range();" |
| " range.setStart(p1.childNodes[0], 10);" |
| " range.setEnd(p2.childNodes[0], 9);" |
| " const selection = window.getSelection();" |
| " selection.removeAllRanges();" |
| " selection.addRange(range);" |
| " </script>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 3u); |
| |
| const auto& paragraph1 = *root.children_nodes[0]; |
| CheckTextNode(*paragraph1.children_nodes[0], "Paragraph 1"); |
| |
| const auto& paragraph2 = *root.children_nodes[1]; |
| CheckTextNode(*paragraph2.children_nodes[0], "Paragraph 2"); |
| |
| const auto& paragraph3 = *root.children_nodes[2]; |
| CheckTextNode(*paragraph3.children_nodes[0], "Paragraph 3"); |
| |
| const auto& frame_interaction_info = |
| Content()->frame_data->frame_interaction_info; |
| ASSERT_TRUE(frame_interaction_info->selection); |
| const auto& selection = *frame_interaction_info->selection; |
| EXPECT_EQ(selection.selected_text, "1\n\nParagraph"); |
| EXPECT_EQ(selection.start_dom_node_id, |
| paragraph1.children_nodes[0]->content_attributes->dom_node_id); |
| EXPECT_EQ(selection.end_dom_node_id, |
| paragraph2.children_nodes[0]->content_attributes->dom_node_id); |
| EXPECT_EQ(selection.start_offset, 10); |
| EXPECT_EQ(selection.end_offset, 9); |
| } |
| |
| TEST_F(AIPageContentAgentTest, SelectionInIframe) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <iframe srcdoc='" |
| " <p id=\"p1\">Paragraph 1</p>" |
| " <p id=\"p2\">Paragraph 2</p>" |
| " <p id=\"p3\">Paragraph 3</p>" |
| " <script>" |
| " const p1 = document.getElementById(\"p1\");" |
| " const p2 = document.getElementById(\"p2\");" |
| " const range = new Range();" |
| " range.setStart(p1.childNodes[0], 10);" |
| " range.setEnd(p2.childNodes[0], 9);" |
| " const selection = window.getSelection();" |
| " selection.removeAllRanges();" |
| " selection.addRange(range);" |
| " </script>" |
| " '></iframe>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& iframe = *root.children_nodes[0]; |
| CheckIframeNode(iframe); |
| EXPECT_EQ(iframe.children_nodes.size(), 1u); |
| |
| const auto& iframe_root = *iframe.children_nodes[0]; |
| CheckRootNode(iframe_root); |
| EXPECT_EQ(iframe_root.children_nodes.size(), 3u); |
| |
| const auto& paragraph1 = *iframe_root.children_nodes[0]; |
| CheckTextNode(*paragraph1.children_nodes[0], "Paragraph 1"); |
| |
| const auto& paragraph2 = *iframe_root.children_nodes[1]; |
| CheckTextNode(*paragraph2.children_nodes[0], "Paragraph 2"); |
| |
| const auto& paragraph3 = *iframe_root.children_nodes[2]; |
| CheckTextNode(*paragraph3.children_nodes[0], "Paragraph 3"); |
| |
| const auto& frame_interaction_info = |
| Content()->frame_data->frame_interaction_info; |
| ASSERT_FALSE(frame_interaction_info->selection); |
| |
| EXPECT_TRUE(iframe.content_attributes->iframe_data->content); |
| const auto& iframe_interaction_info = |
| iframe.content_attributes->iframe_data->content->get_local_frame_data() |
| ->frame_interaction_info; |
| ASSERT_TRUE(iframe_interaction_info->selection); |
| const auto& selection = *iframe_interaction_info->selection; |
| EXPECT_EQ(selection.selected_text, "1\n\nParagraph"); |
| EXPECT_EQ(selection.start_dom_node_id, |
| paragraph1.children_nodes[0]->content_attributes->dom_node_id); |
| EXPECT_EQ(selection.end_dom_node_id, |
| paragraph2.children_nodes[0]->content_attributes->dom_node_id); |
| EXPECT_EQ(selection.start_offset, 10); |
| EXPECT_EQ(selection.end_offset, 9); |
| } |
| |
| TEST_F(AIPageContentAgentTest, Focus) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <button id='button'>button</button>" |
| " <script>" |
| " const button = document.getElementById('button');" |
| " button.focus();" |
| " </script>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& button = *root.children_nodes[0]; |
| const auto& page_interaction_info = Content()->page_interaction_info; |
| EXPECT_EQ(page_interaction_info->focused_dom_node_id, |
| button.content_attributes->dom_node_id); |
| |
| const auto& frame_interaction_info = |
| Content()->frame_data->frame_interaction_info; |
| EXPECT_EQ(frame_interaction_info->focused_dom_node_id, |
| button.content_attributes->dom_node_id); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AccessibilityFocus) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " #button1 {" |
| " position: absolute;" |
| " top: -10px;" |
| " left: -20px;" |
| " width: 30px;" |
| " height: 40px;" |
| " }" |
| " </style>" |
| " <button id='button1'>button1</button>" |
| " <div id='div2'>div2</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // Enable accessibility. |
| ui::AXMode ax_mode = ui::kAXModeComplete; |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto context = std::make_unique<AXContext>(*document, ax_mode); |
| EXPECT_TRUE(document->ExistingAXObjectCache()); |
| auto* ax_object_cache = |
| To<AXObjectCacheImpl>(document->ExistingAXObjectCache()); |
| EXPECT_EQ(ax_mode, ax_object_cache->GetAXMode()); |
| ax_object_cache->UpdateAXForAllDocuments(); |
| |
| // Set accessibility focus to the button. |
| auto* button_element = document->getElementById(AtomicString("button1")); |
| auto* button_ax_object = ax_object_cache->Get(button_element); |
| ui::AXActionData action_data; |
| action_data.action = ax::mojom::blink::Action::kSetAccessibilityFocus; |
| button_ax_object->PerformAction(action_data); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& button = *root.children_nodes[0]; |
| const auto& div2 = *root.children_nodes[1]; |
| const auto& page_interaction_info = Content()->page_interaction_info; |
| EXPECT_EQ(page_interaction_info->accessibility_focused_dom_node_id, |
| button.content_attributes->dom_node_id); |
| CheckGeometry(button, gfx::Rect(-20, -10, 30, 40), gfx::Rect(0, 0, 10, 30)); |
| EXPECT_FALSE(div2.content_attributes->geometry); |
| |
| const auto& frame_interaction_info = |
| Content()->frame_data->frame_interaction_info; |
| EXPECT_EQ(frame_interaction_info->accessibility_focused_dom_node_id, |
| button.content_attributes->dom_node_id); |
| } |
| |
| TEST_F(AIPageContentAgentTest, MousePosition) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " div {" |
| " position: absolute;" |
| " top: 100px;" |
| " left: 200px;" |
| " }" |
| " </style>" |
| " <div>text</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // Move the mouse to the middle of the page. |
| FireMouseMoveEvent(gfx::PointF(150, 50)); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& text = *root.children_nodes[0]; |
| CheckTextNode(text, "text"); |
| |
| EXPECT_EQ(Content()->page_interaction_info->mouse_position->x(), 150); |
| EXPECT_EQ(Content()->page_interaction_info->mouse_position->y(), 50); |
| } |
| |
| TEST_F(AIPageContentAgentTest, MetaTags) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<head>" |
| " <meta charset='UTF-8'>" |
| " <meta content='ignored'>" |
| " <meta name='author' content='George'>" |
| " <meta name='keywords' content='HTML, CSS, JavaScript'>" |
| " <meta name='nocontent'>" |
| " <meta name='emptycontent' content=''>" |
| " <meta id='nullcontent' name='nullcontent'>" |
| "</head>" |
| "<body>" |
| " <meta name='ignored'>" |
| " <iframe srcdoc=\"" |
| " <head>" |
| " <meta charset='UTF-8'>" |
| " <meta name='author' content='Gary'>" |
| " <meta name='keywords' content='HTML, CSS, JavaScript'>" |
| " </head>" |
| " <body>child frame</body>" |
| " \"" |
| " </iframe>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // Explicitly set the content of the nullcontent meta tag to the null atom to |
| // test this case. |
| auto& document = *helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| document.getElementById(AtomicString("nullcontent")) |
| ->setAttribute(html_names::kContentAttr, g_null_atom); |
| |
| auto options = mojom::blink::AIPageContentOptions::New(); |
| options->max_meta_elements = 32; |
| GetAIPageContent(std::move(options)); |
| |
| EXPECT_EQ(Content()->frame_data->meta_data.size(), 5u); |
| |
| EXPECT_EQ(Content()->frame_data->meta_data[0]->name, "author"); |
| EXPECT_EQ(Content()->frame_data->meta_data[0]->content, "George"); |
| |
| EXPECT_EQ(Content()->frame_data->meta_data[1]->name, "keywords"); |
| EXPECT_EQ(Content()->frame_data->meta_data[1]->content, |
| "HTML, CSS, JavaScript"); |
| |
| EXPECT_EQ(Content()->frame_data->meta_data[2]->name, "nocontent"); |
| EXPECT_EQ(Content()->frame_data->meta_data[3]->content, ""); |
| |
| EXPECT_EQ(Content()->frame_data->meta_data[3]->name, "emptycontent"); |
| EXPECT_EQ(Content()->frame_data->meta_data[3]->content, ""); |
| |
| EXPECT_EQ(Content()->frame_data->meta_data[4]->name, "nullcontent"); |
| EXPECT_EQ(Content()->frame_data->meta_data[4]->content, ""); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& iframe = *root.children_nodes[0]; |
| EXPECT_EQ(iframe.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kIframe); |
| |
| const auto& iframe_data = *iframe.content_attributes->iframe_data; |
| |
| EXPECT_TRUE(iframe.content_attributes->iframe_data->content); |
| EXPECT_EQ(iframe_data.content->get_local_frame_data()->meta_data.size(), 2u); |
| EXPECT_EQ(iframe_data.content->get_local_frame_data()->meta_data[0]->name, |
| "author"); |
| EXPECT_EQ(iframe_data.content->get_local_frame_data()->meta_data[0]->content, |
| "Gary"); |
| |
| EXPECT_EQ(iframe_data.content->get_local_frame_data()->meta_data[1]->name, |
| "keywords"); |
| EXPECT_EQ(iframe_data.content->get_local_frame_data()->meta_data[1]->content, |
| "HTML, CSS, JavaScript"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, NestedIframesMetaTags) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<head><meta name=author content=George></head>" |
| "<body>parent" |
| " <iframe srcdoc=\"" |
| " <head><meta name=author content=Gary></head>" |
| " <body>child" |
| " <iframe srcdoc='" |
| " <head><meta name=author content=Jordan></head>" |
| " <body>grandchild</body" |
| " '></iframe>" |
| " </body>" |
| " \"></iframe>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto options = mojom::blink::AIPageContentOptions::New(); |
| options->max_meta_elements = 32; |
| GetAIPageContent(std::move(options)); |
| |
| EXPECT_EQ(Content()->frame_data->meta_data.size(), 1u); |
| |
| EXPECT_EQ(Content()->frame_data->meta_data[0]->name, "author"); |
| EXPECT_EQ(Content()->frame_data->meta_data[0]->content, "George"); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& iframe = *root.children_nodes[1]; |
| EXPECT_EQ(iframe.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kIframe); |
| |
| const auto& iframe_data = *iframe.content_attributes->iframe_data; |
| EXPECT_TRUE(iframe_data.content); |
| EXPECT_EQ(iframe_data.content->get_local_frame_data()->meta_data.size(), 1u); |
| |
| EXPECT_EQ(iframe_data.content->get_local_frame_data()->meta_data[0]->name, |
| "author"); |
| EXPECT_EQ(iframe_data.content->get_local_frame_data()->meta_data[0]->content, |
| "Gary"); |
| |
| EXPECT_EQ(iframe.children_nodes.size(), 1u); |
| |
| // In the iframe children_nodes there is a root node that has two children. |
| // The first child is a text node and the second is the subiframe. The key |
| // thing we want to check here is that the subiframe has the correct metadata. |
| const auto& subiframe = *iframe.children_nodes[0]->children_nodes[1]; |
| EXPECT_EQ(subiframe.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kIframe); |
| |
| const auto& subiframe_data = *subiframe.content_attributes->iframe_data; |
| EXPECT_TRUE(subiframe_data.content); |
| EXPECT_EQ(subiframe_data.content->get_local_frame_data()->meta_data.size(), |
| 1u); |
| |
| EXPECT_EQ(subiframe_data.content->get_local_frame_data()->meta_data[0]->name, |
| "author"); |
| EXPECT_EQ( |
| subiframe_data.content->get_local_frame_data()->meta_data[0]->content, |
| "Jordan"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, NodeIdAllowlist_DefaultModeTypePolicy) { |
| // This page has a paragraph with a text child. It gives us a simple shape to |
| // verify that type-based node-id policy does not implicitly propagate ids to |
| // descendants. |
| LoadNodeIdPolicyParagraphFixture(); |
| |
| GetAIPageContent(CreateNodeIdPolicyOptionsForTest( |
| {mojom::blink::AIPageContentAttributeType::kParagraph})); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& paragraph = *root.children_nodes[0]; |
| EXPECT_EQ(paragraph.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kParagraph); |
| ASSERT_TRUE(paragraph.content_attributes->dom_node_id.has_value()); |
| EXPECT_GT(*paragraph.content_attributes->dom_node_id, kInvalidDOMNodeId); |
| |
| ASSERT_EQ(paragraph.children_nodes.size(), 1u); |
| const auto& text = *paragraph.children_nodes[0]; |
| EXPECT_EQ(text.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kText); |
| EXPECT_FALSE(text.content_attributes->dom_node_id.has_value()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| NodeIdAllowlist_UnsetOptionsPreserveLegacyIdEmission) { |
| // If `node_id_allowlist` is unset, APC should preserve legacy broad emission. |
| LoadNodeIdPolicyParagraphFixture(); |
| |
| GetAIPageContent(GetAIPageContentOptionsForTest()); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& paragraph = *root.children_nodes[0]; |
| ASSERT_TRUE(paragraph.content_attributes->dom_node_id.has_value()); |
| |
| ASSERT_EQ(paragraph.children_nodes.size(), 1u); |
| const auto& text = *paragraph.children_nodes[0]; |
| ASSERT_TRUE(text.content_attributes->dom_node_id.has_value()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| NodeIdAllowlist_EmptyOptionsSuppressTypeBasedIds) { |
| // With explicit but empty options, regular structural nodes should not emit |
| // ids. The APC root still needs one so later metadata can point back to it. |
| LoadNodeIdPolicyParagraphFixture(); |
| |
| GetAIPageContent(CreateNodeIdPolicyOptionsForTest()); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_TRUE(root.content_attributes); |
| ASSERT_TRUE(root.content_attributes->dom_node_id.has_value()); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& paragraph = *root.children_nodes[0]; |
| EXPECT_FALSE(paragraph.content_attributes->dom_node_id.has_value()); |
| |
| ASSERT_EQ(paragraph.children_nodes.size(), 1u); |
| const auto& text = *paragraph.children_nodes[0]; |
| EXPECT_FALSE(text.content_attributes->dom_node_id.has_value()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| NodeIdAllowlist_EmptyOptionsDoNotGenerateIdForSuppressedTextNode) { |
| // Build a simple paragraph dynamically and verify APC does not generate a |
| // DOM id for its text node when empty node-id options suppress output ids. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), "<body></body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| ASSERT_TRUE(document->body()); |
| |
| auto* paragraph = document->CreateRawElement(html_names::kPTag); |
| paragraph->setAttribute(html_names::kIdAttr, AtomicString("dynamic_p")); |
| auto* text_node = document->createTextNode("dynamic paragraph text"); |
| paragraph->appendChild(text_node); |
| document->body()->appendChild(paragraph); |
| |
| // Precondition: this test is only meaningful if APC starts from an idless |
| // text node. |
| ASSERT_EQ(DOMNodeIds::ExistingIdForNode(text_node), kInvalidDOMNodeId); |
| |
| GetAIPageContent(CreateNodeIdPolicyOptionsForTest()); |
| |
| // The text node is suppressed by policy, so APC must not generate its id. |
| EXPECT_EQ(DOMNodeIds::ExistingIdForNode(text_node), kInvalidDOMNodeId); |
| |
| // Keep the output-side assertion as an additional behavior guard. |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& output_paragraph = *root.children_nodes[0]; |
| ASSERT_EQ(output_paragraph.children_nodes.size(), 1u); |
| const auto& output_text = *output_paragraph.children_nodes[0]; |
| EXPECT_FALSE(output_text.content_attributes->dom_node_id.has_value()); |
| } |
| |
| TEST_F( |
| AIPageContentAgentTest, |
| NodeIdAllowlist_AllowlistedParentDoesNotGenerateIdForSuppressedTextNode) { |
| // The parent paragraph is allowlisted and may emit its id. The text child is |
| // still suppressed and must remain idless before and after APC extraction. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), "<body></body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| ASSERT_TRUE(document->body()); |
| |
| auto* paragraph = document->CreateRawElement(html_names::kPTag); |
| paragraph->setTextContent("allowlisted parent text"); |
| auto* text_node = paragraph->firstChild(); |
| ASSERT_TRUE(text_node); |
| |
| document->body()->appendChild(paragraph); |
| ASSERT_EQ(DOMNodeIds::ExistingIdForNode(text_node), kInvalidDOMNodeId); |
| |
| GetAIPageContent(CreateNodeIdPolicyOptionsForTest( |
| {mojom::blink::AIPageContentAttributeType::kParagraph})); |
| |
| EXPECT_EQ(DOMNodeIds::ExistingIdForNode(text_node), kInvalidDOMNodeId); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& output_paragraph = *root.children_nodes[0]; |
| ASSERT_TRUE(output_paragraph.content_attributes->dom_node_id.has_value()); |
| ASSERT_EQ(output_paragraph.children_nodes.size(), 1u); |
| const auto& output_text = *output_paragraph.children_nodes[0]; |
| EXPECT_FALSE(output_text.content_attributes->dom_node_id.has_value()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, NodeIdAllowlist_ActionableNodesAlwaysShowId) { |
| // Action execution depends on ids for actionable targets. This override |
| // should apply even if the type allowlist is empty. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <button id='button'>button</button>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(CreateNodeIdPolicyOptionsForTest( |
| mojom::blink::AIPageContentMode::kActionableElements)); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& button = *root.children_nodes[0]; |
| ASSERT_TRUE(button.content_attributes->node_interaction_info); |
| ASSERT_TRUE(button.content_attributes->dom_node_id.has_value()); |
| EXPECT_GT(*button.content_attributes->dom_node_id, kInvalidDOMNodeId); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| NodeIdAllowlist_AnchoredOffscreenActionableNodeLosesActionableState) { |
| // A fixed popup item parked below the viewport is not reachable by |
| // scrolling. It should therefore lose actionable metadata even if earlier |
| // output-policy decisions already caused APC to mint a DOM id for it. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <button id='trigger'>Open sizes</button>" |
| " <div id='sheet' style='position: fixed; left: 0; right: 0; bottom: 0;" |
| " transform: translateY(100%);'>" |
| " <button id='item'>Size 6.5</button>" |
| " </div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(CreateNodeIdPolicyOptionsForTest( |
| mojom::blink::AIPageContentMode::kActionableElements)); |
| |
| const auto* trigger_node = FindNodeBySelector("#trigger"); |
| ASSERT_TRUE(trigger_node); |
| ASSERT_TRUE(trigger_node->content_attributes->node_interaction_info); |
| ASSERT_TRUE(trigger_node->content_attributes->dom_node_id.has_value()); |
| |
| const auto* item_node = |
| FindFormControlNodeWithTextSubstring(ContentRootNode(), "Size 6.5"); |
| ASSERT_TRUE(item_node); |
| EXPECT_FALSE(item_node->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTest, NodeIdAllowlist_FocusedNodeAlwaysShowsId) { |
| // Focus metadata is consumed browser-side. The focused node must remain |
| // id-backed even with an empty allowlist. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <input id='focused_input' value='x'>" |
| " <p id='paragraph'>visible paragraph text</p>" |
| " <script>" |
| " document.getElementById('focused_input').focus();" |
| " </script>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(CreateNodeIdPolicyOptionsForTest()); |
| |
| const auto& page_interaction_info = Content()->page_interaction_info; |
| ASSERT_TRUE(page_interaction_info->focused_dom_node_id.has_value()); |
| EXPECT_GT(*page_interaction_info->focused_dom_node_id, kInvalidDOMNodeId); |
| |
| const mojom::blink::AIPageContentNode* focused_node = |
| FindNodeByDomNodeId(*page_interaction_info->focused_dom_node_id); |
| ASSERT_TRUE(focused_node); |
| ASSERT_TRUE(focused_node->content_attributes->dom_node_id.has_value()); |
| EXPECT_EQ(*focused_node->content_attributes->dom_node_id, |
| *page_interaction_info->focused_dom_node_id); |
| |
| // Non-focused nodes should continue to suppress ids under empty allowlist |
| // policy. |
| ExpectSelectorNotInApcOutput("#paragraph"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, NodeIdAllowlist_LabelForTargetAlwaysShowsId) { |
| // `label_for_dom_node_id` is a metadata edge. The referenced control must |
| // still emit a node id so browser-side linking remains valid. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <label for='name_input' id='name_label'>Name</label>" |
| " <input id='name_input' value='Ada'>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(CreateNodeIdPolicyOptionsForTest( |
| mojom::blink::AIPageContentMode::kActionableElements)); |
| |
| const auto* label_node = FindNodeBySelector("#name_label"); |
| ASSERT_TRUE(label_node); |
| ASSERT_TRUE( |
| label_node->content_attributes->label_for_dom_node_id.has_value()); |
| |
| const DOMNodeId target_dom_node_id = |
| *label_node->content_attributes->label_for_dom_node_id; |
| const auto* target_node = FindNodeByDomNodeId(target_dom_node_id); |
| ASSERT_TRUE(target_node); |
| ASSERT_TRUE(target_node->content_attributes->dom_node_id.has_value()); |
| EXPECT_EQ(*target_node->content_attributes->dom_node_id, target_dom_node_id); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| NodeIdAllowlist_LabelTargetShowsIdWhenLabelFollowsControl) { |
| // The label can appear after its target control in layout order. |
| // The target must still remain id-backed for label metadata round-trips. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <input id='name_input' value='Ada'>" |
| " <label for='name_input' id='name_label'>Name</label>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(CreateNodeIdPolicyOptionsForTest( |
| mojom::blink::AIPageContentMode::kActionableElements)); |
| |
| const auto* label_node = FindNodeBySelector("#name_label"); |
| ASSERT_TRUE(label_node); |
| ASSERT_TRUE( |
| label_node->content_attributes->label_for_dom_node_id.has_value()); |
| |
| const DOMNodeId target_dom_node_id = |
| *label_node->content_attributes->label_for_dom_node_id; |
| const auto* target_node = FindNodeByDomNodeId(target_dom_node_id); |
| ASSERT_TRUE(target_node); |
| ASSERT_TRUE(target_node->content_attributes->dom_node_id.has_value()); |
| EXPECT_EQ(*target_node->content_attributes->dom_node_id, target_dom_node_id); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| NodeIdAllowlist_AccessibilityFocusedNodeAlwaysShowsId) { |
| // Accessibility focus should force id emission even when type policy would |
| // otherwise suppress ids. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <button id='button1'>button1</button>" |
| " <div id='div2'>div2</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| ui::AXMode ax_mode = ui::kAXModeComplete; |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| auto context = std::make_unique<AXContext>(*document, ax_mode); |
| auto* ax_object_cache = |
| To<AXObjectCacheImpl>(document->ExistingAXObjectCache()); |
| ASSERT_TRUE(ax_object_cache); |
| ax_object_cache->UpdateAXForAllDocuments(); |
| auto* button_element = document->getElementById(AtomicString("button1")); |
| ASSERT_TRUE(button_element); |
| auto* button_ax_object = ax_object_cache->Get(button_element); |
| ASSERT_TRUE(button_ax_object); |
| ui::AXActionData action_data; |
| action_data.action = ax::mojom::blink::Action::kSetAccessibilityFocus; |
| button_ax_object->PerformAction(action_data); |
| |
| GetAIPageContent(CreateNodeIdPolicyOptionsForTest()); |
| |
| const auto& page_interaction_info = Content()->page_interaction_info; |
| ASSERT_TRUE( |
| page_interaction_info->accessibility_focused_dom_node_id.has_value()); |
| EXPECT_GT(*page_interaction_info->accessibility_focused_dom_node_id, |
| kInvalidDOMNodeId); |
| |
| const mojom::blink::AIPageContentNode* focused_node = FindNodeByDomNodeId( |
| *page_interaction_info->accessibility_focused_dom_node_id); |
| ASSERT_TRUE(focused_node); |
| ASSERT_TRUE(focused_node->content_attributes->dom_node_id.has_value()); |
| |
| // Non-focused nodes should continue to suppress ids under empty allowlist |
| // policy. |
| ExpectSelectorNotInApcOutput("#div2"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, NodeIdAllowlist_SelectionNodesAlwaysShowId) { |
| // Selection metadata references start/end DOM nodes and must remain |
| // round-trippable even when the policy allowlist is empty. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p id='p1'>Paragraph 1</p>" |
| " <p id='p2'>Paragraph 2</p>" |
| " <p id='p3'>Paragraph 3</p>" |
| " <script>" |
| " const p1 = document.getElementById('p1');" |
| " const p2 = document.getElementById('p2');" |
| " const range = new Range();" |
| " range.setStart(p1.childNodes[0], 10);" |
| " range.setEnd(p2.childNodes[0], 9);" |
| " const selection = window.getSelection();" |
| " selection.removeAllRanges();" |
| " selection.addRange(range);" |
| " </script>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(CreateNodeIdPolicyOptionsForTest()); |
| |
| const auto& frame_interaction_info = |
| Content()->frame_data->frame_interaction_info; |
| ASSERT_TRUE(frame_interaction_info->selection); |
| const auto& selection = *frame_interaction_info->selection; |
| |
| EXPECT_GT(selection.start_dom_node_id, kInvalidDOMNodeId); |
| EXPECT_GT(selection.end_dom_node_id, kInvalidDOMNodeId); |
| |
| const auto* start_node = FindNodeByDomNodeId(selection.start_dom_node_id); |
| ASSERT_TRUE(start_node); |
| ASSERT_TRUE(start_node->content_attributes->dom_node_id.has_value()); |
| |
| const auto* end_node = FindNodeByDomNodeId(selection.end_dom_node_id); |
| ASSERT_TRUE(end_node); |
| ASSERT_TRUE(end_node->content_attributes->dom_node_id.has_value()); |
| |
| // Nodes unrelated to the selection should continue to suppress ids. |
| ExpectSelectorNotInApcOutput("#p3"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| NodeIdAllowlist_DefaultModeMultipleAllowlistedTypes) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <h1 id='heading'>Visible heading text</h1>" |
| " <p id='paragraph'>Visible paragraph text</p>" |
| " <div id='container'>Visible container text</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(CreateNodeIdPolicyOptionsForTest( |
| {mojom::blink::AIPageContentAttributeType::kParagraph, |
| mojom::blink::AIPageContentAttributeType::kHeading})); |
| |
| const auto* heading_node = FindNodeBySelector("#heading"); |
| ASSERT_TRUE(heading_node); |
| ASSERT_TRUE(heading_node->content_attributes->dom_node_id.has_value()); |
| EXPECT_GT(*heading_node->content_attributes->dom_node_id, kInvalidDOMNodeId); |
| |
| const auto* paragraph_node = FindNodeBySelector("#paragraph"); |
| ASSERT_TRUE(paragraph_node); |
| ASSERT_TRUE(paragraph_node->content_attributes->dom_node_id.has_value()); |
| EXPECT_GT(*paragraph_node->content_attributes->dom_node_id, |
| kInvalidDOMNodeId); |
| |
| ExpectSelectorNotInApcOutput("#container"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, Title) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<head>" |
| " <title>test title</title>" |
| "</head>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| EXPECT_EQ(Content()->frame_data->title, "test title"); |
| } |
| |
| bool ContainsRole(const Vector<mojom::blink::AIPageContentAnnotatedRole>& roles, |
| mojom::blink::AIPageContentAnnotatedRole role) { |
| for (const auto& r : roles) { |
| if (r == role) { |
| return true; |
| } |
| } |
| return false; |
| } |
| |
| TEST_F(AIPageContentAgentTest, PaidContent) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"HTML( |
| <head> |
| <script></script> |
| <script type='unrelated'></script> |
| <script type="application/ld+json">{this: "will fail parsing",}</script> |
| <script type="application/ld+json">"not": "an object"</script> |
| <script type="application/ld+json">{ |
| "@context": "http://schema.org", |
| "@type": "NewsArticle", |
| "mainEntityOfPage": "https://www.evergreengazette.com/world/world-news/", |
| "headline": "City Council Debates Future of Automated Transit System", |
| "alternativeHeadline": "City Council Debates Future of Automated Transit System", |
| "dateModified": "2025-03-25T19:17:05.541Z", |
| "datePublished": "2025-03-25T09:02:58.131Z", |
| "description": "The City Council has been asked to discuss the future of automated transit systems, including the feasibility of a bus-on-rails system, in a special meeting on Thursday, March 28.", |
| "author": [ |
| { |
| "@type": "Person", |
| "name": "Finlay Joy", |
| "url": "https://www.evergreengazette.com/people/finlay-joy/" |
| }, |
| { |
| "@type": "Person", |
| "name": "Calum Gerhard", |
| "url": "https://www.evergreengazette.com/people/calum-gerhard/" |
| } |
| ], |
| "isPartOf": { |
| "@type": [ |
| "CreativeWork", |
| "Product" |
| ], |
| "name": "The Evergreen Gazette", |
| "productID": "evergreengazette.com:basic", |
| "description": "The Evergreen Gazette is your trusted source for comprehensive local news, insightful analysis, and community-focused reporting.", |
| "sku": "https://subscribe.evergreengazette.com", |
| "image": "https://www.evergreengazette.com/evergreen-gazette-logo.png", |
| "brand": { |
| "@type": "brand", |
| "name": "The Evergreen Gazette" |
| }, |
| "offers": { |
| "@type": "offer", |
| "url": "https://subscribe.evergreengazette.com/acquisition?promo=h97" |
| } |
| }, |
| "publisher": { |
| "@id": "evergreengazette.com", |
| "@type": "NewsMediaOrganization", |
| "name": "The Evergreen Gazette" |
| }, |
| "isAccessibleForFree": false, |
| "hasPart": { |
| "@type": "WebPageElement", |
| "cssSelector": ".paidContent", |
| "isAccessibleForFree": false |
| } |
| }</script> |
| <body> |
| Content |
| <div class="paidContent">Paid Content</div> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| // The root node contains paid content. |
| EXPECT_TRUE(Content()->frame_data->contains_paid_content); |
| |
| const auto& root = ContentRootNode(); |
| |
| // The text node should not have the paid content role. |
| const auto& text_node = *root.children_nodes[0]; |
| EXPECT_FALSE( |
| ContainsRole(text_node.content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| |
| // The paid content node should have the paid content role. |
| const auto& paid_node = *root.children_nodes[1]; |
| EXPECT_TRUE( |
| ContainsRole(paid_node.content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, PaidContentContextMismatch) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"HTML( |
| <script type="application/ld+json">{ |
| "@context": "http://acme.org", |
| "@type": "NewsArticle", |
| "isAccessibleForFree": false, |
| "hasPart": { |
| "@type": "WebPageElement", |
| "cssSelector": ".paidContent", |
| "isAccessibleForFree": false |
| } |
| }</script> |
| <body> |
| Content |
| <div class="paidContent">Paid Content</div> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| // The root node does not contain paid content. |
| EXPECT_FALSE(Content()->frame_data->contains_paid_content); |
| |
| const auto& root = ContentRootNode(); |
| |
| // The text node should not have the paid content role. |
| const auto& text_node = *root.children_nodes[0]; |
| EXPECT_FALSE( |
| ContainsRole(text_node.content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| |
| // The paid content node should have the paid content role. |
| const auto& paid_node = *root.children_nodes[1]; |
| EXPECT_FALSE( |
| ContainsRole(paid_node.content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, PaidContentRootOnly) { |
| // Note that isAccessibleForFree = "False" to match real world examples. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"HTML( |
| <script type="application/ld+json">{ |
| "@context": "http://schema.org", |
| "@type": "NewsArticle", |
| "isAccessibleForFree": "False", |
| "hasPart": { |
| "@type": "unrelated" |
| } |
| }</script> |
| <body> |
| Content |
| <div class="paidContent">Paid Content</div> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| // The root node contains paid content. |
| EXPECT_TRUE(Content()->frame_data->contains_paid_content); |
| |
| const auto& root = ContentRootNode(); |
| |
| // The text node should not have the paid content role. |
| const auto& text_node = *root.children_nodes[0]; |
| EXPECT_FALSE( |
| ContainsRole(text_node.content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| |
| // The paid content node should have the paid content role. |
| const auto& paid_node = *root.children_nodes[1]; |
| EXPECT_FALSE( |
| ContainsRole(paid_node.content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, PaidContentMicrodata) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"HTML( |
| <script type="application/ld+json">{ |
| "@context": "http://schema.org", |
| "@type": "NewsArticle", |
| "isAccessibleForFree": false |
| }</script> |
| <body> |
| Content |
| <div class="paidContent"> |
| <meta itemprop="isAccessibleForFree" content="false"> |
| Paid Content |
| </div> |
| <div class="paidContent"> |
| <meta itemprop="unrelated"> |
| Content |
| </div> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| // The root node contains paid content. |
| EXPECT_TRUE(Content()->frame_data->contains_paid_content); |
| |
| const auto& root = ContentRootNode(); |
| |
| // The text node should not have the paid content role. |
| const auto& text_node = *root.children_nodes[0]; |
| EXPECT_FALSE( |
| ContainsRole(text_node.content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| |
| // The paid content node should have the paid content role. |
| const auto& paid_node = *root.children_nodes[1]; |
| EXPECT_TRUE( |
| ContainsRole(paid_node.content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, PaidContentSomeYesSomeNo) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"HTML( |
| <script type="application/ld+json">{ |
| "@context": "http://schema.org", |
| "@type": "NewsArticle", |
| "isAccessibleForFree": false, |
| "hasPart": { |
| "@type": "WebPageElement", |
| "cssSelector": ".paidContent", |
| "isAccessibleForFree": false |
| } |
| }</script> |
| <body> |
| Content |
| <div class="paidContent">Paid Content</div> |
| <div>Free Content</div> |
| <div class="paidContent">Paid Content</div> |
| <div>Free Content</div> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| // The root node contains paid content. |
| EXPECT_TRUE(Content()->frame_data->contains_paid_content); |
| |
| const auto& root = ContentRootNode(); |
| |
| auto& nodes = root.children_nodes; |
| |
| // Every other node should have the paid content role. |
| EXPECT_FALSE( |
| ContainsRole(nodes[0]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| EXPECT_TRUE( |
| ContainsRole(nodes[1]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| EXPECT_FALSE( |
| ContainsRole(nodes[2]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| EXPECT_TRUE( |
| ContainsRole(nodes[3]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| EXPECT_FALSE( |
| ContainsRole(nodes[4]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, PaidContentMultipleHasParts) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"HTML( |
| <script type="application/ld+json">{ |
| "@context": "https://schema.org", |
| "@type": "NewsArticle", |
| "mainEntityOfPage": { |
| "@type": "WebPage", |
| "@id": "https://example.org/article" |
| }, |
| "isAccessibleForFree": false, |
| "hasPart": [ |
| { |
| "@type": "WebPageElement", |
| "isAccessibleForFree": false, |
| "cssSelector": ".section1" |
| }, { |
| "@type": "WebPageElement", |
| "isAccessibleForFree": false, |
| "cssSelector": ".section2" |
| } |
| ] |
| }</script> |
| <body> |
| Content |
| <div class="section1">Paid Content</div> |
| <div class="section2">Paid Content</div> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| // The root node contains paid content. |
| EXPECT_TRUE(Content()->frame_data->contains_paid_content); |
| |
| const auto& root = ContentRootNode(); |
| |
| auto& nodes = root.children_nodes; |
| EXPECT_FALSE( |
| ContainsRole(nodes[0]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| EXPECT_TRUE( |
| ContainsRole(nodes[1]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| EXPECT_TRUE( |
| ContainsRole(nodes[2]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, PaidContentSubframe) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"HTML( |
| <body> |
| Parent doc is free! |
| <iframe srcdoc=' |
| <script type="application/ld+json">{ |
| "@context": "http://schema.org", |
| "@type": "NewsArticle", |
| "isAccessibleForFree": false, |
| "hasPart": { |
| "@type": "WebPageElement", |
| "cssSelector": ".paidContent", |
| "isAccessibleForFree": false |
| } |
| }</script> |
| <body> |
| Content |
| <div class="paidContent">Paid Content</div> |
| </body> |
| '></iframe> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| // The root node does not contain paid content. |
| EXPECT_FALSE(Content()->frame_data->contains_paid_content); |
| |
| const auto& root = ContentRootNode(); |
| auto& nodes = root.children_nodes; |
| |
| EXPECT_FALSE( |
| ContainsRole(nodes[0]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| |
| const auto& iframe = nodes[1]; |
| EXPECT_EQ(iframe->content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kIframe); |
| EXPECT_TRUE(iframe->content_attributes->iframe_data->content); |
| EXPECT_TRUE( |
| iframe->content_attributes->iframe_data->content->get_local_frame_data() |
| ->contains_paid_content); |
| |
| auto& children = iframe->children_nodes[0]->children_nodes; |
| EXPECT_FALSE( |
| ContainsRole(children[0]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| EXPECT_TRUE( |
| ContainsRole(children[1]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, PaidContentSubframeMicrodata) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"HTML( |
| <script type="application/ld+json">{ |
| "@context": "https://schema.org", |
| "@type": "NewsArticle", |
| "isAccessibleForFree": true |
| }</script> |
| <body> |
| Free Content |
| <div class="paidContent"> |
| <meta itemprop="isAccessibleForFree" content="false"> |
| Microdata not checked |
| </div> |
| <iframe srcdoc=' |
| <script type="application/ld+json">{ |
| "@context": "http://schema.org", |
| "@type": "NewsArticle", |
| "isAccessibleForFree": false |
| }</script> |
| <body> |
| Content |
| <div class="paidContent"> |
| <meta itemprop="isAccessibleForFree" content="false"> |
| Paid Content |
| </div> |
| </body> |
| '></iframe> |
| <iframe srcdoc=' |
| <body> |
| Content |
| <div class="paidContent"> |
| <meta itemprop="isAccessibleForFree" content="false"> |
| Microdata not checked |
| </div> |
| </body> |
| '></iframe> |
| <iframe srcdoc=' |
| <script type="application/ld+json">{ |
| "@context": "http://schema.org", |
| "@type": "NewsArticle", |
| "isAccessibleForFree": false |
| }</script> |
| <body> |
| Content |
| <div class="paidContent"> |
| <meta itemprop="isAccessibleForFree" content="false"> |
| Paid Content |
| </div> |
| </body> |
| '></iframe> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| // The root node does not contain paid content. |
| EXPECT_FALSE(Content()->frame_data->contains_paid_content); |
| |
| const auto& root = ContentRootNode(); |
| auto& nodes = root.children_nodes; |
| |
| EXPECT_FALSE( |
| ContainsRole(nodes[0]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| EXPECT_FALSE( |
| ContainsRole(nodes[1]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| |
| const auto& iframe1 = nodes[2]; |
| EXPECT_EQ(iframe1->content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kIframe); |
| EXPECT_TRUE(iframe1->content_attributes->iframe_data->content); |
| EXPECT_TRUE( |
| iframe1->content_attributes->iframe_data->content->get_local_frame_data() |
| ->contains_paid_content); |
| |
| const auto& children1 = iframe1->children_nodes[0]->children_nodes; |
| EXPECT_FALSE( |
| ContainsRole(children1[0]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| EXPECT_TRUE( |
| ContainsRole(children1[1]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| |
| const auto& iframe2 = nodes[3]; |
| EXPECT_EQ(iframe2->content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kIframe); |
| EXPECT_TRUE(iframe2->content_attributes->iframe_data->content); |
| EXPECT_FALSE( |
| iframe2->content_attributes->iframe_data->content->get_local_frame_data() |
| ->contains_paid_content); |
| |
| const auto& children2 = iframe2->children_nodes[0]->children_nodes; |
| EXPECT_FALSE( |
| ContainsRole(children2[0]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| EXPECT_FALSE( |
| ContainsRole(children2[1]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| |
| const auto& iframe3 = nodes[4]; |
| EXPECT_EQ(iframe3->content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kIframe); |
| EXPECT_TRUE(iframe3->content_attributes->iframe_data->content); |
| EXPECT_TRUE( |
| iframe3->content_attributes->iframe_data->content->get_local_frame_data() |
| ->contains_paid_content); |
| |
| const auto& children3 = iframe3->children_nodes[0]->children_nodes; |
| EXPECT_FALSE( |
| ContainsRole(children3[0]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| EXPECT_TRUE( |
| ContainsRole(children3[1]->content_attributes->annotated_roles, |
| mojom::blink::AIPageContentAnnotatedRole::kPaidContent)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AnchorInInlineWithFloatingSibling) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<!DOCTYPE html>" |
| "<body style='margin:0; font: 1px/1px Ahem'>" |
| " <span>" |
| " <a href='https://www.google.com'>" |
| " <div style='position: relative; float: left;'>text in div</div>" |
| " <span>text</span>" |
| " </a>" |
| " </span>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| LoadAhem(); |
| GetAIPageContentWithActionableElements(); |
| |
| const mojom::blink::AIPageContentNode* anchor = FindNodeBySelector("a"); |
| ASSERT_TRUE(anchor->content_attributes->geometry); |
| CheckAnchorNode(*anchor, blink::KURL("https://www.google.com/"), {}); |
| ASSERT_TRUE(anchor->content_attributes->node_interaction_info); |
| EXPECT_TRUE(anchor->content_attributes->node_interaction_info |
| ->document_scoped_z_order); |
| CheckGeometry(*anchor, gfx::Rect(11, 0, 4, 1), gfx::Rect(11, 0, 4, 1)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, OverflowHiddenGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div style='width: 100px; height: 100px; overflow-y: hidden;'>" |
| " <article style='width: 50px; height: 300px;'></article>" |
| " </div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& outer = ContentRootNode().children_nodes[0]; |
| const auto& article = outer->children_nodes[0]; |
| CheckAnnotatedRole(*article, |
| mojom::blink::AIPageContentAnnotatedRole::kArticle); |
| |
| EXPECT_GT(*article->content_attributes->node_interaction_info |
| ->document_scoped_z_order, |
| *outer->content_attributes->node_interaction_info |
| ->document_scoped_z_order); |
| |
| CheckGeometry(*outer, gfx::Rect(8, 8, 100, 100), gfx::Rect(8, 8, 100, 100)); |
| CheckGeometry(*article, gfx::Rect(8, 8, 50, 300), gfx::Rect(8, 8, 50, 100)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, OverflowVisibleGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <section style='width: 100px; height: 100px; overflow-y: visible;'>" |
| " <article style='width: 50px; height: 300px;'></article>" |
| " </section>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& outer = ContentRootNode().children_nodes[0]; |
| const auto& article = outer->children_nodes[0]; |
| CheckAnnotatedRole(*article, |
| mojom::blink::AIPageContentAnnotatedRole::kArticle); |
| |
| EXPECT_GT(*article->content_attributes->node_interaction_info |
| ->document_scoped_z_order, |
| *outer->content_attributes->node_interaction_info |
| ->document_scoped_z_order); |
| |
| CheckGeometry(*outer, gfx::Rect(8, 8, 100, 100), gfx::Rect(8, 8, 100, 100)); |
| CheckGeometry(*article, gfx::Rect(8, 8, 50, 300), gfx::Rect(8, 8, 50, 300)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, BlurGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <section style='width: 100px; height: 100px; filter: " |
| "blur(10px);'></section>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& section = ContentRootNode().children_nodes[0]; |
| CheckAnnotatedRole(*section, |
| mojom::blink::AIPageContentAnnotatedRole::kSection); |
| |
| // Although blurring causes the rectangle to show outside of the 100x100 rect, |
| // the extra area is not hit testable, and is therefore not included in the |
| // visible bounding box. |
| CheckGeometry(*section, gfx::Rect(8, 8, 100, 100), gfx::Rect(8, 8, 100, 100)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, GeomtryAbsPos) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <section style='width: 100px; height: 100px; position: absolute; top: " |
| "200px; left: 200px;'>" |
| "</section>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& section = ContentRootNode().children_nodes[0]; |
| CheckAnnotatedRole(*section, |
| mojom::blink::AIPageContentAnnotatedRole::kSection); |
| |
| CheckGeometry(*section, gfx::Rect(200, 200, 100, 100), |
| gfx::Rect(200, 200, 100, 100)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, GeometryTransform) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <section style='width: 100px; height: 100px; transform: " |
| "translate(200px, 200px)'>" |
| "</section>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& section = ContentRootNode().children_nodes[0]; |
| CheckAnnotatedRole(*section, |
| mojom::blink::AIPageContentAnnotatedRole::kSection); |
| |
| CheckGeometry(*section, gfx::Rect(208, 208, 100, 100), |
| gfx::Rect(208, 208, 100, 100)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, CursorForClickability) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div style='cursor: pointer'>" |
| " <p>no-click</p>" |
| " <p style='cursor: pointer'>click</p>" |
| " </div>" |
| " <article>article</article>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| EXPECT_EQ(ContentRootNode().children_nodes.size(), 2u); |
| |
| const auto& cursor = *ContentRootNode().children_nodes[0]; |
| EXPECT_TRUE(cursor.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(cursor, {ClickabilityReason::kCursorPointer}); |
| |
| const auto& no_click = *cursor.children_nodes[0]; |
| EXPECT_TRUE(no_click.content_attributes->node_interaction_info); |
| CheckHitTestableButNotInteractive(no_click); |
| |
| const auto& click = *cursor.children_nodes[1]; |
| EXPECT_TRUE(click.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(click, {ClickabilityReason::kCursorPointer}); |
| |
| const auto& article = *ContentRootNode().children_nodes[1]; |
| EXPECT_TRUE(article.content_attributes->node_interaction_info); |
| CheckHitTestableButNotInteractive(article); |
| } |
| |
| TEST_F(AIPageContentAgentTest, LinkForClickability) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <a href='test.com'>valid</a>" |
| " <a>invalid</a>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| EXPECT_EQ(ContentRootNode().children_nodes.size(), 2u); |
| |
| const auto& valid = *ContentRootNode().children_nodes[0]; |
| EXPECT_TRUE(valid.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(valid, {ClickabilityReason::kCursorPointer}); |
| |
| const auto& invalid = *ContentRootNode().children_nodes[1]; |
| EXPECT_TRUE(invalid.content_attributes->node_interaction_info); |
| CheckHitTestableButNotInteractive(invalid); |
| } |
| |
| TEST_F(AIPageContentAgentTest, LabelWithForSibling) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <input type='checkbox' id='myCheckbox' />" |
| " <label for='myCheckbox'>Check me!</label>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& input = *root.children_nodes[0]; |
| CheckFormControlNode(input, mojom::blink::FormControlType::kInputCheckbox); |
| ASSERT_TRUE(input.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(input, |
| {ClickabilityReason::kClickableControl}); |
| EXPECT_EQ(input.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kNoRedactionNecessary); |
| |
| const auto& label = *root.children_nodes[1]; |
| CheckContainerNode(label); |
| ASSERT_TRUE(label.content_attributes->node_interaction_info); |
| EXPECT_TRUE(label.content_attributes->node_interaction_info |
| ->clickability_reasons.empty()); |
| EXPECT_EQ(label.content_attributes->label_for_dom_node_id, |
| input.content_attributes->dom_node_id); |
| } |
| |
| TEST_F(AIPageContentAgentTest, LabelGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<style>body * { margin:0; padding:0; font:1px/1px 'Ahem'; }</style>" |
| "<body style='margin: 3px;'>" |
| " <label for='myCheckbox'>1234567890</label>" |
| " <input type='checkbox' id='myCheckbox' " |
| " style='width:1px;height:1px;appearance:none;'/>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| LoadAhem(); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& label = *root.children_nodes[0]; |
| CheckContainerNode(label); |
| ASSERT_TRUE(label.content_attributes->node_interaction_info); |
| EXPECT_TRUE(label.content_attributes->node_interaction_info |
| ->clickability_reasons.empty()); |
| |
| const auto& input = *root.children_nodes[1]; |
| CheckFormControlNode(input, mojom::blink::FormControlType::kInputCheckbox); |
| ASSERT_TRUE(input.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(input, |
| {ClickabilityReason::kClickableControl}); |
| EXPECT_EQ(input.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kNoRedactionNecessary); |
| |
| EXPECT_EQ(label.content_attributes->label_for_dom_node_id, |
| input.content_attributes->dom_node_id); |
| |
| ASSERT_TRUE(label.content_attributes->geometry); |
| const auto& label_geometry = *label.content_attributes->geometry; |
| // With the 1px Ahem font loaded above, each glyph occupies a 1x1 cell so the |
| // 10-character label spans exactly 10x1 CSS pixels. |
| EXPECT_EQ(label_geometry.outer_bounding_box, gfx::Rect(3, 3, 10, 1)); |
| EXPECT_EQ(label_geometry.visible_bounding_box, |
| label_geometry.outer_bounding_box); |
| } |
| |
| TEST_F(AIPageContentAgentTest, LabelWithForDescendant) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <label>" |
| " <input type='checkbox' id='myCheckbox' />" |
| "Check me!" |
| "</label>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& label = *root.children_nodes[0]; |
| EXPECT_EQ(label.children_nodes.size(), 2u); |
| CheckContainerNode(label); |
| ASSERT_TRUE(label.content_attributes->node_interaction_info); |
| CheckHitTestableButNotInteractive(label); |
| |
| const auto& input = *label.children_nodes[0]; |
| CheckFormControlNode(input, mojom::blink::FormControlType::kInputCheckbox); |
| ASSERT_TRUE(input.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(input, |
| {ClickabilityReason::kClickableControl}); |
| EXPECT_EQ(label.content_attributes->label_for_dom_node_id, |
| input.content_attributes->dom_node_id); |
| |
| CheckTextNode(*label.children_nodes[1], "Check me!"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, SVGWithText) { |
| ScopedAIPageContentIncludeSVGSubtreeForTest scoped_feature( |
| /*enabled=*/true); |
| |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <svg width='400' height='200'>" |
| " <text x='50%' y='50/%' font-size='24'>" |
| " Hello SVG Text!" |
| " </text>" |
| " </svg>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& svg = *ContentRootNode().children_nodes[0]; |
| EXPECT_EQ(svg.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kSvgRoot); |
| ASSERT_TRUE(svg.content_attributes->svg_root_data); |
| EXPECT_EQ(svg.content_attributes->svg_root_data->inner_text, |
| "Hello SVG Text!"); |
| |
| const auto& text_child = *svg.children_nodes[0]; |
| EXPECT_EQ(text_child.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kText); |
| // Note that whitespace is kept. |
| CheckTextNode(text_child, " Hello SVG Text! "); |
| } |
| |
| TEST_F(AIPageContentAgentTest, SVGWithNoText) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <svg width='400' height='200' style='content-visibility: hidden'>" |
| " <text x='50%' y='50/%' font-size='24'>" |
| " Hello SVG Text!" |
| " </text>" |
| " </svg>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& svg = *ContentRootNode().children_nodes[0]; |
| EXPECT_EQ(svg.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kSvgRoot); |
| ASSERT_TRUE(svg.content_attributes->svg_root_data); |
| EXPECT_FALSE(svg.content_attributes->svg_root_data->inner_text); |
| |
| // Only visible text nodes are extracted. |
| EXPECT_EQ(svg.children_nodes.size(), 0u); |
| } |
| |
| TEST_F(AIPageContentAgentTest, SVGSubtreeContainersAreKept) { |
| ScopedAIPageContentIncludeSVGSubtreeForTest scoped_feature( |
| /*enabled=*/true); |
| |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <svg width='400' height='200'>" |
| " <a href='example.html'>" |
| " <image/>" |
| " <rect width='10%' height='10%' fill='red'/>" |
| " <text x='50%' y='50/%' font-size='24'>" |
| " Hello SVG Text!" |
| " </text>" |
| " </a>" |
| " </svg>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| auto& document = *helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| document.getElementsByTagName(AtomicString("image")) |
| ->item(0) |
| ->setAttribute(html_names::kSrcAttr, AtomicString(kSmallImage)); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& svg = *ContentRootNode().children_nodes[0]; |
| EXPECT_EQ(svg.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kSvgRoot); |
| ASSERT_TRUE(svg.content_attributes->svg_root_data); |
| EXPECT_EQ(svg.content_attributes->svg_root_data->inner_text, |
| "Hello SVG Text!"); |
| |
| ASSERT_EQ(svg.children_nodes.size(), 1u); |
| const auto& a_child = *svg.children_nodes[0]; |
| EXPECT_EQ(a_child.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kContainer); |
| ASSERT_TRUE(a_child.content_attributes->node_interaction_info); |
| EXPECT_FALSE(a_child.content_attributes->node_interaction_info |
| ->clickability_reasons.empty()); |
| |
| ASSERT_EQ(a_child.children_nodes.size(), 3u); |
| |
| const auto& image_child = *a_child.children_nodes[0]; |
| EXPECT_EQ(image_child.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kImage); |
| |
| // Non-text, non-image elements are processed as generic containers. |
| const auto& rect_child = *a_child.children_nodes[1]; |
| EXPECT_EQ(rect_child.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kContainer); |
| |
| const auto& text_child = *a_child.children_nodes[2]; |
| EXPECT_EQ(text_child.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kText); |
| // Note that whitespace is kept. |
| CheckTextNode(text_child, " Hello SVG Text! "); |
| ASSERT_TRUE(text_child.content_attributes->node_interaction_info); |
| EXPECT_TRUE(text_child.content_attributes->node_interaction_info |
| ->clickability_reasons.empty()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, Canvas) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " canvas {" |
| " width: 200px;" |
| " height: 300px;" |
| " }" |
| " </style>" |
| " <canvas id='myCanvas' width='100' height='200'></canvas>" |
| " <script>" |
| " const canvas = document.getElementById('myCanvas');" |
| " const ctx = canvas.getContext('2d');" |
| " ctx.fillStyle = 'pink';" |
| " ctx.fillRect(0, 0, 100, 200);" |
| " </script>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& canvas = *ContentRootNode().children_nodes[0]; |
| EXPECT_EQ(canvas.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kCanvas); |
| ASSERT_TRUE(canvas.content_attributes->canvas_data); |
| EXPECT_EQ(canvas.content_attributes->canvas_data->layout_size, |
| gfx::Size(200, 300)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaLabelledBy) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='hiddenLabel1' style='display: none;'>and first</div>" |
| " <div id='hiddenLabel2' style='display: none;'>and second</div>" |
| " <input type='text' aria-labelledby='hiddenLabel1 hiddenLabel2' " |
| "aria-label='on element'/>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& input = *root.children_nodes[0]; |
| CheckFormControlNode(input, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(input.content_attributes->label, "on element and first and second"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, DisabledButton) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <button disabled>Text</button> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& button = *root.children_nodes.at(0); |
| CheckHitTestableButNotInteractive(button); |
| EXPECT_TRUE(button.content_attributes->node_interaction_info->is_disabled); |
| EXPECT_THAT( |
| button.content_attributes->node_interaction_info |
| ->interaction_disabled_reasons, |
| testing::UnorderedElementsAre(InteractionDisabledReason::kDisabled)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, InertButton) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <button inert>Text</button> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& button = *root.children_nodes.at(0); |
| EXPECT_FALSE(button.content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ActionablePseudoElements) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style> a::before { content: 'hello'; cursor: pointer;} </style>" |
| " <a href='#'></a>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| EXPECT_EQ(ContentRootNode().children_nodes.size(), 1u); |
| const auto& a = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(a.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(a, {ClickabilityReason::kCursorPointer}); |
| |
| EXPECT_EQ(a.children_nodes.size(), 1u); |
| const auto& before = *a.children_nodes[0]; |
| ASSERT_TRUE(before.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(before, {ClickabilityReason::kCursorPointer}); |
| } |
| |
| TEST_F(AIPageContentAgentTest, PseudoElementNotActionable) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style> a::before { content: 'hello';} </style>" |
| " <a href='#'></a>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| EXPECT_EQ(ContentRootNode().children_nodes.size(), 1u); |
| |
| const auto& a = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(a.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(a, {ClickabilityReason::kCursorPointer}); |
| |
| EXPECT_EQ(a.children_nodes.size(), 1u); |
| const auto& before = *a.children_nodes[0]; |
| ASSERT_TRUE(before.content_attributes->node_interaction_info); |
| CheckHitTestableButNotInteractive(before); |
| } |
| |
| TEST_F(AIPageContentAgentTest, PseudoElementNoPointerEvents) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style> a::before { content: 'hello'; pointer-events: none;} </style>" |
| " <a href='#'></a>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| EXPECT_EQ(Content()->root_node->children_nodes.size(), 1u); |
| |
| const auto& a = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(a.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(a, {ClickabilityReason::kCursorPointer}); |
| |
| EXPECT_EQ(a.children_nodes.size(), 1u); |
| const auto& text = *a.children_nodes[0]; |
| CheckTextNode(text, "hello"); |
| EXPECT_FALSE(text.content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaDisabled) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <section style='cursor: pointer' aria-disabled=true> |
| <input type=text aria-disabled=false></input> |
| </section> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| // aria-disabled is advisory, so the section keeps its normal clickability |
| // signal while also reporting why an actor may want to avoid it. |
| const auto& section = *root.children_nodes.at(0); |
| CheckContainerNode(section); |
| CheckHitTestableAndInteractive(section, {ClickabilityReason::kCursorPointer}); |
| EXPECT_FALSE(section.content_attributes->node_interaction_info->is_disabled); |
| EXPECT_THAT( |
| section.content_attributes->node_interaction_info |
| ->interaction_disabled_reasons, |
| testing::UnorderedElementsAre(InteractionDisabledReason::kAriaDisabled)); |
| |
| // The inherited reason is also advisory for descendants. A child-level |
| // aria-disabled=false does not override the ancestor's true value. |
| ASSERT_EQ(section.children_nodes.size(), 1u); |
| const auto& input = *section.children_nodes.at(0); |
| CheckHitTestableAndInteractive(input, |
| {ClickabilityReason::kClickableControl}); |
| EXPECT_FALSE(input.content_attributes->node_interaction_info->is_disabled); |
| EXPECT_THAT( |
| input.content_attributes->node_interaction_info |
| ->interaction_disabled_reasons, |
| testing::UnorderedElementsAre(InteractionDisabledReason::kAriaDisabled)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaHiddenInteractionReason) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <section aria-hidden=true> |
| <button>Text</button> |
| </section> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& section = *root.children_nodes.at(0); |
| CheckContainerNode(section); |
| ASSERT_EQ(section.children_nodes.size(), 1u); |
| |
| // aria-hidden is inherited, so the button carries the reason even though the |
| // attribute is on its section ancestor. |
| const auto& button = *section.children_nodes.at(0); |
| CheckHitTestableAndInteractive(button, |
| {ClickabilityReason::kClickableControl, |
| ClickabilityReason::kHoverPseudoClass}); |
| EXPECT_FALSE(button.content_attributes->node_interaction_info->is_disabled); |
| EXPECT_THAT( |
| button.content_attributes->node_interaction_info |
| ->interaction_disabled_reasons, |
| testing::UnorderedElementsAre(InteractionDisabledReason::kAriaHidden)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaPresentationalRoleInteractionReason) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <button role=presentation>Presentation</button> |
| <button role=none>None</button> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 2u); |
| |
| for (const auto& button : root.children_nodes) { |
| // role=presentation and role=none are synonymous ARIA roles. |
| CheckHitTestableAndInteractive(*button, |
| {ClickabilityReason::kClickableControl, |
| ClickabilityReason::kHoverPseudoClass}); |
| EXPECT_FALSE( |
| button->content_attributes->node_interaction_info->is_disabled); |
| EXPECT_THAT(button->content_attributes->node_interaction_info |
| ->interaction_disabled_reasons, |
| testing::UnorderedElementsAre( |
| InteractionDisabledReason::kAriaRolePresentational)); |
| } |
| } |
| |
| TEST_F(AIPageContentAgentTest, DisabledInheritance) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <form> |
| <fieldset disabled> |
| <button type="submit"></button> |
| </fieldset> |
| </form> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& form = *root.children_nodes.at(0); |
| CheckHitTestableButNotInteractive(form); |
| ASSERT_EQ(form.children_nodes.size(), 1u); |
| |
| const auto& fieldset = *form.children_nodes.at(0); |
| CheckHitTestableButNotInteractive(fieldset); |
| ASSERT_EQ(fieldset.children_nodes.size(), 1u); |
| EXPECT_TRUE(fieldset.content_attributes->node_interaction_info->is_disabled); |
| EXPECT_THAT( |
| fieldset.content_attributes->node_interaction_info |
| ->interaction_disabled_reasons, |
| testing::UnorderedElementsAre(InteractionDisabledReason::kDisabled)); |
| |
| const auto& button = *fieldset.children_nodes.at(0); |
| CheckHitTestableButNotInteractive(button); |
| EXPECT_TRUE(button.content_attributes->node_interaction_info->is_disabled); |
| EXPECT_THAT( |
| button.content_attributes->node_interaction_info |
| ->interaction_disabled_reasons, |
| testing::UnorderedElementsAre(InteractionDisabledReason::kDisabled)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, Fieldset) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <form> |
| <fieldset> |
| <button type="submit"></button> |
| </fieldset> |
| </form> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& form = *root.children_nodes.at(0); |
| CheckHitTestableButNotInteractive(form); |
| ASSERT_EQ(form.children_nodes.size(), 1u); |
| |
| const auto& fieldset = *form.children_nodes.at(0); |
| CheckHitTestableButNotInteractive(fieldset); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ShadowDOMInInput) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <input type=range></input> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& input = *root.children_nodes.at(0); |
| ASSERT_TRUE(input.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(input, |
| {ClickabilityReason::kClickableControl}); |
| |
| EXPECT_NE(input.children_nodes.size(), 0u); |
| const auto& shadow_div = *input.children_nodes.at(0); |
| CheckHitTestableButNotInteractive(shadow_div); |
| } |
| |
| TEST_F(AIPageContentAgentTest, DisabledOption) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <select> |
| <option value="banana">Banana</option> |
| <option value="cherry" disabled>Cherry</option> |
| </select> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& select = *root.children_nodes.at(0); |
| CheckFormControlNode(select, mojom::blink::FormControlType::kSelectOne); |
| |
| const auto& options = |
| select.content_attributes->form_control_data->select_options; |
| ASSERT_EQ(options.size(), 2u); |
| |
| const auto& banana = *options.at(0); |
| EXPECT_EQ(banana.value, "banana"); |
| EXPECT_FALSE(banana.disabled); |
| |
| const auto& cherry = *options.at(1); |
| EXPECT_EQ(cherry.value, "cherry"); |
| EXPECT_TRUE(cherry.disabled); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaRole) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <div role="button">hello</div> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& button = *root.children_nodes.at(0); |
| ASSERT_TRUE(button.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(button, {ClickabilityReason::kAriaRole}); |
| EXPECT_EQ(button.content_attributes->aria_role, |
| ax::mojom::blink::Role::kButton); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| ActionableModeKeepsInteractiveContainersButDropsEmptySpan) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <div id="outer" onclick="void(0)"> |
| <div id="option" role="option"> |
| <span id="empty"></span> |
| </div> |
| </div> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| // The outer wrapper has a click handler, so actionable mode should keep it |
| // as a generic container with click-event metadata. |
| const mojom::blink::AIPageContentNode* outer = FindNodeBySelector("#outer"); |
| ASSERT_TRUE(outer); |
| CheckContainerNode(*outer); |
| ASSERT_TRUE(outer->content_attributes->node_interaction_info); |
| EXPECT_THAT( |
| outer->content_attributes->node_interaction_info->clickability_reasons, |
| testing::Contains(ClickabilityReason::kClickEvents)); |
| |
| // The inner wrapper has role=option. APC still uses a generic container |
| // here, but actionable mode should preserve the node because the ARIA role |
| // makes it interactive. |
| const mojom::blink::AIPageContentNode* option = FindNodeBySelector("#option"); |
| ASSERT_TRUE(option); |
| CheckContainerNode(*option); |
| EXPECT_EQ(option->content_attributes->aria_role, |
| ax::mojom::blink::Role::kListBoxOption); |
| ASSERT_TRUE(option->content_attributes->node_interaction_info); |
| EXPECT_THAT( |
| option->content_attributes->node_interaction_info->clickability_reasons, |
| testing::Contains(ClickabilityReason::kAriaRole)); |
| |
| // The span has no text and no interactive signal, so APC should flatten it |
| // away instead of emitting an empty wrapper node. |
| ExpectSelectorNotInApcOutput("#empty"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, LabelNotActionable) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <input type='checkbox' id='myCheckbox' /> |
| <label for='myCheckbox' style='pointer-events: none;'>Check me!</label> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& button = *root.children_nodes.at(0); |
| ASSERT_TRUE(button.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(button, |
| {ClickabilityReason::kClickableControl}); |
| |
| const auto& label = *root.children_nodes.at(1); |
| EXPECT_FALSE(label.content_attributes->node_interaction_info); |
| EXPECT_EQ(*label.content_attributes->label_for_dom_node_id, |
| button.content_attributes->dom_node_id); |
| } |
| |
| TEST_F(AIPageContentAgentTest, SelectLabelNotActionable) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <label for="fruit-select">Choose a fruit:</label> |
| <select id="fruit-select" name="fruits"> |
| <option value="">--Please choose an option--</option> |
| <option value="apple">Apple</option> |
| <option value="banana">Banana</option> |
| </select> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& label = *root.children_nodes.at(0); |
| ASSERT_TRUE(label.content_attributes->node_interaction_info); |
| CheckHitTestableButNotInteractive(label); |
| |
| const auto& select = *root.children_nodes.at(1); |
| ASSERT_TRUE(select.content_attributes->node_interaction_info); |
| CheckHitTestableAndInteractive(select, |
| {ClickabilityReason::kClickableControl, |
| ClickabilityReason::kHoverPseudoClass}); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClickabilityReasonClickableControl) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body><button id='testButton'>Click Me</button></body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& button_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(button_node.content_attributes->node_interaction_info); |
| EXPECT_THAT( |
| button_node.content_attributes->node_interaction_info |
| ->clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kClickableControl)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClickabilityReasonClickEvents) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body><div id='testDiv'>Clickable</div>" |
| "<script>document.getElementById('testDiv').onclick = " |
| "function(){};</script>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(div_node.content_attributes->node_interaction_info); |
| EXPECT_THAT( |
| div_node.content_attributes->node_interaction_info->clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kClickEvents)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClickabilityReasonMouseHover) { |
| // An element with various mouse event listeners. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body><div id='testDiv'>Mouse Events</div>" |
| "<script>" |
| " const div = document.getElementById('testDiv');" |
| " div.onmouseover = function(){};" |
| "</script>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(div_node.content_attributes->node_interaction_info); |
| EXPECT_THAT( |
| div_node.content_attributes->node_interaction_info->clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kMouseHover)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClickabilityReasonMouseClick) { |
| // An element with various mouse event listeners. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body><div id='testDiv'>Mouse Events</div>" |
| "<script>" |
| " const div = document.getElementById('testDiv');" |
| " div.onmousedown = function(){};" |
| "</script>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(div_node.content_attributes->node_interaction_info); |
| EXPECT_THAT( |
| div_node.content_attributes->node_interaction_info->clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kMouseClick)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClickabilityReasonKeyEvents) { |
| // An element with keyboard event listeners. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body><input type='text' id='testInput'>" |
| "<script>" |
| " const input = document.getElementById('testInput');" |
| " input.onkeydown = function(){};" |
| "</script>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& input_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(input_node.content_attributes->node_interaction_info); |
| EXPECT_THAT(input_node.content_attributes->node_interaction_info |
| ->clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kKeyEvents)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClickabilityReasonEditable) { |
| // A div with contenteditable attribute. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body><div contenteditable='true'>Editable Content</div></body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(div_node.content_attributes->node_interaction_info); |
| EXPECT_THAT( |
| div_node.content_attributes->node_interaction_info->clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kEditable)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClickabilityReasonCursorPointer) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body><div style='cursor: pointer;'>Pointer Cursor</div></body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(div_node.content_attributes->node_interaction_info); |
| EXPECT_THAT( |
| div_node.content_attributes->node_interaction_info->clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kCursorPointer)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClickabilityReasonAriaRole) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), "<body><div role='link'>ARIA Link</div></body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(div_node.content_attributes->node_interaction_info); |
| EXPECT_EQ(div_node.content_attributes->aria_role, |
| ax::mojom::blink::Role::kLink); |
| EXPECT_THAT( |
| div_node.content_attributes->node_interaction_info->clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kAriaRole)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClickabilityReasonMultipleReasons) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| "<button id='multiReasonBtn' contenteditable='true' style='cursor: " |
| "pointer;' role='menuitem'>" |
| "Multi-Reason Button" |
| "</button>" |
| "<script>" |
| " const btn = document.getElementById('multiReasonBtn');" |
| " btn.onclick = function(){};" |
| " btn.onmouseover = function(){};" |
| " btn.onmouseup = function(){};" |
| " btn.onkeydown = function(){};" |
| "</script>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& button_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(button_node.content_attributes->node_interaction_info); |
| EXPECT_THAT( |
| button_node.content_attributes->node_interaction_info |
| ->clickability_reasons, |
| testing::UnorderedElementsAre( |
| mojom::blink::AIPageContentClickabilityReason::kClickableControl, |
| mojom::blink::AIPageContentClickabilityReason::kClickEvents, |
| mojom::blink::AIPageContentClickabilityReason::kMouseHover, |
| mojom::blink::AIPageContentClickabilityReason::kMouseClick, |
| mojom::blink::AIPageContentClickabilityReason::kKeyEvents, |
| mojom::blink::AIPageContentClickabilityReason::kEditable, |
| mojom::blink::AIPageContentClickabilityReason::kCursorPointer, |
| mojom::blink::AIPageContentClickabilityReason::kHoverPseudoClass, |
| mojom::blink::AIPageContentClickabilityReason::kAriaRole)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClickabilityReasonNoReasons) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), "<body><div>Plain Div</div></body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(div_node.content_attributes->node_interaction_info); |
| EXPECT_TRUE(div_node.content_attributes->node_interaction_info |
| ->clickability_reasons.empty()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaHasPopup) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body><div aria-haspopup=true>Plain Div</div></body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(div_node.content_attributes->node_interaction_info); |
| |
| const auto& interaction_info = |
| *div_node.content_attributes->node_interaction_info; |
| EXPECT_THAT( |
| interaction_info.clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kAriaHasPopup)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaExpandedTrue) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body><div aria-expanded=true>Plain Div</div></body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(div_node.content_attributes->node_interaction_info); |
| |
| const auto& interaction_info = |
| *div_node.content_attributes->node_interaction_info; |
| EXPECT_THAT( |
| interaction_info.clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kAriaExpandedTrue)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaExpandedFalse) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body><div aria-expanded=false>Plain Div</div></body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(div_node.content_attributes->node_interaction_info); |
| |
| const auto& interaction_info = |
| *div_node.content_attributes->node_interaction_info; |
| EXPECT_THAT( |
| interaction_info.clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kAriaExpandedFalse)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClickabilityReasonAriaToggleAndSelectable) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"( |
| <body> |
| <button aria-pressed="false">Toggle Button</button> |
| <div role="checkbox" aria-checked="mixed">Toggle Checkbox</div> |
| <div role="option" aria-selected="false">Selectable Option</div> |
| </body>)", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& pressed_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(pressed_node.content_attributes->node_interaction_info); |
| EXPECT_THAT(pressed_node.content_attributes->node_interaction_info |
| ->clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kAriaToggle)); |
| |
| const auto& checked_node = *ContentRootNode().children_nodes[1]; |
| ASSERT_TRUE(checked_node.content_attributes->node_interaction_info); |
| EXPECT_THAT(checked_node.content_attributes->node_interaction_info |
| ->clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kAriaToggle)); |
| |
| const auto& selected_node = *ContentRootNode().children_nodes[2]; |
| ASSERT_TRUE(selected_node.content_attributes->node_interaction_info); |
| EXPECT_THAT( |
| selected_node.content_attributes->node_interaction_info |
| ->clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kAriaSelectable)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, Autocomplete) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"(<body> |
| <input> |
| <input autocomplete=off> |
| <input autocomplete=on> |
| <input aria-autocomplete> |
| <input aria-autocomplete=none> |
| <input aria-autocomplete=list> |
| </body>)", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| const bool kExpected[] = { |
| false, // no attribute |
| false, // disabled |
| true, |
| false, // empty |
| false, // disabled |
| true, |
| }; |
| |
| GetAIPageContentWithActionableElements(); |
| |
| for (int i = 0; bool expected : kExpected) { |
| SCOPED_TRACE(i); |
| |
| const auto& input_node = *ContentRootNode().children_nodes[i]; |
| ASSERT_TRUE(input_node.content_attributes->node_interaction_info); |
| const auto& interaction_info = |
| *input_node.content_attributes->node_interaction_info; |
| |
| EXPECT_THAT( |
| interaction_info.clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kAutocomplete) |
| .Times(expected)); |
| |
| ++i; |
| } |
| } |
| |
| TEST_F(AIPageContentAgentTest, TabIndex) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), "<body><div tabindex=0>Plain Div</div></body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(div_node.content_attributes->node_interaction_info); |
| |
| const auto& interaction_info = |
| *div_node.content_attributes->node_interaction_info; |
| EXPECT_THAT(interaction_info.clickability_reasons, |
| testing::Contains( |
| mojom::blink::AIPageContentClickabilityReason::kTabIndex)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, IsTabbable) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"( |
| <body> |
| <button tabindex="-1">Programmatic Focus</button> |
| <div tabindex="0">Tab Stop</div> |
| </body>)", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& focusable_only_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(focusable_only_node.content_attributes->node_interaction_info); |
| const auto& focusable_only_interaction_info = |
| *focusable_only_node.content_attributes->node_interaction_info; |
| EXPECT_TRUE(focusable_only_interaction_info.is_focusable); |
| EXPECT_FALSE(focusable_only_interaction_info.is_tabbable); |
| |
| const auto& tabbable_node = *ContentRootNode().children_nodes[1]; |
| ASSERT_TRUE(tabbable_node.content_attributes->node_interaction_info); |
| const auto& tabbable_interaction_info = |
| *tabbable_node.content_attributes->node_interaction_info; |
| EXPECT_TRUE(tabbable_interaction_info.is_focusable); |
| EXPECT_TRUE(tabbable_interaction_info.is_tabbable); |
| } |
| |
| TEST_F(AIPageContentAgentTest, HasAriaActivedescendant) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"( |
| <body> |
| <div role="listbox" tabindex="0" aria-activedescendant="active-option"> |
| <div id="active-option" role="option">Active Option</div> |
| </div> |
| </body>)", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& listbox_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(listbox_node.content_attributes->node_interaction_info); |
| EXPECT_TRUE(listbox_node.content_attributes->node_interaction_info |
| ->has_aria_activedescendant); |
| } |
| |
| TEST_F(AIPageContentAgentTest, AriaActionTargetNodeIds) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"( |
| <body> |
| <div role="tab" tabindex="0" aria-actions="close-action"> |
| Closable Tab |
| <button id="close-action">Close</button> |
| </div> |
| </body>)", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& tab_node = *ContentRootNode().children_nodes[0]; |
| ASSERT_TRUE(tab_node.content_attributes->node_interaction_info); |
| ASSERT_EQ(tab_node.content_attributes->node_interaction_info |
| ->aria_action_target_node_ids.size(), |
| 1u); |
| |
| const auto& close_button_node = *tab_node.children_nodes[1]; |
| ASSERT_TRUE(close_button_node.content_attributes->dom_node_id.has_value()); |
| EXPECT_EQ(tab_node.content_attributes->node_interaction_info |
| ->aria_action_target_node_ids[0], |
| *close_button_node.content_attributes->dom_node_id); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClipPathCircle) { |
| // The <div> element is clipped to a small circle. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"( |
| <body> |
| <style> |
| div { |
| position: absolute; |
| top: 0; |
| left: 0; |
| width: 100px; |
| height: 100px; |
| background: red; |
| clip-path: circle(20%); |
| } |
| </style> |
| <div onclick=console.log(1)></div> |
| </body>)", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| |
| CheckGeometry(div_node, gfx::Rect(30, 30, 40, 40), gfx::Rect(30, 30, 40, 40)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClipPathEllipse) { |
| // The <div> element is clipped to an ellipse. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"( |
| <body> |
| <style> |
| div { |
| position: absolute; |
| top: 0; |
| left: 0; |
| width: 100px; |
| height: 100px; |
| background: red; |
| clip-path: ellipse(20px 50px); |
| } |
| </style> |
| <div onclick=console.log(1)></div> |
| </body>)", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| |
| CheckGeometry(div_node, gfx::Rect(30, 0, 40, 100), gfx::Rect(30, 0, 40, 100)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClipPathCircleHalf) { |
| // Only the bottom half of the circle is within the viewport. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"( |
| <body> |
| <style> |
| div { |
| position: absolute; |
| top: -50px; |
| left: 0; |
| width: 100px; |
| height: 100px; |
| background: red; |
| clip-path: circle(20%); |
| } |
| </style> |
| <div onclick=console.log(1)></div> |
| </body>)", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| |
| CheckGeometry(div_node, gfx::Rect(30, -20, 40, 40), gfx::Rect(30, 0, 40, 20)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ClipPathEmpty) { |
| // The entire <div> element is clipped. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"( |
| <body> |
| <style> |
| body { margin: 0; } |
| div { |
| position: absolute; |
| top: 200px; |
| left: 300px; |
| width: 100px; |
| height: 100px; |
| background: red; |
| clip-path: circle(0 at left top); |
| } |
| </style> |
| <div onclick=console.log(1)></div> |
| </body>)", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| |
| const auto& geometry = *div_node.content_attributes->geometry; |
| EXPECT_TRUE(geometry.outer_bounding_box.IsEmpty()); |
| EXPECT_TRUE(geometry.visible_bounding_box.IsEmpty()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, InlineWithFloatAndInlineContentGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"HTML( |
| <body> |
| <style> |
| body { margin: 0; font: 10px/10px Ahem; } |
| a { position: absolute; top: 0; left: 0; color: black; } |
| #floater { float: left; width: 30px; height: 10px; background: #ccc; } |
| </style> |
| <a id="target" href="#"><span id="floater"></span>XX</a> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| LoadAhem(); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| Element* anchor_element = document->getElementById(AtomicString("target")); |
| ASSERT_TRUE(anchor_element); |
| LayoutObject* anchor_layout_object = anchor_element->GetLayoutObject(); |
| ASSERT_TRUE(anchor_layout_object); |
| const auto* anchor_box = |
| DynamicTo<LayoutBoxModelObject>(anchor_layout_object); |
| ASSERT_TRUE(anchor_box); |
| |
| const mojom::blink::AIPageContentNode* anchor_node = |
| FindNodeBySelector("#target"); |
| |
| ASSERT_TRUE(anchor_node); |
| ASSERT_TRUE(anchor_node->content_attributes->geometry); |
| const auto& anchor_geometry = *anchor_node->content_attributes->geometry; |
| |
| EXPECT_EQ(gfx::Rect(0, 0, 50, 10), anchor_geometry.outer_bounding_box); |
| EXPECT_EQ(gfx::Rect(0, 0, 50, 10), anchor_geometry.visible_bounding_box); |
| |
| const mojom::blink::AIPageContentNode* floater_node = |
| FindNodeBySelector("#floater"); |
| ASSERT_TRUE(floater_node); |
| ASSERT_TRUE(floater_node->content_attributes->geometry); |
| const auto& floater_geometry = *floater_node->content_attributes->geometry; |
| |
| EXPECT_EQ(gfx::Rect(0, 0, 30, 10), floater_geometry.outer_bounding_box); |
| EXPECT_EQ(gfx::Rect(0, 0, 30, 10), floater_geometry.visible_bounding_box); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ActionableModeKeepsContainerQuadGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"HTML( |
| <body style="margin: 0; font: 10px/10px Ahem;"> |
| <details id="wrapper"> |
| <summary>Expandable</summary> |
| Contents. |
| </details> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| LoadAhem(); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| Element* wrapper_element = document->getElementById(AtomicString("wrapper")); |
| ASSERT_TRUE(wrapper_element); |
| DOMNodeId wrapper_dom_node_id = DOMNodeIds::IdForNode(wrapper_element); |
| |
| const auto* wrapper_node = FindNodeByDomNodeId(wrapper_dom_node_id); |
| ASSERT_TRUE(wrapper_node); |
| CheckContainerNode(*wrapper_node); |
| ASSERT_TRUE(wrapper_node->content_attributes->geometry); |
| const auto& geometry = *wrapper_node->content_attributes->geometry; |
| |
| LayoutObject* wrapper_layout_object = wrapper_element->GetLayoutObject(); |
| ASSERT_TRUE(wrapper_layout_object); |
| const auto* wrapper_box = |
| DynamicTo<LayoutBoxModelObject>(wrapper_layout_object); |
| ASSERT_TRUE(wrapper_box); |
| |
| EXPECT_EQ(gfx::Rect(0, 0, 1000, 10), geometry.outer_bounding_box); |
| EXPECT_EQ(gfx::Rect(0, 0, 1000, 10), geometry.visible_bounding_box); |
| } |
| |
| TEST_F(AIPageContentAgentTest, InlineWithFloatInlineBoxUnionGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"HTML( |
| <body style="margin: 0; font: 10px/10px Ahem;"> |
| <a id="inline-float-union"> |
| <span id="inline-wrapper"> |
| <span id="floated" class="inner-float">1</span> |
| <span id="inline-box" style="display:inline-block; width: 4px; height: 20px;">2</span> |
| </span> |
| </a> |
| <style> |
| .inner-float { |
| width: 20px; |
| height: 20px; |
| display: block; |
| float: left; |
| } |
| </style> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| LoadAhem(); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| |
| // As there is no clipping for either node, the outer box == visible box. |
| |
| { |
| const auto* anchor_node = FindNodeBySelector("#inline-float-union"); |
| ASSERT_TRUE(anchor_node); |
| ASSERT_TRUE(anchor_node->content_attributes); |
| ASSERT_TRUE(anchor_node->content_attributes->geometry); |
| |
| const auto& anchor_geometry = *anchor_node->content_attributes->geometry; |
| EXPECT_EQ(anchor_geometry.outer_bounding_box, |
| anchor_geometry.visible_bounding_box); |
| } |
| |
| { |
| const auto* container_node = FindNodeBySelector("#inline-wrapper"); |
| ASSERT_TRUE(container_node); |
| ASSERT_TRUE(container_node->content_attributes); |
| ASSERT_TRUE(container_node->content_attributes->geometry); |
| const auto& container_geometry = |
| *container_node->content_attributes->geometry; |
| EXPECT_EQ(container_geometry.outer_bounding_box, |
| container_geometry.visible_bounding_box); |
| } |
| } |
| |
| TEST_F(AIPageContentAgentTest, InlineWithOnlyFloatGeometry) { |
| // An inline anchor with no inline text content but containing a floated |
| // descendant should not inherit geometry from the float. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"( |
| <body> |
| <style> |
| body { margin: 0; } |
| a { position: absolute; left: 0; top: 0; } |
| #floater { float: left; width: 20px; height: 10px; background: #000; } |
| </style> |
| <a href="#"><span><span id="floater"></span></span></a> |
| </body>)", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| // Use actionable mode so the anchor is included in the APC tree. |
| GetAIPageContentWithActionableElements(); |
| |
| // Find the first node that has anchor data (iterative DFS, no std::function). |
| const auto& root = ContentRootNode(); |
| const mojom::blink::AIPageContentNode* anchor_node = nullptr; |
| Vector<const mojom::blink::AIPageContentNode*> stack; |
| stack.push_back(&root); |
| while (!stack.empty()) { |
| const auto* node = stack.back(); |
| stack.pop_back(); |
| if (node->content_attributes && node->content_attributes->anchor_data) { |
| anchor_node = node; |
| break; |
| } |
| // Push children in reverse so traversal order matches natural order. |
| for (wtf_size_t i = node->children_nodes.size(); i > 0; --i) { |
| stack.push_back(node->children_nodes[i - 1].get()); |
| } |
| } |
| ASSERT_TRUE(anchor_node); |
| |
| ASSERT_TRUE(anchor_node->content_attributes->geometry); |
| const auto& anchor_geom = *anchor_node->content_attributes->geometry; |
| |
| // Inline elements that keep their own fragment should retain geometry even |
| // when their only ink comes from a floating descendant. |
| EXPECT_EQ(anchor_geom.outer_bounding_box, gfx::Rect(0, 0, 20, 10)); |
| EXPECT_EQ(anchor_geom.visible_bounding_box, gfx::Rect(0, 0, 20, 10)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, StructuralWrapperWithoutPaintGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0; font: 10px/10px Ahem;"> |
| <a id="wrapper" href="#" style="position: relative; display: inline-block;"> |
| <span id="child" style="position: absolute; left: 0; top: 0; |
| width: 10px; height: 10px; |
| background: black; color: white;">X</span> |
| </a> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| LoadAhem(); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| auto* wrapper_node = FindNodeBySelector("#wrapper"); |
| ASSERT_TRUE(wrapper_node); |
| EXPECT_TRUE(wrapper_node->content_attributes->anchor_data); |
| ASSERT_TRUE(wrapper_node->content_attributes->geometry); |
| const auto& wrapper_geometry = *wrapper_node->content_attributes->geometry; |
| ASSERT_EQ(wrapper_geometry.fragment_visible_bounding_boxes.size(), 1u); |
| |
| auto* child_node = FindNodeBySelector("#child"); |
| ASSERT_TRUE(child_node); |
| ASSERT_TRUE(child_node->content_attributes->geometry); |
| const auto& child_geometry = *child_node->content_attributes->geometry; |
| EXPECT_FALSE(child_geometry.visible_bounding_box.IsEmpty()); |
| EXPECT_FALSE(child_geometry.outer_bounding_box.IsEmpty()); |
| EXPECT_EQ(wrapper_geometry.outer_bounding_box, |
| child_geometry.outer_bounding_box); |
| EXPECT_EQ(wrapper_geometry.visible_bounding_box, |
| child_geometry.visible_bounding_box); |
| EXPECT_EQ(wrapper_geometry.fragment_visible_bounding_boxes[0], |
| child_geometry.visible_bounding_box); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| NonActionableZeroAreaContainerUsesChildGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0; font: 10px/10px Ahem;"> |
| <article id="container" style="position: relative; width: 0; |
| height: 0;"> |
| <button id="child" style="position: absolute; left: 10px; top: 20px; |
| width: 20px; height: 10px;">X</button> |
| </article> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| LoadAhem(); |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* container = FindNodeBySelector("#container"); |
| const auto* child = FindNodeBySelector("#child"); |
| ASSERT_TRUE(container); |
| ASSERT_TRUE(child); |
| ASSERT_TRUE(container->content_attributes->geometry); |
| ASSERT_TRUE(child->content_attributes->geometry); |
| // The article is included for its structure, not because it is actionable. |
| EXPECT_FALSE(container->content_attributes->node_interaction_info); |
| |
| const auto& container_geometry = *container->content_attributes->geometry; |
| const auto& child_geometry = *child->content_attributes->geometry; |
| // Ensure equality cannot pass because both source and repaired boxes are |
| // empty. |
| EXPECT_FALSE(child_geometry.outer_bounding_box.IsEmpty()); |
| EXPECT_FALSE(child_geometry.visible_bounding_box.IsEmpty()); |
| EXPECT_EQ(container_geometry.outer_bounding_box, |
| child_geometry.outer_bounding_box); |
| EXPECT_EQ(container_geometry.visible_bounding_box, |
| child_geometry.visible_bounding_box); |
| EXPECT_THAT(container_geometry.fragment_visible_bounding_boxes, |
| testing::ElementsAre(child_geometry.visible_bounding_box)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| ZeroAreaAnchorsUseVisibleOutOfFlowChildrenAsFragments) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0; font: 10px/10px Ahem;"> |
| <a id="float" href="#" class="zero"> |
| <span id="float-child-1" class="float-child" onclick="void(0)">A</span> |
| <span id="float-child-2" class="float-child" onclick="void(0)">B</span> |
| </a> |
| <a id="absolute" href="#" class="zero"> |
| <span id="absolute-child-1" class="absolute-child" |
| onclick="void(0)">C</span> |
| <span id="absolute-child-2" class="absolute-child second" |
| onclick="void(0)">D</span> |
| </a> |
| <a id="fixed" href="#" class="zero"> |
| <span id="fixed-child-1" class="fixed-child" |
| onclick="void(0)">E</span> |
| <span id="fixed-child-2" class="fixed-child second" |
| onclick="void(0)">F</span> |
| </a> |
| <style> |
| .zero { |
| display: inline-block; |
| position: relative; |
| width: 0; |
| height: 0; |
| } |
| .float-child { float: left; width: 20px; height: 10px; } |
| .absolute-child { |
| position: absolute; |
| left: 0; |
| top: 20px; |
| width: 20px; |
| height: 10px; |
| } |
| .fixed-child { |
| position: fixed; |
| left: 0; |
| top: 40px; |
| width: 20px; |
| height: 10px; |
| } |
| .second { left: 30px; } |
| </style> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| LoadAhem(); |
| GetAIPageContentWithActionableElements(); |
| |
| auto expect_anchor_geometry_from_children = |
| [this](const char* anchor_selector, const char* first_child_selector, |
| const char* second_child_selector) { |
| const auto* anchor_node = FindNodeBySelector(anchor_selector); |
| ASSERT_TRUE(anchor_node); |
| ASSERT_TRUE(anchor_node->content_attributes->geometry); |
| const auto& anchor_geometry = |
| *anchor_node->content_attributes->geometry; |
| |
| const auto* first_child = FindNodeBySelector(first_child_selector); |
| ASSERT_TRUE(first_child); |
| ASSERT_TRUE(first_child->content_attributes->geometry); |
| const gfx::Rect first_child_box = |
| first_child->content_attributes->geometry->visible_bounding_box; |
| EXPECT_FALSE(first_child_box.IsEmpty()); |
| |
| const auto* second_child = FindNodeBySelector(second_child_selector); |
| ASSERT_TRUE(second_child); |
| ASSERT_TRUE(second_child->content_attributes->geometry); |
| const gfx::Rect second_child_box = |
| second_child->content_attributes->geometry->visible_bounding_box; |
| EXPECT_FALSE(second_child_box.IsEmpty()); |
| |
| EXPECT_THAT( |
| anchor_geometry.fragment_visible_bounding_boxes, |
| testing::UnorderedElementsAre(first_child_box, second_child_box)); |
| |
| gfx::Rect expected_outer_box = |
| first_child->content_attributes->geometry->outer_bounding_box; |
| expected_outer_box.Union( |
| second_child->content_attributes->geometry->outer_bounding_box); |
| EXPECT_EQ(anchor_geometry.outer_bounding_box, expected_outer_box); |
| |
| gfx::Rect expected_visible_box = first_child_box; |
| expected_visible_box.Union(second_child_box); |
| EXPECT_EQ(anchor_geometry.visible_bounding_box, expected_visible_box); |
| }; |
| |
| expect_anchor_geometry_from_children("#float", "#float-child-1", |
| "#float-child-2"); |
| expect_anchor_geometry_from_children("#absolute", "#absolute-child-1", |
| "#absolute-child-2"); |
| expect_anchor_geometry_from_children("#fixed", "#fixed-child-1", |
| "#fixed-child-2"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| ZeroAreaAncestorUsesFirstNonemptyGeometryFromEachBranch) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0; font: 10px/10px Ahem;"> |
| <a id="anchor" href="#" class="zero"> |
| <span id="deep-zero-1" class="zero" onclick="void(0)"> |
| <span id="deep-zero-2" class="zero" onclick="void(0)"> |
| <span id="deep-leaf" class="deep-leaf" |
| onclick="void(0)">A</span> |
| </span> |
| </span> |
| <span id="nonempty-branch" class="nonempty-branch" |
| onclick="void(0)"> |
| <span id="far-leaf" class="far-leaf" |
| onclick="void(0)">B</span> |
| </span> |
| </a> |
| <style> |
| .zero { |
| display: inline-block; |
| position: relative; |
| width: 0; |
| height: 0; |
| } |
| .deep-leaf, .far-leaf { |
| position: absolute; |
| display: block; |
| width: 10px; |
| height: 10px; |
| } |
| .deep-leaf { left: 20px; top: 10px; } |
| .nonempty-branch { |
| display: inline-block; |
| position: relative; |
| width: 5px; |
| height: 5px; |
| } |
| .far-leaf { left: 100px; top: 100px; } |
| </style> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| LoadAhem(); |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* anchor = FindNodeBySelector("#anchor"); |
| const auto* deep_zero_1 = FindNodeBySelector("#deep-zero-1"); |
| const auto* deep_zero_2 = FindNodeBySelector("#deep-zero-2"); |
| const auto* deep_leaf = FindNodeBySelector("#deep-leaf"); |
| const auto* nonempty_branch = FindNodeBySelector("#nonempty-branch"); |
| const auto* far_leaf = FindNodeBySelector("#far-leaf"); |
| ASSERT_TRUE(anchor); |
| ASSERT_TRUE(deep_zero_1); |
| ASSERT_TRUE(deep_zero_2); |
| ASSERT_TRUE(deep_leaf); |
| ASSERT_TRUE(nonempty_branch); |
| ASSERT_TRUE(far_leaf); |
| ASSERT_TRUE(anchor->content_attributes->geometry); |
| ASSERT_TRUE(deep_zero_1->content_attributes->geometry); |
| ASSERT_TRUE(deep_zero_2->content_attributes->geometry); |
| ASSERT_TRUE(deep_leaf->content_attributes->geometry); |
| ASSERT_TRUE(nonempty_branch->content_attributes->geometry); |
| ASSERT_TRUE(far_leaf->content_attributes->geometry); |
| |
| const auto& anchor_geometry = *anchor->content_attributes->geometry; |
| const auto& deep_leaf_geometry = *deep_leaf->content_attributes->geometry; |
| const auto& nonempty_branch_geometry = |
| *nonempty_branch->content_attributes->geometry; |
| const auto& far_leaf_geometry = *far_leaf->content_attributes->geometry; |
| |
| // Each zero-area level on the deep branch receives the same first nonempty |
| // geometry from below it. |
| EXPECT_EQ(deep_zero_2->content_attributes->geometry->visible_bounding_box, |
| deep_leaf_geometry.visible_bounding_box); |
| EXPECT_EQ(deep_zero_1->content_attributes->geometry->visible_bounding_box, |
| deep_leaf_geometry.visible_bounding_box); |
| |
| // The anchor receives one contribution from each branch. The far leaf does |
| // not contribute because its branch already has nonempty container geometry. |
| EXPECT_THAT(anchor_geometry.fragment_visible_bounding_boxes, |
| testing::UnorderedElementsAre( |
| deep_leaf_geometry.visible_bounding_box, |
| nonempty_branch_geometry.visible_bounding_box)); |
| EXPECT_THAT( |
| anchor_geometry.fragment_visible_bounding_boxes, |
| testing::Not(testing::Contains(far_leaf_geometry.visible_bounding_box))); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| ZeroAreaAnchorsUseGeometryThroughNonpaintingWrappers) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0; font: 10px/10px Ahem;"> |
| <a id="collapse-anchor" href="#" class="zero"> |
| <span style="visibility: collapse;"> |
| <span id="collapse-child" class="collapse-child" |
| onclick="void(0)">A</span> |
| </span> |
| </a> |
| <a id="contents-anchor" href="#" class="zero"> |
| <span style="display: contents;"> |
| <span id="contents-child" class="contents-child" |
| onclick="void(0)">B</span> |
| </span> |
| </a> |
| <style> |
| .zero { |
| display: inline-block; |
| position: relative; |
| width: 0; |
| height: 0; |
| } |
| .collapse-child, .contents-child { |
| position: absolute; |
| display: block; |
| width: 20px; |
| height: 10px; |
| visibility: visible; |
| } |
| .collapse-child { left: 10px; top: 20px; } |
| .contents-child { left: 40px; top: 20px; } |
| </style> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| LoadAhem(); |
| GetAIPageContentWithActionableElements(); |
| |
| auto expect_anchor_matches_child = [this](const char* anchor_selector, |
| const char* child_selector) { |
| const auto* anchor = FindNodeBySelector(anchor_selector); |
| const auto* child = FindNodeBySelector(child_selector); |
| ASSERT_TRUE(anchor); |
| ASSERT_TRUE(child); |
| ASSERT_TRUE(anchor->content_attributes->geometry); |
| ASSERT_TRUE(child->content_attributes->geometry); |
| |
| const auto& anchor_geometry = *anchor->content_attributes->geometry; |
| const auto& child_geometry = *child->content_attributes->geometry; |
| EXPECT_EQ(anchor_geometry.outer_bounding_box, |
| child_geometry.outer_bounding_box); |
| EXPECT_EQ(anchor_geometry.visible_bounding_box, |
| child_geometry.visible_bounding_box); |
| EXPECT_THAT(anchor_geometry.fragment_visible_bounding_boxes, |
| testing::ElementsAre(child_geometry.visible_bounding_box)); |
| }; |
| |
| expect_anchor_matches_child("#collapse-anchor", "#collapse-child"); |
| expect_anchor_matches_child("#contents-anchor", "#contents-child"); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| ZeroAreaAnchorCombinesFragmentsFromMultipleSources) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0; font: 10px/10px Ahem;"> |
| <a id="anchor" href="#">AB CD<span id="sibling" |
| onclick="void(0)">E</span></a> |
| <style> |
| #anchor { |
| display: block; |
| position: relative; |
| width: 20px; |
| height: 0; |
| } |
| #sibling { |
| position: absolute; |
| left: 50px; |
| top: 30px; |
| width: 10px; |
| height: 10px; |
| } |
| </style> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| LoadAhem(); |
| GetAIPageContentWithActionableElements(); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| Element* anchor = document->getElementById(AtomicString("anchor")); |
| ASSERT_TRUE(anchor); |
| Node* wrapping_text = anchor->firstChild(); |
| ASSERT_TRUE(wrapping_text); |
| ASSERT_TRUE(wrapping_text->IsTextNode()); |
| |
| const auto* anchor_node = FindNodeBySelector("#anchor"); |
| const auto* text_node = |
| FindNodeByDomNodeId(DOMNodeIds::IdForNode(wrapping_text)); |
| const auto* sibling_node = FindNodeBySelector("#sibling"); |
| ASSERT_TRUE(anchor_node); |
| ASSERT_TRUE(text_node); |
| ASSERT_TRUE(sibling_node); |
| ASSERT_TRUE(anchor_node->content_attributes->geometry); |
| ASSERT_TRUE(text_node->content_attributes->geometry); |
| ASSERT_TRUE(sibling_node->content_attributes->geometry); |
| |
| const auto& anchor_geometry = *anchor_node->content_attributes->geometry; |
| const auto& text_geometry = *text_node->content_attributes->geometry; |
| const auto& sibling_geometry = *sibling_node->content_attributes->geometry; |
| ASSERT_EQ(text_geometry.fragment_visible_bounding_boxes.size(), 2u); |
| ASSERT_TRUE(sibling_geometry.fragment_visible_bounding_boxes.empty()); |
| |
| // `#sibling` is inside the anchor and is the wrapping text node's sibling. |
| // The empty anchor therefore combines the first nonempty geometry from both |
| // child branches. |
| Vector<gfx::Rect> expected_fragments = |
| text_geometry.fragment_visible_bounding_boxes; |
| expected_fragments.push_back(sibling_geometry.visible_bounding_box); |
| EXPECT_THAT(anchor_geometry.fragment_visible_bounding_boxes, |
| testing::UnorderedElementsAreArray(expected_fragments)); |
| |
| gfx::Rect expected_outer_box = text_geometry.outer_bounding_box; |
| expected_outer_box.Union(sibling_geometry.outer_bounding_box); |
| EXPECT_EQ(anchor_geometry.outer_bounding_box, expected_outer_box); |
| |
| gfx::Rect expected_visible_box = text_geometry.visible_bounding_box; |
| expected_visible_box.Union(sibling_geometry.visible_bounding_box); |
| EXPECT_EQ(anchor_geometry.visible_bounding_box, expected_visible_box); |
| } |
| |
| TEST_F(AIPageContentAgentTest, InlinePreWrapGeometry) { |
| // Inline wrappers that rely on white-space:pre-wrap frequently delegate all |
| // actual painting to anonymous block fragments generated for line wrapping. |
| // The legacy outer-bounding-box path used AbsoluteBoundingBoxRect() on the |
| // LayoutInline host, so it produced an empty rect even though the wrapped |
| // text occupied multiple lines. Mapping via GeometryMapper keeps outer and |
| // visible boxes consistent in these inlines-with-block-descendants cases. |
| ScopedAIPageContentOuterBoxMapToAncestorSpaceForTest enable_outer_box_mapping( |
| true); |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <style> |
| body { margin: 0; font: 16px/16px Ahem; } |
| #prewrap-inline { white-space: pre-wrap; } |
| </style> |
| <body> |
| <span id="prewrap-inline"> |
| <span>Label:</span> Wrapped inline text. |
| </span> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| LoadAhem(); |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* entry_node = FindNodeBySelector("#prewrap-inline"); |
| ASSERT_TRUE(entry_node); |
| ASSERT_TRUE(entry_node->content_attributes); |
| ASSERT_TRUE(entry_node->content_attributes->geometry); |
| |
| const auto& geometry = *entry_node->content_attributes->geometry; |
| EXPECT_FALSE(geometry.outer_bounding_box.IsEmpty()); |
| EXPECT_FALSE(geometry.visible_bounding_box.IsEmpty()); |
| EXPECT_EQ(geometry.outer_bounding_box, geometry.visible_bounding_box); |
| } |
| |
| TEST_F(AIPageContentAgentTest, IframeOuterBoxNotViewportClipped) { |
| // Force outer-box mapping on so GeometryMapper is used for both the visible |
| // and unclipped bounds. |
| ScopedAIPageContentOuterBoxMapToAncestorSpaceForTest enable_outer_box_mapping( |
| true); |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <style> |
| body { margin: 0; } |
| iframe { |
| border: none; |
| width: 200px; |
| height: 150px; |
| } |
| </style> |
| <body> |
| <iframe id="offscreen-frame" srcdoc=" |
| <style> |
| body { margin: 0; height: 800px; position: relative; font: 10px/10px Ahem; } |
| #deep { |
| position: absolute; |
| left: 20px; |
| top: -10px; |
| width: 50px; |
| height: 40px; |
| background: lightgreen; |
| } |
| </style> |
| <body> |
| <a id='deep' href='#'>Deep target</a> |
| </body>"> |
| </iframe> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| LocalFrameView* view = document->View(); |
| ASSERT_TRUE(view); |
| test::RunPendingTasks(); |
| view->UpdateAllLifecyclePhasesForTest(); |
| auto* iframe_element = DynamicTo<HTMLIFrameElement>( |
| document->getElementById(AtomicString("offscreen-frame"))); |
| ASSERT_TRUE(iframe_element); |
| LocalFrame* child_frame = |
| DynamicTo<LocalFrame>(iframe_element->ContentFrame()); |
| ASSERT_TRUE(child_frame); |
| PageTestBase::LoadAhem(*child_frame); |
| if (LocalFrameView* child_view = child_frame->View()) { |
| test::RunPendingTasks(); |
| child_view->UpdateAllLifecyclePhasesForTest(); |
| } |
| Document* child_document = child_frame->GetDocument(); |
| ASSERT_TRUE(child_document); |
| |
| Element* deep = child_document->getElementById(AtomicString("deep")); |
| ASSERT_TRUE(deep); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| DOMNodeId deep_dom_node_id = DOMNodeIds::IdForNode(deep); |
| ASSERT_GE(deep_dom_node_id, 1); |
| const auto* deep_node = FindNodeByDomNodeId(deep_dom_node_id); |
| ASSERT_TRUE(deep_node); |
| ASSERT_TRUE(deep_node->content_attributes); |
| ASSERT_TRUE(deep_node->content_attributes->geometry); |
| |
| // The element straddles the iframe's viewport top edge. When |
| // kSkipAncestorAndViewportClips is honored, MapToVisualRectInAncestorSpace |
| // skips that viewport clip so the outer box reports the true location in the |
| // embedder viewport, while the visible box remains clipped to the portion |
| // that is painted. |
| const auto& geometry = *deep_node->content_attributes->geometry; |
| EXPECT_EQ(geometry.outer_bounding_box, gfx::Rect(20, -10, 50, 40)); |
| EXPECT_EQ(geometry.visible_bounding_box, gfx::Rect(20, 0, 50, 30)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, InlineBlockFixedDescendantKeepsGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <style> |
| body { margin: 0; font: 10px/10px Ahem; } |
| .content { padding: 60px 0 0 40px; } |
| a.inline-block-anchor { |
| display: inline-block; |
| width: 100px; |
| height: 100px; |
| border: 1px solid black; |
| } |
| .fixed-box { |
| position: fixed; |
| top: 0; |
| left: 0; |
| width: 200px; |
| height: 25px; |
| } |
| </style> |
| <body> |
| <div class="content"> |
| <a id="anchor" class="inline-block-anchor" href="#test"> |
| <div class="fixed-box">a</div> |
| </a> |
| </div> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* anchor_node = FindNodeBySelector("#anchor"); |
| ASSERT_TRUE(anchor_node); |
| const auto& attributes = *anchor_node->content_attributes; |
| EXPECT_EQ(attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kAnchor); |
| ASSERT_TRUE(attributes.geometry); |
| |
| const auto& geometry = *attributes.geometry; |
| EXPECT_EQ(gfx::Rect(40, 60, 102, 102), geometry.outer_bounding_box); |
| EXPECT_EQ(geometry.outer_bounding_box, geometry.visible_bounding_box); |
| } |
| |
| TEST_F(AIPageContentAgentTest, GeometryIncludesCssPosition) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <style> |
| body { margin: 0; font: 10px/10px Ahem; } |
| #fixed { |
| position: fixed; |
| top: 0; |
| left: 0; |
| width: 50px; |
| height: 10px; |
| } |
| </style> |
| <body> |
| <button id="fixed">Action</button> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* fixed_node = FindNodeBySelector("#fixed"); |
| ASSERT_TRUE(fixed_node); |
| ASSERT_TRUE(fixed_node->content_attributes); |
| ASSERT_TRUE(fixed_node->content_attributes->geometry); |
| // A fixed control should carry its computed CSS position alongside geometry. |
| EXPECT_EQ(fixed_node->content_attributes->geometry->css_position, |
| mojom::blink::AIPageContentCssPosition::kFixed); |
| } |
| |
| TEST_F(AIPageContentAgentTest, TableTextClippedByScrollerBeforeScroll) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <style> |
| body { margin: 0; font: 10px/10px Ahem; } |
| * { margin: 0; padding: 0; box-sizing: border-box; } |
| main { |
| width: 70px; |
| height: 30px; |
| overflow: auto; |
| } |
| table { |
| width: 120%; |
| height: 30px; |
| table-layout: fixed; |
| border-collapse: collapse; |
| } |
| td.small10x10 { |
| width: 100px; |
| height: 3ch; |
| vertical-align: top; |
| font: 10px/10px Ahem; |
| } |
| </style> |
| <body> |
| <main id="scroller"> |
| <table> |
| <tr> |
| <td id="cell" class="small10x10">ABC DEF GHI JKL MNO PQR STU VWX YZ 0123456789</td> |
| <td></td> |
| </tr> |
| <tr> |
| <td></td> |
| <td style="height: 100vh; width: 100vh;"></td> |
| </tr> |
| </table> |
| </main> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| LoadAhem(); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| |
| Element* cell = document->getElementById(AtomicString("cell")); |
| ASSERT_TRUE(cell); |
| Node* text = cell->firstChild(); |
| ASSERT_TRUE(text); |
| ASSERT_TRUE(text->IsTextNode()); |
| |
| const auto* text_node = FindNodeByDomNodeId(DOMNodeIds::IdForNode(text)); |
| ASSERT_TRUE(text_node); |
| ASSERT_TRUE(text_node->content_attributes->geometry); |
| |
| Element* scroller_element = |
| document->getElementById(AtomicString("scroller")); |
| ASSERT_TRUE(scroller_element); |
| |
| const auto& geometry = *text_node->content_attributes->geometry; |
| const auto& fragments = geometry.fragment_visible_bounding_boxes; |
| const ComputedStyle& before_style = text->GetLayoutObject()->StyleRef(); |
| LocalFrame* local_frame = document->GetFrame(); |
| ASSERT_TRUE(local_frame); |
| EXPECT_NEAR(before_style.ComputedFontSize(), 10.0f, 0.01f); |
| EXPECT_NEAR(before_style.GetFont()->GetFontDescription().ComputedSize(), |
| 10.0f, 0.01f); |
| |
| EXPECT_EQ(gfx::Rect(0, 0, 100, 50), geometry.outer_bounding_box); |
| EXPECT_EQ(gfx::Rect(0, 0, 70, 30), geometry.visible_bounding_box); |
| ASSERT_EQ(fragments.size(), 3u); |
| EXPECT_EQ(fragments[0], gfx::Rect(0, 0, 70, 10)); |
| EXPECT_EQ(fragments[1], gfx::Rect(0, 10, 70, 10)); |
| EXPECT_EQ(fragments[2], gfx::Rect(0, 20, 70, 10)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, TableTextClippedByScrollerAfterScroll) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <style> |
| body { margin: 0; font: 10px/10px Ahem; } |
| * { margin: 0; padding: 0; box-sizing: border-box; } |
| main { |
| width: 70px; |
| height: 30px; |
| overflow: auto; |
| } |
| table { |
| width: 120%; |
| height: 30px; |
| table-layout: fixed; |
| border-collapse: collapse; |
| } |
| td.small10x10 { |
| width: 100px; |
| height: 3ch; |
| vertical-align: top; |
| font: 10px/10px Ahem; |
| } |
| </style> |
| <body> |
| <main id="scroller"> |
| <table> |
| <tr> |
| <td id="cell" class="small10x10">ABC DEF GHI JKL MNO PQR STU VWX YZ 0123456789</td> |
| <td></td> |
| </tr> |
| <tr> |
| <td></td> |
| <td style="height: 100vh; width: 100vh;"></td> |
| </tr> |
| </table> |
| </main> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| LoadAhem(); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| |
| Element* scroller = document->getElementById(AtomicString("scroller")); |
| ASSERT_TRUE(scroller); |
| scroller->setScrollLeft(15); |
| scroller->setScrollTop(15); |
| |
| LocalFrameView* view = document->View(); |
| ASSERT_TRUE(view); |
| test::RunPendingTasks(); |
| view->UpdateAllLifecyclePhasesForTest(); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| Element* cell = document->getElementById(AtomicString("cell")); |
| ASSERT_TRUE(cell); |
| Node* text = cell->firstChild(); |
| ASSERT_TRUE(text); |
| ASSERT_TRUE(text->IsTextNode()); |
| |
| const auto* text_node = FindNodeByDomNodeId(DOMNodeIds::IdForNode(text)); |
| ASSERT_TRUE(text_node); |
| ASSERT_TRUE(text_node->content_attributes->geometry); |
| |
| const auto& geometry = *text_node->content_attributes->geometry; |
| const auto& fragments = geometry.fragment_visible_bounding_boxes; |
| const ComputedStyle& after_style = text->GetLayoutObject()->StyleRef(); |
| std::string fragments_trace; |
| for (wtf_size_t i = 0; i < fragments.size(); ++i) { |
| if (!fragments_trace.empty()) { |
| fragments_trace.append("; "); |
| } |
| std::string fragment_rect = fragments[i].ToString(); |
| fragments_trace.append( |
| base::StringPrintf("%zu:%s", i, fragment_rect.c_str())); |
| } |
| LocalFrame* local_frame = document->GetFrame(); |
| ASSERT_TRUE(local_frame); |
| EXPECT_NEAR(after_style.ComputedFontSize(), 10.0f, 0.01f); |
| EXPECT_NEAR(after_style.GetFont()->GetFontDescription().ComputedSize(), 10.0f, |
| 0.01f); |
| |
| EXPECT_EQ(gfx::Rect(-15, -15, 100, 50), geometry.outer_bounding_box); |
| EXPECT_EQ(gfx::Rect(0, 0, 70, 30), geometry.visible_bounding_box); |
| ASSERT_EQ(fragments.size(), 4u); |
| EXPECT_EQ(fragments[0], gfx::Rect(0, 0, 55, 5)); |
| EXPECT_EQ(fragments[1], gfx::Rect(0, 5, 55, 10)); |
| EXPECT_EQ(fragments[2], gfx::Rect(0, 15, 70, 10)); |
| EXPECT_EQ(fragments[3], gfx::Rect(0, 25, 70, 5)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, IframeInlineTextClippedWhenViewportScrolled) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <style> |
| body { margin: 0; height: 2000px; font: 10px/10px Ahem; } |
| iframe { |
| border: none; |
| width: 100px; |
| height: 200px; |
| } |
| </style> |
| <body> |
| <iframe id="target" srcdoc=" |
| <style> |
| body { margin: 0; font: 10px/10px Ahem; } |
| p { margin: 0; background: red; } |
| </style> |
| <body> |
| <p id='inner'>ABC DEF GHI JKL MNO PQR STU</p> |
| </body>"> |
| </iframe> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://example.com")); |
| |
| LoadAhem(); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| Element* scrolling_element = document->scrollingElement(); |
| ASSERT_TRUE(scrolling_element); |
| scrolling_element->setScrollLeft(15); |
| scrolling_element->setScrollTop(15); |
| |
| LocalFrameView* view = document->View(); |
| ASSERT_TRUE(view); |
| test::RunPendingTasks(); |
| view->UpdateAllLifecyclePhasesForTest(); |
| |
| HTMLIFrameElement* iframe_element = DynamicTo<HTMLIFrameElement>( |
| document->getElementById(AtomicString("target"))); |
| ASSERT_TRUE(iframe_element); |
| LocalFrame* child_frame = |
| DynamicTo<LocalFrame>(iframe_element->ContentFrame()); |
| ASSERT_TRUE(child_frame); |
| // Load Ahem inside the iframe before we snapshot geometry to avoid races on |
| // platforms where font activation is asynchronous. |
| PageTestBase::LoadAhem(*child_frame); |
| test::RunPendingTasks(); |
| if (LocalFrameView* child_view = child_frame->View()) { |
| child_view->UpdateAllLifecyclePhasesForTest(); |
| } |
| Document* child_document = child_frame->GetDocument(); |
| ASSERT_TRUE(child_document); |
| |
| Element* inner_p = child_document->getElementById(AtomicString("inner")); |
| ASSERT_TRUE(inner_p); |
| Node* inner_text = inner_p->firstChild(); |
| ASSERT_TRUE(inner_text); |
| ASSERT_TRUE(inner_text->IsTextNode()); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* text_node = |
| FindNodeByDomNodeId(DOMNodeIds::IdForNode(inner_text)); |
| ASSERT_TRUE(text_node); |
| ASSERT_TRUE(text_node->content_attributes->geometry); |
| |
| const auto& geometry = *text_node->content_attributes->geometry; |
| const auto& fragments = geometry.fragment_visible_bounding_boxes; |
| const ComputedStyle& iframe_style = inner_text->GetLayoutObject()->StyleRef(); |
| std::string fragments_trace; |
| for (wtf_size_t i = 0; i < fragments.size(); ++i) { |
| if (!fragments_trace.empty()) { |
| fragments_trace.append("; "); |
| } |
| std::string fragment_rect = fragments[i].ToString(); |
| fragments_trace.append( |
| base::StringPrintf("%zu:%s", i, fragment_rect.c_str())); |
| } |
| EXPECT_NEAR(iframe_style.ComputedFontSize(), 10.0f, 0.01f); |
| EXPECT_NEAR(iframe_style.GetFont()->GetFontDescription().ComputedSize(), |
| 10.0f, 0.01f); |
| EXPECT_EQ(AtomicString("Ahem"), |
| iframe_style.GetFont()->GetFontDescription().Family().FamilyName()); |
| |
| EXPECT_EQ(gfx::Rect(0, -15, 70, 40), geometry.outer_bounding_box); |
| EXPECT_EQ(gfx::Rect(0, 0, 70, 25), geometry.visible_bounding_box); |
| ASSERT_EQ(fragments.size(), 3u); |
| EXPECT_EQ(fragments[0], gfx::Rect(0, 0, 70, 5)); |
| EXPECT_EQ(fragments[1], gfx::Rect(0, 5, 70, 10)); |
| EXPECT_EQ(fragments[2], gfx::Rect(0, 15, 30, 10)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, CSSHoverPseudoClass) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"( |
| <body> |
| <style> |
| div:hover { |
| background-color: red; |
| } |
| </style> |
| <div onclick=console.log(1)></div> |
| <p>sibling</p> |
| </body>)", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| EXPECT_TRUE( |
| div_node.content_attributes->node_interaction_info->clickability_reasons |
| .Contains(ClickabilityReason::kHoverPseudoClass)); |
| |
| const auto& p_node = *ContentRootNode().children_nodes[1]; |
| EXPECT_FALSE( |
| p_node.content_attributes->node_interaction_info->clickability_reasons |
| .Contains(ClickabilityReason::kHoverPseudoClass)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, CSSHoverPseudoClassNotInherited) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), R"( |
| <body> |
| <style> |
| div:hover { |
| background-color: red; |
| } |
| </style> |
| <div onclick=console.log(1)> |
| <p>child</p> |
| </div> |
| <p>sibling</p> |
| </body>)", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& div_node = *ContentRootNode().children_nodes[0]; |
| EXPECT_TRUE( |
| div_node.content_attributes->node_interaction_info->clickability_reasons |
| .Contains(ClickabilityReason::kHoverPseudoClass)); |
| |
| const auto& child_p_node = *div_node.children_nodes[0]; |
| EXPECT_FALSE(child_p_node.content_attributes->node_interaction_info |
| ->clickability_reasons.Contains( |
| ClickabilityReason::kHoverPseudoClass)); |
| |
| const auto& sibling_p_node = *ContentRootNode().children_nodes[1]; |
| EXPECT_FALSE(sibling_p_node.content_attributes->node_interaction_info |
| ->clickability_reasons.Contains( |
| ClickabilityReason::kHoverPseudoClass)); |
| } |
| |
| // Tests hit-testing and z-order computations for AIPageContentAgent. |
| class AIPageContentAgentTestZOrder : public AIPageContentAgentTest {}; |
| |
| TEST_F(AIPageContentAgentTestZOrder, HitTestElementsBasic) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p style='background:red'>Text 1</p>" |
| " <p>Text 2</p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = *Content()->root_node; |
| |
| ASSERT_TRUE(root.content_attributes->node_interaction_info); |
| EXPECT_EQ( |
| root.content_attributes->node_interaction_info->document_scoped_z_order, |
| 1); |
| |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& html = *root.children_nodes.at(0); |
| EXPECT_EQ( |
| html.content_attributes->node_interaction_info->document_scoped_z_order, |
| 2); |
| |
| ASSERT_EQ(html.children_nodes.size(), 1u); |
| const auto& body = *html.children_nodes.at(0); |
| EXPECT_EQ( |
| body.content_attributes->node_interaction_info->document_scoped_z_order, |
| 3); |
| |
| // The tree should look as follows, with the given z order. |
| // root - 1 |
| // |_html - 2 |
| // |_body - 3 |
| // |_p - 4 |
| // | |_Text1 - 5 |
| // |_p - 6 |
| // |_Text2 - 7 |
| ASSERT_EQ(body.children_nodes.size(), 2u); |
| const auto& p1 = *body.children_nodes.at(0); |
| EXPECT_EQ( |
| p1.content_attributes->node_interaction_info->document_scoped_z_order, 4); |
| |
| const auto& p2 = *body.children_nodes.at(1); |
| EXPECT_EQ( |
| p2.content_attributes->node_interaction_info->document_scoped_z_order, 6); |
| |
| ASSERT_EQ(p1.children_nodes.size(), 1u); |
| const auto& text1 = *p1.children_nodes.at(0); |
| CheckTextNode(text1, "Text 1"); |
| EXPECT_EQ( |
| text1.content_attributes->node_interaction_info->document_scoped_z_order, |
| 5); |
| |
| ASSERT_EQ(p2.children_nodes.size(), 1u); |
| const auto& text2 = *p2.children_nodes.at(0); |
| CheckTextNode(text2, "Text 2"); |
| EXPECT_EQ( |
| text2.content_attributes->node_interaction_info->document_scoped_z_order, |
| 7); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, HitTestElementsFixedPos) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p style='position: fixed; top: 10px;'>Text 1</p>" |
| " <p>Text 2</p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 2u); |
| |
| // The first node is now on top. |
| const auto& p1 = *root.children_nodes.at(0); |
| ASSERT_TRUE(p1.content_attributes->node_interaction_info); |
| ASSERT_TRUE( |
| p1.content_attributes->node_interaction_info->document_scoped_z_order); |
| EXPECT_EQ( |
| p1.content_attributes->node_interaction_info->document_scoped_z_order, 6); |
| |
| const auto& p2 = *root.children_nodes.at(1); |
| ASSERT_TRUE(p2.content_attributes->node_interaction_info); |
| ASSERT_TRUE( |
| p2.content_attributes->node_interaction_info->document_scoped_z_order); |
| EXPECT_EQ( |
| p2.content_attributes->node_interaction_info->document_scoped_z_order, 4); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, HitTestElementsPointerNone) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p style='pointer-events:none'>Text 1</p>" |
| " <p>Text 2</p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 2u); |
| |
| // The first node is not actionable anymore. |
| const auto& p1 = *root.children_nodes.at(0); |
| EXPECT_FALSE(p1.content_attributes->node_interaction_info); |
| |
| const auto& p2 = *root.children_nodes.at(1); |
| ASSERT_TRUE(p2.content_attributes->node_interaction_info); |
| ASSERT_TRUE( |
| p2.content_attributes->node_interaction_info->document_scoped_z_order); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, HitTestElementsOffscreen) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p style='cursor:pointer; position:fixed; top:110vh;'>Text 1</p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| // A viewport-anchored node parked offscreen cannot be reached by scrolling, |
| // so APC should not serialize it as actionable. |
| const auto& p1 = *root.children_nodes.at(0); |
| EXPECT_FALSE(p1.content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, HitTestElementsOffscreenFeatureDisabled) { |
| ScopedAIPageContentAnchoredFixedOffscreenNonActionabilityForTest |
| scoped_feature(false); |
| |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p style='cursor:pointer; position:fixed; top:110vh;'>Text 1</p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| // With the new gate disabled, APC keeps the previous behavior and still |
| // serializes actionability for the offscreen fixed node. |
| const auto& p1 = *root.children_nodes.at(0); |
| ASSERT_TRUE(p1.content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsNestedScrollerOffscreenFeaturesDisabled) { |
| ScopedAIPageContentAnchoredFixedOffscreenNonActionabilityForTest |
| scoped_fixed_feature(false); |
| ScopedAIPageContentAnchoredNonFixedOffscreenNonActionabilityForTest |
| scoped_non_fixed_feature(false); |
| |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <div id="scroller" style="overflow: auto; width: 200px; height: 200px; position: relative;"> |
| <p id="target" style="cursor: pointer; position: absolute; left: -9999px; top: 100px;">Text 1</p> |
| <div style="height: 1000px;"></div> |
| </div> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| // Overflow-container state is tracked during traversal even when the |
| // actionability gates are off. With both gates disabled, APC should keep the |
| // older behavior and leave this offscreen nested-scroller target actionable. |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| ASSERT_TRUE(target->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsFixedScrollableAncestorKeepsOffscreenChildActionable) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body style='margin: 0;'>" |
| " <div id='dialog' style='position: fixed; inset: 0;'>" |
| " <div id='scroller' style='height: 100px; overflow-y: auto;'>" |
| " <div style='height: 1200px;'></div>" |
| " <button id='target'>Bottom action</button>" |
| " </div>" |
| " </div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| // The button is below the current scrollport inside the fixed dialog, but it |
| // is still reachable by scrolling #scroller. APC should keep it actionable so |
| // downstream clients can scroll the ancestor before clicking the button. |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| ASSERT_TRUE(target->content_attributes->node_interaction_info); |
| |
| const auto& interaction_info = |
| *target->content_attributes->node_interaction_info; |
| EXPECT_FALSE(interaction_info.clickability_reasons.empty()); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsFixedScrollerEscapesUnreachableAncestorScroller) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body style='margin: 0;'>" |
| " <div id='outer-scroller' style='overflow: auto; width: 200px;" |
| " height: 200px; position: absolute; left: -9999px; top: 0;'>" |
| " <div id='fixed-scroller' style='position: fixed; overflow: auto;" |
| " width: 100px; height: 100px; left: 10px; top: 10px;'>" |
| " <p id='target' style='cursor: pointer;'>Text 1</p>" |
| " <div style='height: 200px;'></div>" |
| " </div>" |
| " </div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| // The fixed scroller escapes the offscreen ancestor scroller and is visible |
| // in the viewport. Its target should not inherit the ancestor's unreachable |
| // overflow state. |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| ASSERT_TRUE(target->content_attributes->node_interaction_info); |
| |
| const auto& interaction_info = |
| *target->content_attributes->node_interaction_info; |
| EXPECT_FALSE(interaction_info.clickability_reasons.empty()); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsOffscreenFixedInsideTransform) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body style='margin: 0; height: 2500px;'>" |
| " <div style='height: 1200px;'></div>" |
| " <div style='transform: translateZ(0); position: relative;'>" |
| " <p id='target' style='cursor:pointer; position:fixed; top:0;'>" |
| " Text 1" |
| " </p>" |
| " </div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| ASSERT_TRUE(target->content_attributes->node_interaction_info); |
| |
| const auto& interaction_info = |
| *target->content_attributes->node_interaction_info; |
| EXPECT_FALSE(interaction_info.clickability_reasons.empty()); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, HitTestElementsAbsoluteNegativeTrap) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p id='target' style='cursor:pointer; position:absolute;" |
| " left:-9999px; top:0;'>" |
| " Text 1" |
| " </p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| EXPECT_FALSE(target->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, HitTestElementsAbsoluteReachableByScroll) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body style='margin: 0; height: 7000px;'>" |
| " <p id='target' style='cursor:pointer; position:absolute;" |
| " left:0; top:5000px;'>" |
| " Text 1" |
| " </p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| ASSERT_TRUE(target->content_attributes->node_interaction_info); |
| |
| const auto& interaction_info = |
| *target->content_attributes->node_interaction_info; |
| EXPECT_FALSE(interaction_info.clickability_reasons.empty()); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsAbsoluteReachableWhenScrolledPast) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body style='margin: 0; height: 7000px;'>" |
| " <p id='target' style='cursor:pointer; position:absolute;" |
| " left:0; top:200px;'>" |
| " Text 1" |
| " </p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // Scroll the page so the target moves above the current viewport. The node |
| // should still stay actionable because the user can scroll back to it. |
| helper_.LocalMainFrame()->ExecuteScript( |
| WebScriptSource("window.scrollTo(0, 2000);")); |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| ASSERT_TRUE(document->View()); |
| document->View()->UpdateAllLifecyclePhasesForTest(); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| ASSERT_TRUE(target->content_attributes->node_interaction_info); |
| |
| const auto& interaction_info = |
| *target->content_attributes->node_interaction_info; |
| EXPECT_FALSE(interaction_info.clickability_reasons.empty()); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsAbsoluteReachableWhenScrolledPastOnHighDPI) { |
| // This regression combines the two coordinate transforms the offscreen check |
| // now relies on: a visual-viewport shift from browser controls and a scaled |
| // page surface. The node is above the current viewport, but it should remain |
| // actionable because the user can scroll back to it. |
| frame_test_helpers::WebViewHelper high_dpi_helper(base::BindRepeating( |
| [](base::PassKey<WebLocalFrame> pass_key, |
| CrossVariantMojoAssociatedRemote< |
| mojom::blink::FrameWidgetHostInterfaceBase> frame_widget_host, |
| CrossVariantMojoAssociatedReceiver< |
| mojom::blink::FrameWidgetInterfaceBase> frame_widget, |
| CrossVariantMojoAssociatedRemote<mojom::blink::WidgetHostInterfaceBase> |
| widget_host, |
| CrossVariantMojoAssociatedReceiver<mojom::blink::WidgetInterfaceBase> |
| widget, |
| scoped_refptr<base::SingleThreadTaskRunner> task_runner, |
| const viz::FrameSinkId& frame_sink_id, bool hidden, |
| bool never_composited, bool is_for_child_local_root, |
| bool is_for_nested_main_frame, |
| bool is_for_scalable_page) -> frame_test_helpers::TestWebFrameWidget* { |
| auto* test_web_frame_widget = |
| MakeGarbageCollected<frame_test_helpers::TestWebFrameWidget>( |
| std::move(pass_key), std::move(frame_widget_host), |
| std::move(frame_widget), std::move(widget_host), |
| std::move(widget), std::move(task_runner), frame_sink_id, |
| hidden, never_composited, is_for_child_local_root, |
| is_for_nested_main_frame, is_for_scalable_page); |
| display::ScreenInfo screen_info; |
| screen_info.device_scale_factor = 2.f; |
| test_web_frame_widget->SetInitialScreenInfo(screen_info); |
| return test_web_frame_widget; |
| })); |
| high_dpi_helper.InitializeWithSettings( |
| [](WebSettings* settings) { settings->SetTextAreasAreResizable(true); }); |
| high_dpi_helper.LoadAhem(); |
| ASSERT_TRUE(high_dpi_helper.LocalMainFrame()); |
| |
| constexpr gfx::Size kDipViewportSize{464, 828}; |
| constexpr int kDeviceScaleFactor = 2; |
| high_dpi_helper.Resize( |
| gfx::Size(kDipViewportSize.width() * kDeviceScaleFactor, |
| kDipViewportSize.height() * kDeviceScaleFactor)); |
| |
| frame_test_helpers::LoadHTMLString( |
| high_dpi_helper.LocalMainFrame(), |
| "<body style='margin: 0; height: 7000px;'>" |
| " <p id='target' style='cursor:pointer; position:absolute;" |
| " left:0; top:200px;'>" |
| " Text 1" |
| " </p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| Document* document = |
| high_dpi_helper.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| LocalFrameView* view = document->View(); |
| ASSERT_TRUE(view); |
| |
| // Establish layout before applying viewport transforms. |
| view->UpdateAllLifecyclePhasesForTest(); |
| |
| constexpr int kVisualViewportOffsetDip = 20; |
| document->GetPage()->GetChromeClient().SetBrowserControlsState( |
| kVisualViewportOffsetDip, 0, /*shrinks_layout=*/true); |
| |
| ScriptState* script_state = |
| ToScriptStateForMainWorld(high_dpi_helper.LocalMainFrame()->GetFrame()); |
| ScriptState::Scope scope(script_state); |
| ViewTransitionSupplement::startViewTransition(script_state, *document, |
| IGNORE_EXCEPTION_FOR_TESTING); |
| test::RunPendingTasks(); |
| |
| high_dpi_helper.LocalMainFrame()->ExecuteScript( |
| WebScriptSource("window.scrollTo(0, 2000);")); |
| view->UpdateAllLifecyclePhasesForTest(); |
| |
| Element* target_element = document->getElementById(AtomicString("target")); |
| ASSERT_TRUE(target_element); |
| const DOMNodeId target_dom_node_id = DOMNodeIds::IdForNode(target_element); |
| ASSERT_GT(target_dom_node_id, kInvalidDOMNodeId); |
| |
| auto options = GetAIPageContentOptionsForTest(); |
| options->mode = mojom::blink::AIPageContentMode::kActionableElements; |
| auto* agent = AIPageContentAgent::GetOrCreateForTesting(*document); |
| ASSERT_TRUE(agent); |
| auto content = agent->GetAIPageContentInternal(*options); |
| ASSERT_TRUE(content); |
| ASSERT_TRUE(content->root_node); |
| |
| const auto* target_node = |
| FindNodeByDomNodeId(*content->root_node, target_dom_node_id); |
| ASSERT_TRUE(target_node); |
| ASSERT_TRUE(target_node->content_attributes->node_interaction_info); |
| |
| const auto& interaction_info = |
| *target_node->content_attributes->node_interaction_info; |
| EXPECT_FALSE(interaction_info.clickability_reasons.empty()); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsNestedScrollerAbsoluteReachable) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <div id="scroller" style="overflow: auto; width: 200px; height: 200px; position: relative;"> |
| <div style="height: 2000px;"> |
| <p id="target" style="cursor: pointer; position: absolute; left: 0; top: 1500px;">Text 1</p> |
| </div> |
| </div> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| Element* scroller = document->getElementById(AtomicString("scroller")); |
| ASSERT_TRUE(scroller); |
| scroller->setScrollTop(1000); |
| |
| LocalFrameView* view = document->View(); |
| ASSERT_TRUE(view); |
| test::RunPendingTasks(); |
| view->UpdateAllLifecyclePhasesForTest(); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| ASSERT_TRUE(target->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsNestedScrollerAbsoluteReachableWhenScrolledPast) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <div id="scroller" style="overflow: auto; width: 200px; height: 200px; position: relative;"> |
| <div style="height: 2000px;"> |
| <p id="target" style="cursor: pointer; position: absolute; left: 0; top: 200px;">Text 1</p> |
| </div> |
| </div> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| Element* scroller = document->getElementById(AtomicString("scroller")); |
| ASSERT_TRUE(scroller); |
| // The target is above the scroller's current viewport, but the user can |
| // scroll the container back to it. |
| scroller->setScrollTop(1000); |
| |
| LocalFrameView* view = document->View(); |
| ASSERT_TRUE(view); |
| test::RunPendingTasks(); |
| view->UpdateAllLifecyclePhasesForTest(); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| ASSERT_TRUE(target->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsFixedNestedScrollerAbsoluteReachable) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <div id="scroller" style="overflow: auto; width: 200px; height: 200px; position: fixed; left: 0; top: 0;"> |
| <div style="height: 2000px; position: relative;"> |
| <p id="target" style="cursor: pointer; position: absolute; left: 0; top: 1500px;">Text 1</p> |
| </div> |
| </div> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| // The fixed container is visible, so the user can scroll it to the target. |
| ASSERT_TRUE(target->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsFixedChildOfScrollerNegativeTrap) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <div id="scroller" style="overflow: auto; width: 200px; height: 200px; position: relative;"> |
| <div style="height: 2000px;"> |
| <p id="target" style="cursor: pointer; position: fixed; left: 0; top: 1500px;">Text 1</p> |
| </div> |
| </div> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| // The target is fixed to the viewport, so scrolling its DOM scroller cannot |
| // bring it into view. |
| EXPECT_FALSE(target->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsNestedScrollerAbsoluteNegativeTrap) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <div id="scroller" style="overflow: auto; width: 200px; height: 200px; position: relative;"> |
| <div style="height: 2000px;"> |
| <p id="target" style="cursor: pointer; position: absolute; left: -9999px; top: 100px;">Text 1</p> |
| </div> |
| </div> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| EXPECT_FALSE(target->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsOverflowHiddenAbsoluteNegativeTrap) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <div id="clipper" style="overflow: hidden; width: 200px; height: 200px; position: relative;"> |
| <div style="height: 2000px;"> |
| <p id="target" style="cursor: pointer; position: absolute; left: 0; top: 1500px;">Text 1</p> |
| </div> |
| </div> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| // `overflow: hidden` clips the target, but the user cannot scroll the |
| // clipper. |
| EXPECT_FALSE(target->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsOffscreenScrollerSelfNegativeTrap) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <div id="scroller" style="cursor: pointer; overflow: auto; width: 200px; height: 200px; position: absolute; left: -9999px; top: 0;"> |
| <div style="height: 2000px;">Text 1</div> |
| </div> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* scroller = FindNodeBySelector("#scroller"); |
| ASSERT_TRUE(scroller); |
| // A scroller must be reachable through its parent before it can be |
| // actionable. |
| EXPECT_FALSE(scroller->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsOffscreenNestedScrollerAbsoluteNegativeTrap) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <div id="scroller" style="overflow: auto; width: 200px; height: 200px; position: absolute; left: -9999px; top: 0;"> |
| <div style="height: 2000px; position: relative;"> |
| <p id="target" style="cursor: pointer; position: absolute; left: 0; top: 100px;">Text 1</p> |
| </div> |
| </div> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| // A child cannot be reached when its nearest scroller is itself offscreen. |
| EXPECT_FALSE(target->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsOffscreenScrollerIframeChildNegativeTrap) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <div id="scroller" style="overflow: auto; width: 200px; height: 200px; position: absolute; left: -9999px; top: 0;"> |
| <iframe id="target-frame" |
| src="about:blank" |
| style="border: 0; width: 200px; height: 200px;"></iframe> |
| </div> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| auto* iframe_element = DynamicTo<HTMLIFrameElement>( |
| document->getElementById(AtomicString("target-frame"))); |
| ASSERT_TRUE(iframe_element); |
| auto* child_frame = DynamicTo<LocalFrame>(iframe_element->ContentFrame()); |
| ASSERT_TRUE(child_frame); |
| Document* child_document = child_frame->GetDocument(); |
| ASSERT_TRUE(child_document); |
| ASSERT_TRUE(child_document->body()); |
| |
| child_document->body()->SetInnerHTMLWithoutTrustedTypes( |
| "<body style='margin: 0;'>" |
| " <button id='target'>Text 1</button>" |
| "</body>"); |
| |
| LocalFrameView* child_view = child_document->View(); |
| ASSERT_TRUE(child_view); |
| test::RunPendingTasks(); |
| child_view->UpdateAllLifecyclePhasesForTest(); |
| |
| Element* target_element = |
| child_document->getElementById(AtomicString("target")); |
| ASSERT_TRUE(target_element); |
| const DOMNodeId target_dom_node_id = DOMNodeIds::IdForNode(target_element); |
| ASSERT_GT(target_dom_node_id, kInvalidDOMNodeId); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target_node = FindNodeByDomNodeId(target_dom_node_id); |
| ASSERT_TRUE(target_node); |
| // The iframe is inside an unreachable scroller, so its child cannot be |
| // directly actionable in this APC snapshot. |
| EXPECT_FALSE(target_node->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, HitTestElementsStaticNegativeTrap) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p id='target' style='cursor:pointer; transform: translate(-9999px, " |
| "-9999px);'>" |
| " Text 1" |
| " </p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| EXPECT_FALSE(target->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsNestedScrollerStaticNegativeTrap) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <div id="scroller" style="overflow: auto; width: 200px; height: 200px;"> |
| <div style="height: 2000px;"> |
| <p id="target" style="cursor: pointer; transform: translate(-9999px, -9999px);">Text 1</p> |
| </div> |
| </div> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| EXPECT_FALSE(target->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, HitTestElementsRelativeNegativeTrap) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p id='target' style='cursor:pointer; position:relative; " |
| "left:-9999px; top:0;'>" |
| " Text 1" |
| " </p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target = FindNodeBySelector("#target"); |
| ASSERT_TRUE(target); |
| EXPECT_FALSE(target->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, |
| HitTestElementsIFrameAbsoluteReachableWhenScrolledPast) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <iframe id="target-frame" |
| src="about:blank" |
| style="border: 0; width: 200px; height: 200px;"></iframe> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| auto* iframe_element = DynamicTo<HTMLIFrameElement>( |
| document->getElementById(AtomicString("target-frame"))); |
| ASSERT_TRUE(iframe_element); |
| auto* child_frame = DynamicTo<LocalFrame>(iframe_element->ContentFrame()); |
| ASSERT_TRUE(child_frame); |
| Document* child_document = child_frame->GetDocument(); |
| ASSERT_TRUE(child_document); |
| ASSERT_TRUE(child_document->body()); |
| |
| child_document->body()->SetInnerHTMLWithoutTrustedTypes( |
| "<style>" |
| " body { margin: 0; height: 7000px; }" |
| " #target { cursor: pointer; position: absolute; left: 0; top: 200px; }" |
| "</style>" |
| "<p id='target'>Text 1</p>"); |
| |
| // Scroll the iframe document so the target moves above the iframe viewport. |
| // The node should stay actionable because the iframe can scroll back to it. |
| Element* child_scrolling_element = child_document->scrollingElement(); |
| ASSERT_TRUE(child_scrolling_element); |
| child_scrolling_element->setScrollTop(2000); |
| |
| LocalFrameView* child_view = child_document->View(); |
| ASSERT_TRUE(child_view); |
| test::RunPendingTasks(); |
| child_view->UpdateAllLifecyclePhasesForTest(); |
| |
| Element* target_element = |
| child_document->getElementById(AtomicString("target")); |
| ASSERT_TRUE(target_element); |
| const DOMNodeId target_dom_node_id = DOMNodeIds::IdForNode(target_element); |
| ASSERT_GT(target_dom_node_id, kInvalidDOMNodeId); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* target_node = FindNodeByDomNodeId(target_dom_node_id); |
| ASSERT_TRUE(target_node); |
| ASSERT_TRUE(target_node->content_attributes->node_interaction_info); |
| |
| const auto& interaction_info = |
| *target_node->content_attributes->node_interaction_info; |
| EXPECT_FALSE(interaction_info.clickability_reasons.empty()); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, HitTestElementsIFrameFixedOffscreen) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body style="margin: 0;"> |
| <iframe id="target-frame" |
| src="about:blank" |
| style="border: 0; width: 200px; height: 200px;"></iframe> |
| </body>)HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| ASSERT_TRUE(document); |
| auto* iframe_element = DynamicTo<HTMLIFrameElement>( |
| document->getElementById(AtomicString("target-frame"))); |
| ASSERT_TRUE(iframe_element); |
| auto* child_frame = DynamicTo<LocalFrame>(iframe_element->ContentFrame()); |
| ASSERT_TRUE(child_frame); |
| Document* child_document = child_frame->GetDocument(); |
| ASSERT_TRUE(child_document); |
| ASSERT_TRUE(child_document->body()); |
| |
| child_document->body()->SetInnerHTMLWithoutTrustedTypes( |
| "<style>" |
| " body { margin: 0; min-height: 400px; }" |
| " #sheet {" |
| " position: fixed;" |
| " left: 0;" |
| " right: 0;" |
| " bottom: 0;" |
| " transform: translateY(100%);" |
| " }" |
| "</style>" |
| "<button id='trigger'>Open sizes</button>" |
| "<div id='sheet'><button id='item'>Size 6.5</button></div>"); |
| |
| LocalFrameView* child_view = child_document->View(); |
| ASSERT_TRUE(child_view); |
| test::RunPendingTasks(); |
| child_view->UpdateAllLifecyclePhasesForTest(); |
| |
| Element* trigger_element = |
| child_document->getElementById(AtomicString("trigger")); |
| ASSERT_TRUE(trigger_element); |
| const DOMNodeId trigger_dom_node_id = DOMNodeIds::IdForNode(trigger_element); |
| ASSERT_GT(trigger_dom_node_id, kInvalidDOMNodeId); |
| |
| Element* item_element = child_document->getElementById(AtomicString("item")); |
| ASSERT_TRUE(item_element); |
| const DOMNodeId item_dom_node_id = DOMNodeIds::IdForNode(item_element); |
| ASSERT_GT(item_dom_node_id, kInvalidDOMNodeId); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* trigger_node = FindNodeByDomNodeId(trigger_dom_node_id); |
| ASSERT_TRUE(trigger_node); |
| ASSERT_TRUE(trigger_node->content_attributes->node_interaction_info); |
| |
| const auto* item_node = FindNodeByDomNodeId(item_dom_node_id); |
| ASSERT_TRUE(item_node); |
| EXPECT_FALSE(item_node->content_attributes->node_interaction_info); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, HitTestElementsIframe) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <iframe srcdoc='<p>Text 1</p>'></iframe> |
| <p>Text 2</p> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| // The iframe and outer p have z order relative to each other. |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 2u); |
| |
| const auto& iframe = *root.children_nodes.at(0); |
| ASSERT_TRUE(iframe.content_attributes->node_interaction_info); |
| ASSERT_TRUE(iframe.content_attributes->node_interaction_info |
| ->document_scoped_z_order); |
| |
| const auto& p = *root.children_nodes.at(1); |
| ASSERT_TRUE(p.content_attributes->node_interaction_info); |
| ASSERT_TRUE( |
| p.content_attributes->node_interaction_info->document_scoped_z_order); |
| |
| // If we're respecting tree-order traversal when computing z-order, the |
| // iframe will have a lower z-order because it is the first child. |
| EXPECT_LT( |
| *iframe.content_attributes->node_interaction_info |
| ->document_scoped_z_order, |
| *p.content_attributes->node_interaction_info->document_scoped_z_order); |
| |
| ASSERT_EQ(iframe.children_nodes.size(), 1u); |
| const auto& doc_inside_iframe = *iframe.children_nodes.at(0); |
| ASSERT_TRUE(doc_inside_iframe.content_attributes->node_interaction_info); |
| ASSERT_TRUE(doc_inside_iframe.content_attributes->node_interaction_info |
| ->document_scoped_z_order); |
| EXPECT_EQ(*doc_inside_iframe.content_attributes->node_interaction_info |
| ->document_scoped_z_order, |
| 1); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, OverflowHiddenGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div style='width: 100px; height: 100px; overflow-y: hidden;'>" |
| " <article style='width: 50px; height: 300px;'></article>" |
| " </div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& outer = ContentRootNode().children_nodes[0]; |
| const auto& article = outer->children_nodes[0]; |
| CheckAnnotatedRole(*article, |
| mojom::blink::AIPageContentAnnotatedRole::kArticle); |
| |
| EXPECT_GT(*article->content_attributes->node_interaction_info |
| ->document_scoped_z_order, |
| *outer->content_attributes->node_interaction_info |
| ->document_scoped_z_order); |
| |
| CheckGeometry(*outer, gfx::Rect(8, 8, 100, 100), gfx::Rect(8, 8, 100, 100)); |
| CheckGeometry(*article, gfx::Rect(8, 8, 50, 300), gfx::Rect(8, 8, 50, 100)); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, OverflowVisibleGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <section style='width: 100px; height: 100px; overflow-y: visible;'>" |
| " <article style='width: 50px; height: 300px;'></article>" |
| " </section>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& outer = ContentRootNode().children_nodes[0]; |
| const auto& article = outer->children_nodes[0]; |
| CheckAnnotatedRole(*article, |
| mojom::blink::AIPageContentAnnotatedRole::kArticle); |
| |
| EXPECT_GT(*article->content_attributes->node_interaction_info |
| ->document_scoped_z_order, |
| *outer->content_attributes->node_interaction_info |
| ->document_scoped_z_order); |
| |
| CheckGeometry(*outer, gfx::Rect(8, 8, 100, 100), gfx::Rect(8, 8, 100, 100)); |
| CheckGeometry(*article, gfx::Rect(8, 8, 50, 300), gfx::Rect(8, 8, 50, 300)); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, HitTestElementsRelativePos) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <section style='width: 100px; height: 100px; position: relative; " |
| "overflow: clip;'>" |
| " <article style='width: 50px; height: 50px; position: absolute; " |
| "left: " |
| "150px; top:0px;'></article>" |
| " </section>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& outer = ContentRootNode().children_nodes[0]; |
| const auto& article = outer->children_nodes[0]; |
| CheckAnnotatedRole(*article, |
| mojom::blink::AIPageContentAnnotatedRole::kArticle); |
| |
| EXPECT_GT(*article->content_attributes->node_interaction_info |
| ->document_scoped_z_order, |
| *outer->content_attributes->node_interaction_info |
| ->document_scoped_z_order); |
| |
| CheckGeometry(*outer, gfx::Rect(8, 8, 100, 100), gfx::Rect(8, 8, 100, 100)); |
| CheckGeometry(*article, gfx::Rect(158, 8, 50, 50), gfx::Rect()); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, LabelWithText) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body style='margin:0; font:1px/1px Ahem'>" |
| " <label>xyz</label>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| LoadAhem(); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& body = ContentRootNode(); |
| ASSERT_EQ(body.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kContainer); |
| const auto& label = *body.children_nodes.at(0); |
| ASSERT_EQ(label.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kContainer); |
| const auto& text = *label.children_nodes.at(0); |
| ASSERT_EQ(text.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kText); |
| |
| SCOPED_TRACE("Label"); |
| CheckGeometry(label, gfx::Rect(0, 0, 3, 1), gfx::Rect(0, 0, 3, 1)); |
| SCOPED_TRACE("Text"); |
| CheckGeometry(text, gfx::Rect(0, 0, 3, 1), gfx::Rect(0, 0, 3, 1)); |
| } |
| |
| TEST_F(AIPageContentAgentTestZOrder, HitTestElementsAnchorWithSpanParent) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <span id="target-span"> |
| <a id="link" href="https://example.com"> |
| <span id="inner-span"> |
| This is the inner span. |
| </span> |
| <div id="inner-div"> |
| This is the inner div. |
| </div> |
| </a> |
| </span> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = *Content()->root_node; |
| EXPECT_EQ( |
| root.content_attributes->node_interaction_info->document_scoped_z_order, |
| 1); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| const auto& html = *root.children_nodes.at(0); |
| EXPECT_EQ( |
| html.content_attributes->node_interaction_info->document_scoped_z_order, |
| 2); |
| ASSERT_EQ(html.children_nodes.size(), 1u); |
| |
| const auto& body = *html.children_nodes.at(0); |
| EXPECT_EQ( |
| body.content_attributes->node_interaction_info->document_scoped_z_order, |
| 3); |
| ASSERT_EQ(body.children_nodes.size(), 1u); |
| |
| // The resulting tree with corresponding z-order is: |
| // root - 1 |
| // |_html - 2 |
| // |_body - 3 |
| // |_span - 4 |
| // |_a - 5 |
| // |_span - 6 |
| // | |_text - 7 |
| // |_div - 8 |
| // |_text - 9 |
| |
| const auto& target_span = *body.children_nodes.at(0); |
| EXPECT_EQ(target_span.content_attributes->node_interaction_info |
| ->document_scoped_z_order, |
| 4); |
| ASSERT_EQ(target_span.children_nodes.size(), 1u); |
| |
| const auto& anchor = *target_span.children_nodes.at(0); |
| EXPECT_EQ( |
| anchor.content_attributes->node_interaction_info->document_scoped_z_order, |
| 5); |
| ASSERT_EQ(anchor.children_nodes.size(), 2u); |
| |
| const auto& inner_span = *anchor.children_nodes.at(0); |
| EXPECT_EQ(inner_span.content_attributes->node_interaction_info |
| ->document_scoped_z_order, |
| 6); |
| ASSERT_EQ(inner_span.children_nodes.size(), 1u); |
| |
| const auto& span_text = *inner_span.children_nodes.at(0); |
| EXPECT_EQ(span_text.content_attributes->node_interaction_info |
| ->document_scoped_z_order, |
| 7); |
| |
| const auto& inner_div = *anchor.children_nodes.at(1); |
| EXPECT_EQ(inner_div.content_attributes->node_interaction_info |
| ->document_scoped_z_order, |
| 8); |
| ASSERT_EQ(inner_div.children_nodes.size(), 1u); |
| |
| const auto& div_text = *inner_div.children_nodes.at(0); |
| EXPECT_EQ(div_text.content_attributes->node_interaction_info |
| ->document_scoped_z_order, |
| 9); |
| } |
| |
| TEST_F(AIPageContentAgentTest, LinkWithOverflowGeometry) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <style>" |
| " a {" |
| " display: inline-block;" |
| " width: 20px;" |
| " height: 20px;" |
| " overflow: visible;" |
| " }" |
| " </style>" |
| " <a href='#' style='font-size: 50px'>Text that will overflow</a>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 1u); |
| |
| auto& anchor_node = *root.children_nodes[0]; |
| CheckAnchorNode(anchor_node, url_test_helpers::ToKURL("http://foobar.com/#"), |
| {}); |
| |
| const auto& geometry = *anchor_node.content_attributes->geometry; |
| // Visible overflow is not currently included in the outer_bounding_box or |
| // visible_bounding_box. This may not be the correct choice given that visible |
| // overflow is hit testable. However, this is not a major concern because |
| // events bubble up. If we see a problem case caused by the lack of overflow |
| // inclusion we can attempt to incorporate hit test rects (which was attempted |
| // previously but was non-trivial). |
| EXPECT_EQ(geometry.outer_bounding_box.width(), 20); |
| EXPECT_EQ(geometry.outer_bounding_box.width(), 20); |
| EXPECT_EQ(geometry.visible_bounding_box.width(), 20); |
| EXPECT_EQ(geometry.visible_bounding_box.height(), 20); |
| } |
| |
| TEST_F(AIPageContentAgentTest, CursorNotAllowedButton) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <button style="cursor: not-allowed;">Text</button> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& button = *root.children_nodes.at(0); |
| CheckHitTestableAndInteractive(button, |
| {ClickabilityReason::kClickableControl, |
| ClickabilityReason::kHoverPseudoClass}); |
| EXPECT_FALSE(button.content_attributes->node_interaction_info->is_disabled); |
| EXPECT_THAT(button.content_attributes->node_interaction_info |
| ->interaction_disabled_reasons, |
| testing::UnorderedElementsAre( |
| InteractionDisabledReason::kCursorNotAllowed)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, MultipleInteractionDisabledReasons) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| R"HTML( |
| <body> |
| <button disabled aria-disabled=true style="cursor: not-allowed;"> |
| Text |
| </button> |
| </body> |
| )HTML", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& button = *root.children_nodes.at(0); |
| CheckHitTestableButNotInteractive(button); |
| EXPECT_TRUE(button.content_attributes->node_interaction_info->is_disabled); |
| EXPECT_THAT(button.content_attributes->node_interaction_info |
| ->interaction_disabled_reasons, |
| testing::UnorderedElementsAre( |
| InteractionDisabledReason::kDisabled, |
| InteractionDisabledReason::kAriaDisabled, |
| InteractionDisabledReason::kCursorNotAllowed)); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ZeroSizeActionableElement) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='zero' style='width: 0; height: 0;' onclick='void(0)'></div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* zero_node = FindNodeBySelector("#zero"); |
| // An actionable element with 0 size should still be included in the APC tree |
| // if it is visible, e.g. it doesn't have visibility: hidden. |
| ASSERT_TRUE(zero_node); |
| ASSERT_TRUE(zero_node->content_attributes->geometry); |
| EXPECT_TRUE( |
| zero_node->content_attributes->geometry->outer_bounding_box.IsEmpty()); |
| EXPECT_TRUE( |
| zero_node->content_attributes->geometry->visible_bounding_box.IsEmpty()); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ZeroSizeNonActionableElement) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='zero' style='width: 0; height: 0;'></div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* zero_node = FindNodeBySelector("#zero"); |
| // A non-actionable element with 0 size should be excluded from the APC tree. |
| EXPECT_FALSE(zero_node); |
| } |
| |
| TEST_F(AIPageContentAgentTest, ZeroSizeContainerWithVisibleChild) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='zero' style='width: 0; height: 0; position: fixed;'>" |
| " <div id='visible' style='width: 10px; height: 10px;'>text</div>" |
| " </div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* zero_node = FindNodeBySelector("#zero"); |
| // A container with 0 size but visible children should be included. |
| ASSERT_TRUE(zero_node); |
| const auto* visible_node = FindNodeBySelector("#visible"); |
| ASSERT_TRUE(visible_node); |
| |
| // Verify that 'visible' is a child of 'zero' in the APC tree. |
| bool found = false; |
| for (const auto& child : zero_node->children_nodes) { |
| if (child->content_attributes->dom_node_id == |
| visible_node->content_attributes->dom_node_id) { |
| found = true; |
| break; |
| } |
| } |
| EXPECT_TRUE(found); |
| } |
| |
| TEST_F(AIPageContentAgentTest, GetImageBytes) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <img alt=testimg></img>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| auto& document = *helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| document.getElementsByTagName(AtomicString("img")) |
| ->item(0) |
| ->setAttribute(html_names::kSrcAttr, AtomicString(kSmallImage)); |
| |
| test::RunPendingTasks(); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| |
| auto& image_node = *root.children_nodes[0]; |
| CheckImageNode(image_node, "testimg", KURL()); |
| ASSERT_TRUE(image_node.content_attributes->dom_node_id.has_value()); |
| int32_t dom_node_id = image_node.content_attributes->dom_node_id.value(); |
| |
| auto* agent = AIPageContentAgent::From(document); |
| ASSERT_TRUE(agent); |
| |
| base::HistogramTester histogram_tester; |
| |
| base::RunLoop run_loop; |
| agent->GetImageBytes( |
| dom_node_id, |
| base::BindLambdaForTesting( |
| [&](mojom::blink::AIPageContentImageBytesResultPtr result) { |
| ASSERT_TRUE(result); |
| EXPECT_GT(result->image_bytes.size(), 0u); |
| EXPECT_EQ(result->image_info->mime_type, "image/jpeg"); |
| ASSERT_TRUE(result->image_info); |
| EXPECT_EQ(result->image_info->image_caption, "testimg"); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| |
| histogram_tester.ExpectUniqueSample( |
| "OptimizationGuide.AIPageContent.GetImageBytes.Status", 0 /* kSuccess */, |
| 1); |
| } |
| |
| TEST_F(AIPageContentAgentTest, GetImageBytesFailures) { |
| base::HistogramTester histogram_tester; |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <img id='img' alt='testimg'></img>" |
| " <div id='not-image'>hello</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| auto& document = *helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| document.getElementById(AtomicString("img")) |
| ->setAttribute(html_names::kSrcAttr, AtomicString(kSmallImage)); |
| |
| test::RunPendingTasks(); |
| |
| auto* agent = AIPageContentAgent::GetOrCreateForTesting(document); |
| ASSERT_TRUE(agent); |
| |
| int32_t image_node_id = |
| DOMNodeIds::IdForNode(document.getElementById(AtomicString("img"))); |
| int32_t div_node_id = |
| DOMNodeIds::IdForNode(document.getElementById(AtomicString("not-image"))); |
| |
| // 1. Invalid Node ID |
| { |
| base::RunLoop run_loop; |
| agent->GetImageBytes( |
| image_node_id + 9999, |
| base::BindLambdaForTesting( |
| [&](mojom::blink::AIPageContentImageBytesResultPtr result) { |
| EXPECT_FALSE(result); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| histogram_tester.ExpectBucketCount( |
| "OptimizationGuide.AIPageContent.GetImageBytes.Status", |
| 1 /* kNodeNotFound */, 1); |
| } |
| |
| // 2. Cross-Tree Query (different LocalFrameRoot / different WebView) |
| { |
| frame_test_helpers::WebViewHelper helper2; |
| helper2.Initialize(); |
| frame_test_helpers::LoadHTMLString( |
| helper2.LocalMainFrame(), |
| "<body>" |
| " <img id='img2' alt='testimg2'></img>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar2.com")); |
| auto& document2 = *helper2.LocalMainFrame()->GetFrame()->GetDocument(); |
| document2.getElementById(AtomicString("img2")) |
| ->setAttribute(html_names::kSrcAttr, AtomicString(kSmallImage)); |
| |
| test::RunPendingTasks(); |
| |
| int32_t helper2_image_node_id = |
| DOMNodeIds::IdForNode(document2.getElementById(AtomicString("img2"))); |
| |
| base::RunLoop run_loop; |
| agent->GetImageBytes( |
| helper2_image_node_id, |
| base::BindLambdaForTesting( |
| [&](mojom::blink::AIPageContentImageBytesResultPtr result) { |
| EXPECT_FALSE(result); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| histogram_tester.ExpectBucketCount( |
| "OptimizationGuide.AIPageContent.GetImageBytes.Status", |
| 4 /* kCrossTreeQuery */, 1); |
| } |
| |
| // 3. Non-Image Node |
| { |
| base::RunLoop run_loop; |
| agent->GetImageBytes( |
| div_node_id, |
| base::BindLambdaForTesting( |
| [&](mojom::blink::AIPageContentImageBytesResultPtr result) { |
| EXPECT_FALSE(result); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| histogram_tester.ExpectBucketCount( |
| "OptimizationGuide.AIPageContent.GetImageBytes.Status", |
| 5 /* kNotAnImage */, 1); |
| } |
| |
| // 4. Image resource error (broken image) |
| { |
| document.getElementById(AtomicString("img")) |
| ->setAttribute(html_names::kSrcAttr, |
| AtomicString("data:image/jpeg;base64,invalid")); |
| document.UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| test::RunPendingTasks(); |
| |
| base::RunLoop run_loop; |
| agent->GetImageBytes( |
| image_node_id, |
| base::BindLambdaForTesting( |
| [&](mojom::blink::AIPageContentImageBytesResultPtr result) { |
| EXPECT_FALSE(result); |
| run_loop.Quit(); |
| })); |
| run_loop.Run(); |
| histogram_tester.ExpectBucketCount( |
| "OptimizationGuide.AIPageContent.GetImageBytes.Status", |
| 6 /* kImageError */, 1); |
| } |
| } |
| |
| class AIPageContentAgentTestTextEncoding : public AIPageContentAgentTest { |
| private: |
| // All of these tests assume the UTF-8 conversion feature is enabled. |
| ScopedAIPageContentConvertNodeTextToUtf8ForTest enable_utf8_conversion_{true}; |
| }; |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, TextContentCorrected) { |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p id='wrong'>Hello</p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto& document = *helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* p = document.getElementById(AtomicString("wrong")); |
| // Confirm that on the Blink side, we have a valid UTF-16 string. |
| EXPECT_EQ(p->innerText(), String(u"Hello")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"(document.getElementById('wrong').innerText = 'Hello\uD83D')")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| auto* p_node = FindNodeBySelector("#wrong"); |
| CheckTextNode(*p_node->children_nodes[0], String(u"Hello\uFFFD")); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, ImageCaptionCorrected) { |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <img id='wrong' alt='Hello'>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto& document = *helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* img = document.getElementById(AtomicString("wrong")); |
| // Put an actual image in the node. |
| img->setAttribute(html_names::kSrcAttr, AtomicString(kSmallImage)); |
| |
| // Confirm that on the Blink side, we have a valid UTF-16 string. |
| ASSERT_TRUE(IsA<HTMLImageElement>(*img)); |
| EXPECT_EQ(To<HTMLImageElement>(*img).AltText(), String(u"Hello")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"(document.getElementById('wrong').alt = 'Hello\uD83D')")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| auto* image_node = FindNodeBySelector("#wrong"); |
| CheckImageNode(*image_node, String(u"Hello\uFFFD"), KURL()); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, SVGRootCorrected) { |
| ScopedAIPageContentIncludeSVGSubtreeForTest scoped_feature( |
| /*enabled=*/true); |
| |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <svg id='wrongsvg' width='400' height='200'>" |
| " <text id='wrongtext' x='50%' y='50%' font-size='24'>" |
| " Hello SVG Text!" |
| " </text>" |
| " </svg>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"( |
| document |
| .getElementById('wrongsvg') |
| .getElementById('wrongtext') |
| .textContent = ' Hello\uD83D ' |
| )")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& svg = *ContentRootNode().children_nodes[0]; |
| EXPECT_EQ(svg.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kSvgRoot); |
| ASSERT_TRUE(svg.content_attributes->svg_root_data); |
| EXPECT_EQ(svg.content_attributes->svg_root_data->inner_text, u"Hello\uFFFD"); |
| |
| const auto& text_child = *svg.children_nodes[0]; |
| EXPECT_EQ(text_child.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kText); |
| // Note that whitespace is kept. |
| CheckTextNode(text_child, u" Hello\uFFFD "); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, TableNameCorrected) { |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <table>" |
| " <caption id='wrong'>Hello</caption>" |
| " </table>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"(document.getElementById('wrong').innerText = 'Hello\uD83D')")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& table = *ContentRootNode().children_nodes[0]; |
| CheckTableNode(table, u"Hello\uFFFD"); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, FormNameCorrected) { |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form id='wrong' name='Hello'>" |
| " <p>Greetings</p>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"(document.getElementById('wrong').name = 'Hello\uD83D')")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto& form = *ContentRootNode().children_nodes[0]; |
| EXPECT_EQ(form.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kForm); |
| EXPECT_EQ(form.content_attributes->form_data->form_name, u"Hello\uFFFD"); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, |
| AriaFormControlPlaceholderCorrected) { |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='wrong' type='text' aria-required='true' " |
| "aria-placeholder='Hello'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"(document.getElementById('wrong').ariaPlaceholder = 'Hello\uD83D')")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* input = FindNodeBySelector("#wrong"); |
| CheckFormControlNode(*input, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(input->content_attributes->form_control_data->placeholder, |
| u"Hello\uFFFD"); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, TextFormControlValueCorrected) { |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='wrong' type='text' name='Username' value='Hello'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"( |
| let input = document.getElementById('wrong'); |
| input.name = 'Username\uD83D'; |
| input.value = 'Hello\uD83D'; |
| )")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* input = FindNodeBySelector("#wrong"); |
| CheckFormControlNode(*input, mojom::blink::FormControlType::kInputText); |
| const mojom::blink::AIPageContentFormControlDataPtr& form_control_data = |
| input->content_attributes->form_control_data; |
| EXPECT_EQ(form_control_data->field_name, u"Username\uFFFD"); |
| EXPECT_EQ(form_control_data->field_value, u"Hello\uFFFD"); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, |
| TextFormControlPlaceholderCorrected) { |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='wrong' type='text' name='Username' placeholder='Hello'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"( |
| let input = document.getElementById('wrong'); |
| input.name = 'Username\uD83D'; |
| input.placeholder = 'Hello\uD83D'; |
| )")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* input = FindNodeBySelector("#wrong"); |
| CheckFormControlNode(*input, mojom::blink::FormControlType::kInputText); |
| const mojom::blink::AIPageContentFormControlDataPtr& form_control_data = |
| input->content_attributes->form_control_data; |
| EXPECT_EQ(form_control_data->field_name, u"Username\uFFFD"); |
| EXPECT_EQ(form_control_data->placeholder, u"Hello\uFFFD"); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, SelectFormControlOptionsCorrected) { |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <select id='container'>" |
| " <option id='wrong' value='First'>Hello</option>" |
| " </select>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"( |
| let option = document.getElementById('wrong'); |
| option.value = 'First\uD83D'; |
| option.text = 'Hello\uD83D'; |
| )")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| const auto* select = FindNodeBySelector("#container"); |
| CheckFormControlNode(*select, mojom::blink::FormControlType::kSelectOne); |
| const mojom::blink::AIPageContentFormControlDataPtr& form_control_data = |
| select->content_attributes->form_control_data; |
| EXPECT_EQ(form_control_data->select_options[0]->value, u"First\uFFFD"); |
| EXPECT_EQ(form_control_data->select_options[0]->text, u"Hello\uFFFD"); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, MetadataCorrected) { |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<head>" |
| " <meta id='wrong' name='Hello' content='World'>" |
| "</head>" |
| "<body>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"( |
| let meta = document.getElementById('wrong'); |
| meta.name = 'Hello\uD83D'; |
| meta.content = 'World\uD83D'; |
| )")); |
| |
| auto options = GetAIPageContentOptionsForTest(); |
| options->mode = mojom::blink::AIPageContentMode::kActionableElements; |
| options->max_meta_elements = 1; |
| GetAIPageContent(std::move(options)); |
| |
| const mojom::blink::AIPageContentMetaPtr& meta = |
| Content()->frame_data->meta_data[0]; |
| EXPECT_EQ(meta->name, u"Hello\uFFFD"); |
| EXPECT_EQ(meta->content, u"World\uFFFD"); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, AriaLabelCorrected) { |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <button id='wrong' aria-label='Hello'></button>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"( |
| let button = document.getElementById('wrong'); |
| button.ariaLabel = 'Hello\uD83D'; |
| )")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| auto* button = FindNodeBySelector("#wrong"); |
| EXPECT_EQ(button->content_attributes->label, u"Hello\uFFFD"); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, AriaLabeledByCorrected) { |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='wrong' style='display: none;'>Hello</div>" |
| " <input id='on' type='text' aria-labelledby='wrong'>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"( |
| let div = document.getElementById('wrong'); |
| div.textContent = 'Hello\uD83D'; |
| )")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| auto* input = FindNodeBySelector("#on"); |
| EXPECT_EQ(input->content_attributes->label, u"Hello\uFFFD"); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, FrameTitleCorrected) { |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<head>" |
| " <title id='wrong'>Hello</title>" |
| "</head>" |
| "<body>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"( |
| let title = document.getElementById('wrong'); |
| title.textContent = 'Hello\uD83D'; |
| )")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| EXPECT_EQ(Content()->frame_data->title, u"Hello\uFFFD"); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, |
| FrameInteractionInfoSelectedTextCorrected) { |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p id='p1'>Paragraph 1</p>" |
| " <p id='p2'>Paragraph 2</p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"( |
| const p1 = document.getElementById('p1'); |
| p1.innerText = 'Hello\uD83D' |
| const p2 = document.getElementById('p2'); |
| |
| const range = new Range(); |
| range.setStart(p1.childNodes[0], 0); |
| range.setEnd(p2.childNodes[0], 4); |
| const selection = window.getSelection(); |
| selection.removeAllRanges(); |
| selection.addRange(range); |
| )")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| EXPECT_EQ( |
| Content()->frame_data->frame_interaction_info->selection->selected_text, |
| u"Hello\uFFFD\n\nPara"); |
| } |
| |
| TEST_F(AIPageContentAgentTestTextEncoding, FlagDisabled) { |
| ScopedAIPageContentConvertNodeTextToUtf8ForTest enable_utf8_conversion{false}; |
| // Start with a basic valid UTF-16 string. |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <p id='wrong'>Hello</p>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| auto& document = *helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* p = document.getElementById(AtomicString("wrong")); |
| // Confirm that on the Blink side, we have a valid UTF-16 string. |
| EXPECT_EQ(p->innerText(), String(u"Hello")); |
| |
| // The only way to get an invalid UTF-16 string into the element is via |
| // Javascript, which isn't required to match surrogates. In this case, the |
| // unmatched surrogate is \uD83D. We also need to use a raw string so that the |
| // unicode character is interpreted by Javascript, not CPP. |
| helper_.LocalMainFrame()->ExecuteScript(WebScriptSource( |
| R"(document.getElementById('wrong').innerText = 'Hello\uD83D')")); |
| |
| GetAIPageContentWithActionableElements(); |
| |
| auto* p_node = FindNodeBySelector("#wrong"); |
| const auto& text_attributes = *p_node->children_nodes[0]->content_attributes; |
| EXPECT_EQ(text_attributes.attribute_type, |
| mojom::blink::AIPageContentAttributeType::kText); |
| ASSERT_TRUE(text_attributes.text_info); |
| |
| // The last character should be 0xD83D. |
| EXPECT_EQ(text_attributes.text_info->text_content.Span16().back(), 0xD83D); |
| } |
| |
| TEST_F(AIPageContentAgentTest, DivWithWebkitTextSecurityRedactsAndPersists) { |
| ScopedAIPageContentElementCSSRedactionForTest scoped_feature( |
| /*enabled=*/true); |
| |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='masked' style='-webkit-text-security: disc;'>secret</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| EXPECT_EQ(root.children_nodes.size(), 0u); |
| |
| // Now remove the masking style (simulating a "show password" eye icon). |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* div_element = |
| To<HTMLDivElement>(document->getElementById(AtomicString("masked"))); |
| ASSERT_TRUE(div_element); |
| div_element->setAttribute(html_names::kStyleAttr, |
| AtomicString("-webkit-text-security: none;")); |
| |
| // Ensure the DOM is updated. |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| // Extract again: the field should remain redacted since it was previously |
| // classified as password-like. |
| GetAIPageContent(); |
| |
| const auto& root2 = ContentRootNode(); |
| EXPECT_EQ(root2.children_nodes.size(), 0u); |
| } |
| |
| TEST_F(AIPageContentAgentTest, |
| FormWithWebkitTextSecuritySelectRedactsAndPersists) { |
| ScopedAIPageContentElementCSSRedactionForTest scoped_feature( |
| /*enabled=*/true); |
| |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <select id='masked' style='-webkit-text-security: disc;'>" |
| " <option value='Lorem'>Lorem Text</option>" |
| " <option value='Ipsum'>Ipsum Text</option>" |
| " </select>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& form = *root.children_nodes[0]; |
| ASSERT_EQ(form.children_nodes.size(), 1u); |
| |
| const auto& select = *form.children_nodes[0]; |
| CheckFormControlNode(select, mojom::blink::FormControlType::kSelectOne); |
| EXPECT_EQ( |
| select.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_CSS); |
| EXPECT_TRUE( |
| select.content_attributes->form_control_data->select_options.empty()); |
| |
| // Now remove the masking style. |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* select_element = |
| To<HTMLSelectElement>(document->getElementById(AtomicString("masked"))); |
| ASSERT_TRUE(select_element); |
| select_element->setAttribute(html_names::kStyleAttr, |
| AtomicString("-webkit-text-security: none;")); |
| |
| // Ensure the DOM is updated. |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| // Extract again: the field should remain redacted. |
| GetAIPageContent(); |
| |
| const auto& root2 = ContentRootNode(); |
| const auto& form2 = *root2.children_nodes[0]; |
| const auto& select2 = *form2.children_nodes[0]; |
| CheckFormControlNode(select2, mojom::blink::FormControlType::kSelectOne); |
| EXPECT_EQ( |
| select2.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_CSS); |
| EXPECT_TRUE( |
| select2.content_attributes->form_control_data->select_options.empty()); |
| } |
| |
| class AIPageContentAgentTestElementCSSRedactionDisabled |
| : public AIPageContentAgentTest { |
| private: |
| ScopedAIPageContentElementCSSRedactionForTest scoped_feature{false}; |
| }; |
| |
| TEST_F(AIPageContentAgentTestElementCSSRedactionDisabled, |
| DivWithWebkitTextSecurityNotRedacted) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <div id='masked' style='-webkit-text-security: disc;'>secret</div>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| // Since the feature is disabled, the div is flattened (it's generic) |
| // and the text node is extracted without redaction. |
| // Note: the text is still masked by the layout engine (bullets), |
| // but it's not explicitly redacted by our logic. |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& text_node = *root.children_nodes[0]; |
| EXPECT_EQ(text_node.content_attributes->attribute_type, |
| mojom::blink::AIPageContentAttributeType::kText); |
| ASSERT_TRUE(text_node.content_attributes->text_info); |
| // The text should be masked (bullets), but NOT redacted. |
| // We check that it's not the original text and has the same length. |
| EXPECT_NE(text_node.content_attributes->text_info->text_content, "secret"); |
| EXPECT_EQ(text_node.content_attributes->text_info->text_content.length(), 6u); |
| EXPECT_EQ(text_node.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kNoRedactionNecessary); |
| } |
| |
| TEST_F(AIPageContentAgentTestElementCSSRedactionDisabled, |
| FormWithWebkitTextSecuritySelectNotRedacted) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <select id='masked' style='-webkit-text-security: disc;'>" |
| " <option value='Lorem'>Lorem Text</option>" |
| " </select>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| // root -> <select> |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& select = *root.children_nodes[0]; |
| CheckFormControlNode(select, mojom::blink::FormControlType::kSelectOne); |
| EXPECT_EQ(select.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kNoRedactionNecessary); |
| // Options should be present. |
| EXPECT_FALSE( |
| select.content_attributes->form_control_data->select_options.empty()); |
| EXPECT_EQ(select.content_attributes->form_control_data->select_options.size(), |
| 1u); |
| EXPECT_EQ( |
| select.content_attributes->form_control_data->select_options[0]->text, |
| "Lorem Text"); |
| } |
| |
| TEST_F(AIPageContentAgentTestElementCSSRedactionDisabled, |
| FormWithWebkitTextSecurityInputStillRedacted) { |
| frame_test_helpers::LoadHTMLString( |
| helper_.LocalMainFrame(), |
| "<body>" |
| " <form>" |
| " <input id='masked' type='text' name='Enter secret' " |
| "style='-webkit-text-security: disc;' value='supersecret'>" |
| " </form>" |
| "</body>", |
| url_test_helpers::ToKURL("http://foobar.com")); |
| |
| GetAIPageContent(); |
| |
| const auto& root = ContentRootNode(); |
| ASSERT_EQ(root.children_nodes.size(), 1u); |
| const auto& form = *root.children_nodes[0]; |
| ASSERT_EQ(form.children_nodes.size(), 1u); |
| |
| const auto& field = *form.children_nodes[0]; |
| CheckFormControlNode(field, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field.content_attributes->form_control_data->field_name, |
| "Enter secret"); |
| EXPECT_EQ(field.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ( |
| field.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_CSS); |
| |
| // Now remove the masking style (simulating a "show password" eye icon). |
| Document* document = helper_.LocalMainFrame()->GetFrame()->GetDocument(); |
| auto* input_element = |
| To<HTMLInputElement>(document->getElementById(AtomicString("masked"))); |
| ASSERT_TRUE(input_element); |
| input_element->setAttribute(html_names::kStyleAttr, |
| AtomicString("-webkit-text-security: none;")); |
| |
| // Ensure the DOM is updated. |
| document->UpdateStyleAndLayout(DocumentUpdateReason::kTest); |
| |
| // Extract again: the field should remain redacted since it was previously |
| // classified as password-like. |
| GetAIPageContent(); |
| |
| const auto& root2 = ContentRootNode(); |
| ASSERT_EQ(root2.children_nodes.size(), 1u); |
| const auto& form2 = *root2.children_nodes[0]; |
| ASSERT_EQ(form2.children_nodes.size(), 1u); |
| const auto& field2 = *form2.children_nodes[0]; |
| CheckFormControlNode(field2, mojom::blink::FormControlType::kInputText); |
| EXPECT_EQ(field2.content_attributes->form_control_data->field_value, nullptr); |
| EXPECT_EQ( |
| field2.content_attributes->redaction_decision, |
| mojom::AIPageContentRedactionDecision::kRedacted_CustomPassword_CSS); |
| } |
| |
| } // namespace |
| } // namespace blink |
