Move some AX attrs from AXNodeData to AXTreeData.

content/browser/accessibility/browser_accessibility_manager.cc

 // Copyright (c) 2012 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 "content/browser/accessibility/browser_accessibility_manager.h"
 
 #include "base/logging.h"
 #include "content/browser/accessibility/browser_accessibility.h"
 #include "content/common/accessibility_messages.h"
 #include "ui/accessibility/ax_tree_serializer.h"
@@ skipping 22 matching lines @@
   return nullptr;
 }
 
 }  // namespace
 
 // Map from AXTreeID to BrowserAccessibilityManager
 using AXTreeIDMap =
     base::hash_map<AXTreeIDRegistry::AXTreeID, BrowserAccessibilityManager*>;
 base::LazyInstance<AXTreeIDMap> g_ax_tree_id_map = LAZY_INSTANCE_INITIALIZER;
 
-SimpleAXTreeUpdate MakeAXTreeUpdate(
+ui::AXTreeUpdate MakeAXTreeUpdate(
     const ui::AXNodeData& node1,
     const ui::AXNodeData& node2 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node3 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node4 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node5 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node6 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node7 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node8 /* = ui::AXNodeData() */,
     const ui::AXNodeData& node9 /* = ui::AXNodeData() */) {
   CR_DEFINE_STATIC_LOCAL(ui::AXNodeData, empty_data, ());
   int32 no_id = empty_data.id;
 
-  SimpleAXTreeUpdate update;
+  ui::AXTreeUpdate update;
   update.nodes.push_back(node1);
   if (node2.id != no_id)
     update.nodes.push_back(node2);
   if (node3.id != no_id)
     update.nodes.push_back(node3);
   if (node4.id != no_id)
     update.nodes.push_back(node4);
   if (node5.id != no_id)
     update.nodes.push_back(node5);
   if (node6.id != no_id)
@@ skipping 21 matching lines @@
       active_request_id(-1) {}
 
 #if !defined(OS_WIN) && \
     !defined(OS_MACOSX) && \
     !defined(OS_ANDROID) && \
     !(defined(OS_LINUX) && !defined(OS_CHROMEOS) && defined(USE_X11))
 // We have subclassess of BrowserAccessibility on some platforms.
 // For other platforms, instantiate the base class.
 // static
 BrowserAccessibilityManager* BrowserAccessibilityManager::Create(
-    const SimpleAXTreeUpdate& initial_tree,
+    const ui::AXTreeUpdate& initial_tree,
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory) {
   return new BrowserAccessibilityManager(initial_tree, delegate, factory);
 }
 #endif
 
 // static
 BrowserAccessibilityManager* BrowserAccessibilityManager::FromID(
     AXTreeIDRegistry::AXTreeID ax_tree_id) {
   AXTreeIDMap* ax_tree_id_map = g_ax_tree_id_map.Pointer();
   auto iter = ax_tree_id_map->find(ax_tree_id);
   return iter == ax_tree_id_map->end() ? nullptr : iter->second;
 }
 
 BrowserAccessibilityManager::BrowserAccessibilityManager(
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory)
     : delegate_(delegate),
       factory_(factory),
       tree_(new ui::AXSerializableTree()),
       focus_(NULL),
       user_is_navigating_away_(false),
       osk_state_(OSK_ALLOWED),
       ax_tree_id_(AXTreeIDRegistry::kNoAXTreeID),
       parent_node_id_from_parent_tree_(0) {
   tree_->SetDelegate(this);
 }
 
 BrowserAccessibilityManager::BrowserAccessibilityManager(
-    const SimpleAXTreeUpdate& initial_tree,
+    const ui::AXTreeUpdate& initial_tree,
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory)
     : delegate_(delegate),
       factory_(factory),
       tree_(new ui::AXSerializableTree()),
       focus_(NULL),
       user_is_navigating_away_(false),
       osk_state_(OSK_ALLOWED),
       ax_tree_id_(AXTreeIDRegistry::kNoAXTreeID),
       parent_node_id_from_parent_tree_(0) {
   tree_->SetDelegate(this);
   Initialize(initial_tree);
 }
 
 BrowserAccessibilityManager::~BrowserAccessibilityManager() {
   tree_.reset(NULL);
 }
 
 void BrowserAccessibilityManager::Initialize(
-    const SimpleAXTreeUpdate& initial_tree) {
+    const ui::AXTreeUpdate& initial_tree) {
   if (!tree_->Unserialize(initial_tree)) {
     if (delegate_) {
       LOG(ERROR) << tree_->error();
       delegate_->AccessibilityFatalError();
     } else {
       LOG(FATAL) << tree_->error();
     }
   }
 
   if (!focus_)
     SetFocus(tree_->root(), false);
 }
 
 // static
-SimpleAXTreeUpdate
+ui::AXTreeUpdate
 BrowserAccessibilityManager::GetEmptyDocument() {
   ui::AXNodeData empty_document;
   empty_document.id = 0;
   empty_document.role = ui::AX_ROLE_ROOT_WEB_AREA;
-  SimpleAXTreeUpdate update;
+  ui::AXTreeUpdate update;
   update.nodes.push_back(empty_document);
   return update;
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetRoot() {
   // tree_->root() can be null during AXTreeDelegate callbacks.
   ui::AXNode* root = tree_->root();
   return root ? GetFromAXNode(root) : nullptr;
 }
 
@@ skipping 10 matching lines @@
     return iter->second;
 
   return nullptr;
 }
 
 BrowserAccessibility*
 BrowserAccessibilityManager::GetParentNodeFromParentTree() {
   if (!GetRoot())
     return nullptr;
 
-  int parent_tree_id = GetRoot()->GetIntAttribute(ui::AX_ATTR_PARENT_TREE_ID);
+  int parent_tree_id = GetTreeData().parent_tree_id;
   BrowserAccessibilityManager* parent_manager =
       BrowserAccessibilityManager::FromID(parent_tree_id);
   if (!parent_manager)
     return nullptr;
 
   // Try to use the cached parent node from the most recent time this
   // was called.
   if (parent_node_id_from_parent_tree_) {
     BrowserAccessibility* parent_node = parent_manager->GetFromID(
         parent_node_id_from_parent_tree_);
     if (parent_node) {
       int parent_child_tree_id =
           parent_node->GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID);
       if (parent_child_tree_id == ax_tree_id_)
         return parent_node;
     }
   }
 
   // If that fails, search for it and cache it for next time.
   BrowserAccessibility* parent_node = FindNodeWithChildTreeId(
       parent_manager->GetRoot(), ax_tree_id_);
   if (parent_node) {
     parent_node_id_from_parent_tree_ = parent_node->GetId();
     return parent_node;
   }
 
   return nullptr;
 }
 
+const ui::AXTreeData& BrowserAccessibilityManager::GetTreeData() {
+  return tree_->data();
+}
+
 void BrowserAccessibilityManager::OnWindowFocused() {
   if (focus_)
     NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, GetFromAXNode(focus_));
 }
 
 void BrowserAccessibilityManager::OnWindowBlurred() {
   if (focus_)
     NotifyAccessibilityEvent(ui::AX_EVENT_BLUR, GetFromAXNode(focus_));
 }
 
@@ skipping 281 matching lines @@
 
 BrowserAccessibility* BrowserAccessibilityManager::NextTextOnlyObject(
     BrowserAccessibility* node) const {
   BrowserAccessibility* next_node = NextInTreeOrder(node);
   while (next_node && !next_node->IsTextOnlyObject())
     next_node = NextInTreeOrder(next_node);
 
   return next_node;
 }
 
+void BrowserAccessibilityManager::OnTreeDataChanged(ui::AXTree* tree) {
+}
+
 void BrowserAccessibilityManager::OnNodeWillBeDeleted(ui::AXTree* tree,
                                                       ui::AXNode* node) {
   DCHECK(node);
   if (node == focus_ && tree_) {
     if (node != tree_->root())
       SetFocus(tree_->root(), false);
     else
       focus_ = NULL;
   }
   if (id_wrapper_map_.find(node->id()) == id_wrapper_map_.end())
@@ skipping 21 matching lines @@
 void BrowserAccessibilityManager::OnNodeChanged(ui::AXTree* tree,
                                                 ui::AXNode* node) {
   DCHECK(node);
   GetFromAXNode(node)->OnDataChanged();
 }
 
 void BrowserAccessibilityManager::OnAtomicUpdateFinished(
     ui::AXTree* tree,
     bool root_changed,
     const std::vector<ui::AXTreeDelegate::Change>& changes) {
-  if (GetRoot()->HasIntAttribute(ui::AX_ATTR_TREE_ID) &&
-      GetRoot()->GetIntAttribute(ui::AX_ATTR_TREE_ID) != ax_tree_id_) {
+  if (GetTreeData().tree_id != -1 && GetTreeData().tree_id != ax_tree_id_) {
     g_ax_tree_id_map.Get().erase(ax_tree_id_);
-    ax_tree_id_ = GetRoot()->GetIntAttribute(ui::AX_ATTR_TREE_ID);
+    ax_tree_id_ = GetTreeData().tree_id;
     g_ax_tree_id_map.Get().insert(std::make_pair(ax_tree_id_, this));
   }
 }
 
 BrowserAccessibilityDelegate*
     BrowserAccessibilityManager::GetDelegateFromRootManager() {
   if (!GetRoot())
     return nullptr;
-  int parent_tree_id = GetRoot()->GetIntAttribute(ui::AX_ATTR_PARENT_TREE_ID);
+  int parent_tree_id = GetTreeData().parent_tree_id;
   BrowserAccessibilityManager* parent_manager =
       BrowserAccessibilityManager::FromID(parent_tree_id);
   if (parent_manager)
     return parent_manager->GetDelegateFromRootManager();
   return delegate();
 }
 
-SimpleAXTreeUpdate
+ui::AXTreeUpdate
 BrowserAccessibilityManager::SnapshotAXTreeForTesting() {
-  scoped_ptr<ui::AXTreeSource<const ui::AXNode*, ui::AXNodeData> > tree_source(
+  scoped_ptr<ui::AXTreeSource<const ui::AXNode*,
+                              ui::AXNodeData,
+                              ui::AXTreeData> > tree_source(
       tree_->CreateTreeSource());
-  ui::AXTreeSerializer<const ui::AXNode*, ui::AXNodeData> serializer(
-      tree_source.get());
-  SimpleAXTreeUpdate update;
+  ui::AXTreeSerializer<const ui::AXNode*,
+                       ui::AXNodeData,
+                       ui::AXTreeData> serializer(tree_source.get());
+  ui::AXTreeUpdate update;
   serializer.SerializeChanges(tree_->root(), &update);
   return update;
 }
 
 }  // namespace content