Revert "PDF a11y: kTextDirection attribute support"

This reverts commit 753f8707.

Reason for revert: Test failing on multiple bots.
https://ci.chromium.org/p/chromium/builders/ci/Mac10.10%20Tests/46160
https://ci.chromium.org/p/chromium/builders/ci/Linux%20Tests/81082

Original change's description:
> PDF a11y: kTextDirection attribute support
> 
> The text direction attribute is now properly set for text runs in PDF.
> It is inferred by the position of the first and the last characters of
> a text run.
> 
> This change includes a pdf-template file (text-direction.in) with RTL
> text representation used to generate our unit test PDF file.
> 
> Bug: 985604
> Change-Id: If5d82296463331e95c4ded4e5244d65be3fbadfa
> Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1737019
> Commit-Queue: Benjamin Beaudry <benjamin.beaudry@microsoft.com>
> Reviewed-by: Lei Zhang <thestig@chromium.org>
> Reviewed-by: Kevin Babbitt <kbabbitt@microsoft.com>
> Cr-Commit-Position: refs/heads/master@{#690163}

TBR=thestig@chromium.org,kbabbitt@microsoft.com,benjamin.beaudry@microsoft.com

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: 985604
Change-Id: Ic276193fbc4d1d60ae234a653b1decf2094036b7
Reviewed-on: https://chromium-review.googlesource.com/c/chromium/src/+/1768606Reviewed-by: Anand Mistry <amistry@chromium.org>
Commit-Queue: Anand Mistry <amistry@chromium.org>
Cr-Commit-Position: refs/heads/master@{#690260}

chrome/browser/pdf/pdf_extension_test.cc

@@ -2407,44 +2407,13 @@ class PDFExtensionAccessibilityTreeDumpTest
  private:
   using PropertyFilter = content::AccessibilityTreeFormatter::PropertyFilter;
 
-  //  See chrome/test/data/pdf/accessibility/readme.md for more info.
-  void ParsePdfForExtraDirectives(
-      const std::string& pdf_contents,
-      content::AccessibilityTreeFormatter* formatter,
-      std::vector<PropertyFilter>* property_filters) {
-    const char kCommentMark = '%';
-    for (const std::string& line : base::SplitString(
-             pdf_contents, "\n", base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL)) {
-      if (line.size() > 1 && line[0] == kCommentMark) {
-        // Remove first character since it's the comment mark.
-        std::string trimmed_line = line.substr(1);
-        const std::string& allow_str = formatter->GetAllowString();
-        if (base::StartsWith(trimmed_line, allow_str,
-                             base::CompareCase::SENSITIVE)) {
-          property_filters->push_back(PropertyFilter(
-              base::UTF8ToUTF16(trimmed_line.substr(allow_str.size())),
-              PropertyFilter::ALLOW));
-        }
-      }
-    }
-  }
-
   void RunTest(const base::FilePath& test_file_path, const char* file_dir) {
-    std::string pdf_contents;
-    {
-      base::ScopedAllowBlockingForTesting allow_blocking;
-      ASSERT_TRUE(base::ReadFileToString(test_file_path, &pdf_contents));
-    }
-
-    // Set up the tree formatter. Parse filters and other directives in the test
-    // file.
+    // Set up the tree formatter.
     std::unique_ptr<content::AccessibilityTreeFormatter> formatter =
         test_pass_.create_formatter();
     std::vector<PropertyFilter> property_filters;
     formatter->AddDefaultFilters(&property_filters);
     AddDefaultFilters(&property_filters);
-    ParsePdfForExtraDirectives(pdf_contents, formatter.get(),
-                               &property_filters);
     formatter->SetPropertyFilters(property_filters);
 
     // Exit without running the test if we can't find an expectation file or if
@@ -2563,7 +2532,3 @@ IN_PROC_BROWSER_TEST_P(PDFExtensionAccessibilityTreeDumpTest,
                        DirectionalTextRuns) {
   RunPDFTest(FILE_PATH_LITERAL("directional-text-runs.pdf"));
 }
-
-IN_PROC_BROWSER_TEST_P(PDFExtensionAccessibilityTreeDumpTest, TextDirection) {
-  RunPDFTest(FILE_PATH_LITERAL("text-direction.pdf"));
-}
\ No newline at end of file

chrome/test/data/pdf/accessibility/readme.md

-# PdfExtensionAccessibilityTreeDumpTest
-
-A `PdfExtensionAccessibilityTreeDumpTest` loads a PDF file, waits for it
-to load, then dumps the accessibility tree. More about accessibility tree
-dump tests at `content/test/data/accessibility/readme.md`.
-
-## Filters and directives
-
-Please refer to `content/test/data/accessibility/readme.md` to see
-how to use filters. Supported filters and directives are:
-* [x] `@<platform>-ALLOW:`
-* [ ] `@<platform>-ALLOW-EMPTY:`
-* [ ] `@<platform>-DENY:`
-* [ ] `@WAIT-FOR:`
-
-The PdfExtensionAccessibilityTreeDumpTest implementation of extra
-directives/filters is similar to the DumpAccessibilityTreeTest. If you
-need to support additional directives/filters, see
-/src/content/test/data/accessibility/readme.md to respect the same
-interface as the one used for HTML accessibility tree dump tests.
-
-Implementation details for parsing extra directives in HTML can be
-found in `DumpAccessibilityTestBase::ParseHtmlForExtraDirectives()`.

chrome/test/data/pdf/accessibility/text-direction-expected-blink.txt

-embeddedObject textDirection=ltr
-++document restriction=readOnly
-++++region name='Page 1' restriction=readOnly isPageBreakingObject=true
-++++++paragraph restriction=readOnly
-++++++++staticText name='abcdef<newline>شممشا' restriction=readOnly
-++++++++++inlineTextBox name='abcdef<newline>' restriction=readOnly textDirection=ltr
-++++++++++inlineTextBox name='شممشا' restriction=readOnly textDirection=rtl
\ No newline at end of file

chrome/test/data/pdf/accessibility/text-direction.in

-{{header}}
-%@BLINK-ALLOW:textDirection=*
-{{object 1 0}} <<
-  /Type /Catalog
-  /Pages 2 0 R
->>
-endobj
-{{object 2 0}} <<
-  /Type /Pages
-  /MediaBox [0 0 200 200]
-  /Count 1
-  /Kids [3 0 R]
->>
-endobj
-{{object 3 0}} <<
-  /Type /Page
-  /Parent 2 0 R
-  /Resources <<
-    /Font <<
-      /F1 4 0 R
-    >>
-  >>
-  /Contents 8 0 R
->>
-endobj
-{{object 4 0}} <<
-  /Type /Font
-  /Subtype /Type0
-  /BaseFont /Arial
-  /Encoding /Identity-H
-  /DescendantFonts [6 0 R]
-  /ToUnicode 7 0 R
->>
-endobj
-{{object 5 0}} <<
-  /Type /FontDescriptor
-  /FontName /Arial
->>
-endobj
-{{object 6 0}} <<
-  /Type /Font
-  /FontDescriptor 5 0 R
-  /BaseFont /Arial
-  /Subtype /CIDFontType2
-  /W [0 [778] 68 [444 500 444 500 444 333] 910 [229] 951 952 531 996 [394]]
->>
-endobj
-{{object 7 0}} <<
-  {{streamlen}}
->>
-stream
-/CIDInit /ProcSet findresource begin
-12 dict begin
-begincmap
-1 begincodespacerange
-<0000> <FFFF>
-endcodespacerange
-2 beginbfchar
-<038E> <FE8E>
-<03E4> <FEE4>
-endbfchar
-2 beginbfrange
-<0044> <0049> <0061>
-<03B7> <03B8> <FEB7>
-endbfrange
-endcmap
-CMapName currentdict /CMap defineresource pop
-end
-end
-endstream
-endobj
-{{object 8 0}} <<
-  {{streamlen}}
->>
-stream
-BT
-/F1 16 Tf
-30 100 Td
-<004400450046004700480049> Tj
-ET
-BT
-/F1 16 Tf
-30 50 Td
-<038E03B803E403E403B7> Tj
-ET
-endstream
-endobj
-{{xref}}
-{{trailer}}
-{{startxref}}
-%%EOF
\ No newline at end of file

components/pdf/renderer/pdf_accessibility_tree.cc

@@ -574,8 +574,6 @@ ui::AXNodeData* PdfAccessibilityTree::CreateInlineTextBoxNode(
   std::string chars_utf8 = GetTextRunCharsAsUTF8(text_run, chars, char_index);
   inline_text_box_node->AddStringAttribute(ax::mojom::StringAttribute::kName,
                                            chars_utf8);
-  inline_text_box_node->AddIntAttribute(ax::mojom::IntAttribute::kTextDirection,
-                                        text_run.direction);
   inline_text_box_node->relative_bounds.bounds =
       ToGfxRectF(text_run.bounds) + page_bounds.OffsetFromOrigin();
   std::vector<int32_t> char_offsets =

pdf/accessibility.cc

@@ -40,51 +40,33 @@ bool GetAccessibilityInfo(
   int char_index = 0;
   while (char_index < char_count) {
     PP_PrivateAccessibilityTextRunInfo text_run_info;
-    engine->GetTextRunInfo(page_index, char_index, &text_run_info);
+    pp::FloatRect bounds;
+    engine->GetTextRunInfo(page_index, char_index, &text_run_info.len,
+                           &text_run_info.font_size, &bounds);
     DCHECK_LE(char_index + text_run_info.len,
               static_cast<uint32_t>(char_count));
+    text_run_info.direction = PP_PRIVATEDIRECTION_LTR;
+    text_run_info.bounds = bounds;
     text_runs->push_back(text_run_info);
 
     // We need to provide enough information to draw a bounding box
     // around any arbitrary text range, but the bounding boxes of characters
-    // we get from PDFium don't necessarily "line up".
-    // Example for LTR text direction: walk through the
+    // we get from PDFium don't necessarily "line up". Walk through the
     // characters in each text run and let the width of each character be
     // the difference between the x coordinate of one character and the
     // x coordinate of the next. The rest of the bounds of each character
     // can be computed from the bounds of the text run.
-    // The same idea is used for RTL, TTB and BTT text direction.
     pp::FloatRect char_bounds = engine->GetCharBounds(page_index, char_index);
     for (uint32_t i = 0; i < text_run_info.len - 1; i++) {
       DCHECK_LT(char_index + i + 1, static_cast<uint32_t>(char_count));
       pp::FloatRect next_char_bounds =
           engine->GetCharBounds(page_index, char_index + i + 1);
-      double& char_width = (*chars)[char_index + i].char_width;
-      switch (text_run_info.direction) {
-        case PP_PRIVATEDIRECTION_NONE:
-        case PP_PRIVATEDIRECTION_LTR:
-          char_width = next_char_bounds.x() - char_bounds.x();
-          break;
-        case PP_PRIVATEDIRECTION_TTB:
-          char_width = next_char_bounds.y() - char_bounds.y();
-          break;
-        case PP_PRIVATEDIRECTION_RTL:
-          char_width = char_bounds.right() - next_char_bounds.right();
-          break;
-        case PP_PRIVATEDIRECTION_BTT:
-          char_width = char_bounds.bottom() - next_char_bounds.bottom();
-          break;
-      }
+      (*chars)[char_index + i].char_width =
+          next_char_bounds.x() - char_bounds.x();
       char_bounds = next_char_bounds;
     }
-    double& char_width =
-        (*chars)[char_index + text_run_info.len - 1].char_width;
-    if (text_run_info.direction == PP_PRIVATEDIRECTION_BTT ||
-        text_run_info.direction == PP_PRIVATEDIRECTION_TTB) {
-      char_width = char_bounds.height();
-    } else {
-      char_width = char_bounds.width();
-    }
+    (*chars)[char_index + text_run_info.len - 1].char_width =
+        char_bounds.width();
 
     char_index += text_run_info.len;
   }

pdf/pdf_engine.h

@@ -41,7 +41,6 @@ typedef void (*PDFEnsureTypefaceCharactersAccessible)(const LOGFONT* font,
 
 struct PP_PdfAccessibilityActionData;
 struct PP_PdfPrintSettings_Dev;
-struct PP_PrivateAccessibilityTextRunInfo;
 
 namespace gfx {
 class Rect;
@@ -359,13 +358,13 @@ class PDFEngine {
   // Get a given unicode character on a given page.
   virtual uint32_t GetCharUnicode(int page_index, int char_index) = 0;
   // Given a start char index, find the longest continuous run of text that's
-  // in a single direction and with the same style and font size. Fill the
-  // |text_run_info| with the length of that sequence, text direction, bounding
-  // box and font size.
-  virtual void GetTextRunInfo(
-      int page_index,
-      int start_char_index,
-      PP_PrivateAccessibilityTextRunInfo* text_run_info) = 0;
+  // in a single direction and with the same style and font size. Return the
+  // length of that sequence and its font size and bounding box.
+  virtual void GetTextRunInfo(int page_index,
+                              int start_char_index,
+                              uint32_t* out_len,
+                              double* out_font_size,
+                              pp::FloatRect* out_bounds) = 0;
   // Gets the PDF document's print scaling preference. True if the document can
   // be scaled to fit.
   virtual bool GetPrintScaling() = 0;

pdf/pdfium/pdfium_engine.cc

@@ -2189,12 +2189,14 @@ uint32_t PDFiumEngine::GetCharUnicode(int page_index, int char_index) {
   return pages_[page_index]->GetCharUnicode(char_index);
 }
 
-void PDFiumEngine::GetTextRunInfo(
-    int page_index,
-    int start_char_index,
-    PP_PrivateAccessibilityTextRunInfo* text_run_info) {
+void PDFiumEngine::GetTextRunInfo(int page_index,
+                                  int start_char_index,
+                                  uint32_t* out_len,
+                                  double* out_font_size,
+                                  pp::FloatRect* out_bounds) {
   DCHECK(PageIndexInBounds(page_index));
-  return pages_[page_index]->GetTextRunInfo(start_char_index, text_run_info);
+  return pages_[page_index]->GetTextRunInfo(start_char_index, out_len,
+                                            out_font_size, out_bounds);
 }
 
 bool PDFiumEngine::GetPrintScaling() {

pdf/pdfium/pdfium_engine.h

@@ -113,10 +113,11 @@ class PDFiumEngine : public PDFEngine,
   int GetCharCount(int page_index) override;
   pp::FloatRect GetCharBounds(int page_index, int char_index) override;
   uint32_t GetCharUnicode(int page_index, int char_index) override;
-  void GetTextRunInfo(
-      int page_index,
-      int start_char_index,
-      PP_PrivateAccessibilityTextRunInfo* text_run_info) override;
+  void GetTextRunInfo(int page_index,
+                      int start_char_index,
+                      uint32_t* out_len,
+                      double* out_font_size,
+                      pp::FloatRect* out_bounds) override;
   bool GetPrintScaling() override;
   int GetCopiesToPrint() override;
   int GetDuplexType() override;

pdf/pdfium/pdfium_page.cc

@@ -251,30 +251,29 @@ FPDF_TEXTPAGE PDFiumPage::GetTextPage() {
   return text_page();
 }
 
-void PDFiumPage::GetTextRunInfo(
-    int start_char_index,
-    PP_PrivateAccessibilityTextRunInfo* text_run_info) {
+void PDFiumPage::GetTextRunInfo(int start_char_index,
+                                uint32_t* out_len,
+                                double* out_font_size,
+                                pp::FloatRect* out_bounds) {
   if (start_char_index < 0) {
-    text_run_info->len = 0;
-    text_run_info->font_size = 0;
-    text_run_info->bounds = pp::FloatRect();
-    text_run_info->direction = PP_PRIVATEDIRECTION_NONE;
+    *out_len = 0;
+    *out_font_size = 0;
+    *out_bounds = pp::FloatRect();
     return;
   }
+
   FPDF_PAGE page = GetPage();
   FPDF_TEXTPAGE text_page = GetTextPage();
   int chars_count = FPDFText_CountChars(text_page);
 
-  int actual_start_char_index = GetFirstNonUnicodeWhiteSpaceCharIndex(
+  int char_index = GetFirstNonUnicodeWhiteSpaceCharIndex(
       text_page, start_char_index, chars_count);
-  if (actual_start_char_index >= chars_count) {
-    text_run_info->len = 0;
-    text_run_info->font_size = 0;
-    text_run_info->bounds = pp::FloatRect();
-    text_run_info->direction = PP_PRIVATEDIRECTION_NONE;
+  if (char_index >= chars_count) {
+    *out_len = 0;
+    *out_font_size = 0;
+    *out_bounds = pp::FloatRect();
     return;
   }
-  int char_index = actual_start_char_index;
 
   pp::FloatRect start_char_rect =
       GetFloatCharRectInPixels(page, text_page, char_index);
@@ -377,16 +376,9 @@ void PDFiumPage::GetTextRunInfo(
     text_run_font_size = estimated_font_size;
   }
 
-  // Infer text direction from first and last character of the text run. We
-  // can't base our decision on the character direction, since a character of a
-  // RTL language will have an angle of 0 when not rotated, just like a
-  // character in a LTR language.
-  text_run_info->direction = char_index - actual_start_char_index > 1
-                                 ? GetDirectionFromAngle(text_run_angle)
-                                 : PP_PRIVATEDIRECTION_NONE;
-  text_run_info->len = char_index - start_char_index;
-  text_run_info->font_size = text_run_font_size;
-  text_run_info->bounds = text_run_bounds;
+  *out_len = char_index - start_char_index;
+  *out_font_size = text_run_font_size;
+  *out_bounds = text_run_bounds;
 }
 
 uint32_t PDFiumPage::GetCharUnicode(int char_index) {

pdf/pdfium/pdfium_page.h

@@ -20,8 +20,6 @@
 #include "third_party/pdfium/public/fpdf_text.h"
 #include "ui/gfx/geometry/point_f.h"
 
-struct PP_PrivateAccessibilityTextRunInfo;
-
 namespace chrome_pdf {
 
 class PDFiumEngine;
@@ -45,11 +43,12 @@ class PDFiumPage {
   FPDF_TEXTPAGE GetTextPage();
 
   // Given a start char index, find the longest continuous run of text that's
-  // in a single direction and with the same style and font size. Fill the
-  // |text_run_info| with the length of that sequence, text direction, bounding
-  // box and font size.
+  // in a single direction and with the same style and font size. Return the
+  // length of that sequence and its font size and bounding box.
   void GetTextRunInfo(int start_char_index,
-                      PP_PrivateAccessibilityTextRunInfo* text_run_info);
+                      uint32_t* out_len,
+                      double* out_font_size,
+                      pp::FloatRect* out_bounds);
   // Get a unicode character from the page.
   uint32_t GetCharUnicode(int char_index);
   // Get the bounds of a character in page pixels.