Enable PDF accessibility when RenderFrame's accessibility mode changes.

components/pdf/renderer/pdf_accessibility_tree.cc

 // Copyright 2016 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 <algorithm>
 
 #include "base/memory/ptr_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversion_utils.h"
 #include "components/pdf/renderer/pdf_accessibility_tree.h"
 #include "content/public/renderer/render_accessibility.h"
 #include "content/public/renderer/render_frame.h"
 #include "content/public/renderer/render_view.h"
+#include "content/public/renderer/renderer_ppapi_host.h"
 #include "grit/components_strings.h"
 #include "ui/base/l10n/l10n_util.h"
 #include "ui/gfx/geometry/rect_conversions.h"
 
 namespace pdf {
 
 namespace {
 
 // Don't try to apply font size thresholds to automatically identify headings
 // if the median font size is not at least this many points.
@@ skipping 11 matching lines @@
 // page for that line spacing to be considered a paragraph break.
 const double kParagraphLineSpacingRatio = 1.2;
 
 gfx::RectF ToGfxRectF(const PP_FloatRect& r) {
   return gfx::RectF(r.point.x, r.point.y, r.size.width, r.size.height);
 }
 
 }
 
 PdfAccessibilityTree::PdfAccessibilityTree(
-    content::RenderView* render_view)
-    : render_view_(render_view),
-      render_accessibility_(nullptr),
+    content::RendererPpapiHost* host,
+    PP_Instance instance)
+    : host_(host),
+      instance_(instance),
       zoom_(1.0) {
-  content::RenderFrame* render_frame = render_view->GetMainRenderFrame();
-  render_accessibility_ = render_frame->GetRenderAccessibility();
 }
 
 PdfAccessibilityTree::~PdfAccessibilityTree() {
 }
 
 void PdfAccessibilityTree::SetAccessibilityViewportInfo(
     const PP_PrivateAccessibilityViewportInfo& viewport_info) {
   zoom_ = viewport_info.zoom;
   CHECK_GT(zoom_, 0);
   scroll_ = ToVector2dF(viewport_info.scroll);
   scroll_.Scale(1.0 / zoom_);
   offset_ = ToVector2dF(viewport_info.offset);
   offset_.Scale(1.0 / zoom_);
 }
 
 void PdfAccessibilityTree::SetAccessibilityDocInfo(
     const PP_PrivateAccessibilityDocInfo& doc_info) {
   doc_info_ = doc_info;
   doc_node_ = CreateNode(ui::AX_ROLE_GROUP);
 }
 
 void PdfAccessibilityTree::SetAccessibilityPageInfo(
     const PP_PrivateAccessibilityPageInfo& page_info,
     const std::vector<PP_PrivateAccessibilityTextRunInfo>& text_runs,
     const std::vector<PP_PrivateAccessibilityCharInfo>& chars) {
+  content::RenderAccessibility* render_accessibility = GetRenderAccessibility();
+  if (!render_accessibility)
+    return;
+
   uint32_t page_index = page_info.page_index;
   CHECK_GE(page_index, 0U);
   CHECK_LT(page_index, doc_info_.page_count);
 
   ui::AXNodeData* page_node = CreateNode(ui::AX_ROLE_REGION);
   page_node->AddStringAttribute(
       ui::AX_ATTR_NAME,
       l10n_util::GetPluralStringFUTF8(
           IDS_PDF_PAGE_INDEX, page_index + 1));
 
@@ skipping 26 matching lines @@
 
     // If we don't have a paragraph, create one.
     if (!para_node) {
       para_node = CreateNode(ui::AX_ROLE_PARAGRAPH);
       page_node->child_ids.push_back(para_node->id);
 
       if (heading_font_size_threshold > 0 &&
           text_run.font_size > heading_font_size_threshold) {
         para_node->role = ui::AX_ROLE_HEADING;
         para_node->AddIntAttribute(ui::AX_ATTR_HIERARCHICAL_LEVEL, 2);
+        para_node->AddStringAttribute(ui::AX_ATTR_HTML_TAG, "h2");
       }
 
       // This node is for the text inside the paragraph, it includes
       // the text of all of the text runs.
       static_text_node = CreateNode(ui::AX_ROLE_STATIC_TEXT);
       para_node->child_ids.push_back(static_text_node->id);
     }
 
     // Add this text run to the current static text node.
     ui::AXNodeData* inline_text_box_node = CreateNode(
@@ skipping 32 matching lines @@
     Finish();
 }
 
 void PdfAccessibilityTree::Finish() {
   ui::AXTreeUpdate update;
   update.root_id = doc_node_->id;
   for (const auto& node : nodes_)
     update.nodes.push_back(*node);
 
   CHECK(tree_.Unserialize(update)) << update.ToString() << tree_.error();
-  render_accessibility_->SetPdfTreeSource(this);
+  content::RenderAccessibility* render_accessibility = GetRenderAccessibility();
+  if (render_accessibility)
+    render_accessibility->SetPdfTreeSource(this);
 }
 
 void PdfAccessibilityTree::ComputeParagraphAndHeadingThresholds(
     const std::vector<PP_PrivateAccessibilityTextRunInfo>& text_runs,
     double* out_heading_font_size_threshold,
     double* out_line_spacing_threshold) {
   // Scan over the font sizes and line spacing within this page and
   // set heuristic thresholds so that text larger than the median font
   // size can be marked as a heading, and spacing larger than the median
   // line spacing can be a paragraph break.
@@ skipping 53 matching lines @@
 
 gfx::Vector2dF PdfAccessibilityTree::ToVector2dF(const PP_Point& p) {
   return gfx::Vector2dF(p.x, p.y);
 }
 
 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(ui::AXRole role) {
+  content::RenderAccessibility* render_accessibility = GetRenderAccessibility();
+  DCHECK(render_accessibility);

[raymes, 2016/07/14 03:15:54]

Can we trust this to be non-null? 

[dmazzoni, 2016/07/14 21:04:40]

This is private. I did a null check for RenderAccessibility at the top of each
public function so this should be safe.

+
   ui::AXNodeData* node = new ui::AXNodeData();
-  node->id = render_accessibility_->GenerateAXID();
+  node->id = render_accessibility->GenerateAXID();
   node->role = role;
   node->state = 1 << ui::AX_STATE_ENABLED | 1 << ui::AX_STATE_READ_ONLY;
   nodes_.push_back(base::WrapUnique(node));
   return node;
 }
 
 float PdfAccessibilityTree::GetDeviceScaleFactor() const {
-  return render_view_->GetDeviceScaleFactor();
+  content::RenderFrame* render_frame =
+      host_->GetRenderFrameForInstance(instance_);
+  DCHECK(render_frame);

[raymes, 2016/07/14 03:15:54]

And this?

[dmazzoni, 2016/07/14 21:04:40]

Same, private and will only be called after we know it's
not null.

+  return render_frame->GetRenderView()->GetDeviceScaleFactor();
+}
+
+content::RenderAccessibility* PdfAccessibilityTree::GetRenderAccessibility() {
+  content::RenderFrame* render_frame =
+      host_->GetRenderFrameForInstance(instance_);
+  if (!render_frame)
+    return nullptr;
+  return render_frame->GetRenderAccessibility();

[Lei Zhang, 2016/07/15 19:26:21]

ternary operator?

[dmazzoni, 2016/07/18 04:28:32]

Done

 }
 
 //
 // AXTreeSource implementation.
 //
 
 bool PdfAccessibilityTree::GetTreeData(ui::AXTreeData* tree_data) const {
   return false;
 }
 
@@ skipping 32 matching lines @@
 const ui::AXNode* PdfAccessibilityTree::GetNull() const {
   return nullptr;
 }
 
 void PdfAccessibilityTree::SerializeNode(
     const ui::AXNode* node, ui::AXNodeData* out_data) const {
   *out_data = node->data();
 }
 
 }  // namespace pdf