Add private PPAPI interfaces for PDFium accessibility.

pdf/out_of_process_instance.cc

 // Copyright (c) 2012 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/out_of_process_instance.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>  // for min/max()
@@ skipping 135 matching lines @@
 // Selecting text in document (Plugin -> Page)
 const char kJSSetIsSelectingType[] = "setIsSelecting";
 const char kJSIsSelecting[] = "isSelecting";
 
 // Notify when a form field is focused (Plugin -> Page)
 const char kJSFieldFocusType[] = "formFocusChange";
 const char kJSFieldFocus[] = "focused";
 
 const int kFindResultCooldownMs = 100;
 
+// A delay to wait between each accessibility page to keep the system
+// responsive.
+const int kAccessibilityPageDelayMs = 100;
+
 const double kMinZoom = 0.01;
 
 namespace {
 
 static const char kPPPPdfInterface[] = PPP_PDF_INTERFACE_1;
 
 // Used for UMA. Do not delete entries, and keep in sync with histograms.xml.
 enum PDFFeatures {
   LOADED_DOCUMENT = 0,
   HAS_TITLE = 1,
@@ skipping 33 matching lines @@
     PP_PdfPrintPresetOptions_Dev* options) {
   void* object = pp::Instance::GetPerInstanceObject(instance, kPPPPdfInterface);
   if (object) {
     OutOfProcessInstance* obj_instance =
         static_cast<OutOfProcessInstance*>(object);
     obj_instance->GetPrintPresetOptionsFromDocument(options);
   }
   return PP_TRUE;
 }
 
+void EnableAccessibility(PP_Instance instance) {
+  void* object = pp::Instance::GetPerInstanceObject(instance, kPPPPdfInterface);
+  if (object) {
+    OutOfProcessInstance* obj_instance =
+        static_cast<OutOfProcessInstance*>(object);
+    return obj_instance->EnableAccessibility();
+  }
+}
+
 const PPP_Pdf ppp_private = {
   &GetLinkAtPosition,
   &Transform,
-  &GetPrintPresetOptionsFromDocument
+  &GetPrintPresetOptionsFromDocument,
+  &EnableAccessibility,
 };
 
 int ExtractPrintPreviewPageIndex(const std::string& src_url) {
   // Sample |src_url| format: chrome://print/id/page_index/print.pdf
   std::vector<std::string> url_substr = base::SplitString(
       src_url.substr(strlen(kChromePrint)), "/",
       base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   if (url_substr.size() != 3)
     return -1;
 
@@ skipping 58 matching lines @@
       preview_document_load_state_(LOAD_STATE_COMPLETE),
       uma_(this),
       told_browser_about_unsupported_feature_(false),
       print_preview_page_count_(0),
       last_progress_sent_(0),
       recently_sent_find_update_(false),
       received_viewport_message_(false),
       did_call_start_loading_(false),
       stop_scrolling_(false),
       background_color_(0),
-      top_toolbar_height_(0) {
+      top_toolbar_height_(0),
+      accessibility_enabled_(false) {
   loader_factory_.Initialize(this);
   timer_factory_.Initialize(this);
   form_factory_.Initialize(this);
   print_callback_factory_.Initialize(this);
   engine_.reset(PDFEngine::Create(this));
   pp::Module::Get()->AddPluginInterface(kPPPPdfInterface, &ppp_private);
   AddPerInstanceObject(kPPPPdfInterface, this);
 
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_MOUSE);
   RequestFilteringInputEvents(PP_INPUTEVENT_CLASS_KEYBOARD);
@@ skipping 305 matching lines @@
   options->is_scaling_disabled = PP_FromBool(IsPrintScalingDisabled());
   options->duplex =
       static_cast<PP_PrivateDuplexMode_Dev>(engine_->GetDuplexType());
   options->copies = engine_->GetCopiesToPrint();
   pp::Size uniform_page_size;
   options->is_page_size_uniform =
       PP_FromBool(engine_->GetPageSizeAndUniformity(&uniform_page_size));
   options->uniform_page_size = uniform_page_size;
 }
 
+void OutOfProcessInstance::EnableAccessibility() {
+  if (accessibility_enabled_)
+    return;
+
+  accessibility_enabled_ = true;
+
+  PP_PrivateAccessibilityDocInfo doc_info;
+  doc_info.page_count = engine_->GetNumberOfPages();
+  doc_info.text_accessible = PP_FromBool(
+      engine_->HasPermission(PDFEngine::PERMISSION_COPY_ACCESSIBLE));
+  doc_info.text_copyable = PP_FromBool(
+      engine_->HasPermission(PDFEngine::PERMISSION_COPY));
+  pp::PDF::SetAccessibilityDocInfo(GetPluginInstance(), &doc_info);
+
+  // If the document contents isn't accessible, don't send anything more.
+  if (!(engine_->HasPermission(PDFEngine::PERMISSION_COPY) ||
+        engine_->HasPermission(PDFEngine::PERMISSION_COPY_ACCESSIBLE))) {
+    return;
+  }
+
+  PP_PrivateAccessibilityViewportInfo viewport_info;
+  viewport_info.scroll.x = 0;
+  viewport_info.scroll.y = -top_toolbar_height_ * device_scale_;
+  viewport_info.offset = available_area_.point();
+  viewport_info.zoom = zoom_;
+  pp::PDF::SetAccessibilityViewportInfo(GetPluginInstance(), &viewport_info);
+
+  // Schedule loading the first page.
+  pp::CompletionCallback callback = timer_factory_.NewCallback(
+      &OutOfProcessInstance::SendNextAccessibilityPage);
+  pp::Module::Get()->core()->CallOnMainThread(kAccessibilityPageDelayMs,
+                                              callback, 0);
+}
+
+void OutOfProcessInstance::SendNextAccessibilityPage(int32_t page_index) {
+  int page_count = engine_->GetNumberOfPages();
+  if (page_index < 0 || page_index >= page_count)
+    return;
+
+  int char_count = engine_->GetCharCount(page_index);
+  PP_PrivateAccessibilityPageInfo page_info;
+  page_info.page_index = page_index;
+  page_info.bounds = engine_->GetPageBoundsRect(page_index);
+  page_info.char_count = char_count;
+
+  std::vector<PP_PrivateAccessibilityCharInfo> chars(page_info.char_count);
+  for (uint32_t i = 0; i < page_info.char_count; ++i) {
+    chars[i].unicode_character = engine_->GetCharUnicode(page_index, i);
+    chars[i].char_width = engine_->GetCharWidth(page_index, i);
+  }
+
+  std::vector<PP_PrivateAccessibilityTextRunInfo> text_runs;
+  int char_index = 0;
+  while (char_index < char_count) {
+    PP_PrivateAccessibilityTextRunInfo text_run_info;
+    pp::FloatRect bounds;
+    engine_->GetTextRunInfo(page_index, char_index, &text_run_info.len,
+                            &text_run_info.font_size, &bounds);
+    text_run_info.direction = PP_PRIVATEDIRECTION_LTR;
+    text_run_info.bounds = bounds;
+    text_runs.push_back(text_run_info);
+    char_index += text_run_info.len;
+  }
+
+  page_info.text_run_count = text_runs.size();
+  pp::PDF::SetAccessibilityPageInfo(GetPluginInstance(), &page_info,
+                                    text_runs.data(), chars.data());
+
+  // Schedule loading the next page.
+  pp::CompletionCallback callback = timer_factory_.NewCallback(
+      &OutOfProcessInstance::SendNextAccessibilityPage);
+  pp::Module::Get()->core()->CallOnMainThread(kAccessibilityPageDelayMs,
+                                              callback, page_index + 1);
+}
+
 pp::Var OutOfProcessInstance::GetLinkAtPosition(
     const pp::Point& point) {
   pp::Point offset_point(point);
   ScalePoint(device_scale_, &offset_point);
   offset_point.set_x(offset_point.x() - available_area_.x());
   return engine_->GetLinkAtPosition(offset_point);
 }
 
 uint32_t OutOfProcessInstance::QuerySupportedPrintOutputFormats() {
   return engine_->QuerySupportedPrintOutputFormats();
@@ skipping 809 matching lines @@
     const pp::FloatPoint& scroll_offset) {
   float max_x = document_size_.width() * zoom_ - plugin_dip_size_.width();
   float x = std::max(std::min(scroll_offset.x(), max_x), 0.0f);
   float min_y = -top_toolbar_height_;
   float max_y = document_size_.height() * zoom_ - plugin_dip_size_.height();
   float y = std::max(std::min(scroll_offset.y(), max_y), min_y);
   return pp::FloatPoint(x, y);
 }
 
 }  // namespace chrome_pdf