Use relative bounding boxes throughout Chrome accessibility

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 67 matching lines @@
               v8::Integer::New(isolate, rect.y()));
   result->Set(CreateV8String(isolate, "width"),
               v8::Integer::New(isolate, rect.width()));
   result->Set(CreateV8String(isolate, "height"),
               v8::Integer::New(isolate, rect.height()));
   return result;
 }
 
 // Compute the bounding box of a node, fixing nodes with empty bounds by
 // unioning the bounds of their children.
-static gfx::Rect ComputeLocalNodeBounds(TreeCache* cache, ui::AXNode* node) {
-  gfx::Rect bounds = gfx::ToEnclosingRect(node->data().location);
+static gfx::RectF ComputeLocalNodeBounds(TreeCache* cache, ui::AXNode* node) {
+  gfx::RectF bounds = node->data().location;
   if (bounds.width() > 0 && bounds.height() > 0)
     return bounds;
 
   // Compute the bounds of each child.
   for (size_t i = 0; i < node->children().size(); i++) {
     ui::AXNode* child = node->children()[i];
-    gfx::Rect child_bounds = ComputeLocalNodeBounds(cache, child);
+    gfx::RectF child_bounds = ComputeLocalNodeBounds(cache, child);
 
     // Ignore children that don't have valid bounds themselves.
     if (child_bounds.width() == 0 || child_bounds.height() == 0)
       continue;
 
     // For the first valid child, just set the bounds to that child's bounds.
     if (bounds.width() == 0 || bounds.height() == 0) {
       bounds = child_bounds;
       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::Rect bounds = ComputeLocalNodeBounds(cache, node);
+  gfx::RectF bounds = ComputeLocalNodeBounds(cache, node);
 
-  ui::AXNode* root = cache->tree.root();
-  while (root) {
-    // Apply scroll offsets.
-    if (root != node) {
-      int sx = 0;
-      int sy = 0;
-      if (root->data().GetIntAttribute(ui::AX_ATTR_SCROLL_X, &sx) &&
-          root->data().GetIntAttribute(ui::AX_ATTR_SCROLL_Y, &sy)) {
-        bounds.Offset(-sx, -sy);
+  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 {
+        container = cache->tree.root();
       }
     }
 
-    if (root->data().transform) {
-      gfx::RectF boundsf(bounds);
-      root->data().transform->TransformRect(&boundsf);
-      bounds = gfx::Rect(boundsf.x(), boundsf.y(), boundsf.width(),
-                         boundsf.height());
+    if (!container || container == node)
+      break;
+
+    gfx::RectF container_bounds = ComputeLocalNodeBounds(cache, container);
+    bounds.Offset(container_bounds.x(), container_bounds.y());
+
+    int scroll_x = 0;
+    int scroll_y = 0;
+    if (container->data().GetIntAttribute(ui::AX_ATTR_SCROLL_X, &scroll_x) &&
+        container->data().GetIntAttribute(ui::AX_ATTR_SCROLL_Y, &scroll_y)) {
+      bounds.Offset(-scroll_x, -scroll_y);
     }
 
-    ui::AXNode* parent = cache->owner->GetParent(root, &cache);
-    if (!parent)
-      break;
-
-    root = cache->tree.root();
+    node = container;
   }
 
-  return bounds;
+  return gfx::ToEnclosingRect(bounds);
 }
 
 ui::AXNode* FindNodeWithChildTreeId(ui::AXNode* node, int child_tree_id) {
   if (child_tree_id == node->data().GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID))
     return node;
 
   for (int i = 0; i < node->child_count(); ++i) {
     ui::AXNode* result =
         FindNodeWithChildTreeId(node->ChildAtIndex(i), child_tree_id);
     if (result)
@@ skipping 1131 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