Refactor content/renderer/accessibility to use AXTreeSerializer (re-land).

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 154 matching lines @@
       client_root_(NULL) {
 }
 
 template<typename AXSourceNode>
 AXTreeSerializer<AXSourceNode>::~AXTreeSerializer() {
   Reset();
 }
 
 template<typename AXSourceNode>
 void AXTreeSerializer<AXSourceNode>::Reset() {
-  if (client_root_) {
-    DeleteClientSubtree(client_root_);
-    client_root_ = NULL;
-  }
+  if (!client_root_)
+    return;
+
+  DeleteClientSubtree(client_root_);
+  client_id_map_.erase(client_root_->id);
+  delete client_root_;
+  client_root_ = NULL;
 }
 
 template<typename AXSourceNode>
 void AXTreeSerializer<AXSourceNode>::ChangeTreeSourceForTesting(
     AXTreeSource<AXSourceNode>* new_tree) {
   tree_ = new_tree;
 }
 
 template<typename AXSourceNode>
 AXSourceNode AXTreeSerializer<AXSourceNode>::LeastCommonAncestor(
@@ skipping 109 matching lines @@
       // any, we need to delete and reserialize the whole subtree
       // that contains the old and new parents of the reparented node.
       if (AnyDescendantWasReparented(lca, &lca))
         need_delete = true;
     }
 
     if (!tree_->IsValid(lca)) {
       // If there's no LCA, just tell the client to destroy the whole
       // tree and then we'll serialize everything from the new root.
       out_update->node_id_to_clear = client_root_->id;
-      DeleteClientSubtree(client_root_);
-      client_id_map_.erase(client_root_->id);
-      client_root_ = NULL;
+      Reset();
     } else if (need_delete) {
       // Otherwise, if we need to reserialize a subtree, first we need
       // to delete those nodes in our client tree so that
       // SerializeChangedNodes() will be sure to send them again.
       out_update->node_id_to_clear = tree_->GetId(lca);
       ClientTreeNode* client_lca = ClientTreeNodeById(tree_->GetId(lca));
       CHECK(client_lca);
       for (size_t i = 0; i < client_lca->children.size(); ++i) {
         client_id_map_.erase(client_lca->children[i]->id);
         DeleteClientSubtree(client_lca->children[i]);
+        delete client_lca->children[i];
       }
       client_lca->children.clear();
     }
   }
 
   // Serialize from the LCA, or from the root if there isn't one.
   if (!tree_->IsValid(lca))
     lca = tree_->GetRoot();
   SerializeChangedNodes(lca, out_update);
 }
 
 template<typename AXSourceNode>
 void AXTreeSerializer<AXSourceNode>::DeleteClientSubtree(AXSourceNode node) {
   ClientTreeNode* client_node = ClientTreeNodeById(tree_->GetId(node));
   if (client_node)
     DeleteClientSubtree(client_node);
 }
 
 template<typename AXSourceNode>
 void AXTreeSerializer<AXSourceNode>::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>
 void AXTreeSerializer<AXSourceNode>::SerializeChangedNodes(
     AXSourceNode node,
     AXTreeUpdate* 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
   // about. If we don't find it, then this must be the new root of the
   // accessibility tree.
   int id = tree_->GetId(node);
   ClientTreeNode* client_node = ClientTreeNodeById(id);
   if (!client_node) {
-    if (client_root_) {
-      client_id_map_.erase(client_root_->id);
-      DeleteClientSubtree(client_root_);
-    }
+    Reset();
     client_root_ = new ClientTreeNode();
     client_node = client_root_;
     client_node->id = id;
     client_node->parent = NULL;
     client_id_map_[client_node->id] = client_node;
   }
 
   // Iterate over the ids of the children of |node|.
   // Create a set of the child ids so we can quickly look
   // up which children are new and which ones were there before.
@@ skipping 19 matching lines @@
   // of an update, which can lead to a double-free.
   base::hash_map<int32, ClientTreeNode*> client_child_id_map;
   std::vector<ClientTreeNode*> old_children;
   old_children.swap(client_node->children);
   for (size_t i = 0; i < old_children.size(); ++i) {
     ClientTreeNode* old_child = old_children[i];
     int old_child_id = old_child->id;
     if (new_child_ids.find(old_child_id) == new_child_ids.end()) {
       client_id_map_.erase(old_child_id);
       DeleteClientSubtree(old_child);
+      delete old_child;
     } else {
       client_child_id_map[old_child_id] = old_child;
     }
   }
 
   // Serialize this node. This fills in all of the fields in
   // AXNodeData except child_ids, which we handle below.
   out_update->nodes.push_back(AXNodeData());
   AXNodeData* serialized_node = &out_update->nodes.back();
   tree_->SerializeNode(node, serialized_node);
@@ skipping 31 matching lines @@
   }
 
   // Serialize all of the new children, recursively.
   for (size_t i = 0; i < children_to_serialize.size(); ++i)
     SerializeChangedNodes(children_to_serialize[i], out_update);
 }
 
 }  // namespace ui
 
 #endif  // UI_ACCESSIBILITY_AX_TREE_SERIALIZER_H_