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

chrome/browser/extensions/api/automation_internal/automation_internal_api.cc

 // Copyright 2014 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 "chrome/browser/extensions/api/automation_internal/automation_internal_api.h"
 
 #include <stdint.h>
 
 #include <vector>
 
@@ skipping 19 matching lines @@
 #include "content/public/browser/browser_plugin_guest_manager.h"
 #include "content/public/browser/render_frame_host.h"
 #include "content/public/browser/render_view_host.h"
 #include "content/public/browser/render_widget_host.h"
 #include "content/public/browser/render_widget_host_view.h"
 #include "content/public/browser/web_contents.h"
 #include "content/public/browser/web_contents_observer.h"
 #include "content/public/browser/web_contents_user_data.h"
 #include "extensions/common/extension_messages.h"
 #include "extensions/common/permissions/permissions_data.h"
-#include "ui/accessibility/ax_action_data.h"
 
 #if defined(USE_AURA)
 #include "chrome/browser/ui/aura/accessibility/automation_manager_aura.h"
 #endif
 
 namespace extensions {
 class AutomationWebContentsObserver;
 }  // namespace extensions
 
 DEFINE_WEB_CONTENTS_USER_DATA_KEY(extensions::AutomationWebContentsObserver);
@@ skipping 105 matching lines @@
 
 // Helper class that implements an action adapter for a |RenderFrameHost|.
 class RenderFrameHostActionAdapter : public AutomationActionAdapter {
  public:
   explicit RenderFrameHostActionAdapter(content::RenderFrameHost* rfh)
       : rfh_(rfh) {}
 
   virtual ~RenderFrameHostActionAdapter() {}
 
   // AutomationActionAdapter implementation.
-  void PerformAction(const ui::AXActionData& data) override {
-    rfh_->AccessibilityPerformAction(data);
+  void DoDefault(int32_t id) override {
+    rfh_->AccessibilityDoDefaultAction(id);
+  }
+
+  void Focus(int32_t id) override { rfh_->AccessibilitySetFocus(id); }
+
+  void MakeVisible(int32_t id) override {
+    rfh_->AccessibilityScrollToMakeVisible(id, gfx::Rect());
+  }
+
+  void SetSelection(int32_t anchor_id,
+                    int32_t anchor_offset,
+                    int32_t focus_id,
+                    int32_t focus_offset) override {
+    rfh_->AccessibilitySetSelection(anchor_id, anchor_offset, focus_id,
+                                    focus_offset);
+  }
+
+  void ShowContextMenu(int32_t id) override {
+    rfh_->AccessibilityShowContextMenu(id);
   }
 
  private:
   content::RenderFrameHost* rfh_;
 
   DISALLOW_COPY_AND_ASSIGN(RenderFrameHostActionAdapter);
 };
 
 }  // namespace
 
@@ skipping 164 matching lines @@
   }
 
   RenderFrameHostActionAdapter adapter(rfh);
   return RouteActionToAdapter(params.get(), &adapter);
 }
 
 ExtensionFunction::ResponseAction
 AutomationInternalPerformActionFunction::RouteActionToAdapter(
     api::automation_internal::PerformAction::Params* params,
     AutomationActionAdapter* adapter) {
-  ui::AXActionData action;
-  action.target_node_id = params->args.automation_node_id;
+  int32_t automation_id = params->args.automation_node_id;
   switch (params->args.action_type) {
     case api::automation_internal::ACTION_TYPE_DODEFAULT:
-      action.action = ui::AX_ACTION_DO_DEFAULT;
-      adapter->PerformAction(action);
+      adapter->DoDefault(automation_id);
       break;
     case api::automation_internal::ACTION_TYPE_FOCUS:
-      action.action = ui::AX_ACTION_SET_FOCUS;
-      adapter->PerformAction(action);
+      adapter->Focus(automation_id);
       break;
     case api::automation_internal::ACTION_TYPE_MAKEVISIBLE:
-      action.action = ui::AX_ACTION_SCROLL_TO_MAKE_VISIBLE;
-      adapter->PerformAction(action);
+      adapter->MakeVisible(automation_id);
       break;
     case api::automation_internal::ACTION_TYPE_SETSELECTION: {
       api::automation_internal::SetSelectionParams selection_params;
       EXTENSION_FUNCTION_VALIDATE(
           api::automation_internal::SetSelectionParams::Populate(
               params->opt_args.additional_properties, &selection_params));
-      action.anchor_node_id = params->args.automation_node_id;
-      action.anchor_offset = selection_params.anchor_offset;
-      action.focus_node_id = selection_params.focus_node_id;
-      action.focus_offset = selection_params.focus_offset;
-      action.action = ui::AX_ACTION_SET_SELECTION;
-      adapter->PerformAction(action);
+      adapter->SetSelection(automation_id, selection_params.anchor_offset,
+                            selection_params.focus_node_id,
+                            selection_params.focus_offset);
       break;
     }
     case api::automation_internal::ACTION_TYPE_SHOWCONTEXTMENU: {
-      action.action = ui::AX_ACTION_SHOW_CONTEXT_MENU;
-      adapter->PerformAction(action);
-      break;
-    }
-    case api::automation_internal::ACTION_TYPE_SETACCESSIBILITYFOCUS: {
-      action.action = ui::AX_ACTION_SET_ACCESSIBILITY_FOCUS;
-      adapter->PerformAction(action);
+      adapter->ShowContextMenu(automation_id);
       break;
     }
     default:
       NOTREACHED();
   }
   return RespondNow(NoArguments());
 }
 
 ExtensionFunction::ResponseAction
 AutomationInternalEnableDesktopFunction::Run() {
@@ skipping 60 matching lines @@
   if (!error.empty()) {
     Respond(Error(error));
     return;
   }
 
   Respond(
       OneArgument(base::MakeUnique<base::FundamentalValue>(result_acc_obj_id)));
 }
 
 }  // namespace extensions