Use relative bounding boxes throughout Chrome accessibility

content/browser/accessibility/browser_accessibility_manager.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/browser/accessibility/browser_accessibility_manager.h"
 
 #include <stddef.h>
 
 #include "base/logging.h"
 #include "build/build_config.h"
@@ skipping 395 matching lines @@
   }
 }
 
 void BrowserAccessibilityManager::OnLocationChanges(
     const std::vector<AccessibilityHostMsg_LocationChangeParams>& params) {
   for (size_t i = 0; i < params.size(); ++i) {
     BrowserAccessibility* obj = GetFromID(params[i].id);
     if (!obj)
       continue;
     ui::AXNode* node = obj->node();
-    node->SetLocation(params[i].new_location);
+    node->SetLocation(params[i].new_location.offset_container_id,
+                      params[i].new_location.bounds,
+                      params[i].new_location.transform.get());
   }
   SendLocationChangeEvents(params);
 }
 
 void BrowserAccessibilityManager::SendLocationChangeEvents(
     const std::vector<AccessibilityHostMsg_LocationChangeParams>& params) {
   for (size_t i = 0; i < params.size(); ++i) {
     BrowserAccessibility* obj = GetFromID(params[i].id);
     if (obj)
       obj->OnLocationChanged();
@@ skipping 453 matching lines @@
   if (end_offset <= static_cast<int>(end_text_object->GetText().length())) {
     text += end_text_object->GetText().substr(0, end_offset);
   } else {
     text += end_text_object->GetText();
   }
 
   return text;
 }
 
 // static
-gfx::Rect BrowserAccessibilityManager::GetLocalBoundsForRange(
+gfx::Rect BrowserAccessibilityManager::GetPageBoundsForRange(
     const BrowserAccessibility& start_object,
     int start_offset,
     const BrowserAccessibility& end_object,
     int end_offset) {
   DCHECK_GE(start_offset, 0);
   DCHECK_GE(end_offset, 0);
 
   if (&start_object == &end_object && start_object.IsSimpleTextControl()) {
     if (start_offset > end_offset)
       std::swap(start_offset, end_offset);
 
     if (start_offset >= static_cast<int>(start_object.GetText().length()) ||
         end_offset > static_cast<int>(start_object.GetText().length())) {
       return gfx::Rect();
     }
 
-    return start_object.GetLocalBoundsForRange(
+    return start_object.GetPageBoundsForRange(
         start_offset, end_offset - start_offset);
   }
 
   gfx::Rect result;
   const BrowserAccessibility* first = &start_object;
   const BrowserAccessibility* last = &end_object;
 
   switch (CompareNodes(*first, *last)) {
     case ui::AX_TREE_ORDER_BEFORE:
     case ui::AX_TREE_ORDER_EQUAL:
       break;
     case ui::AX_TREE_ORDER_AFTER:
       std::swap(first, last);
       std::swap(start_offset, end_offset);
       break;
     default:
       return gfx::Rect();
   }
 
   const BrowserAccessibility* current = first;
   do {
     if (current->IsTextOnlyObject()) {
       int len = static_cast<int>(current->GetText().size());
       int start_char_index = 0;
       int end_char_index = len;
       if (current == first)
         start_char_index = start_offset;
       if (current == last)
         end_char_index = end_offset;
-      result.Union(current->GetLocalBoundsForRange(
+      result.Union(current->GetPageBoundsForRange(
           start_char_index, end_char_index - start_char_index));
     } else {
-      result.Union(current->GetLocalBoundsRect());
+      result.Union(current->GetPageBoundsRect());
     }
 
     if (current == last)
       break;
 
     current = NextInTreeOrder(current);
   } while (current);
 
   return result;
 }
@@ skipping 86 matching lines @@
       tree_source(tree_->CreateTreeSource());
   ui::AXTreeSerializer<const ui::AXNode*,
                        ui::AXNodeData,
                        ui::AXTreeData> serializer(tree_source.get());
   ui::AXTreeUpdate update;
   serializer.SerializeChanges(tree_->root(), &update);
   return update;
 }
 
 }  // namespace content