Re-land (2): Reimplement automation API on top of C++-backed AXTree.

ui/accessibility/ax_tree.cc

 // Copyright 2013 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 <set>
 
 #include "base/logging.h"
 #include "base/strings/stringprintf.h"
@@ skipping 71 matching lines @@
   int32 old_root_id = root_ ? root_->id() : 0;
 
   if (update.node_id_to_clear != 0) {
     AXNode* node = GetFromId(update.node_id_to_clear);
     if (!node) {
       error_ = base::StringPrintf("Bad node_id_to_clear: %d",
                                   update.node_id_to_clear);
       return false;
     }
     if (node == root_) {
-      DestroySubtree(root_, &update_state);
-      root_ = NULL;
+      // Clear root_ before calling DestroySubtree so that root_ doesn't
+      // ever point to an invalid node.
+      AXNode* old_root = root_;
+      root_ = nullptr;
+      DestroySubtree(old_root, &update_state);
     } else {
       for (int i = 0; i < node->child_count(); ++i)
         DestroySubtree(node->ChildAtIndex(i), &update_state);
       std::vector<AXNode*> children;
       node->SwapChildren(children);
       update_state.pending_nodes.insert(node);
     }
   }
 
   for (size_t i = 0; i < update.nodes.size(); ++i) {
@@ skipping 93 matching lines @@
   // Now build a new children vector, reusing nodes when possible,
   // and swap it in.
   std::vector<AXNode*> new_children;
   bool success = CreateNewChildVector(
       node, src.child_ids, &new_children, update_state);
   node->SwapChildren(new_children);
 
   // Update the root of the tree if needed.
   if ((src.role == AX_ROLE_ROOT_WEB_AREA || src.role == AX_ROLE_DESKTOP) &&
       (!root_ || root_->id() != src.id)) {
-    if (root_)
-      DestroySubtree(root_, update_state);
+    // Make sure root_ always points to something valid or null_, even inside
+    // DestroySubtree.
+    AXNode* old_root = root_;
     root_ = node;
+    if (old_root)
+      DestroySubtree(old_root, update_state);
   }
 
   return success;
 }
 
 void AXTree::DestroySubtree(AXNode* node,
                             AXTreeUpdateState* update_state) {
   if (delegate_)
     delegate_->OnSubtreeWillBeDeleted(this, node);
   DestroyNodeAndSubtree(node, update_state);
 }
 
 void AXTree::DestroyNodeAndSubtree(AXNode* node,
                                    AXTreeUpdateState* update_state) {
+  if (delegate_)
+    delegate_->OnNodeWillBeDeleted(this, node);
   id_map_.erase(node->id());
   for (int i = 0; i < node->child_count(); ++i)
     DestroyNodeAndSubtree(node->ChildAtIndex(i), update_state);
-  if (delegate_)
-    delegate_->OnNodeWillBeDeleted(this, node);
   if (update_state) {
     update_state->pending_nodes.erase(node);
   }
   node->Destroy();
 }
 
 bool AXTree::DeleteOldChildren(AXNode* node,
                                const std::vector<int32>& new_child_ids,
                                AXTreeUpdateState* update_state) {
   // Create a set of child ids in |src| for fast lookup, and return false
@@ skipping 47 matching lines @@
       update_state->pending_nodes.insert(child);
       update_state->new_nodes.insert(child);
     }
     new_children->push_back(child);
   }
 
   return success;
 }
 
 }  // namespace ui