Revert of Create AXAction and AXActionData as a way to simplify accessibility actions

content/renderer/accessibility/render_accessibility_impl.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/renderer/accessibility/render_accessibility_impl.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
@@ skipping 100 matching lines @@
   }
 }
 
 RenderAccessibilityImpl::~RenderAccessibilityImpl() {
 }
 
 bool RenderAccessibilityImpl::OnMessageReceived(const IPC::Message& message) {
   bool handled = true;
   during_action_ = true;
   IPC_BEGIN_MESSAGE_MAP(RenderAccessibilityImpl, message)
-    IPC_MESSAGE_HANDLER(AccessibilityMsg_PerformAction, OnPerformAction)
+    IPC_MESSAGE_HANDLER(AccessibilityMsg_SetFocus, OnSetFocus)
+    IPC_MESSAGE_HANDLER(AccessibilityMsg_DoDefaultAction, OnDoDefaultAction)
     IPC_MESSAGE_HANDLER(AccessibilityMsg_Events_ACK, OnEventsAck)
+    IPC_MESSAGE_HANDLER(AccessibilityMsg_ScrollToMakeVisible,
+                        OnScrollToMakeVisible)
+    IPC_MESSAGE_HANDLER(AccessibilityMsg_ScrollToPoint, OnScrollToPoint)
+    IPC_MESSAGE_HANDLER(AccessibilityMsg_SetScrollOffset, OnSetScrollOffset)
+    IPC_MESSAGE_HANDLER(AccessibilityMsg_SetSelection, OnSetSelection)
+    IPC_MESSAGE_HANDLER(AccessibilityMsg_SetValue, OnSetValue)
+    IPC_MESSAGE_HANDLER(AccessibilityMsg_ShowContextMenu, OnShowContextMenu)
     IPC_MESSAGE_HANDLER(AccessibilityMsg_HitTest, OnHitTest)
+    IPC_MESSAGE_HANDLER(AccessibilityMsg_SetAccessibilityFocus,
+                        OnSetAccessibilityFocus)
     IPC_MESSAGE_HANDLER(AccessibilityMsg_Reset, OnReset)
     IPC_MESSAGE_HANDLER(AccessibilityMsg_FatalError, OnFatalError)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   during_action_ = false;
   return handled;
 }
 
 void RenderAccessibilityImpl::HandleWebAccessibilityEvent(
     const blink::WebAXObject& obj, blink::WebAXEvent event) {
@@ skipping 292 matching lines @@
     std::vector<blink::WebAXObject> children;
     tree_source_.GetChildren(obj, &children);
     for (size_t i = 0; i < children.size(); ++i)
       objs_to_explore.push(children[i]);
   }
   locations_.swap(new_locations);
 
   Send(new AccessibilityHostMsg_LocationChanges(routing_id(), messages));
 }
 
-void RenderAccessibilityImpl::OnPerformAction(
-    const ui::AXActionData& data) {
+void RenderAccessibilityImpl::OnDoDefaultAction(int acc_obj_id) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
-  WebAXObject root = document.accessibilityObject();
-  if (!root.updateLayoutAndCheckValidity())
+  WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
+  if (obj.isDetached()) {
+#ifndef NDEBUG
+    LOG(WARNING) << "DoDefaultAction on invalid object id " << acc_obj_id;
+#endif
     return;
+  }
 
-  WebAXObject target = document.accessibilityObjectFromID(data.target_node_id);
-  WebAXObject anchor = document.accessibilityObjectFromID(data.anchor_node_id);
-  WebAXObject focus = document.accessibilityObjectFromID(data.focus_node_id);
-
-  switch (data.action) {
-    case ui::AX_ACTION_DO_DEFAULT:
-      target.performDefaultAction();
-      break;
-    case ui::AX_ACTION_HIT_TEST:
-      OnHitTest(data.target_point);
-      break;
-    case ui::AX_ACTION_SCROLL_TO_MAKE_VISIBLE:
-      target.scrollToMakeVisibleWithSubFocus(
-          WebRect(data.target_rect.x(), data.target_rect.y(),
-                  data.target_rect.width(), data.target_rect.height()));
-      break;
-    case ui::AX_ACTION_SCROLL_TO_POINT:
-      target.scrollToGlobalPoint(
-          WebPoint(data.target_point.x(), data.target_point.y()));
-      break;
-    case ui::AX_ACTION_SET_ACCESSIBILITY_FOCUS:
-      OnSetAccessibilityFocus(target);
-      break;
-    case ui::AX_ACTION_SET_FOCUS:
-      // By convention, calling SetFocus on the root of the tree should
-      // clear the current focus. Otherwise set the focus to the new node.
-      if (data.target_node_id == root.axID())
-        render_frame_->GetRenderView()->GetWebView()->clearFocusedElement();
-      else
-        target.setFocused(true);
-      break;
-    case ui::AX_ACTION_SET_SCROLL_OFFSET:
-      target.setScrollOffset(
-          WebPoint(data.target_point.x(), data.target_point.y()));
-      break;
-    case ui::AX_ACTION_SET_SELECTION:
-      anchor.setSelection(anchor, data.anchor_offset, focus, data.focus_offset);
-      HandleAXEvent(root, ui::AX_EVENT_LAYOUT_COMPLETE);
-      break;
-    case ui::AX_ACTION_SET_VALUE:
-      target.setValue(data.value);
-      HandleAXEvent(target, ui::AX_EVENT_VALUE_CHANGED);
-      break;
-    case ui::AX_ACTION_SHOW_CONTEXT_MENU:
-      target.showContextMenu();
-      break;
-    case ui::AX_ACTION_NONE:
-      NOTREACHED();
-      break;
-  }
+  obj.performDefaultAction();
 }
 
 void RenderAccessibilityImpl::OnEventsAck(int ack_token) {
   // Ignore acks intended for a different or previous instance.
   if (ack_token_ != ack_token)
     return;
 
   DCHECK(ack_pending_);
   ack_pending_ = false;
   SendPendingAccessibilityEvents();
 }
 
 void RenderAccessibilityImpl::OnFatalError() {
   CHECK(false) << "Invalid accessibility tree.";
 }
 
-void RenderAccessibilityImpl::OnHitTest(const gfx::Point& point) {
+void RenderAccessibilityImpl::OnHitTest(gfx::Point point) {
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
   WebAXObject root_obj = document.accessibilityObject();
   if (!root_obj.updateLayoutAndCheckValidity())
     return;
 
   WebAXObject obj = root_obj.hitTest(point);
   if (obj.isDetached())
     return;
 
   // If the object that was hit has a child frame, we have to send a
   // message back to the browser to do the hit test in the child frame,
   // recursively.
   AXContentNodeData data;
   ScopedFreezeBlinkAXTreeSource freeze(&tree_source_);
   tree_source_.SerializeNode(obj, &data);
   if (data.HasContentIntAttribute(AX_CONTENT_ATTR_CHILD_ROUTING_ID) ||
       data.HasContentIntAttribute(
           AX_CONTENT_ATTR_CHILD_BROWSER_PLUGIN_INSTANCE_ID)) {
     Send(new AccessibilityHostMsg_ChildFrameHitTestResult(routing_id(), point,
                                                           obj.axID()));
     return;
   }
 
   // Otherwise, send a HOVER event on the node that was hit.
   HandleAXEvent(obj, ui::AX_EVENT_HOVER);
 }
 
-void RenderAccessibilityImpl::OnSetAccessibilityFocus(
-    const blink::WebAXObject& obj) {
+void RenderAccessibilityImpl::OnSetAccessibilityFocus(int acc_obj_id) {
   ScopedFreezeBlinkAXTreeSource freeze(&tree_source_);
-  if (tree_source_.accessibility_focus_id() == obj.axID())
+  if (tree_source_.accessibility_focus_id() == acc_obj_id)
     return;
 
-  tree_source_.set_accessibility_focus_id(obj.axID());
+  tree_source_.set_accessibility_focus_id(acc_obj_id);
 
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
+  WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
+
   // This object may not be a leaf node. Force the whole subtree to be
   // re-serialized.
   serializer_.DeleteClientSubtree(obj);
 
   // Explicitly send a tree change update event now.
   HandleAXEvent(obj, ui::AX_EVENT_TREE_CHANGED);
 }
 
 void RenderAccessibilityImpl::OnReset(int reset_token) {
   reset_token_ = reset_token;
   serializer_.Reset();
   pending_events_.clear();
 
   const WebDocument& document = GetMainDocument();
   if (!document.isNull()) {
     // Tree-only mode gets used by the automation extension API which requires a
     // load complete event to invoke listener callbacks.
     ui::AXEvent evt = document.accessibilityObject().isLoaded()
         ? ui::AX_EVENT_LOAD_COMPLETE : ui::AX_EVENT_LAYOUT_COMPLETE;
     HandleAXEvent(document.accessibilityObject(), evt);
   }
 }
 
+void RenderAccessibilityImpl::OnScrollToMakeVisible(
+    int acc_obj_id, gfx::Rect subfocus) {
+  if (plugin_tree_source_ && plugin_tree_source_->GetFromId(acc_obj_id)) {
+    ScrollPlugin(acc_obj_id);
+    return;
+  }
+
+  const WebDocument& document = GetMainDocument();
+  if (document.isNull())
+    return;
+
+  WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
+  if (obj.isDetached()) {
+#ifndef NDEBUG
+    LOG(WARNING) << "ScrollToMakeVisible on invalid object id " << acc_obj_id;
+#endif
+    return;
+  }
+
+  obj.scrollToMakeVisibleWithSubFocus(
+      WebRect(subfocus.x(), subfocus.y(), subfocus.width(), subfocus.height()));
+
+  // Make sure the browser gets an event when the scroll
+  // position actually changes.
+  // TODO(dmazzoni): remove this once this bug is fixed:
+  // https://bugs.webkit.org/show_bug.cgi?id=73460
+  HandleAXEvent(document.accessibilityObject(), ui::AX_EVENT_LAYOUT_COMPLETE);
+}
+
+void RenderAccessibilityImpl::OnScrollToPoint(
+    int acc_obj_id, gfx::Point point) {
+  const WebDocument& document = GetMainDocument();
+  if (document.isNull())
+    return;
+
+  WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
+  if (obj.isDetached()) {
+#ifndef NDEBUG
+    LOG(WARNING) << "ScrollToPoint on invalid object id " << acc_obj_id;
+#endif
+    return;
+  }
+
+  obj.scrollToGlobalPoint(WebPoint(point.x(), point.y()));
+
+  // Make sure the browser gets an event when the scroll
+  // position actually changes.
+  // TODO(dmazzoni): remove this once this bug is fixed:
+  // https://bugs.webkit.org/show_bug.cgi?id=73460
+  HandleAXEvent(document.accessibilityObject(), ui::AX_EVENT_LAYOUT_COMPLETE);
+}
+
+void RenderAccessibilityImpl::OnSetScrollOffset(int acc_obj_id,
+                                              gfx::Point offset) {
+  const WebDocument& document = GetMainDocument();
+  if (document.isNull())
+    return;
+
+  WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
+  if (obj.isDetached())
+    return;
+
+  obj.setScrollOffset(WebPoint(offset.x(), offset.y()));
+}
+
+void RenderAccessibilityImpl::OnSetFocus(int acc_obj_id) {
+  const WebDocument& document = GetMainDocument();
+  if (document.isNull())
+    return;
+
+  WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
+  if (obj.isDetached()) {
+#ifndef NDEBUG
+    LOG(WARNING) << "OnSetAccessibilityFocus on invalid object id "
+                 << acc_obj_id;
+#endif
+    return;
+  }
+
+  WebAXObject root = document.accessibilityObject();
+  if (root.isDetached()) {
+#ifndef NDEBUG
+    LOG(WARNING) << "OnSetAccessibilityFocus but root is invalid";
+#endif
+    return;
+  }
+
+  // By convention, calling SetFocus on the root of the tree should clear the
+  // current focus. Otherwise set the focus to the new node.
+  if (acc_obj_id == root.axID())
+    render_frame_->GetRenderView()->GetWebView()->clearFocusedElement();
+  else
+    obj.setFocused(true);
+}
+
+void RenderAccessibilityImpl::OnSetSelection(int anchor_acc_obj_id,
+                                           int anchor_offset,
+                                           int focus_acc_obj_id,
+                                           int focus_offset) {
+  const WebDocument& document = GetMainDocument();
+  if (document.isNull())
+    return;
+
+  WebAXObject anchor_obj =
+      document.accessibilityObjectFromID(anchor_acc_obj_id);
+  if (anchor_obj.isDetached()) {
+#ifndef NDEBUG
+    LOG(WARNING) << "SetTextSelection on invalid object id "
+                 << anchor_acc_obj_id;
+#endif
+    return;
+  }
+
+  WebAXObject focus_obj = document.accessibilityObjectFromID(focus_acc_obj_id);
+  if (focus_obj.isDetached()) {
+#ifndef NDEBUG
+    LOG(WARNING) << "SetTextSelection on invalid object id "
+                 << focus_acc_obj_id;
+#endif
+    return;
+  }
+
+  anchor_obj.setSelection(anchor_obj, anchor_offset, focus_obj, focus_offset);
+  WebAXObject root = document.accessibilityObject();
+  if (root.isDetached()) {
+#ifndef NDEBUG
+    LOG(WARNING) << "OnSetAccessibilityFocus but root is invalid";
+#endif
+    return;
+  }
+  HandleAXEvent(root, ui::AX_EVENT_LAYOUT_COMPLETE);
+}
+
+void RenderAccessibilityImpl::OnSetValue(
+    int acc_obj_id,
+    base::string16 value) {
+  const WebDocument& document = GetMainDocument();
+  if (document.isNull())
+    return;
+
+  WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
+  if (obj.isDetached()) {
+#ifndef NDEBUG
+    LOG(WARNING) << "SetTextSelection on invalid object id " << acc_obj_id;
+#endif
+    return;
+  }
+
+  obj.setValue(value);
+  HandleAXEvent(obj, ui::AX_EVENT_VALUE_CHANGED);
+}
+
+void RenderAccessibilityImpl::OnShowContextMenu(int acc_obj_id) {
+  const WebDocument& document = GetMainDocument();
+  if (document.isNull())
+    return;
+
+  WebAXObject obj = document.accessibilityObjectFromID(acc_obj_id);
+  if (obj.isDetached()) {
+#ifndef NDEBUG
+    LOG(WARNING) << "ShowContextMenu on invalid object id " << acc_obj_id;
+#endif
+    return;
+  }
+
+  obj.showContextMenu();
+}
+
 void RenderAccessibilityImpl::OnDestruct() {
   delete this;
 }
 
 void RenderAccessibilityImpl::AddPluginTreeToUpdate(
     AXContentTreeUpdate* update) {
   for (size_t i = 0; i < update->nodes.size(); ++i) {
     if (update->nodes[i].role == ui::AX_ROLE_EMBEDDED_OBJECT) {
       const ui::AXNode* root = plugin_tree_source_->GetRoot();
       update->nodes[i].child_ids.push_back(root->id());
@@ skipping 36 matching lines @@
 
   const WebDocument& document = GetMainDocument();
   if (document.isNull())
     return;
 
   document.accessibilityObject().scrollToMakeVisibleWithSubFocus(
       WebRect(bounds.x(), bounds.y(), bounds.width(), bounds.height()));
 }
 
 }  // namespace content