Improve the notifications sent from AXTree updates.

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 70 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_) {
-      DestroyNodeAndSubtree(root_);
+      DestroySubtree(root_);
       root_ = NULL;
     } else {
       for (int i = 0; i < node->child_count(); ++i)
-        DestroyNodeAndSubtree(node->ChildAtIndex(i));
+        DestroySubtree(node->ChildAtIndex(i));
       std::vector<AXNode*> children;
       node->SwapChildren(children);
       update_state.pending_nodes.insert(node);
     }
   }
 
   for (size_t i = 0; i < update.nodes.size(); ++i) {
     if (!UpdateNode(update.nodes[i], &update_state))
       return false;
   }
 
   if (!update_state.pending_nodes.empty()) {
     error_ = "Nodes left pending by the update:";
     for (std::set<AXNode*>::iterator iter = update_state.pending_nodes.begin();
          iter != update_state.pending_nodes.end(); ++iter) {
       error_ += base::StringPrintf(" %d", (*iter)->id());
     }
     return false;
   }
 
   if (delegate_) {
+    std::set<AXNode*>& new_nodes = update_state.new_nodes;
+    std::vector<AXTreeDelegate::Change> changes;
+    changes.reserve(update.nodes.size());
     for (size_t i = 0; i < update.nodes.size(); ++i) {
       AXNode* node = GetFromId(update.nodes[i].id);
-      if (update_state.new_nodes.find(node) != update_state.new_nodes.end()) {
-        delegate_->OnNodeCreationFinished(node);
-        update_state.new_nodes.erase(node);
+      if (new_nodes.find(node) != new_nodes.end()) {
+        if (new_nodes.find(node->parent()) == new_nodes.end()) {
+          changes.push_back(
+              AXTreeDelegate::Change(node, AXTreeDelegate::SUBTREE_CREATED));
+        } else {
+          changes.push_back(
+              AXTreeDelegate::Change(node, AXTreeDelegate::NODE_CREATED));
+        }
       } else {
-        delegate_->OnNodeChangeFinished(node);
+        changes.push_back(
+            AXTreeDelegate::Change(node, AXTreeDelegate::NODE_CHANGED));
       }
     }
-    if (root_->id() != old_root_id)
-      delegate_->OnRootChanged(root_);
+    delegate_->OnAtomicUpdateFinished(root_->id() != old_root_id, changes);
   }
 
   return true;
 }
 
 std::string AXTree::ToString() const {
   return TreeToStringHelper(root_, 0);
 }
 
 AXNode* AXTree::CreateNode(
@@ skipping 31 matching lines @@
     node->SetData(src);
   }
 
   if (delegate_)
     delegate_->OnNodeChanged(node);
 
   // First, delete nodes that used to be children of this node but aren't
   // anymore.
   if (!DeleteOldChildren(node, src.child_ids)) {
     if (new_root)
-      DestroyNodeAndSubtree(new_root);
+      DestroySubtree(new_root);
     return false;
   }
 
   // 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 &&
       (!root_ || root_->id() != src.id)) {
     if (root_)
-      DestroyNodeAndSubtree(root_);
+      DestroySubtree(root_);
     root_ = node;
   }
 
   return success;
 }
 
+void AXTree::DestroySubtree(AXNode* node) {
+  if (delegate_)
+    delegate_->OnSubtreeWillBeDeleted(node);
+  DestroyNodeAndSubtree(node);
+}
+
 void AXTree::DestroyNodeAndSubtree(AXNode* node) {
   id_map_.erase(node->id());
   for (int i = 0; i < node->child_count(); ++i)
     DestroyNodeAndSubtree(node->ChildAtIndex(i));
   if (delegate_)
     delegate_->OnNodeWillBeDeleted(node);
   node->Destroy();
 }
 
 bool AXTree::DeleteOldChildren(AXNode* node,
                                const std::vector<int32> new_child_ids) {
   // Create a set of child ids in |src| for fast lookup, and return false
   // if a duplicate is found;
   std::set<int32> new_child_id_set;
   for (size_t i = 0; i < new_child_ids.size(); ++i) {
     if (new_child_id_set.find(new_child_ids[i]) != new_child_id_set.end()) {
       error_ = base::StringPrintf("Node %d has duplicate child id %d",
                                   node->id(), new_child_ids[i]);
       return false;
     }
     new_child_id_set.insert(new_child_ids[i]);
   }
 
   // Delete the old children.
   const std::vector<AXNode*>& old_children = node->children();
   for (size_t i = 0; i < old_children.size(); ++i) {
     int old_id = old_children[i]->id();
     if (new_child_id_set.find(old_id) == new_child_id_set.end())
-      DestroyNodeAndSubtree(old_children[i]);
+      DestroySubtree(old_children[i]);
   }
 
   return true;
 }
 
 bool AXTree::CreateNewChildVector(AXNode* node,
                                   const std::vector<int32> new_child_ids,
                                   std::vector<AXNode*>* new_children,
                                   AXTreeUpdateState* update_state) {
   bool success = true;
@@ skipping 20 matching lines @@
       update_state->pending_nodes.insert(child);
       update_state->new_nodes.insert(child);
     }
     new_children->push_back(child);
   }
 
   return success;
 }
 
 }  // namespace ui