PDF accessibility tweaks

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 285 matching lines @@
       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),
-      accessibility_enabled_(false) {
+      accessibility_state_(ACCESSIBILITY_STATE_OFF) {
   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 306 matching lines @@
   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_)
+  if (accessibility_state_ == ACCESSIBILITY_STATE_LOADED)
     return;
 
-  accessibility_enabled_ = true;
+  if (accessibility_state_ == ACCESSIBILITY_STATE_OFF)
+    accessibility_state_ = ACCESSIBILITY_STATE_PENDING;
 
+  if (document_load_state_ == LOAD_STATE_COMPLETE)
+    LoadAccessibility();
+}
+
+void OutOfProcessInstance::LoadAccessibility() {
+  accessibility_state_ = ACCESSIBILITY_STATE_LOADED;
   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;
@@ skipping 16 matching lines @@
 
   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);
+    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". 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.
+    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);
+      chars[char_index + i].char_width = next_char_bounds.x() - char_bounds.x();
+      char_bounds = next_char_bounds;
+    }
+    chars[char_index + text_run_info.len - 1].char_width = char_bounds.width();
+
     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);
@@ skipping 544 matching lines @@
     content_restrictions |= CONTENT_RESTRICTION_COPY;
 
   if (!engine_->HasPermission(PDFEngine::PERMISSION_PRINT_LOW_QUALITY) &&
       !engine_->HasPermission(PDFEngine::PERMISSION_PRINT_HIGH_QUALITY)) {
     content_restrictions |= CONTENT_RESTRICTION_PRINT;
   }
 
   pp::PDF::SetContentRestriction(this, content_restrictions);
 
   uma_.HistogramCustomCounts("PDF.PageCount", page_count, 1, 1000000, 50);
+
+  if (accessibility_state_ == ACCESSIBILITY_STATE_PENDING)
+    LoadAccessibility();
 }
 
 void OutOfProcessInstance::RotateClockwise() {
   engine_->RotateClockwise();
 }
 
 void OutOfProcessInstance::RotateCounterclockwise() {
   engine_->RotateCounterclockwise();
 }
 
@@ skipping 259 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