Refactor content/ to use ui::AXNodeData instead of blink.

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"
 
 namespace content {
 
 BrowserAccessibility* BrowserAccessibilityFactory::Create() {
   return BrowserAccessibility::Create();
 }
 
 #if !defined(OS_MACOSX) && \
     !defined(OS_WIN) && \
     !defined(TOOLKIT_GTK) && \
     !defined(OS_ANDROID) \
 // We have subclassess of BrowserAccessibilityManager on Mac, Linux/GTK,
 // and Win. For any other platform, instantiate the base class.
 // static
 BrowserAccessibilityManager* BrowserAccessibilityManager::Create(
-    const AccessibilityNodeData& src,
+    const ui::AXNodeData& src,
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory) {
   return new BrowserAccessibilityManager(src, delegate, factory);
 }
 #endif
 
 BrowserAccessibilityManager::BrowserAccessibilityManager(
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory)
     : delegate_(delegate),
       factory_(factory),
       root_(NULL),
       focus_(NULL),
       osk_state_(OSK_ALLOWED) {
 }
 
 BrowserAccessibilityManager::BrowserAccessibilityManager(
-    const AccessibilityNodeData& src,
+    const ui::AXNodeData& src,
     BrowserAccessibilityDelegate* delegate,
     BrowserAccessibilityFactory* factory)
     : delegate_(delegate),
       factory_(factory),
       root_(NULL),
       focus_(NULL),
       osk_state_(OSK_ALLOWED) {
   Initialize(src);
 }
 
 BrowserAccessibilityManager::~BrowserAccessibilityManager() {
   if (root_)
     root_->Destroy();
 }
 
-void BrowserAccessibilityManager::Initialize(const AccessibilityNodeData src) {
-  std::vector<AccessibilityNodeData> nodes;
+void BrowserAccessibilityManager::Initialize(const ui::AXNodeData src) {
+  std::vector<ui::AXNodeData> nodes;
   nodes.push_back(src);
   if (!UpdateNodes(nodes))
     return;
   if (!focus_)
     SetFocus(root_, false);
 }
 
 // static
-AccessibilityNodeData BrowserAccessibilityManager::GetEmptyDocument() {
-  AccessibilityNodeData empty_document;
+ui::AXNodeData BrowserAccessibilityManager::GetEmptyDocument() {
+  ui::AXNodeData empty_document;
   empty_document.id = 0;
-  empty_document.role = blink::WebAXRoleRootWebArea;
+  empty_document.role = ui::AX_ROLE_ROOT_WEB_AREA;
   return empty_document;
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetRoot() {
   return root_;
 }
 
 BrowserAccessibility* BrowserAccessibilityManager::GetFromRendererID(
     int32 renderer_id) {
   base::hash_map<int32, BrowserAccessibility*>::iterator iter =
       renderer_id_map_.find(renderer_id);
   if (iter != renderer_id_map_.end())
     return iter->second;
   return NULL;
 }
 
 void BrowserAccessibilityManager::GotFocus(bool touch_event_context) {
   if (!touch_event_context)
     osk_state_ = OSK_DISALLOWED_BECAUSE_TAB_JUST_APPEARED;
 
   if (!focus_)
     return;
 
-  NotifyAccessibilityEvent(blink::WebAXEventFocus, focus_);
+  NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, focus_);
 }
 
 void BrowserAccessibilityManager::WasHidden() {
   osk_state_ = OSK_DISALLOWED_BECAUSE_TAB_HIDDEN;
 }
 
 void BrowserAccessibilityManager::GotMouseDown() {
   osk_state_ = OSK_ALLOWED_WITHIN_FOCUSED_OBJECT;
-  NotifyAccessibilityEvent(blink::WebAXEventFocus, focus_);
+  NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, focus_);
 }
 
 bool BrowserAccessibilityManager::IsOSKAllowed(const gfx::Rect& bounds) {
   if (!delegate_ || !delegate_->HasFocus())
     return false;
 
   gfx::Point touch_point = delegate_->GetLastTouchEventLocation();
   return bounds.Contains(touch_point);
 }
 
@@ skipping 12 matching lines @@
     const std::vector<AccessibilityHostMsg_EventParams>& params) {
   bool should_send_initial_focus = false;
 
   // Process all changes to the accessibility tree first.
   for (uint32 index = 0; index < params.size(); index++) {
     const AccessibilityHostMsg_EventParams& param = params[index];
     if (!UpdateNodes(param.nodes))
       return;
 
     // Set initial focus when a page is loaded.
-    blink::WebAXEvent event_type = param.event_type;
-    if (event_type == blink::WebAXEventLoadComplete) {
+    ui::AXEvent event_type = param.event_type;
+    if (event_type == ui::AX_EVENT_LOAD_COMPLETE) {
       if (!focus_) {
         SetFocus(root_, false);
         should_send_initial_focus = true;
       }
     }
   }
 
   if (should_send_initial_focus &&
       (!delegate_ || delegate_->HasFocus())) {
-    NotifyAccessibilityEvent(blink::WebAXEventFocus, focus_);
+    NotifyAccessibilityEvent(ui::AX_EVENT_FOCUS, focus_);
   }
 
   // Now iterate over the events again and fire the events.
   for (uint32 index = 0; index < params.size(); index++) {
     const AccessibilityHostMsg_EventParams& param = params[index];
 
     // Find the node corresponding to the id that's the target of the
     // event (which may not be the root of the update tree).
     BrowserAccessibility* node = GetFromRendererID(param.id);
     if (!node)
       continue;
 
-    blink::WebAXEvent event_type = param.event_type;
-    if (event_type == blink::WebAXEventFocus ||
-        event_type == blink::WebAXEventBlur) {
+    ui::AXEvent event_type = param.event_type;
+    if (event_type == ui::AX_EVENT_FOCUS ||
+        event_type == ui::AX_EVENT_BLUR) {
       SetFocus(node, false);
 
       if (osk_state_ != OSK_DISALLOWED_BECAUSE_TAB_HIDDEN &&
           osk_state_ != OSK_DISALLOWED_BECAUSE_TAB_JUST_APPEARED)
         osk_state_ = OSK_ALLOWED;
 
       // Don't send a native focus event if the window itself doesn't
       // have focus.
       if (delegate_ && !delegate_->HasFocus())
         continue;
@@ skipping 63 matching lines @@
   }
 }
 
 gfx::Rect BrowserAccessibilityManager::GetViewBounds() {
   if (delegate_)
     return delegate_->GetViewBounds();
   return gfx::Rect();
 }
 
 void BrowserAccessibilityManager::UpdateNodesForTesting(
-    const AccessibilityNodeData& node1,
-    const AccessibilityNodeData& node2 /* = AccessibilityNodeData() */,
-    const AccessibilityNodeData& node3 /* = AccessibilityNodeData() */,
-    const AccessibilityNodeData& node4 /* = AccessibilityNodeData() */,
-    const AccessibilityNodeData& node5 /* = AccessibilityNodeData() */,
-    const AccessibilityNodeData& node6 /* = AccessibilityNodeData() */,
-    const AccessibilityNodeData& node7 /* = AccessibilityNodeData() */) {
-  std::vector<AccessibilityNodeData> nodes;
+    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() */) {
+  std::vector<ui::AXNodeData> nodes;
   nodes.push_back(node1);
-  if (node2.id != AccessibilityNodeData().id)
+  if (node2.id != ui::AXNodeData().id)
     nodes.push_back(node2);
-  if (node3.id != AccessibilityNodeData().id)
+  if (node3.id != ui::AXNodeData().id)
     nodes.push_back(node3);
-  if (node4.id != AccessibilityNodeData().id)
+  if (node4.id != ui::AXNodeData().id)
     nodes.push_back(node4);
-  if (node5.id != AccessibilityNodeData().id)
+  if (node5.id != ui::AXNodeData().id)
     nodes.push_back(node5);
-  if (node6.id != AccessibilityNodeData().id)
+  if (node6.id != ui::AXNodeData().id)
     nodes.push_back(node6);
-  if (node7.id != AccessibilityNodeData().id)
+  if (node7.id != ui::AXNodeData().id)
     nodes.push_back(node7);
   UpdateNodes(nodes);
 }
 
 bool BrowserAccessibilityManager::UpdateNodes(
-    const std::vector<AccessibilityNodeData>& nodes) {
+    const std::vector<ui::AXNodeData>& nodes) {
   bool success = true;
 
   // First, update all of the nodes in the tree.
   for (size_t i = 0; i < nodes.size() && success; i++) {
     if (!UpdateNode(nodes[i]))
       success = false;
   }
 
   // In a second pass, call PostInitialize on each one - this must
   // be called after all of each node's children are initialized too.
@@ skipping 45 matching lines @@
   node->InitializeTreeStructure(
       this, parent, renderer_id, index_in_parent);
   AddNodeToMap(node);
   return node;
 }
 
 void BrowserAccessibilityManager::AddNodeToMap(BrowserAccessibility* node) {
   renderer_id_map_[node->renderer_id()] = node;
 }
 
-bool BrowserAccessibilityManager::UpdateNode(const AccessibilityNodeData& src) {
+bool BrowserAccessibilityManager::UpdateNode(const ui::AXNodeData& src) {
   // This method updates one node in the tree based on serialized data
   // received from the renderer.
 
   // Create a set of child ids in |src| for fast lookup. If a duplicate id is
   // found, exit now with a fatal error before changing anything else.
   std::set<int32> new_child_ids;
   for (size_t i = 0; i < src.child_ids.size(); ++i) {
     if (new_child_ids.find(src.child_ids[i]) != new_child_ids.end())
       return false;
     new_child_ids.insert(src.child_ids[i]);
   }
 
   // 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 renderer
   // and this is a serious error.
   BrowserAccessibility* instance = GetFromRendererID(src.id);
   if (!instance) {
-    if (src.role != blink::WebAXRoleRootWebArea)
+    if (src.role != ui::AX_ROLE_ROOT_WEB_AREA)
       return false;
     instance = CreateNode(NULL, src.id, 0);
   }
 
   // Update all of the node-specific data, like its role, state, name, etc.
   instance->InitializeData(src);
 
   //
   // Update the children in three steps:
   //
@@ skipping 37 matching lines @@
     } else {
       child = CreateNode(instance, child_renderer_id, index_in_parent);
     }
     new_children.push_back(child);
   }
 
   // Finally, swap in the new children vector for the old.
   instance->SwapChildren(new_children);
 
   // Handle the case where this node is the new root of the tree.
-  if (src.role == blink::WebAXRoleRootWebArea &&
+  if (src.role == ui::AX_ROLE_ROOT_WEB_AREA &&
       (!root_ || root_->renderer_id() != src.id)) {
     if (root_)
       root_->Destroy();
     if (focus_ == root_)
       SetFocus(instance, false);
     SetRoot(instance);
   }
 
   // Keep track of what node is focused.
-  if (src.role != blink::WebAXRoleRootWebArea &&
-      src.role != blink::WebAXRoleWebArea &&
-      (src.state >> blink::WebAXStateFocused & 1)) {
+  if (src.role != ui::AX_ROLE_ROOT_WEB_AREA &&
+      src.role != ui::AX_ROLE_WEB_AREA &&
+      (src.state >> ui::AX_STATE_FOCUSED & 1)) {
     SetFocus(instance, false);
   }
   return success;
 }
 
 }  // namespace content