Update PDF accessibility when zoom level changes

chrome/renderer/extensions/automation_internal_custom_bindings.cc

 // Copyright 2014 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 "chrome/renderer/extensions/automation_internal_custom_bindings.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <memory>
@@ skipping 94 matching lines @@
       continue;
     }
 
     // Union each additional child's bounds.
     bounds.Union(child_bounds);
   }
 
   return bounds;
 }
 
-// Compute the bounding box of a node in global coordinates, walking up the
-// parent hierarchy to offset by frame offsets and scroll offsets.
-static gfx::Rect ComputeGlobalNodeBounds(TreeCache* cache, ui::AXNode* node) {
-  gfx::RectF bounds = ComputeLocalNodeBounds(cache, node);
-
+// Adjust the bounding box of a node from local to global coordinates,
+// walking up the parent hierarchy to offset by frame offsets and
+// scroll offsets.
+static gfx::Rect ComputeGlobalNodeBounds(TreeCache* cache,
+                                         ui::AXNode* node,
+                                         gfx::RectF local_bounds) {
+  gfx::RectF bounds = local_bounds;
   while (node) {
     if (node->data().transform)
       node->data().transform->TransformRect(&bounds);
 
     ui::AXNode* container =
         cache->tree.GetFromId(node->data().offset_container_id);
     if (!container) {
       if (node == cache->tree.root()) {
         container = cache->owner->GetParent(node, &cache);
       } else {
@@ skipping 386 matching lines @@
       });
   RouteNodeIDFunction(
       "GetRole", [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
                     TreeCache* cache, ui::AXNode* node) {
         std::string role_name = ui::ToString(node->data().role);
         result.Set(v8::String::NewFromUtf8(isolate, role_name.c_str()));
       });
   RouteNodeIDFunction(
       "GetLocation", [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
                         TreeCache* cache, ui::AXNode* node) {
-        gfx::Rect location = ComputeGlobalNodeBounds(cache, node);
-        location.Offset(cache->location_offset);
-        result.Set(RectToV8Object(isolate, location));
+        gfx::RectF local_bounds = ComputeLocalNodeBounds(cache, node);
+        gfx::Rect global_bounds =
+            ComputeGlobalNodeBounds(cache, node, local_bounds);
+        global_bounds.Offset(cache->location_offset);
+        result.Set(RectToV8Object(isolate, global_bounds));
       });
   RouteNodeIDFunction(
       "GetLineStartOffsets",
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          TreeCache* cache, ui::AXNode* node) {
         const std::vector<int> line_starts =
             node->GetOrComputeLineStartOffsets();
         v8::Local<v8::Array> array_result(
             v8::Array::New(isolate, line_starts.size()));
         for (size_t i = 0; i < line_starts.size(); ++i) {
@@ skipping 14 matching lines @@
     result.Set(array_result);
   });
 
   // Bindings that take a Tree ID and Node ID and string attribute name
   // and return a property of the node.
 
   RouteNodeIDPlusRangeFunction(
       "GetBoundsForRange",
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          TreeCache* cache, ui::AXNode* node, int start, int end) {
-        gfx::Rect location = ComputeGlobalNodeBounds(cache, node);
-        location.Offset(cache->location_offset);
-        if (node->data().role == ui::AX_ROLE_INLINE_TEXT_BOX) {
-          std::string name = node->data().GetStringAttribute(ui::AX_ATTR_NAME);
-          std::vector<int> character_offsets =
-              node->data().GetIntListAttribute(ui::AX_ATTR_CHARACTER_OFFSETS);
-          int len =
-              static_cast<int>(std::min(name.size(), character_offsets.size()));
-          if (start >= 0 && start <= end && end <= len) {
-            int start_offset = start > 0 ? character_offsets[start - 1] : 0;
-            int end_offset = end > 0 ? character_offsets[end - 1] : 0;
+        gfx::RectF local_bounds = ComputeLocalNodeBounds(cache, node);
+        if (node->data().role != ui::AX_ROLE_INLINE_TEXT_BOX) {
+          gfx::Rect global_bounds =
+              ComputeGlobalNodeBounds(cache, node, local_bounds);
+          global_bounds.Offset(cache->location_offset);
+          result.Set(RectToV8Object(isolate, global_bounds));
+        }
 
-            switch (node->data().GetIntAttribute(ui::AX_ATTR_TEXT_DIRECTION)) {
-              case ui::AX_TEXT_DIRECTION_LTR:
-              default:
-                location.set_x(location.x() + start_offset);
-                location.set_width(end_offset - start_offset);
-                break;
-              case ui::AX_TEXT_DIRECTION_RTL:
-                location.set_x(location.x() + location.width() - end_offset);
-                location.set_width(end_offset - start_offset);
-                break;
-              case ui::AX_TEXT_DIRECTION_TTB:
-                location.set_y(location.y() + start_offset);
-                location.set_height(end_offset - start_offset);
-                break;
-              case ui::AX_TEXT_DIRECTION_BTT:
-                location.set_y(location.y() + location.height() - end_offset);
-                location.set_height(end_offset - start_offset);
-                break;
-            }
+        // Use character offsets to compute the local bounds of this subrange.
+        std::string name = node->data().GetStringAttribute(ui::AX_ATTR_NAME);
+        std::vector<int> character_offsets =
+            node->data().GetIntListAttribute(ui::AX_ATTR_CHARACTER_OFFSETS);
+        int len =
+            static_cast<int>(std::min(name.size(), character_offsets.size()));
+        if (start >= 0 && start <= end && end <= len) {
+          int start_offset = start > 0 ? character_offsets[start - 1] : 0;
+          int end_offset = end > 0 ? character_offsets[end - 1] : 0;
+
+          switch (node->data().GetIntAttribute(ui::AX_ATTR_TEXT_DIRECTION)) {
+            case ui::AX_TEXT_DIRECTION_LTR:
+            default:
+              local_bounds.set_x(local_bounds.x() + start_offset);
+              local_bounds.set_width(end_offset - start_offset);
+              break;
+            case ui::AX_TEXT_DIRECTION_RTL:
+              local_bounds.set_x(local_bounds.x() + local_bounds.width() -
+                                 end_offset);
+              local_bounds.set_width(end_offset - start_offset);
+              break;
+            case ui::AX_TEXT_DIRECTION_TTB:
+              local_bounds.set_y(local_bounds.y() + start_offset);
+              local_bounds.set_height(end_offset - start_offset);
+              break;
+            case ui::AX_TEXT_DIRECTION_BTT:
+              local_bounds.set_y(local_bounds.y() + local_bounds.height() -
+                                 end_offset);
+              local_bounds.set_height(end_offset - start_offset);
+              break;
           }
         }
-        result.Set(RectToV8Object(isolate, location));
+
+        // Convert from local to global coordinates second, after subsetting,
+        // because the local to global conversion might involve matrix
+        // transformations.
+        gfx::Rect global_bounds =
+            ComputeGlobalNodeBounds(cache, node, local_bounds);
+        global_bounds.Offset(cache->location_offset);
+        result.Set(RectToV8Object(isolate, global_bounds));
       });
 
   // Bindings that take a Tree ID and Node ID and string attribute name
   // and return a property of the node.
 
   RouteNodeIDPlusAttributeFunction(
       "GetStringAttribute",
       [](v8::Isolate* isolate, v8::ReturnValue<v8::Value> result,
          ui::AXNode* node, const std::string& attribute_name) {
         ui::AXStringAttribute attribute =
@@ skipping 759 matching lines @@
   v8::Local<v8::Array> args(v8::Array::New(GetIsolate(), 2U));
   args->Set(0U, v8::Integer::New(GetIsolate(), tree_id));
   v8::Local<v8::Array> nodes(v8::Array::New(GetIsolate(), ids.size()));
   args->Set(1U, nodes);
   for (size_t i = 0; i < ids.size(); ++i)
     nodes->Set(i, v8::Integer::New(GetIsolate(), ids[i]));
   context()->DispatchEvent("automationInternal.onNodesRemoved", args);
 }
 
 }  // namespace extensions