Add text fields in PdfAccessibilityTree

This CL creates text field nodes using PdfAccessibilityTextFieldInfo
sent from plugin process and inserts them in the PdfAccessibilityTree.
A feature flag is added to guard PDF Form accessibility feature.

This CL also includes test to validate the creation of text field nodes
in PdfAccessibilityTree.

Bug: 1030242
Change-Id: Idd92c04c8dd4f30b821d109284e0c0e724ab960b
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/2087318
Commit-Queue: Mansi Awasthi <maawas@microsoft.com>
Reviewed-by: Kevin Babbitt <kbabbitt@microsoft.com>
Reviewed-by: Lei Zhang <thestig@chromium.org>
Reviewed-by: Dominic Mazzoni <dmazzoni@chromium.org>
Cr-Commit-Position: refs/heads/master@{#752414}

components/pdf/renderer/pdf_accessibility_tree.cc

@@ -376,7 +376,8 @@ void PdfAccessibilityTree::SetAccessibilityDocInfo(
     return;
 
   doc_info_ = doc_info;
-  doc_node_ = CreateNode(ax::mojom::Role::kDocument);
+  doc_node_ =
+      CreateNode(ax::mojom::Role::kDocument, ax::mojom::Restriction::kReadOnly);
   doc_node_->AddStringAttribute(
       ax::mojom::StringAttribute::kName,
       l10n_util::GetPluralStringFUTF8(IDS_PDF_DOCUMENT_PAGE_COUNT,
@@ -411,7 +412,8 @@ void PdfAccessibilityTree::SetAccessibilityPageInfo(
   CHECK_GE(page_index, 0U);
   CHECK_LT(page_index, doc_info_.page_count);
 
-  ui::AXNodeData* page_node = CreateNode(ax::mojom::Role::kRegion);
+  ui::AXNodeData* page_node =
+      CreateNode(ax::mojom::Role::kRegion, ax::mojom::Restriction::kReadOnly);
   page_node->AddStringAttribute(
       ax::mojom::StringAttribute::kName,
       l10n_util::GetPluralStringFUTF8(IDS_PDF_PAGE_INDEX, page_index + 1));
@@ -459,6 +461,7 @@ void PdfAccessibilityTree::AddPageContent(
   uint32_t current_link_index = 0;
   uint32_t current_image_index = 0;
   uint32_t current_highlight_index = 0;
+  uint32_t current_text_field_index = 0;
   LineHelper line_helper(text_runs);
   const std::vector<ppapi::PdfAccessibilityLinkInfo>& links =
       page_objects.links;
@@ -466,6 +469,8 @@ void PdfAccessibilityTree::AddPageContent(
       page_objects.images;
   const std::vector<ppapi::PdfAccessibilityHighlightInfo>& highlights =
       page_objects.highlights;
+  const std::vector<ppapi::PdfAccessibilityTextFieldInfo>& text_fields =
+      page_objects.text_fields;
 
   for (size_t text_run_index = 0; text_run_index < text_runs.size();
        ++text_run_index) {
@@ -566,6 +571,19 @@ void PdfAccessibilityTree::AddPageContent(
 
       text_run_index =
           std::max<size_t>(highlight_end_text_run_index, text_run_index);
+    } else if (IsObjectInTextRun(text_fields, current_text_field_index,
+                                 text_run_index) &&
+               base::FeatureList::IsEnabled(
+                   chrome_pdf::features::kAccessiblePDFForm)) {
+      FinishStaticNode(&static_text_node, &static_text);
+      // If the |text_run_index| is less than or equal to the text_field's text
+      // run index, then push the text_field ahead of the current text run.
+      ui::AXNodeData* text_field_node =
+          CreateTextFieldNode(text_fields[current_text_field_index]);
+      para_node->child_ids.push_back(text_field_node->id);
+      ++current_text_field_index;
+      --text_run_index;
+      continue;
     } else {
       PP_PdfPageCharacterIndex page_char_index = {
           page_index, text_run_start_indices[text_run_index]};
@@ -629,8 +647,10 @@ void PdfAccessibilityTree::AddPageContent(
       base::make_span(links).subspan(current_link_index);
   base::span<const ppapi::PdfAccessibilityImageInfo> remaining_images =
       base::make_span(images).subspan(current_image_index);
+  base::span<const ppapi::PdfAccessibilityTextFieldInfo> remaining_text_fields =
+      base::make_span(text_fields).subspan(current_text_field_index);
   AddRemainingAnnotations(page_node, page_bounds, page_index, remaining_links,
-                          remaining_images, para_node);
+                          remaining_images, remaining_text_fields, para_node);
 }
 
 void PdfAccessibilityTree::AddRemainingAnnotations(
@@ -639,11 +659,14 @@ void PdfAccessibilityTree::AddRemainingAnnotations(
     uint32_t page_index,
     base::span<const ppapi::PdfAccessibilityLinkInfo> links,
     base::span<const ppapi::PdfAccessibilityImageInfo> images,
+    base::span<const ppapi::PdfAccessibilityTextFieldInfo> text_fields,
     ui::AXNodeData* para_node) {
-  // If we have additional links or images to insert in the tree, and we don't
-  // have a paragraph node, create a new one.
-  if (!para_node && (!links.empty() || !images.empty())) {
-    para_node = CreateNode(ax::mojom::Role::kParagraph);
+  // If we have additional links, images or text fields to insert in the tree,
+  // and we don't have a paragraph node, create a new one.
+  if (!para_node &&
+      (!links.empty() || !images.empty() || !text_fields.empty())) {
+    para_node = CreateNode(ax::mojom::Role::kParagraph,
+                           ax::mojom::Restriction::kReadOnly);
     page_node->child_ids.push_back(para_node->id);
   }
   // Push all the links not anchored to any text run to the last paragraph.
@@ -656,6 +679,15 @@ void PdfAccessibilityTree::AddRemainingAnnotations(
     ui::AXNodeData* image_node = CreateImageNode(image);
     para_node->child_ids.push_back(image_node->id);
   }
+
+  if (base::FeatureList::IsEnabled(chrome_pdf::features::kAccessiblePDFForm)) {
+    // Push all the text fields not anchored to any text run to the last
+    // paragraph.
+    for (const ppapi::PdfAccessibilityTextFieldInfo& text_field : text_fields) {
+      ui::AXNodeData* text_field_node = CreateTextFieldNode(text_field);
+      para_node->child_ids.push_back(text_field_node->id);
+    }
+  }
 }
 
 void PdfAccessibilityTree::Finish() {
@@ -775,14 +807,16 @@ gfx::RectF PdfAccessibilityTree::ToRectF(const PP_Rect& r) {
   return gfx::RectF(r.point.x, r.point.y, r.size.width, r.size.height);
 }
 
-ui::AXNodeData* PdfAccessibilityTree::CreateNode(ax::mojom::Role role) {
+ui::AXNodeData* PdfAccessibilityTree::CreateNode(
+    ax::mojom::Role role,
+    ax::mojom::Restriction restriction) {
   content::RenderAccessibility* render_accessibility = GetRenderAccessibility();
   DCHECK(render_accessibility);
 
   ui::AXNodeData* node = new ui::AXNodeData();
   node->id = render_accessibility->GenerateAXID();
   node->role = role;
-  node->SetRestriction(ax::mojom::Restriction::kReadOnly);
+  node->SetRestriction(restriction);
 
   // All nodes other than the first one have coordinates relative to
   // the first node.
@@ -797,7 +831,8 @@ ui::AXNodeData* PdfAccessibilityTree::CreateNode(ax::mojom::Role role) {
 ui::AXNodeData* PdfAccessibilityTree::CreateParagraphNode(
     float font_size,
     float heading_font_size_threshold) {
-  ui::AXNodeData* para_node = CreateNode(ax::mojom::Role::kParagraph);
+  ui::AXNodeData* para_node = CreateNode(ax::mojom::Role::kParagraph,
+                                         ax::mojom::Restriction::kReadOnly);
   para_node->AddBoolAttribute(ax::mojom::BoolAttribute::kIsLineBreakingObject,
                               true);
 
@@ -815,7 +850,8 @@ ui::AXNodeData* PdfAccessibilityTree::CreateParagraphNode(
 
 ui::AXNodeData* PdfAccessibilityTree::CreateStaticTextNode(
     const PP_PdfPageCharacterIndex& page_char_index) {
-  ui::AXNodeData* static_text_node = CreateNode(ax::mojom::Role::kStaticText);
+  ui::AXNodeData* static_text_node = CreateNode(
+      ax::mojom::Role::kStaticText, ax::mojom::Restriction::kReadOnly);
   node_id_to_page_char_index_.emplace(static_text_node->id, page_char_index);
   return static_text_node;
 }
@@ -825,8 +861,8 @@ ui::AXNodeData* PdfAccessibilityTree::CreateInlineTextBoxNode(
     const std::vector<PP_PrivateAccessibilityCharInfo>& chars,
     const PP_PdfPageCharacterIndex& page_char_index,
     const gfx::RectF& page_bounds) {
-  ui::AXNodeData* inline_text_box_node =
-      CreateNode(ax::mojom::Role::kInlineTextBox);
+  ui::AXNodeData* inline_text_box_node = CreateNode(
+      ax::mojom::Role::kInlineTextBox, ax::mojom::Restriction::kReadOnly);
 
   std::string chars_utf8 =
       GetTextRunCharsAsUTF8(text_run, chars, page_char_index.char_index);
@@ -867,7 +903,8 @@ ui::AXNodeData* PdfAccessibilityTree::CreateInlineTextBoxNode(
 ui::AXNodeData* PdfAccessibilityTree::CreateLinkNode(
     const ppapi::PdfAccessibilityLinkInfo& link,
     uint32_t page_index) {
-  ui::AXNodeData* link_node = CreateNode(ax::mojom::Role::kLink);
+  ui::AXNodeData* link_node =
+      CreateNode(ax::mojom::Role::kLink, ax::mojom::Restriction::kReadOnly);
 
   link_node->AddStringAttribute(ax::mojom::StringAttribute::kUrl, link.url);
   link_node->AddStringAttribute(ax::mojom::StringAttribute::kName,
@@ -881,7 +918,8 @@ ui::AXNodeData* PdfAccessibilityTree::CreateLinkNode(
 
 ui::AXNodeData* PdfAccessibilityTree::CreateImageNode(
     const ppapi::PdfAccessibilityImageInfo& image) {
-  ui::AXNodeData* image_node = CreateNode(ax::mojom::Role::kImage);
+  ui::AXNodeData* image_node =
+      CreateNode(ax::mojom::Role::kImage, ax::mojom::Restriction::kReadOnly);
 
   if (image.alt_text.empty()) {
     image_node->AddStringAttribute(
@@ -898,7 +936,8 @@ ui::AXNodeData* PdfAccessibilityTree::CreateImageNode(
 ui::AXNodeData* PdfAccessibilityTree::CreateHighlightNode(
     const ppapi::PdfAccessibilityHighlightInfo& highlight) {
   ui::AXNodeData* highlight_node =
-      CreateNode(ax::mojom::Role::kPdfActionableHighlight);
+      CreateNode(ax::mojom::Role::kPdfActionableHighlight,
+                 ax::mojom::Restriction::kReadOnly);
 
   highlight_node->AddStringAttribute(
       ax::mojom::StringAttribute::kRoleDescription,
@@ -912,6 +951,29 @@ ui::AXNodeData* PdfAccessibilityTree::CreateHighlightNode(
   return highlight_node;
 }
 
+ui::AXNodeData* PdfAccessibilityTree::CreateTextFieldNode(
+    const ppapi::PdfAccessibilityTextFieldInfo& text_field) {
+  ax::mojom::Restriction restriction = text_field.is_read_only
+                                           ? ax::mojom::Restriction::kReadOnly
+                                           : ax::mojom::Restriction::kNone;
+  ui::AXNodeData* text_field_node =
+      CreateNode(ax::mojom::Role::kTextField, restriction);
+
+  text_field_node->AddStringAttribute(ax::mojom::StringAttribute::kName,
+                                      text_field.name);
+  text_field_node->AddStringAttribute(ax::mojom::StringAttribute::kValue,
+                                      text_field.value);
+  text_field_node->AddState(ax::mojom::State::kFocusable);
+  if (text_field.is_required)
+    text_field_node->AddState(ax::mojom::State::kRequired);
+  if (text_field.is_password)
+    text_field_node->AddState(ax::mojom::State::kProtected);
+  if (!text_field.is_read_only)
+    text_field_node->AddState(ax::mojom::State::kEditable);
+  text_field_node->relative_bounds.bounds = ToGfxRectF(text_field.bounds);
+  return text_field_node;
+}
+
 void PdfAccessibilityTree::AddTextToAXNode(
     uint32_t start_text_run_index,
     uint32_t end_text_run_index,

components/pdf/renderer/pdf_accessibility_tree.h

@@ -123,6 +123,7 @@ class PdfAccessibilityTree : public content::PluginAXTreeSource {
       uint32_t page_index,
       base::span<const ppapi::PdfAccessibilityLinkInfo> links,
       base::span<const ppapi::PdfAccessibilityImageInfo> images,
+      base::span<const ppapi::PdfAccessibilityTextFieldInfo> text_fields,
       ui::AXNodeData* para_node);
 
   std::string GetTextRunCharsAsUTF8(
@@ -135,7 +136,8 @@ class PdfAccessibilityTree : public content::PluginAXTreeSource {
       int char_index);
   gfx::Vector2dF ToVector2dF(const PP_Point& p);
   gfx::RectF ToRectF(const PP_Rect& r);
-  ui::AXNodeData* CreateNode(ax::mojom::Role role);
+  ui::AXNodeData* CreateNode(ax::mojom::Role role,
+                             ax::mojom::Restriction restriction);
   ui::AXNodeData* CreateParagraphNode(float font_size,
                                       float heading_font_size_threshold);
   ui::AXNodeData* CreateStaticTextNode(
@@ -151,6 +153,8 @@ class PdfAccessibilityTree : public content::PluginAXTreeSource {
       const ppapi::PdfAccessibilityImageInfo& image);
   ui::AXNodeData* CreateHighlightNode(
       const ppapi::PdfAccessibilityHighlightInfo& highlight);
+  ui::AXNodeData* CreateTextFieldNode(
+      const ppapi::PdfAccessibilityTextFieldInfo& text_field);
   void AddTextToAXNode(
       uint32_t start_text_run_index,
       uint32_t end_text_run_index,

components/pdf/renderer/pdf_accessibility_tree_browsertest.cc

@@ -432,6 +432,135 @@ TEST_F(PdfAccessibilityTreeTest, TestHighlightCreation) {
   ASSERT_EQ(2u, static_text_node->children().size());
 }
 
+TEST_F(PdfAccessibilityTreeTest, TestTextFieldNodeCreation) {
+  // Enable feature flag
+  base::test::ScopedFeatureList scoped_feature_list;
+  scoped_feature_list.InitAndEnableFeature(
+      chrome_pdf::features::kAccessiblePDFForm);
+  text_runs_.emplace_back(kFirstTextRun);
+  text_runs_.emplace_back(kSecondTextRun);
+  chars_.insert(chars_.end(), std::begin(kDummyCharsData),
+                std::end(kDummyCharsData));
+
+  {
+    ppapi::PdfAccessibilityTextFieldInfo text_field;
+    text_field.bounds = PP_MakeFloatRectFromXYWH(1.0f, 1.0f, 5.0f, 6.0f);
+    text_field.index_in_page = 0;
+    text_field.text_run_index = 2;
+    text_field.name = "Text Box";
+    text_field.value = "Text";
+    text_field.is_read_only = false;
+    text_field.is_required = false;
+    text_field.is_password = false;
+    page_objects_.text_fields.push_back(std::move(text_field));
+  }
+
+  {
+    ppapi::PdfAccessibilityTextFieldInfo text_field;
+    text_field.bounds = PP_MakeFloatRectFromXYWH(1.0f, 10.0f, 5.0f, 6.0f);
+    text_field.index_in_page = 1;
+    text_field.text_run_index = 2;
+    text_field.name = "Text Box 2";
+    text_field.value = "Text 2";
+    text_field.is_read_only = true;
+    text_field.is_required = true;
+    text_field.is_password = true;
+    page_objects_.text_fields.push_back(std::move(text_field));
+  }
+
+  page_info_.text_run_count = text_runs_.size();
+  page_info_.char_count = chars_.size();
+
+  content::RenderFrame* render_frame = view_->GetMainRenderFrame();
+  ASSERT_TRUE(render_frame);
+  render_frame->SetAccessibilityModeForTest(ui::AXMode::kWebContents);
+  ASSERT_TRUE(render_frame->GetRenderAccessibility());
+
+  FakeRendererPpapiHost host(view_->GetMainRenderFrame());
+  PP_Instance instance = 0;
+  pdf::PdfAccessibilityTree pdf_accessibility_tree(&host, instance);
+
+  pdf_accessibility_tree.SetAccessibilityViewportInfo(viewport_info_);
+  pdf_accessibility_tree.SetAccessibilityDocInfo(doc_info_);
+  pdf_accessibility_tree.SetAccessibilityPageInfo(page_info_, text_runs_,
+                                                  chars_, page_objects_);
+
+  /*
+   * Expected tree structure
+   * Document
+   * ++ Region
+   * ++++ Paragraph
+   * ++++++ Static Text
+   * ++++ Paragraph
+   * ++++++ Static Text
+   * ++++++ Text Field
+   * ++++++ Text Field
+   */
+
+  ui::AXNode* root_node = pdf_accessibility_tree.GetRoot();
+  ASSERT_TRUE(root_node);
+  EXPECT_EQ(ax::mojom::Role::kDocument, root_node->data().role);
+  ASSERT_EQ(1u, root_node->children().size());
+
+  ui::AXNode* page_node = root_node->children()[0];
+  ASSERT_TRUE(page_node);
+  EXPECT_EQ(ax::mojom::Role::kRegion, page_node->data().role);
+  ASSERT_EQ(2u, page_node->children().size());
+
+  ui::AXNode* paragraph_node = page_node->children()[0];
+  ASSERT_TRUE(paragraph_node);
+  EXPECT_EQ(ax::mojom::Role::kParagraph, paragraph_node->data().role);
+  ASSERT_EQ(1u, paragraph_node->children().size());
+
+  ui::AXNode* static_text_node = paragraph_node->children()[0];
+  ASSERT_TRUE(static_text_node);
+  EXPECT_EQ(ax::mojom::Role::kStaticText, static_text_node->data().role);
+  ASSERT_EQ(1u, static_text_node->children().size());
+
+  paragraph_node = page_node->children()[1];
+  ASSERT_TRUE(paragraph_node);
+  EXPECT_EQ(ax::mojom::Role::kParagraph, paragraph_node->data().role);
+  const std::vector<ui::AXNode*>& child_nodes = paragraph_node->children();
+  ASSERT_EQ(3u, child_nodes.size());
+
+  static_text_node = child_nodes[0];
+  ASSERT_TRUE(static_text_node);
+  EXPECT_EQ(ax::mojom::Role::kStaticText, static_text_node->data().role);
+  ASSERT_EQ(1u, static_text_node->children().size());
+
+  ui::AXNode* text_field_node = child_nodes[1];
+  ASSERT_TRUE(text_field_node);
+  EXPECT_EQ(ax::mojom::Role::kTextField, text_field_node->data().role);
+  EXPECT_EQ("Text Box", text_field_node->GetStringAttribute(
+                            ax::mojom::StringAttribute::kName));
+  EXPECT_EQ("Text", text_field_node->GetStringAttribute(
+                        ax::mojom::StringAttribute::kValue));
+  EXPECT_FALSE(text_field_node->data().HasState(ax::mojom::State::kRequired));
+  EXPECT_FALSE(text_field_node->data().HasState(ax::mojom::State::kProtected));
+  EXPECT_TRUE(text_field_node->data().HasState(ax::mojom::State::kEditable));
+  EXPECT_NE(ax::mojom::Restriction::kReadOnly,
+            text_field_node->data().GetRestriction());
+  EXPECT_EQ(gfx::RectF(1.0f, 1.0f, 5.0f, 6.0f),
+            text_field_node->data().relative_bounds.bounds);
+  EXPECT_EQ(0u, text_field_node->children().size());
+
+  text_field_node = child_nodes[2];
+  ASSERT_TRUE(text_field_node);
+  EXPECT_EQ(ax::mojom::Role::kTextField, text_field_node->data().role);
+  EXPECT_EQ("Text Box 2", text_field_node->GetStringAttribute(
+                              ax::mojom::StringAttribute::kName));
+  EXPECT_EQ("Text 2", text_field_node->GetStringAttribute(
+                          ax::mojom::StringAttribute::kValue));
+  EXPECT_TRUE(text_field_node->data().HasState(ax::mojom::State::kRequired));
+  EXPECT_TRUE(text_field_node->data().HasState(ax::mojom::State::kProtected));
+  EXPECT_FALSE(text_field_node->data().HasState(ax::mojom::State::kEditable));
+  EXPECT_EQ(ax::mojom::Restriction::kReadOnly,
+            text_field_node->data().GetRestriction());
+  EXPECT_EQ(gfx::RectF(1.0f, 10.0f, 5.0f, 6.0f),
+            text_field_node->data().relative_bounds.bounds);
+  EXPECT_EQ(0u, text_field_node->children().size());
+}
+
 TEST_F(PdfAccessibilityTreeTest, TestPreviousNextOnLine) {
   text_runs_.emplace_back(kFirstRunMultiLine);
   text_runs_.emplace_back(kSecondRunMultiLine);

pdf/pdf_features.cc

@@ -7,6 +7,9 @@
 namespace chrome_pdf {
 namespace features {
 
+const base::Feature kAccessiblePDFForm = {"AccessiblePDFForm",
+                                          base::FEATURE_DISABLED_BY_DEFAULT};
+
 const base::Feature kAccessiblePDFHighlight = {
     "AccessiblePDFHighlight", base::FEATURE_DISABLED_BY_DEFAULT};
 

pdf/pdf_features.h

@@ -13,6 +13,7 @@
 namespace chrome_pdf {
 namespace features {
 
+extern const base::Feature kAccessiblePDFForm;
 extern const base::Feature kAccessiblePDFHighlight;
 extern const base::Feature kPDFAnnotations;
 extern const base::Feature kPDFTwoUpView;