Initial support for accessibility actions on ARC.

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 <memory>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/string16.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/utf_string_conversions.h"
-#include "chrome/browser/extensions/api/automation_internal/automation_action_adapter.h"
 #include "chrome/browser/extensions/api/automation_internal/automation_event_router.h"
 #include "chrome/browser/extensions/api/tabs/tabs_constants.h"
 #include "chrome/browser/extensions/extension_tab_util.h"
 #include "chrome/browser/profiles/profile.h"
 #include "chrome/browser/ui/browser.h"
 #include "chrome/browser/ui/tabs/tab_strip_model.h"
 #include "chrome/common/extensions/api/automation_api_constants.h"
 #include "chrome/common/extensions/api/automation_internal.h"
 #include "chrome/common/extensions/chrome_extension_messages.h"
 #include "chrome/common/extensions/manifest_handlers/automation.h"
 #include "content/public/browser/ax_event_notification_details.h"
 #include "content/public/browser/browser_accessibility_state.h"
 #include "content/public/browser/browser_context.h"
 #include "content/public/browser/browser_plugin_guest_manager.h"
 #include "content/public/browser/media_session.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"
+#include "ui/accessibility/ax_host_delegate.h"
+#include "ui/accessibility/ax_tree_id_registry.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 96 matching lines @@
   // TODO(aboxhall): check for webstore URL
   if (automation_info->matches.MatchesURL(url))
     return true;
 
   int tab_id = ExtensionTabUtil::GetTabId(contents);
   std::string unused_error;
   return extension->permissions_data()->CanAccessPage(extension, url, tab_id,
                                                       &unused_error);
 }
 
-// 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);
-  }
-
- private:
-  content::RenderFrameHost* rfh_;
-
-  DISALLOW_COPY_AND_ASSIGN(RenderFrameHostActionAdapter);
-};
-
 }  // namespace
 
 // Helper class that receives accessibility data from |WebContents|.
 class AutomationWebContentsObserver
     : public content::WebContentsObserver,
       public content::WebContentsUserData<AutomationWebContentsObserver> {
  public:
   ~AutomationWebContentsObserver() override {}
 
   // content::WebContentsObserver overrides.
@@ skipping 151 matching lines @@
 
   // Only call this if this is the root of a frame tree, to avoid resetting
   // the accessibility state multiple times.
   if (!rfh->GetParent())
     contents->EnableWebContentsOnlyAccessibilityMode();
 
   return RespondNow(NoArguments());
 }
 
 ExtensionFunction::ResponseAction
+AutomationInternalPerformActionFunction::ConvertToAXActionData(
+    api::automation_internal::PerformAction::Params* params,
+    ui::AXActionData* action) {
+  action->target_node_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;
+      break;
+    case api::automation_internal::ACTION_TYPE_FOCUS:
+      action->action = ui::AX_ACTION_FOCUS;
+      break;
+    case api::automation_internal::ACTION_TYPE_GETIMAGEDATA: {
+      api::automation_internal::GetImageDataParams get_image_data_params;
+      EXTENSION_FUNCTION_VALIDATE(
+          api::automation_internal::GetImageDataParams::Populate(
+              params->opt_args.additional_properties, &get_image_data_params));
+      action->action = ui::AX_ACTION_GET_IMAGE_DATA;
+      action->target_rect = gfx::Rect(0, 0, get_image_data_params.max_width,
+                                      get_image_data_params.max_height);
+      break;
+    }
+    case api::automation_internal::ACTION_TYPE_MAKEVISIBLE:
+      action->action = ui::AX_ACTION_SCROLL_TO_MAKE_VISIBLE;
+      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;
+      break;
+    }
+    case api::automation_internal::ACTION_TYPE_SHOWCONTEXTMENU: {
+      action->action = ui::AX_ACTION_SHOW_CONTEXT_MENU;
+      break;
+    }
+    case api::automation_internal::ACTION_TYPE_SETACCESSIBILITYFOCUS: {
+      action->action = ui::AX_ACTION_SET_ACCESSIBILITY_FOCUS;
+      break;
+    }
+    case api::automation_internal::
+        ACTION_TYPE_SETSEQUENTIALFOCUSNAVIGATIONSTARTINGPOINT: {
+      action->action =
+          ui::AX_ACTION_SET_SEQUENTIAL_FOCUS_NAVIGATION_STARTING_POINT;
+      break;
+    }
+    default:
+      NOTREACHED();
+  }
+  return RespondNow(NoArguments());
+}
+
+ExtensionFunction::ResponseAction
 AutomationInternalPerformActionFunction::Run() {
   const AutomationInfo* automation_info = AutomationInfo::Get(extension());
   EXTENSION_FUNCTION_VALIDATE(automation_info && automation_info->interact);
 
   using api::automation_internal::PerformAction::Params;
   std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
-
-  if (params->args.tree_id == api::automation::kDesktopTreeID) {
+  ui::AXTreeIDRegistry* registry = ui::AXTreeIDRegistry::GetInstance();
+  ui::AXHostDelegate* delegate =
+      registry->GetHostDelegate(params->args.tree_id);
+  if (delegate) {
 #if defined(USE_AURA)
-    return RouteActionToAdapter(params.get(),
-                                AutomationManagerAura::GetInstance());
+    ui::AXActionData data;
+    ConvertToAXActionData(params.get(), &data);
+    delegate->PerformAction(data);
 #else
     NOTREACHED();
     return RespondNow(Error("Unexpected action on desktop automation tree;"
                             " platform does not support desktop automation"));
 #endif  // defined(USE_AURA)
   }
   content::RenderFrameHost* rfh =
       content::RenderFrameHost::FromAXTreeID(params->args.tree_id);
   if (!rfh)
     return RespondNow(Error("Ignoring action on destroyed node"));
@@ skipping 20 matching lines @@
              api::automation_internal::ACTION_TYPE_RESUMEMEDIA) {
     content::MediaSession* session = content::MediaSession::Get(contents);
     session->Resume(content::MediaSession::SuspendType::SYSTEM);
     return RespondNow(NoArguments());
   } else if (params->args.action_type ==
              api::automation_internal::ACTION_TYPE_SUSPENDMEDIA) {
     content::MediaSession* session = content::MediaSession::Get(contents);
     session->Suspend(content::MediaSession::SuspendType::SYSTEM);
     return RespondNow(NoArguments());
   }
-
-  RenderFrameHostActionAdapter adapter(rfh);
-  return RouteActionToAdapter(params.get(), &adapter);
+  ui::AXActionData data;
+  ExtensionFunction::ResponseAction result =
+      ConvertToAXActionData(params.get(), &data);
+  rfh->AccessibilityPerformAction(data);
+  return result;
 }
 
 ExtensionFunction::ResponseAction
-AutomationInternalPerformActionFunction::RouteActionToAdapter(
-    api::automation_internal::PerformAction::Params* params,
-    AutomationActionAdapter* adapter) {
-  ui::AXActionData action;
-  action.target_node_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);
-      break;
-    case api::automation_internal::ACTION_TYPE_FOCUS:
-      action.action = ui::AX_ACTION_FOCUS;
-      adapter->PerformAction(action);
-      break;
-    case api::automation_internal::ACTION_TYPE_GETIMAGEDATA: {
-      api::automation_internal::GetImageDataParams get_image_data_params;
-      EXTENSION_FUNCTION_VALIDATE(
-          api::automation_internal::GetImageDataParams::Populate(
-              params->opt_args.additional_properties, &get_image_data_params));
-      action.action = ui::AX_ACTION_GET_IMAGE_DATA;
-      action.target_rect = gfx::Rect(
-          0, 0, get_image_data_params.max_width,
-          get_image_data_params.max_height);
-      adapter->PerformAction(action);
-      break;
-    }
-    case api::automation_internal::ACTION_TYPE_MAKEVISIBLE:
-      action.action = ui::AX_ACTION_SCROLL_TO_MAKE_VISIBLE;
-      adapter->PerformAction(action);
-      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);
-      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);
-      break;
-    }
-    case api::automation_internal::
-        ACTION_TYPE_SETSEQUENTIALFOCUSNAVIGATIONSTARTINGPOINT: {
-      action.action =
-          ui::AX_ACTION_SET_SEQUENTIAL_FOCUS_NAVIGATION_STARTING_POINT;
-      adapter->PerformAction(action);
-      break;
-    }
-    default:
-      NOTREACHED();
-  }
-  return RespondNow(NoArguments());
-}
-
-ExtensionFunction::ResponseAction
 AutomationInternalEnableDesktopFunction::Run() {
 #if defined(USE_AURA)
   const AutomationInfo* automation_info = AutomationInfo::Get(extension());
   if (!automation_info || !automation_info->desktop)
     return RespondNow(Error("desktop permission must be requested"));
 
   using api::automation_internal::EnableDesktop::Params;
   std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
@@ skipping 15 matching lines @@
 
 ExtensionFunction::ResponseAction
 AutomationInternalQuerySelectorFunction::Run() {
   const AutomationInfo* automation_info = AutomationInfo::Get(extension());
   EXTENSION_FUNCTION_VALIDATE(automation_info);
 
   using api::automation_internal::QuerySelector::Params;
   std::unique_ptr<Params> params(Params::Create(*args_));
   EXTENSION_FUNCTION_VALIDATE(params.get());
 
-  if (params->args.tree_id == api::automation::kDesktopTreeID) {
-    return RespondNow(
-        Error("domQuerySelector queries may not be used on the desktop."));
-  }
   content::RenderFrameHost* rfh =
       content::RenderFrameHost::FromAXTreeID(params->args.tree_id);
-  if (!rfh)
-    return RespondNow(Error("domQuerySelector query sent on destroyed tree."));
+  if (!rfh) {
+    return RespondNow(
+        Error("domQuerySelector query sent on non-web or destroyed tree."));
+  }
 
   content::WebContents* contents =
       content::WebContents::FromRenderFrameHost(rfh);
 
   int request_id = query_request_id_counter_++;
   base::string16 selector = base::UTF8ToUTF16(params->args.selector);
 
   // QuerySelectorHandler handles IPCs and deletes itself on completion.
   new QuerySelectorHandler(
       contents, request_id, params->args.automation_node_id, selector,
       base::Bind(&AutomationInternalQuerySelectorFunction::OnResponse, this));
 
   return RespondLater();
 }
 
 void AutomationInternalQuerySelectorFunction::OnResponse(
     const std::string& error,
     int result_acc_obj_id) {
   if (!error.empty()) {
     Respond(Error(error));
     return;
   }
 
   Respond(
       OneArgument(base::MakeUnique<base::FundamentalValue>(result_acc_obj_id)));
 }
 
 }  // namespace extensions