Add a treeChange type to Automation

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 95 matching lines @@
       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);
     }
   }
+  std::set<int> node_created_ids;
+  std::set<int> text_changed_ids;
+  for (size_t i = 0; i < update.nodes.size(); ++i) {
+    AXNode* original_node = GetFromId(update.nodes[i].id);
+    std::string original_text;
+    if (original_node)
+      original_text = original_node->data().GetStringAttribute(AX_ATTR_NAME);
 
-  for (size_t i = 0; i < update.nodes.size(); ++i) {
     if (!UpdateNode(update.nodes[i], &update_state))
       return false;
+
+    AXNode* updated_node = GetFromId(update.nodes[i].id);
+    std::string updated_text;
+    if (updated_node)
+      updated_text = updated_node->data().GetStringAttribute(AX_ATTR_NAME);
+    if (!original_node && updated_node)
+      node_created_ids.insert(update.nodes[i].id);
+    if (!original_text.empty() && !updated_text.empty() &&
+        updated_text != original_text) {
+      text_changed_ids.insert(update.nodes[i].id);
+    }
   }
 
   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 (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));
+          // Node creation based on |new_nodes| is sometimes unreliable. Define
+          // creation based on this tree.
+          if (node_created_ids.find(node->data().id) !=
+              node_created_ids.end()) {
+            changes.push_back(
+                AXTreeDelegate::Change(node, AXTreeDelegate::NODE_CREATED));
+          }
         }
       } else {
-        changes.push_back(
-            AXTreeDelegate::Change(node, AXTreeDelegate::NODE_CHANGED));
+        if (text_changed_ids.find(node->data().id) == text_changed_ids.end()) {
+          changes.push_back(
+              AXTreeDelegate::Change(node, AXTreeDelegate::NODE_CHANGED));
+        } else {
+          changes.push_back(
+              AXTreeDelegate::Change(node, AXTreeDelegate::TEXT_CHANGED));
+        }
       }
     }
     delegate_->OnAtomicUpdateFinished(
         this, root_->id() != old_root_id, changes);
   }
 
   return true;
 }
 
 std::string AXTree::ToString() const {
@@ 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);
     node->SetData(src);

[dmazzoni, 2016/02/19 04:17:32]

I think this would be the place to hook it. Right before this line of code,
|node->data()| is the old data, and |src| is the new data. I suggest just
directly calling a new delegate function OnNodeWillChange that can take both
|node| and |src| as arguments.

Then the logic of deciding whether to do something with text changed, or role
changed, or whatever is up to the delegate, rather than making AX_ATTR_NAME
somehow magical.

This also avoids needing to keep track of sets here.

In automation_custom_bindings, we shouldn't call into JS when we get
OnNodeWillChange because the tree is in the middle of an update. We should see
if the name changed, and if so, add it to a list of nodes - then actually do the
javascript callbacks the same way we handle SendNodesRemovedEvent.

   } else {
     if (src.role != AX_ROLE_ROOT_WEB_AREA &&
         src.role != AX_ROLE_DESKTOP) {
       error_ = base::StringPrintf(
           "%d is not in the tree and not the new root", src.id);
       return false;
     }
     if (update_state->new_root) {
       error_ = "Tree update contains two new roots";
       return false;
@@ skipping 111 matching lines @@
       update_state->pending_nodes.insert(child);
       update_state->new_nodes.insert(child);
     }
     new_children->push_back(child);
   }
 
   return success;
 }
 
 }  // namespace ui