Refactor BrowserAccessibility to prepare for AXNode (re-land)

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 "base/logging.h"
 #include "content/browser/accessibility/browser_accessibility.h"
 #include "content/common/accessibility_messages.h"
 
@@ skipping 98 matching lines @@
   return bounds.Contains(touch_point);
 }
 
 bool BrowserAccessibilityManager::UseRootScrollOffsetsWhenComputingBounds() {
   return true;
 }
 
 void BrowserAccessibilityManager::RemoveNode(BrowserAccessibility* node) {
   if (node == focus_)
     SetFocus(root_, false);
-  int renderer_id = node->renderer_id();
+  int renderer_id = node->GetId();
   renderer_id_map_.erase(renderer_id);
 }
 
 void BrowserAccessibilityManager::OnAccessibilityEvents(
     const std::vector<AccessibilityHostMsg_EventParams>& params) {
   bool should_send_initial_focus = false;
 
   // Process all changes to the accessibility tree first.
   for (uint32 index = 0; index < params.size(); index++) {
     const AccessibilityHostMsg_EventParams& param = params[index];
@@ skipping 61 matching lines @@
 
   return NULL;
 }
 
 void BrowserAccessibilityManager::SetFocus(
     BrowserAccessibility* node, bool notify) {
   if (focus_ != node)
     focus_ = node;
 
   if (notify && node && delegate_)
-    delegate_->SetAccessibilityFocus(node->renderer_id());
+    delegate_->SetAccessibilityFocus(node->GetId());
 }
 
 void BrowserAccessibilityManager::SetRoot(BrowserAccessibility* node) {
   root_ = node;
   NotifyRootChanged();
 }
 
 void BrowserAccessibilityManager::DoDefaultAction(
     const BrowserAccessibility& node) {
   if (delegate_)
-    delegate_->AccessibilityDoDefaultAction(node.renderer_id());
+    delegate_->AccessibilityDoDefaultAction(node.GetId());
 }
 
 void BrowserAccessibilityManager::ScrollToMakeVisible(
     const BrowserAccessibility& node, gfx::Rect subfocus) {
   if (delegate_) {
-    delegate_->AccessibilityScrollToMakeVisible(node.renderer_id(), subfocus);
+    delegate_->AccessibilityScrollToMakeVisible(node.GetId(), subfocus);
   }
 }
 
 void BrowserAccessibilityManager::ScrollToPoint(
     const BrowserAccessibility& node, gfx::Point point) {
   if (delegate_) {
-    delegate_->AccessibilityScrollToPoint(node.renderer_id(), point);
+    delegate_->AccessibilityScrollToPoint(node.GetId(), point);
   }
 }
 
 void BrowserAccessibilityManager::SetTextSelection(
     const BrowserAccessibility& node, int start_offset, int end_offset) {
   if (delegate_) {
     delegate_->AccessibilitySetTextSelection(
-        node.renderer_id(), start_offset, end_offset);
+        node.GetId(), start_offset, end_offset);
   }
 }
 
 gfx::Rect BrowserAccessibilityManager::GetViewBounds() {
   if (delegate_)
     return delegate_->GetViewBounds();
   return gfx::Rect();
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::NextInTreeOrder(
     BrowserAccessibility* node) {
   if (!node)
     return NULL;
 
   if (node->PlatformChildCount() > 0)
     return node->PlatformGetChild(0);
   while (node) {
-    if (node->parent() &&
-        node->index_in_parent() <
-            static_cast<int>(node->parent()->PlatformChildCount()) - 1) {
-      return node->parent()->PlatformGetChild(node->index_in_parent() + 1);
+    if (node->GetParent() &&
+        node->GetIndexInParent() <
+            static_cast<int>(node->GetParent()->PlatformChildCount()) - 1) {
+      return node->GetParent()->PlatformGetChild(node->GetIndexInParent() + 1);
     }
-    node = node->parent();
+    node = node->GetParent();
   }
 
   return NULL;
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::PreviousInTreeOrder(
     BrowserAccessibility* node) {
   if (!node)
     return NULL;
 
-  if (node->parent() && node->index_in_parent() > 0) {
-    node = node->parent()->PlatformGetChild(node->index_in_parent() - 1);
+  if (node->GetParent() && node->GetIndexInParent() > 0) {
+    node = node->GetParent()->PlatformGetChild(node->GetIndexInParent() - 1);
     while (node->PlatformChildCount() > 0)
       node = node->PlatformGetChild(node->PlatformChildCount() - 1);
     return node;
   }
 
-  return node->parent();
+  return node->GetParent();
 }
 
 void BrowserAccessibilityManager::UpdateNodesForTesting(
     const ui::AXNodeData& node1,
     const ui::AXNodeData& node2 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node3 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node4 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node5 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node6 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node7 /* = ui::AXNodeData() */) {
@@ skipping 71 matching lines @@
     int32 renderer_id,
     int32 index_in_parent) {
   BrowserAccessibility* node = factory_->Create();
   node->InitializeTreeStructure(
       this, parent, renderer_id, index_in_parent);
   AddNodeToMap(node);
   return node;
 }
 
 void BrowserAccessibilityManager::AddNodeToMap(BrowserAccessibility* node) {
-  renderer_id_map_[node->renderer_id()] = node;
+  renderer_id_map_[node->GetId()] = node;
 }
 
 bool BrowserAccessibilityManager::UpdateNode(const ui::AXNodeData& src) {
   // This method updates one node in the tree based on serialized data
   // received from the renderer.
 
   // Create a set of child ids in |src| for fast lookup. If a duplicate id is
   // found, exit now with a fatal error before changing anything else.
   std::set<int32> new_child_ids;
   for (size_t i = 0; i < src.child_ids.size(); ++i) {
@@ skipping 24 matching lines @@
   //    changed (but may have been reordered) and adding new empty
   //    objects for new children.
   // 3. Swap in the new children vector for the old one.
 
   // Delete any previous children of this instance that are no longer
   // children first. We make a deletion-only pass first to prevent a
   // node that's being reparented from being the child of both its old
   // parent and new parent, which could lead to a double-free.
   // If a node is reparented, the renderer will always send us a fresh
   // copy of the node.
-  const std::vector<BrowserAccessibility*>& old_children = instance->children();
+  const std::vector<BrowserAccessibility*>& old_children =
+      instance->deprecated_children();
   for (size_t i = 0; i < old_children.size(); ++i) {
-    int old_id = old_children[i]->renderer_id();
+    int old_id = old_children[i]->GetId();
     if (new_child_ids.find(old_id) == new_child_ids.end())
       old_children[i]->Destroy();
   }
 
   // Now build a vector of new children, reusing objects that were already
   // children of this node before.
   std::vector<BrowserAccessibility*> new_children;
   bool success = true;
   for (size_t i = 0; i < src.child_ids.size(); i++) {
     int32 child_renderer_id = src.child_ids[i];
     int32 index_in_parent = static_cast<int32>(i);
     BrowserAccessibility* child = GetFromRendererID(child_renderer_id);
     if (child) {
-      if (child->parent() != instance) {
+      if (child->GetParent() != instance) {
         // This is a serious error - nodes should never be reparented.
         // If this case occurs, continue so this node isn't left in an
         // inconsistent state, but return failure at the end.
         success = false;
         continue;
       }
       child->UpdateParent(instance, index_in_parent);
     } else {
       child = CreateNode(instance, child_renderer_id, index_in_parent);
     }
     new_children.push_back(child);
   }
 
   // Finally, swap in the new children vector for the old.
   instance->SwapChildren(new_children);
 
   // Handle the case where this node is the new root of the tree.
   if (src.role == ui::AX_ROLE_ROOT_WEB_AREA &&
-      (!root_ || root_->renderer_id() != src.id)) {
+      (!root_ || root_->GetId() != src.id)) {
     if (root_)
       root_->Destroy();
     if (focus_ == root_)
       SetFocus(instance, false);
     SetRoot(instance);
   }
 
   // Keep track of what node is focused.
   if (src.role != ui::AX_ROLE_ROOT_WEB_AREA &&
       src.role != ui::AX_ROLE_WEB_AREA &&
       (src.state >> ui::AX_STATE_FOCUSED & 1)) {
     SetFocus(instance, false);
   }
   return success;
 }
 
 }  // namespace content