Create AXAction and AXActionData as a way to simplify accessibility actions

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 <stddef.h>
 
 #include "base/logging.h"
 #include "build/build_config.h"
@@ skipping 441 matching lines @@
   BrowserAccessibility* obj = GetFromID(hit_obj_id);
   if (!obj || !obj->HasIntAttribute(ui::AX_ATTR_CHILD_TREE_ID))
     return;
 
   BrowserAccessibilityManager* child_manager =
       BrowserAccessibilityManager::FromID(
           obj->GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID));
   if (!child_manager || !child_manager->delegate())
     return;
 
-  return child_manager->delegate()->AccessibilityHitTest(point);
+  ui::AXActionData action_data;
+  action_data.target_point = point;
+  return child_manager->delegate()->AccessibilityPerformAction(
+      ui::AX_ACTION_HIT_TEST, action_data);
 }
 
 void BrowserAccessibilityManager::ActivateFindInPageResult(
     int request_id) {
   find_in_page_info_.active_request_id = request_id;
   if (find_in_page_info_.request_id != request_id)
     return;
 
   BrowserAccessibility* node = GetFromID(find_in_page_info_.start_id);
   if (!node)
@@ skipping 77 matching lines @@
         BrowserAccessibilityManager::FromID(
             obj->GetIntAttribute(ui::AX_ATTR_CHILD_TREE_ID));
     if (child_manager)
       return child_manager->GetFocusFromThisOrDescendantFrame();
   }
 
   return obj;
 }
 
 void BrowserAccessibilityManager::SetFocus(const BrowserAccessibility& node) {
-  if (delegate_)
-    delegate_->AccessibilitySetFocus(node.GetId());
+  if (!delegate_)
+    return;
+
+  ui::AXActionData action_data;
+  action_data.target_node_id = node.GetId();
+  delegate_->AccessibilityPerformAction(ui::AX_ACTION_SET_FOCUS, action_data);
 }
 
 void BrowserAccessibilityManager::SetFocusLocallyForTesting(
     BrowserAccessibility* node) {
   ui::AXTreeData data = GetTreeData();
   data.focus_id = node->GetId();
   tree_->UpdateData(data);
 }
 
 // static
 void BrowserAccessibilityManager::SetFocusChangeCallbackForTesting(
     const base::Closure& callback) {
   g_focus_change_callback_for_testing.Get() = callback;
 }
 
 void BrowserAccessibilityManager::DoDefaultAction(
     const BrowserAccessibility& node) {
-  if (delegate_)
-    delegate_->AccessibilityDoDefaultAction(node.GetId());
+  if (!delegate_)
+    return;
+
+  ui::AXActionData action_data;
+  action_data.target_node_id = node.GetId();
+  delegate_->AccessibilityPerformAction(ui::AX_ACTION_DO_DEFAULT, action_data);
+}
+
+void BrowserAccessibilityManager::ShowContextMenu(
+    const BrowserAccessibility& node) {
+  if (!delegate_)
+    return;
+
+  ui::AXActionData action_data;
+  action_data.target_node_id = node.GetId();
+  delegate_->AccessibilityPerformAction(ui::AX_ACTION_SHOW_CONTEXT_MENU,
+                                        action_data);
 }
 
 void BrowserAccessibilityManager::ScrollToMakeVisible(
     const BrowserAccessibility& node, gfx::Rect subfocus) {
-  if (delegate_) {
-    delegate_->AccessibilityScrollToMakeVisible(node.GetId(), subfocus);
-  }
+  if (!delegate_)
+    return;
+
+  ui::AXActionData action_data;
+  action_data.target_node_id = node.GetId();
+  action_data.target_rect = subfocus;
+  delegate_->AccessibilityPerformAction(ui::AX_ACTION_SCROLL_TO_MAKE_VISIBLE,
+                                        action_data);
 }
 
 void BrowserAccessibilityManager::ScrollToPoint(
     const BrowserAccessibility& node, gfx::Point point) {
-  if (delegate_) {
-    delegate_->AccessibilityScrollToPoint(node.GetId(), point);
-  }
+  if (!delegate_)
+    return;
+
+  ui::AXActionData action_data;
+  action_data.target_node_id = node.GetId();
+  action_data.target_point = point;
+  delegate_->AccessibilityPerformAction(ui::AX_ACTION_SCROLL_TO_POINT,
+                                        action_data);
 }
 
 void BrowserAccessibilityManager::SetScrollOffset(
     const BrowserAccessibility& node, gfx::Point offset) {
-  if (delegate_) {
-    delegate_->AccessibilitySetScrollOffset(node.GetId(), offset);
-  }
+  if (!delegate_)
+    return;
+
+  ui::AXActionData action_data;
+  action_data.target_node_id = node.GetId();
+  action_data.target_point = offset;
+  delegate_->AccessibilityPerformAction(ui::AX_ACTION_SET_SCROLL_OFFSET,
+                                        action_data);
 }
 
 void BrowserAccessibilityManager::SetValue(
     const BrowserAccessibility& node,
     const base::string16& value) {
-  if (delegate_)
-    delegate_->AccessibilitySetValue(node.GetId(), value);
+  if (!delegate_)
+    return;
+
+  ui::AXActionData action_data;
+  action_data.target_node_id = node.GetId();
+  action_data.value = value;
+  delegate_->AccessibilityPerformAction(ui::AX_ACTION_SET_VALUE, action_data);
 }
 
 void BrowserAccessibilityManager::SetTextSelection(
     const BrowserAccessibility& node,
     int start_offset,
     int end_offset) {
-  if (delegate_) {
-    delegate_->AccessibilitySetSelection(node.GetId(), start_offset,
-                                         node.GetId(), end_offset);
-  }
+  if (!delegate_)
+    return;
+
+  ui::AXActionData action_data;
+  action_data.anchor_node_id = node.GetId();
+  action_data.anchor_offset = start_offset;
+  action_data.focus_node_id = node.GetId();
+  action_data.focus_offset = end_offset;
+  delegate_->AccessibilityPerformAction(ui::AX_ACTION_SET_SELECTION,
+                                        action_data);
+}
+
+void BrowserAccessibilityManager::SetAccessibilityFocus(
+    const BrowserAccessibility& node) {
+  if (!delegate_)
+    return;
+
+  ui::AXActionData action_data;
+  action_data.target_node_id = node.GetId();
+  delegate_->AccessibilityPerformAction(ui::AX_ACTION_SET_ACCESSIBILITY_FOCUS,
+                                        action_data);
+}
+
+void BrowserAccessibilityManager::HitTest(const gfx::Point& point) {
+  if (!delegate_)
+    return;
+
+  ui::AXActionData action_data;
+  action_data.target_point = point;
+  delegate_->AccessibilityPerformAction(ui::AX_ACTION_HIT_TEST, action_data);
 }
 
 gfx::Rect BrowserAccessibilityManager::GetViewBounds() {
   BrowserAccessibilityDelegate* delegate = GetDelegateFromRootManager();
   if (delegate)
     return delegate->AccessibilityGetViewBounds();
   return gfx::Rect();
 }
 
 // static
@@ skipping 466 matching lines @@
 
 BrowserAccessibility* BrowserAccessibilityManager::CachingAsyncHitTest(
     const gfx::Point& screen_point) {
   BrowserAccessibilityManager* root_manager = GetRootManager();
   if (root_manager && root_manager != this)
     return root_manager->CachingAsyncHitTest(screen_point);
 
   if (delegate()) {
     // This triggers an asynchronous request to compute the true object that's
     // under |screen_point|.
-    gfx::Point local_point = screen_point - GetViewBounds().OffsetFromOrigin();
-    delegate()->AccessibilityHitTest(local_point);
+    HitTest(screen_point - GetViewBounds().OffsetFromOrigin());
 
     // Unfortunately we still have to return an answer synchronously because
     // the APIs were designed that way. The best case scenario is that the
     // screen point is within the bounds of the last result we got from a
     // call to AccessibilityHitTest - in that case, we can return that object!
     if (last_hover_bounds_.Contains(screen_point)) {
       BrowserAccessibilityManager* manager =
           BrowserAccessibilityManager::FromID(last_hover_ax_tree_id_);
       if (manager) {
         BrowserAccessibility* node = manager->GetFromID(last_hover_node_id_);
@@ skipping 22 matching lines @@
       hit_test_result = parent;
     parent = parent->GetParent();
   }
 
   last_hover_ax_tree_id_ = hit_test_result->manager()->ax_tree_id();
   last_hover_node_id_ = hit_test_result->GetId();
   last_hover_bounds_ = hit_test_result->GetScreenBoundsRect();
 }
 
 }  // namespace content