AXTreeCombiner no longer needs to convert to global coordinates.

ui/accessibility/ax_tree_combiner.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 "ui/accessibility/ax_tree.h"
 #include "ui/accessibility/ax_tree_combiner.h"
 #include "ui/gfx/geometry/rect_f.h"
 
 namespace ui {
 namespace {
@@ skipping 150 matching lines @@
 }
 
 int32_t AXTreeCombiner::MapId(int32_t tree_id, int32_t node_id) {
   auto tree_id_node_id = std::make_pair(tree_id, node_id);
   if (tree_id_node_id_map_[tree_id_node_id] == 0)
     tree_id_node_id_map_[tree_id_node_id] = next_id_++;
   return tree_id_node_id_map_[tree_id_node_id];
 }
 
 void AXTreeCombiner::ProcessTree(const AXTreeUpdate* tree) {
-  // The root of each tree may contain a transform that needs to apply
-  // to all of its descendants.
-  gfx::Transform old_transform = transform_;
-  if (!tree->nodes.empty() && tree->nodes[0].transform)
-    transform_.ConcatTransform(*tree->nodes[0].transform);
-
   int32_t tree_id = tree->tree_data.tree_id;
   for (size_t i = 0; i < tree->nodes.size(); ++i) {
     AXNodeData node = tree->nodes[i];
     int32_t child_tree_id = node.GetIntAttribute(AX_ATTR_CHILD_TREE_ID);
 
     // Map the node's ID.
     node.id = MapId(tree_id, node.id);
 
     // Map the node's child IDs.
     for (size_t j = 0; j < node.child_ids.size(); ++j)
       node.child_ids[j] = MapId(tree_id, node.child_ids[j]);
 
-    // Reset the offset container ID because we make all bounding boxes
-    // absolute.
-    node.offset_container_id = -1;
+    // Map the container id.
+    if (node.offset_container_id > 0)
+      node.offset_container_id = MapId(tree_id, node.offset_container_id);
 
     // Map other int attributes that refer to node IDs, and remove the
     // AX_ATTR_CHILD_TREE_ID attribute.
     for (size_t j = 0; j < node.int_attributes.size(); ++j) {
       auto& attr = node.int_attributes[j];
       if (IsNodeIdIntAttribute(attr.first))
         attr.second = MapId(tree_id, attr.second);
       if (attr.first == AX_ATTR_CHILD_TREE_ID) {
         attr.first = AX_INT_ATTRIBUTE_NONE;
         attr.second = 0;
       }
     }
 
     // Map other int list attributes that refer to node IDs.
     for (size_t j = 0; j < node.intlist_attributes.size(); ++j) {
       auto& attr = node.intlist_attributes[j];
       if (IsNodeIdIntListAttribute(attr.first)) {
         for (size_t k = 0; k < attr.second.size(); k++)
           attr.second[k] = MapId(tree_id, attr.second[k]);
       }
     }
 
-    // Apply the transformation to the object's bounds to put it in
-    // the coordinate space of the root frame.
-    transform_.TransformRect(&node.location);
-
     // See if this node has a child tree. As a sanity check make sure the
     // child tree lists this tree as its parent tree id.
     const AXTreeUpdate* child_tree = nullptr;
     if (tree_id_map_.find(child_tree_id) != tree_id_map_.end()) {
       child_tree = tree_id_map_.find(child_tree_id)->second;
       if (child_tree->tree_data.parent_tree_id != tree_id)
         child_tree = nullptr;
       if (child_tree && child_tree->nodes.empty())
         child_tree = nullptr;
       if (child_tree) {
         node.child_ids.push_back(MapId(child_tree_id,
                                        child_tree->nodes[0].id));
       }
     }
 
     // Put the rewritten AXNodeData into the output data structure.
     combined_.nodes.push_back(node);
 
     // Recurse into the child tree now, if any.
     if (child_tree)
       ProcessTree(child_tree);
   }
-
-  // Reset the transform.
-  transform_ = old_transform;
 }
 
 }  // namespace ui