Add support for attribute change callbacks in AXNodeData.

ui/accessibility/ax_tree.h

 // 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.
 
 #ifndef UI_ACCESSIBILITY_AX_TREE_H_
 #define UI_ACCESSIBILITY_AX_TREE_H_
 
 #include <stdint.h>
 
 #include <set>
@@ skipping 31 matching lines @@
 class AX_EXPORT AXTreeDelegate {
  public:
   AXTreeDelegate();
   virtual ~AXTreeDelegate();
 
   // Called before a node's data gets updated.
   virtual void OnNodeDataWillChange(AXTree* tree,
                                     const AXNodeData& old_node_data,
                                     const AXNodeData& new_node_data) = 0;
 
+  // Individual callbacks for every attribute of AXNodeData that can change.
+  virtual void OnRoleChanged(AXTree* tree,
+                             AXNode* node,
+                             AXRole old_role,
+                             AXRole new_role) {}
+  virtual void OnStateChanged(AXTree* tree,
+                              AXNode* node,
+                              AXState state,
+                              bool new_value) {}
+  virtual void OnStringAttributeChanged(AXTree* tree,
+                                        AXNode* node,
+                                        AXStringAttribute attr,
+                                        const std::string& old_value,
+                                        const std::string& new_value) {}
+  virtual void OnIntAttributeChanged(AXTree* tree,
+                                     AXNode* node,
+                                     AXIntAttribute attr,
+                                     int32_t old_value,
+                                     int32_t new_value) {}
+  virtual void OnFloatAttributeChanged(AXTree* tree,
+                                       AXNode* node,
+                                       AXFloatAttribute attr,
+                                       float old_value,
+                                       float new_value) {}
+  virtual void OnBoolAttributeChanged(AXTree* tree,
+                                      AXNode* node,
+                                      AXBoolAttribute attr,
+                                      bool new_value) {}
+  virtual void OnIntListAttributeChanged(
+      AXTree* tree,
+      AXNode* node,
+      AXIntListAttribute attr,
+      const std::vector<int32_t>& old_value,
+      const std::vector<int32_t>& new_value) {}
+
   // Called when tree data changes.
   virtual void OnTreeDataChanged(AXTree* tree) = 0;
 
   // Called just before a node is deleted. Its id and data will be valid,
   // but its links to parents and children are invalid. This is called
   // in the middle of an update, the tree may be in an invalid state!
   virtual void OnNodeWillBeDeleted(AXTree* tree, AXNode* node) = 0;
 
   // Same as OnNodeWillBeDeleted, but only called once for an entire subtree.
   // This is called in the middle of an update, the tree may be in an
@@ skipping 87 matching lines @@
   AXNode* CreateNode(AXNode* parent,
                      int32_t id,
                      int32_t index_in_parent,
                      AXTreeUpdateState* update_state);
 
   // This is called from within Unserialize(), it returns true on success.
   bool UpdateNode(const AXNodeData& src,
                   bool is_new_root,
                   AXTreeUpdateState* update_state);
 
+  void CallNodeChangeCallbacks(AXNode* node, const AXNodeData& new_data);
+
   void OnRootChanged();
 
   // Notify the delegate that the subtree rooted at |node| will be destroyed,
   // then call DestroyNodeAndSubtree on it.
   void DestroySubtree(AXNode* node, AXTreeUpdateState* update_state);
 
   // Call Destroy() on |node|, and delete it from the id map, and then
   // call recursively on all nodes in its subtree.
   void DestroyNodeAndSubtree(AXNode* node, AXTreeUpdateState* update_state);
 
@@ skipping 17 matching lines @@
   AXTreeDelegate* delegate_;
   AXNode* root_;
   base::hash_map<int32_t, AXNode*> id_map_;
   std::string error_;
   AXTreeData data_;
 };
 
 }  // namespace ui
 
 #endif  // UI_ACCESSIBILITY_AX_TREE_H_