Correctly ignore AXTree event creation change state for reparented nodes

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 <stddef.h>
 
 #include <set>
 
@@ skipping 23 matching lines @@
   // implicitly referenced as part of this update, but haven't been
   // updated yet. It's an error if there are any pending nodes at the
   // end of Unserialize.
   std::set<AXNode*> pending_nodes;
 
   // Keeps track of new nodes created during this update.
   std::set<AXNode*> new_nodes;
 
   // The new root in this update, if any.
   AXNode* new_root;
+
+  // Keeps track of any nodes removed. Used to identify re-parented nodes.
+  std::set<int> removed_node_ids;
 };
 
 AXTreeDelegate::AXTreeDelegate() {
 }
 
 AXTreeDelegate::~AXTreeDelegate() {
 }
 
 AXTree::AXTree()
     : delegate_(NULL), root_(NULL) {
@@ skipping 80 matching lines @@
     }
     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 (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));
+      bool is_new_node = new_nodes.find(node) != new_nodes.end();
+      bool is_reparented_node =
+          is_new_node &&
+          update_state.removed_node_ids.find(node->id()) !=
+              update_state.removed_node_ids.end();
+
+      AXTreeDelegate::ChangeType change = AXTreeDelegate::NODE_CHANGED;
+      if (is_new_node) {
+        bool is_subtree = new_nodes.find(node->parent()) == new_nodes.end();
+        if (is_reparented_node) {
+          change = is_subtree ? AXTreeDelegate::SUBTREE_REPARENTED
+                              : AXTreeDelegate::NODE_REPARENTED;
         } else {
-          changes.push_back(
-              AXTreeDelegate::Change(node, AXTreeDelegate::NODE_CREATED));
+          change = is_subtree ? AXTreeDelegate::SUBTREE_CREATED
+                              : AXTreeDelegate::NODE_CREATED;
         }
-      } else {
-        changes.push_back(
-            AXTreeDelegate::Change(node, AXTreeDelegate::NODE_CHANGED));
       }
+      changes.push_back(AXTreeDelegate::Change(node, change));
     }
     delegate_->OnAtomicUpdateFinished(
         this, root_->id() != old_root_id, changes);
   }
 
   return true;
 }
 
 std::string AXTree::ToString() const {
   return "AXTree" + data_.ToString() + "\n" + TreeToStringHelper(root_, 0);
@@ skipping 15 matching lines @@
   // This method updates one node in the tree based on serialized data
   // received in an AXTreeUpdate. See AXTreeUpdate for pre and post
   // conditions.
 
   // Look up the node by id. If it's not found, then either the root
   // of the tree is being swapped, or we're out of sync with the source
   // and this is a serious error.
   AXNode* node = GetFromId(src.id);
   if (node) {
     update_state->pending_nodes.erase(node);
-    if (delegate_)
+    if (delegate_ &&
+        update_state->new_nodes.find(node) == update_state->new_nodes.end())
       delegate_->OnNodeDataWillChange(this, node->data(), src);
     node->SetData(src);
   } else {
     if (!is_new_root) {
       error_ = base::StringPrintf(
           "%d is not in the tree and not the new root", src.id);
       return false;
     }
 
     update_state->new_root = CreateNode(NULL, src.id, 0);
@@ skipping 42 matching lines @@
 
 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 (update_state) {
     update_state->pending_nodes.erase(node);
+    update_state->removed_node_ids.insert(node->id());
   }
   node->Destroy();
 }
 
 bool AXTree::DeleteOldChildren(AXNode* node,
                                const std::vector<int32_t>& new_child_ids,
                                AXTreeUpdateState* update_state) {
   // Create a set of child ids in |src| for fast lookup, and return false
   // if a duplicate is found;
   std::set<int32_t> new_child_id_set;
@@ skipping 45 matching lines @@
       update_state->pending_nodes.insert(child);
       update_state->new_nodes.insert(child);
     }
     new_children->push_back(child);
   }
 
   return success;
 }
 
 }  // namespace ui