Move some AX attrs from AXNodeData to AXTreeData.

ui/accessibility/ax_tree_serializer.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_SERIALIZER_H_
 #define UI_ACCESSIBILITY_AX_TREE_SERIALIZER_H_
 
 #include <set>
 
 #include "base/containers/hash_tables.h"
@@ skipping 13 matching lines @@
 // AXTree. An AXTreeSerializer keeps track of the tree of node ids that its
 // client is aware of so that it will never generate an AXTreeUpdate that
 // results in an invalid tree.
 //
 // Every node in the source tree must have an id that's a unique positive
 // integer, the same node must not appear twice.
 //
 // Usage:
 //
 // You must call SerializeChanges() every time a node in the tree changes,
-// and send the generated AXTreeUpdate to the client.
+// and send the generated AXTreeUpdate to the client. Changes to the
+// AXTreeData, if any, are also automatically included in the AXTreeUpdate.
 //
 // If a node is added, call SerializeChanges on its parent.
 // If a node is removed, call SerializeChanges on its parent.
 // If a whole new subtree is added, just call SerializeChanges on its root.
 // If the root of the tree changes, call SerializeChanges on the new root.
 //
 // AXTreeSerializer will avoid re-serializing nodes that do not change.
 // For example, if node 1 has children 2, 3, 4, 5 and then child 2 is
 // removed and a new child 6 is added, the AXTreeSerializer will only
 // update nodes 1 and 6 (and any children of node 6 recursively). It will
 // assume that nodes 3, 4, and 5 are not modified unless you explicitly
 // call SerializeChanges() on them.
 //
 // As long as the source tree has unique ids for every node and no loops,
 // and as long as every update is applied to the client tree, AXTreeSerializer
 // will continue to work. If the source tree makes a change but fails to
 // call SerializeChanges properly, the trees may get out of sync - but
 // because AXTreeSerializer always keeps track of what updates it's sent,
 // it will never send an invalid update and the client tree will not break,
 // it just may not contain all of the changes.
-template<typename AXSourceNode, typename AXNodeData>
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
 class AXTreeSerializer {
  public:
-  explicit AXTreeSerializer(AXTreeSource<AXSourceNode, AXNodeData>* tree);
+  explicit AXTreeSerializer(
+      AXTreeSource<AXSourceNode, AXNodeData, AXTreeData>* tree);
   ~AXTreeSerializer();
 
   // Throw out the internal state that keeps track of the nodes the client
   // knows about. This has the effect that the next update will send the
   // entire tree over because it assumes the client knows nothing.
   void Reset();
 
   // Sets the maximum number of nodes that will be serialized, or zero
   // for no maximum. This is not a hard maximum - once it hits or
   // exceeds this maximum it stops walking the children of nodes, but
   // it may exceed this value a bit in order to create a consistent
   // tree.
   void set_max_node_count(size_t max_node_count) {
     max_node_count_ = max_node_count;
   }
 
   // Serialize all changes to |node| and append them to |out_update|.
   void SerializeChanges(AXSourceNode node,
-                        AXTreeUpdate<AXNodeData>* out_update);
+                        AXTreeUpdateBase<AXNodeData, AXTreeData>* out_update);
 
   // Delete the client subtree for this node, ensuring that the subtree
   // is re-serialized.
   void DeleteClientSubtree(AXSourceNode node);
 
   // Only for unit testing. Normally this class relies on getting a call
   // to SerializeChanges() every time the source tree changes. For unit
   // testing, it's convenient to create a static AXTree for the initial
   // state and then call ChangeTreeSourceForTesting and then SerializeChanges
   // to simulate the changes you'd get if a tree changed from the initial
   // state to the second tree's state.
   void ChangeTreeSourceForTesting(
-      AXTreeSource<AXSourceNode, AXNodeData>* new_tree);
+      AXTreeSource<AXSourceNode, AXNodeData, AXTreeData>* new_tree);
 
  private:
   // Return the least common ancestor of a node in the source tree
   // and a node in the client tree, or NULL if there is no such node.
   // The least common ancestor is the closest ancestor to |node| (which
   // may be |node| itself) that's in both the source tree and client tree,
   // and for which both the source and client tree agree on their ancestor
   // chain up to the root.
   //
   // Example 1:
@@ skipping 37 matching lines @@
   bool AnyDescendantWasReparented(AXSourceNode node,
                                   AXSourceNode* out_lca);
 
   ClientTreeNode* ClientTreeNodeById(int32 id);
 
   // Delete the given client tree node and recursively delete all of its
   // descendants.
   void DeleteClientSubtree(ClientTreeNode* client_node);
 
   // Helper function, called recursively with each new node to serialize.
-  void SerializeChangedNodes(AXSourceNode node,
-                             AXTreeUpdate<AXNodeData>* out_update);
+  void SerializeChangedNodes(
+      AXSourceNode node,
+      AXTreeUpdateBase<AXNodeData, AXTreeData>* out_update);
 
   // Visit all of the descendants of |node| once.
   void WalkAllDescendants(AXSourceNode node);
 
   // The tree source.
-  AXTreeSource<AXSourceNode, AXNodeData>* tree_;
+  AXTreeSource<AXSourceNode, AXNodeData, AXTreeData>* tree_;
+
+  // The tree data most recently sent to the client.
+  AXTreeData client_tree_data_;
 
   // Our representation of the client tree.
   ClientTreeNode* client_root_;
 
   // A map from IDs to nodes in the client tree.
   base::hash_map<int32, ClientTreeNode*> client_id_map_;
 
   // The maximum number of nodes to serialize in a given call to
   // SerializeChanges, or 0 if there's no maximum.
   size_t max_node_count_;
 };
 
 // In order to keep track of what nodes the client knows about, we keep a
 // representation of the client tree - just IDs and parent/child
 // relationships.
 struct AX_EXPORT ClientTreeNode {
   ClientTreeNode();
   virtual ~ClientTreeNode();
   int32 id;
   ClientTreeNode* parent;
   std::vector<ClientTreeNode*> children;
 };
 
-template<typename AXSourceNode, typename AXNodeData>
-AXTreeSerializer<AXSourceNode, AXNodeData>::AXTreeSerializer(
-    AXTreeSource<AXSourceNode, AXNodeData>* tree)
-    : tree_(tree),
-      client_root_(NULL),
-      max_node_count_(0) {
-}
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
+AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::AXTreeSerializer(
+    AXTreeSource<AXSourceNode, AXNodeData, AXTreeData>* tree)
+    : tree_(tree), client_root_(NULL), max_node_count_(0) {}
 
-template<typename AXSourceNode, typename AXNodeData>
-AXTreeSerializer<AXSourceNode, AXNodeData>::~AXTreeSerializer() {
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
+AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::~AXTreeSerializer() {
   Reset();
 }
 
-template<typename AXSourceNode, typename AXNodeData>
-void AXTreeSerializer<AXSourceNode, AXNodeData>::Reset() {
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
+void AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::Reset() {
+  client_tree_data_ = AXTreeData();
   if (!client_root_)
     return;
 
   DeleteClientSubtree(client_root_);
   client_id_map_.erase(client_root_->id);
   delete client_root_;
   client_root_ = NULL;
 }
 
-template<typename AXSourceNode, typename AXNodeData>
-void AXTreeSerializer<AXSourceNode, AXNodeData>::ChangeTreeSourceForTesting(
-    AXTreeSource<AXSourceNode, AXNodeData>* new_tree) {
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
+void AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::
+    ChangeTreeSourceForTesting(
+        AXTreeSource<AXSourceNode, AXNodeData, AXTreeData>* new_tree) {
   tree_ = new_tree;
 }
 
-template<typename AXSourceNode, typename AXNodeData>
-AXSourceNode AXTreeSerializer<AXSourceNode, AXNodeData>::LeastCommonAncestor(
-    AXSourceNode node, ClientTreeNode* client_node) {
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
+AXSourceNode
+AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::LeastCommonAncestor(
+    AXSourceNode node,
+    ClientTreeNode* client_node) {
   if (!tree_->IsValid(node) || client_node == NULL)
     return tree_->GetNull();
 
   std::vector<AXSourceNode> ancestors;
   while (tree_->IsValid(node)) {
     ancestors.push_back(node);
     node = tree_->GetParent(node);
   }
 
   std::vector<ClientTreeNode*> client_ancestors;
@@ skipping 13 matching lines @@
             client_ancestors[client_index]->id) {
       return lca;
     }
     lca = ancestors[source_index];
     source_index--;
     client_index--;
   }
   return lca;
 }
 
-template<typename AXSourceNode, typename AXNodeData>
-AXSourceNode AXTreeSerializer<AXSourceNode, AXNodeData>::LeastCommonAncestor(
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
+AXSourceNode
+AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::LeastCommonAncestor(
     AXSourceNode node) {
   // Walk up the tree until the source node's id also exists in the
   // client tree, then call LeastCommonAncestor on those two nodes.
   ClientTreeNode* client_node = ClientTreeNodeById(tree_->GetId(node));
   while (tree_->IsValid(node) && !client_node) {
     node = tree_->GetParent(node);
     if (tree_->IsValid(node))
       client_node = ClientTreeNodeById(tree_->GetId(node));
   }
   return LeastCommonAncestor(node, client_node);
 }
 
-template<typename AXSourceNode, typename AXNodeData>
-bool AXTreeSerializer<AXSourceNode, AXNodeData>::AnyDescendantWasReparented(
-    AXSourceNode node, AXSourceNode* out_lca) {
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
+bool AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::
+    AnyDescendantWasReparented(AXSourceNode node, AXSourceNode* out_lca) {
   bool result = false;
   int id = tree_->GetId(node);
   std::vector<AXSourceNode> children;
   tree_->GetChildren(node, &children);
   for (size_t i = 0; i < children.size(); ++i) {
     AXSourceNode& child = children[i];
     int child_id = tree_->GetId(child);
     ClientTreeNode* client_child = ClientTreeNodeById(child_id);
     if (client_child) {
       if (!client_child->parent) {
@@ skipping 14 matching lines @@
       }
     }
 
     // This is a new child or reparented child, check it recursively.
     if (AnyDescendantWasReparented(child, out_lca))
       result = true;
   }
   return result;
 }
 
-template<typename AXSourceNode, typename AXNodeData>
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
 ClientTreeNode*
-    AXTreeSerializer<AXSourceNode, AXNodeData>::ClientTreeNodeById(int32 id) {
+AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::ClientTreeNodeById(
+    int32 id) {
   base::hash_map<int32, ClientTreeNode*>::iterator iter =
       client_id_map_.find(id);
   if (iter != client_id_map_.end())
     return iter->second;
   else
     return NULL;
 }
 
-template<typename AXSourceNode, typename AXNodeData>
-void AXTreeSerializer<AXSourceNode, AXNodeData>::SerializeChanges(
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
+void AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::SerializeChanges(
     AXSourceNode node,
-    AXTreeUpdate<AXNodeData>* out_update) {
+    AXTreeUpdateBase<AXNodeData, AXTreeData>* out_update) {
+  // Send the tree data if it's changed since the last update.
+  AXTreeData new_tree_data = tree_->GetTreeData();
+  if (new_tree_data != client_tree_data_) {
+    out_update->has_tree_data = true;
+    out_update->tree_data = new_tree_data;
+    client_tree_data_ = new_tree_data;
+  }
+
   // If the node isn't in the client tree, we need to serialize starting
   // with the LCA.
   AXSourceNode lca = LeastCommonAncestor(node);
 
   // This loop computes the least common ancestor that includes the old
   // and new parents of any nodes that have been reparented, and clears the
   // whole client subtree of that LCA if necessary. If we do end up clearing
   // any client nodes, keep looping because we have to search for more
   // nodes that may have been reparented from this new LCA.
   bool need_delete;
@@ skipping 31 matching lines @@
 
   // Work around flaky source trees where nodes don't figure out their
   // correct parent/child relationships until you walk the whole tree once.
   // Covered by this test in the content_browsertests suite:
   //     DumpAccessibilityTreeTest.AccessibilityAriaOwns.
   WalkAllDescendants(lca);
 
   SerializeChangedNodes(lca, out_update);
 }
 
-template<typename AXSourceNode, typename AXNodeData>
-void AXTreeSerializer<AXSourceNode, AXNodeData>::DeleteClientSubtree(
-    AXSourceNode node) {
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
+void AXTreeSerializer<AXSourceNode,
+                      AXNodeData,
+                      AXTreeData>::DeleteClientSubtree(AXSourceNode node) {
   ClientTreeNode* client_node = ClientTreeNodeById(tree_->GetId(node));
   if (client_node)
     DeleteClientSubtree(client_node);
 }
 
-template<typename AXSourceNode, typename AXNodeData>
-void AXTreeSerializer<AXSourceNode, AXNodeData>::DeleteClientSubtree(
-    ClientTreeNode* client_node) {
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
+void AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::
+    DeleteClientSubtree(ClientTreeNode* client_node) {
   for (size_t i = 0; i < client_node->children.size(); ++i) {
     client_id_map_.erase(client_node->children[i]->id);
     DeleteClientSubtree(client_node->children[i]);
     delete client_node->children[i];
   }
   client_node->children.clear();
 }
 
-template<typename AXSourceNode, typename AXNodeData>
-void AXTreeSerializer<AXSourceNode, AXNodeData>::SerializeChangedNodes(
-    AXSourceNode node,
-    AXTreeUpdate<AXNodeData>* out_update) {
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
+void AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::
+    SerializeChangedNodes(
+        AXSourceNode node,
+        AXTreeUpdateBase<AXNodeData, AXTreeData>* out_update) {
   // This method has three responsibilities:
   // 1. Serialize |node| into an AXNodeData, and append it to
   //    the AXTreeUpdate to be sent to the client.
   // 2. Determine if |node| has any new children that the client doesn't
   //    know about yet, and call SerializeChangedNodes recursively on those.
   // 3. Update our internal data structure that keeps track of what nodes
   //    the client knows about.
 
   // First, find the ClientTreeNode for this id in our data structure where
   // we keep track of what accessibility objects the client already knows
@@ skipping 107 matching lines @@
       SerializeChangedNodes(child, out_update);
     }
   }
 
   // Finally, update the child ids of this node to reflect the actual child
   // ids that were valid during serialization.
   out_update->nodes[serialized_node_index].child_ids.swap(
       actual_serialized_node_child_ids);
 }
 
-template<typename AXSourceNode, typename AXNodeData>
-void AXTreeSerializer<AXSourceNode, AXNodeData>::WalkAllDescendants(
+template <typename AXSourceNode, typename AXNodeData, typename AXTreeData>
+void AXTreeSerializer<AXSourceNode, AXNodeData, AXTreeData>::WalkAllDescendants(
     AXSourceNode node) {
   std::vector<AXSourceNode> children;
   tree_->GetChildren(node, &children);
   for (size_t i = 0; i < children.size(); ++i)
     WalkAllDescendants(children[i]);
 }
 
 }  // namespace ui
 
 #endif  // UI_ACCESSIBILITY_AX_TREE_SERIALIZER_H_