Use relative bounding boxes throughout Chrome accessibility

content/renderer/accessibility/render_accessibility_impl.cc

 // Copyright (c) 2012 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 "content/renderer/accessibility/render_accessibility_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
 
 #include "base/bind.h"
 #include "base/location.h"
 #include "base/single_thread_task_runner.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "build/build_config.h"
 #include "content/common/accessibility_messages.h"
 #include "content/renderer/accessibility/blink_ax_enum_conversion.h"
 #include "content/renderer/render_frame_impl.h"
 #include "content/renderer/render_view_impl.h"
+#include "third_party/WebKit/public/platform/WebFloatRect.h"
 #include "third_party/WebKit/public/web/WebAXObject.h"
 #include "third_party/WebKit/public/web/WebDocument.h"
 #include "third_party/WebKit/public/web/WebInputElement.h"
 #include "third_party/WebKit/public/web/WebLocalFrame.h"
 #include "third_party/WebKit/public/web/WebSettings.h"
 #include "third_party/WebKit/public/web/WebView.h"
 #include "ui/accessibility/ax_node.h"
 
 using blink::WebAXObject;
 using blink::WebDocument;
 using blink::WebElement;
+using blink::WebFloatRect;
 using blink::WebLocalFrame;
 using blink::WebNode;
 using blink::WebPoint;
 using blink::WebRect;
 using blink::WebScopedAXContext;
 using blink::WebSettings;
 using blink::WebView;
 
 namespace content {
 
@@ skipping 287 matching lines @@
     }
 
     if (pdf_tree_source_)
       AddPdfTreeToUpdate(&event_msg.update);
 
     event_msgs.push_back(event_msg);
 
     // For each node in the update, set the location in our map from
     // ids to locations.
     for (size_t i = 0; i < event_msg.update.nodes.size(); ++i) {
-      locations_[event_msg.update.nodes[i].id] =
-          event_msg.update.nodes[i].location;
+      ui::AXNodeData& src = event_msg.update.nodes[i];
+      ui::AXRelativeBounds& dst = locations_[event_msg.update.nodes[i].id];
+      dst.offset_container_id = src.offset_container_id;
+      dst.bounds = src.location;
+      dst.transform.reset(nullptr);
+      if (src.transform)
+        dst.transform.reset(new gfx::Transform(*src.transform));
     }
 
     DVLOG(0) << "Accessibility event: " << ui::ToString(event.event_type)
              << " on node id " << event_msg.id
              << "\n" << event_msg.update.ToString();
   }
 
   Send(new AccessibilityHostMsg_Events(routing_id(), event_msgs, reset_token_));
   reset_token_ = 0;
 
   if (had_layout_complete_messages)
     SendLocationChanges();
 }
 
 void RenderAccessibilityImpl::SendLocationChanges() {
   std::vector<AccessibilityHostMsg_LocationChangeParams> messages;
 
   // Update layout on the root of the tree.
   WebAXObject root = tree_source_.GetRoot();
   if (!root.updateLayoutAndCheckValidity())
     return;
 
   // Do a breadth-first explore of the whole blink AX tree.
-  base::hash_map<int, gfx::RectF> new_locations;
+  base::hash_map<int, ui::AXRelativeBounds> new_locations;
   std::queue<WebAXObject> objs_to_explore;
   objs_to_explore.push(root);
   while (objs_to_explore.size()) {
     WebAXObject obj = objs_to_explore.front();
     objs_to_explore.pop();
 
     // See if we had a previous location. If not, this whole subtree must
     // be new, so don't continue to explore this branch.
     int id = obj.axID();
-    base::hash_map<int, gfx::RectF>::iterator iter = locations_.find(id);
+    auto iter = locations_.find(id);
     if (iter == locations_.end())
       continue;
 
     // If the location has changed, append it to the IPC message.
-    gfx::RectF new_location = gfx::RectF(obj.boundingBoxRect());
+    WebAXObject offset_container;
+    WebFloatRect bounds_in_container;
+    SkMatrix44 container_transform;
+    obj.getRelativeBounds(
+        offset_container, bounds_in_container, container_transform);
+    ui::AXRelativeBounds new_location;
+    new_location.offset_container_id = offset_container.axID();
+    new_location.bounds = bounds_in_container;
+    if (!container_transform.isIdentity())
+      new_location.transform = base::WrapUnique(
+          new gfx::Transform(container_transform));
     if (iter != locations_.end() && iter->second != new_location) {
       AccessibilityHostMsg_LocationChangeParams message;
       message.id = id;
       message.new_location = new_location;
       messages.push_back(message);
     }
 
     // Save the new location.
     new_locations[id] = new_location;
 
@@ skipping 281 matching lines @@
       size_t new_count = pdf_update.nodes.size();
       update->nodes.resize(old_count + new_count);
       for (size_t i = 0; i < new_count; ++i)
         update->nodes[old_count + i] = pdf_update.nodes[i];
       break;
     }
   }
 }
 
 }  // namespace content