Add private PPAPI interfaces for PDFium accessibility.

pdf/pdfium/pdfium_page.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "pdf/pdfium/pdfium_page.h"
 
 #include <math.h>
 #include <stddef.h>
 
 #include <algorithm>
 #include <memory>
 
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/values.h"
 #include "pdf/pdfium/pdfium_api_string_buffer_adapter.h"
 #include "pdf/pdfium/pdfium_engine.h"
+#include "printing/units.h"
 
 // Used when doing hit detection.
 #define kTolerance 20.0
 
+using printing::ConvertUnitDouble;
+using printing::kPointsPerInch;
+using printing::kPixelsPerInch;
+
 namespace {
 
 // Dictionary Value key names for returning the accessible page content as JSON.
 const char kPageWidth[] = "width";
 const char kPageHeight[] = "height";
 const char kPageTextBox[] = "textBox";
 const char kTextBoxLeft[] = "left";
 const char kTextBoxTop[]  = "top";
 const char kTextBoxWidth[] = "width";
 const char kTextBoxHeight[]  = "height";
@@ skipping 19 matching lines @@
   if (max_x < min_x)
     std::swap(min_x, max_x);
   if (max_y < min_y)
     std::swap(min_y, max_y);
 
   pp::Rect output_rect(min_x, min_y, max_x - min_x, max_y - min_y);
   output_rect.Intersect(pp::Rect(0, 0, output_width, output_height));
   return output_rect;
 }
 
+pp::FloatRect FloatPageRectToPixelRect(FPDF_PAGE page,
+                                       const pp::FloatRect& input) {
+  int output_width = FPDF_GetPageWidth(page);
+  int output_height = FPDF_GetPageHeight(page);
+
+  int min_x;
+  int min_y;
+  int max_x;
+  int max_y;
+  FPDF_PageToDevice(page, 0, 0, output_width, output_height, 0, input.x(),
+                    input.y(), &min_x, &min_y);
+  FPDF_PageToDevice(page, 0, 0, output_width, output_height, 0, input.right(),
+                    input.bottom(), &max_x, &max_y);
+
+  if (max_x < min_x)
+    std::swap(min_x, max_x);
+  if (max_y < min_y)
+    std::swap(min_y, max_y);
+
+  pp::FloatRect output_rect(
+      ConvertUnitDouble(min_x, kPointsPerInch, kPixelsPerInch),
+      ConvertUnitDouble(min_y, kPointsPerInch, kPixelsPerInch),
+      ConvertUnitDouble(max_x - min_x, kPointsPerInch, kPixelsPerInch),
+      ConvertUnitDouble(max_y - min_y, kPointsPerInch, kPixelsPerInch));
+  return output_rect;
+}
+
 pp::Rect GetCharRectInGViewCoords(FPDF_PAGE page, FPDF_TEXTPAGE text_page,
                                   int index) {
   double left, right, bottom, top;
   FPDFText_GetCharBox(text_page, index, &left, &right, &bottom, &top);
   if (right < left)
     std::swap(left, right);
   if (bottom < top)
     std::swap(top, bottom);
   pp::Rect page_coords(left, top, right - left, bottom - top);
   return PageRectToGViewRect(page, page_coords);
 }
 
+pp::FloatRect GetFloatCharRectInPixels(FPDF_PAGE page,
+                                       FPDF_TEXTPAGE text_page,
+                                       int index) {
+  double left, right, bottom, top;
+  FPDFText_GetCharBox(text_page, index, &left, &right, &bottom, &top);
+  if (right < left)
+    std::swap(left, right);
+  if (bottom < top)
+    std::swap(top, bottom);
+  pp::FloatRect page_coords(left, top, right - left, bottom - top);
+  return FloatPageRectToPixelRect(page, page_coords);
+}
+
 // This is the character PDFium inserts where a word is broken across lines.
 const unsigned int kSoftHyphen = 0x02;
 
 // The following characters should all be recognized as Unicode newlines:
 //   LF:    Line Feed, U+000A
 //   VT:    Vertical Tab, U+000B
 //   FF:    Form Feed, U+000C
 //   CR:    Carriage Return, U+000D
 //   CR+LF: CR (U+000D) followed by LF (U+000A)
 //   NEL:   Next Line, U+0085
 //   LS:    Line Separator, U+2028
 //   PS:    Paragraph Separator, U+2029.
 // Source: http://en.wikipedia.org/wiki/Newline#Unicode .
 const unsigned int kUnicodeNewlines[] = {
   0xA, 0xB, 0xC, 0xD, 0X85, 0x2028, 0x2029
 };
 
 bool IsSoftHyphen(unsigned int character) {
   return kSoftHyphen == character;
 }
 
 bool OverlapsOnYAxis(const pp::Rect &a, const pp::Rect& b) {
   return !(a.IsEmpty() || b.IsEmpty() ||
            a.bottom() < b.y() || b.bottom() < a.y());
 }
 
+bool OverlapsOnYAxis(const pp::FloatRect &a, const pp::FloatRect& b) {
+  return !(a.IsEmpty() || b.IsEmpty() ||
+           a.bottom() < b.y() || b.bottom() < a.y());
+}
+
 bool IsEol(unsigned int character) {
   const unsigned int* first = kUnicodeNewlines;
   const unsigned int* last = kUnicodeNewlines + arraysize(kUnicodeNewlines);
   return std::find(first, last, character) != last;
 }
 
 }  // namespace
 
 namespace chrome_pdf {
 
@@ skipping 181 matching lines @@
       if (!base::IsUnicodeWhitespace(character))
         word_rect = word_rect.Union(char_rect);
     }
   }
 
   node->Set(kPageTextBox, text.release());  // Takes ownership of |text|
 
   return node;
 }
 
+void PDFiumPage::GetTextRunInfo(int start_char_index,
+                                uint32_t* out_len,
+                                double* out_font_size,
+                                pp::FloatRect* out_bounds) {
+  FPDF_PAGE page = GetPage();
+  FPDF_TEXTPAGE text_page = GetTextPage();
+  int chars_count = FPDFText_CountChars(text_page);
+  int char_index = start_char_index;
+  while (
+      char_index < chars_count &&
+      base::IsUnicodeWhitespace(FPDFText_GetUnicode(text_page, char_index))) {
+    char_index++;
+  }
+  int text_run_font_size = FPDFText_GetFontSize(text_page, char_index);
+  pp::FloatRect text_run_bounds =
+      GetFloatCharRectInPixels(page, text_page, char_index);
+  char_index++;
+  while (char_index < chars_count) {
+    unsigned int character = FPDFText_GetUnicode(text_page, char_index);
+
+    if (!base::IsUnicodeWhitespace(character)) {
+      // TODO(dmazzoni): this assumes horizontal text.
+      // https://crbug.com/580311
+      pp::FloatRect char_rect =
+          GetFloatCharRectInPixels(page, text_page, char_index);
+      if (!char_rect.IsEmpty() && !OverlapsOnYAxis(text_run_bounds, char_rect))
+        break;
+
+      int font_size = FPDFText_GetFontSize(text_page, char_index);
+      if (font_size != text_run_font_size)
+        break;
+
+      text_run_bounds = text_run_bounds.Union(char_rect);
+    }
+
+    char_index++;
+  }
+
+  *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) {
+  FPDF_TEXTPAGE text_page = GetTextPage();
+  return FPDFText_GetUnicode(text_page, char_index);
+}
+
+double PDFiumPage::GetCharWidth(int char_index) {
+  FPDF_PAGE page = GetPage();
+  FPDF_TEXTPAGE text_page = GetTextPage();
+  return GetFloatCharRectInPixels(page, text_page, char_index).width();
+}
+
 PDFiumPage::Area PDFiumPage::GetCharIndex(const pp::Point& point,
                                           int rotation,
                                           int* char_index,
                                           int* form_type,
                                           LinkTarget* target) {
   if (!available_)
     return NONSELECTABLE_AREA;
   pp::Point point2 = point - rect_.point();
   double new_x;
   double new_y;
@@ skipping 255 matching lines @@
   page_->loading_count_--;
 }
 
 PDFiumPage::Link::Link() {
 }
 
 PDFiumPage::Link::~Link() {
 }
 
 }  // namespace chrome_pdf