Finish implementation of automation API hit testing for the desktop.

chrome/browser/ui/aura/accessibility/automation_manager_aura.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/ui/aura/accessibility/automation_manager_aura.h"
 
 #include <stddef.h>
 
 #include "base/memory/singleton.h"
 #include "build/build_config.h"
 #include "chrome/browser/browser_process.h"
 #include "chrome/browser/extensions/api/automation_internal/automation_event_router.h"
 #include "chrome/browser/profiles/profile_manager.h"
 #include "chrome/common/extensions/api/automation_api_constants.h"
 #include "chrome/common/extensions/chrome_extension_messages.h"
 #include "content/public/browser/ax_event_notification_details.h"
 #include "content/public/browser/browser_context.h"
+#include "content/public/browser/render_frame_host.h"
 #include "ui/accessibility/ax_action_data.h"
 #include "ui/accessibility/ax_enums.h"
 #include "ui/accessibility/ax_tree_id_registry.h"
+#include "ui/accessibility/platform/aura_window_properties.h"
 #include "ui/aura/env.h"
 #include "ui/aura/window.h"
 #include "ui/views/accessibility/ax_aura_obj_wrapper.h"
 #include "ui/views/view.h"
 #include "ui/views/widget/widget.h"
 
 #if defined(OS_CHROMEOS)
+#include "ash/shell.h"           // nogncheck
 #include "ash/wm/window_util.h"  // nogncheck
 #endif
 
 using content::BrowserContext;
 using extensions::AutomationEventRouter;
 
 // static
 AutomationManagerAura* AutomationManagerAura::GetInstance() {
   return base::Singleton<AutomationManagerAura>::get();
 }
@@ skipping 36 matching lines @@
                                         const std::string& text) {
   if (!enabled_)
     return;
 
   views::AXAuraObjWrapper* obj =
       static_cast<AXRootObjWrapper*>(current_tree_->GetRoot())
           ->GetAlertForText(text);
   SendEvent(context, obj, ui::AX_EVENT_ALERT);
 }
 
-void AutomationManagerAura::PerformAction(
-    const ui::AXActionData& data) {
+void AutomationManagerAura::PerformAction(const ui::AXActionData& data) {
   CHECK(enabled_);
 
+  // Unlike all of the other actions, a hit test requires determining the
+  // node to perform the action on first.
+  if (data.action == ui::AX_ACTION_HIT_TEST) {
+    PerformHitTest(data);
+    return;
+  }
+
   current_tree_->HandleAccessibleAction(data);
 }
 
 void AutomationManagerAura::OnChildWindowRemoved(
     views::AXAuraObjWrapper* parent) {
   if (!enabled_)
     return;
 
   if (!parent)
     parent = current_tree_->GetRoot();
@@ skipping 56 matching lines @@
 
   processing_events_ = false;
   auto pending_events_copy = pending_events_;
   pending_events_.clear();
   for (size_t i = 0; i < pending_events_copy.size(); ++i) {
     SendEvent(context,
               pending_events_copy[i].first,
               pending_events_copy[i].second);
   }
 }
+
+void AutomationManagerAura::PerformHitTest(
+    const ui::AXActionData& original_action) {
+#if defined(OS_CHROMEOS)
+  ui::AXActionData action = original_action;
+  aura::Window* root_window = ash::Shell::Get()->GetPrimaryRootWindow();
+  if (!root_window)
+    return;
+
+  // Determine which aura Window is associated with the target point.
+  aura::Window* window =
+      root_window->GetEventHandlerForPoint(action.target_point);
+  if (!window)
+    return;
+
+  // Convert point to local coordinates of the hit window.
+  aura::Window::ConvertPointToTarget(root_window, window, &action.target_point);
+
+  // If the window has a child AX tree ID, forward the action to the
+  // associated AXHostDelegate or RenderFrameHost.
+  ui::AXTreeIDRegistry::AXTreeID child_ax_tree_id =
+      window->GetProperty(ui::kChildAXTreeID);
+  if (child_ax_tree_id != ui::AXTreeIDRegistry::kNoAXTreeID) {
+    ui::AXTreeIDRegistry* registry = ui::AXTreeIDRegistry::GetInstance();
+    ui::AXHostDelegate* delegate = registry->GetHostDelegate(child_ax_tree_id);
+    if (delegate) {
+      delegate->PerformAction(action);
+      return;
+    }
+
+    content::RenderFrameHost* rfh =
+        content::RenderFrameHost::FromAXTreeID(child_ax_tree_id);
+    if (rfh)
+      rfh->AccessibilityPerformAction(action);
+    return;
+  }
+
+  // If the window doesn't have a child tree ID, try to fire the event
+  // on a View.
+  views::Widget* widget = views::Widget::GetWidgetForNativeView(window);
+  if (widget) {
+    views::View* root_view = widget->GetRootView();
+    views::View* hit_view =
+        root_view->GetEventHandlerForPoint(action.target_point);
+    if (hit_view) {
+      hit_view->NotifyAccessibilityEvent(action.hit_test_event_to_fire, true);
+      return;
+    }
+  }
+
+  // Otherwise, fire the event directly on the Window.
+  views::AXAuraObjWrapper* window_wrapper =
+      views::AXAuraObjCache::GetInstance()->GetOrCreate(window);
+  if (window_wrapper)
+    SendEvent(nullptr, window_wrapper, action.hit_test_event_to_fire);
+#endif
+}