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"
@@ skipping 26 matching lines @@
 
 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),
       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::RenderFrame* render_frame = render_view_->GetMainRenderFrame();

[nasko, 2016/06/28 21:59:51]

Are we guaranteed to have a main frame? We avoid making this assumption in the
face of out-of-process iframes, in which case the return value will be nullptr.
If it is guaranteed to exist, it might be useful to put a comment explaining
why.

[raymes, 2016/06/29 00:31:36]

Good question and I don't know the answer for sure. There are 2 cases where we
load the PDF plugin: 
1) If a PDF is loaded on a web page, we will load a browser plugin. This could
be at the top level (most commonly) or in an iframe. I'm not sure how browser
plugin works with OOPIF and I'm not sure how accessibility information gets
propagated for iframes with OOPIF so it would depend on those 2 things.

2) In print preview. In this case it's loaded in a same-origin subframe. In this
case we should always have access to the main frame I believe.

dmazzoni: you may want to do some tests of these cases with OOPIF to see the
result.

[dmazzoni, 2016/06/30 22:35:14]

In this case, GetMainFrame() would always work as currently implemented,
because the browser plugin always has a guest WebContents with the PDF
extension as its main frame.

It did expose another bug, though - OutOfProcessInstance wasn't loading
accessibility if it wasn't full-window. Fixed.

I added several new tests, including a PDF in an iframe and a PDF in
an OOPIF.
Ah! This case was actually wrong, thanks for pointing it out. We had
access to the main frame, yes - but that wasn't the host frame for
the PDF plug-in, so we weren't attaching the PDF's accessibility
tree to anything.

I fixed this by adding an interface to get the RenderFrame from the
instance, rather than the RenderView. Now this case works and I
added a test for Print Preview PDF accessibility too.

+  content::RenderAccessibility* render_accessibility =
+      render_frame->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 78 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::RenderFrame* render_frame = render_view_->GetMainRenderFrame();
+  content::RenderAccessibility* render_accessibility =
+      render_frame->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::RenderFrame* render_frame = render_view_->GetMainRenderFrame();
+  content::RenderAccessibility* render_accessibility =
+      render_frame->GetRenderAccessibility();
+
   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();
 }
 
@@ skipping 40 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