Implement web content hit testing in win aura.

ui/views/accessibility/native_view_accessibility_win.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 "ui/views/accessibility/native_view_accessibility_win.h"
 
 #include <UIAutomationClient.h>
 #include <oleacc.h>
 
 #include <set>
 #include <vector>
 
 #include "base/memory/singleton.h"
+#include "base/strings/utf_string_conversions.h"
 #include "base/win/windows_version.h"
 #include "third_party/iaccessible2/ia2_api_all.h"
 #include "ui/base/accessibility/accessible_text_utils.h"
 #include "ui/base/accessibility/accessible_view_state.h"
 #include "ui/base/win/accessibility_ids_win.h"
 #include "ui/base/win/accessibility_misc_utils.h"
 #include "ui/base/win/atl_module.h"
 #include "ui/views/controls/button/custom_button.h"
 #include "ui/views/focus/focus_manager.h"
 #include "ui/views/focus/view_storage.h"
 #include "ui/views/win/hwnd_util.h"
 
 using ui::AccessibilityTypes;
 
 namespace views {
 namespace {
 
 class AccessibleWebViewRegistry {
  public:
   static AccessibleWebViewRegistry* GetInstance();
 
-  void RegisterWebView(AccessibleWebView* web_view);
+  void RegisterWebView(View* web_view);
 
-  void UnregisterWebView(AccessibleWebView* web_view);
+  void UnregisterWebView(View* web_view);
 
   // Given the view that received the request for the accessible
   // id in |top_view|, and the child id requested, return the native
   // accessible object with that child id from one of the WebViews in
   // |top_view|'s view hierarchy, if any.
   IAccessible* GetAccessibleFromWebView(View* top_view, long child_id);
 
  private:
   friend struct DefaultSingletonTraits<AccessibleWebViewRegistry>;
   AccessibleWebViewRegistry();
   ~AccessibleWebViewRegistry() {}
 
+  IAccessible* AccessibleObjectFromChildId(View* web_view, long child_id);
+
   // Set of all web views. We check whether each one is contained in a
   // top view dynamically rather than keeping track of a map.
-  std::set<AccessibleWebView*> web_views_;
+  std::set<View*> web_views_;
 
   // The most recent top view used in a call to GetAccessibleFromWebView.
   View* last_top_view_;
 
   // The most recent web view where an accessible object was found,
   // corresponding to |last_top_view_|.
-  AccessibleWebView* last_web_view_;
+  View* last_web_view_;
 
   DISALLOW_COPY_AND_ASSIGN(AccessibleWebViewRegistry);
 };
 
 AccessibleWebViewRegistry::AccessibleWebViewRegistry()
     : last_top_view_(NULL),
       last_web_view_(NULL) {
 }
 
 AccessibleWebViewRegistry* AccessibleWebViewRegistry::GetInstance() {
   return Singleton<AccessibleWebViewRegistry>::get();
 }
 
-void AccessibleWebViewRegistry::RegisterWebView(AccessibleWebView* web_view) {
+void AccessibleWebViewRegistry::RegisterWebView(View* web_view) {
   DCHECK(web_views_.find(web_view) == web_views_.end());
   web_views_.insert(web_view);
 }
 
-void AccessibleWebViewRegistry::UnregisterWebView(AccessibleWebView* web_view) {
+void AccessibleWebViewRegistry::UnregisterWebView(View* web_view) {
   DCHECK(web_views_.find(web_view) != web_views_.end());
   web_views_.erase(web_view);
   if (last_web_view_ == web_view) {
     last_top_view_ = NULL;
     last_web_view_ = NULL;
   }
 }
 
 IAccessible* AccessibleWebViewRegistry::GetAccessibleFromWebView(
     View* top_view, long child_id) {
   // This function gets called frequently, so try to avoid searching all
   // of the web views if the notification is on the same web view that
   // sent the last one.
   if (last_top_view_ == top_view) {
     IAccessible* accessible =
-        last_web_view_->AccessibleObjectFromChildId(child_id);
+        AccessibleObjectFromChildId(last_web_view_, child_id);
     if (accessible)
       return accessible;
   }
 
   // Search all web views. For each one, first ensure it's a descendant
   // of this view where the event was posted - and if so, see if it owns
   // an accessible object with that child id. If so, save the view to speed
   // up the next notification.
-  for (std::set<AccessibleWebView*>::iterator iter = web_views_.begin();
+  for (std::set<View*>::iterator iter = web_views_.begin();
        iter != web_views_.end(); ++iter) {
-    AccessibleWebView* web_view = *iter;
-    if (!top_view->Contains(web_view->AsView()))
+    View* web_view = *iter;
+    if (!top_view->Contains(web_view))
       continue;
-    IAccessible* accessible = web_view->AccessibleObjectFromChildId(child_id);
+    IAccessible* accessible = AccessibleObjectFromChildId(web_view, child_id);
     if (accessible) {
       last_top_view_ = top_view;
       last_web_view_ = web_view;
       return accessible;
     }
   }
+
   return NULL;
 }
 
+IAccessible* AccessibleWebViewRegistry::AccessibleObjectFromChildId(
+    View* web_view,
+    long child_id) {
+  IAccessible* web_view_accessible = web_view->GetNativeViewAccessible();
+  if (web_view_accessible == NULL)
+    return NULL;
+
+  VARIANT var_child;
+  var_child.vt = VT_I4;
+  var_child.lVal = child_id;
+  IAccessible* result = NULL;
+  if (S_OK == web_view_accessible->get_accChild(
+      var_child, reinterpret_cast<IDispatch**>(&result))) {
+    return result;
+  }
+
+  return NULL;
+}
+
 }  // anonymous namespace
 
 // static
 long NativeViewAccessibilityWin::next_unique_id_ = 1;
 int NativeViewAccessibilityWin::view_storage_ids_[kMaxViewStorageIds] = {0};
 int NativeViewAccessibilityWin::next_view_storage_id_index_ = 0;
 
 // static
 NativeViewAccessibility* NativeViewAccessibility::Create(View* view) {
   // Make sure ATL is initialized in this module.
@@ skipping 44 matching lines @@
 
 gfx::NativeViewAccessible NativeViewAccessibilityWin::GetNativeObject() {
   return this;
 }
 
 void NativeViewAccessibilityWin::Destroy() {
   view_ = NULL;
   Release();
 }
 
-// TODO(ctguil): Handle case where child View is not contained by parent.
 STDMETHODIMP NativeViewAccessibilityWin::accHitTest(
     LONG x_left, LONG y_top, VARIANT* child) {
   if (!child)
     return E_INVALIDARG;
 
   if (!view_)
     return E_FAIL;
 
   gfx::Point point(x_left, y_top);
   View::ConvertPointToTarget(NULL, view_, &point);
 
+  // If the point is not inside this view, return false.
   if (!view_->HitTestPoint(point)) {
-    // If containing parent is not hit, return with failure.
     child->vt = VT_EMPTY;
     return S_FALSE;
   }
 
-  View* view = view_->GetEventHandlerForPoint(point);
-  if (view == view_) {
-    // No child hit, return parent id.
-    child->vt = VT_I4;
-    child->lVal = CHILDID_SELF;
-  } else {
-    child->vt = VT_DISPATCH;
-    child->pdispVal = view->GetNativeViewAccessible();
-    child->pdispVal->AddRef();
+  // Check if the point is within any of the immediate children of this
+  // view.
+  View* hit_child_view = NULL;
+  for (int i = view_->child_count() - 1; i >= 0; --i) {
+    View* child_view = view_->child_at(i);
+    if (!child_view->visible())
+      continue;
+
+    gfx::Point point_in_child_coords(point);
+    view_->ConvertPointToTarget(view_, child_view, &point_in_child_coords);
+    if (child_view->HitTestPoint(point_in_child_coords)) {
+      hit_child_view = child_view;
+      break;
+    }
   }
+
+  // If the point was within one of this view's immediate children,
+  // call accHitTest recursively on that child's native view accessible -
+  // which may be a recursive call to this function or it may be overridden,
+  // for example in the case of a WebView.
+  if (hit_child_view) {
+    HRESULT result = hit_child_view->GetNativeViewAccessible()->accHitTest(
+        x_left, y_top, child);
+
+    // If the recursive call returned CHILDID_SELF, we have to convert that
+    // into a VT_DISPATCH for the return value to this call.
+    if (S_OK == result && child->vt == VT_I4 && child->lVal == CHILDID_SELF) {
+      child->vt = VT_DISPATCH;
+      child->pdispVal = hit_child_view->GetNativeViewAccessible();
+      // Always increment ref when returning a reference to a COM object.
+      child->pdispVal->AddRef();
+    }
+    return result;
+  }
+
+  // This object is the best match, so return CHILDID_SELF. It's tempting to
+  // simplify the logic and use VT_DISPATCH everywhere, but the Windows
+  // call AccessibleObjectFromPoint will keep calling accHitTest until some
+  // object returns CHILDID_SELF.
+  child->vt = VT_I4;
+  child->lVal = CHILDID_SELF;
   return S_OK;
 }
 
 HRESULT NativeViewAccessibilityWin::accDoDefaultAction(VARIANT var_id) {
   if (!IsValidId(var_id))
     return E_INVALIDARG;
 
   // The object does not support the method. This value is returned for
   // controls that do not perform actions, such as edit fields.
   return DISP_E_MEMBERNOTFOUND;
@@ skipping 151 matching lines @@
     int view_storage_id_index =
         base::win::kFirstViewsAccessibilityId - child_id;
     if (view_storage_id_index >= 0 &&
         view_storage_id_index < kMaxViewStorageIds) {
       int view_storage_id = view_storage_ids_[view_storage_id_index];
       ViewStorage* view_storage = ViewStorage::GetInstance();
       child_view = view_storage->RetrieveView(view_storage_id);
     } else {
       *disp_child = AccessibleWebViewRegistry::GetInstance()->
           GetAccessibleFromWebView(view_, child_id);
-      if (*disp_child) {
-        (*disp_child)->AddRef();
+      if (*disp_child)
         return S_OK;
-      }
     }
   }
 
   if (!child_view) {
     // No child found.
     *disp_child = NULL;
     return E_FAIL;
   }
 
   *disp_child = child_view->GetNativeViewAccessible();
@@ skipping 582 matching lines @@
   } else {
     V_VT(ret) = VT_EMPTY;
   }
   return S_OK;
 }
 
 //
 // Static methods.
 //
 
-void NativeViewAccessibility::RegisterWebView(AccessibleWebView* web_view) {
+void NativeViewAccessibility::RegisterWebView(View* web_view) {
   AccessibleWebViewRegistry::GetInstance()->RegisterWebView(web_view);
 }
 
-void NativeViewAccessibility::UnregisterWebView(AccessibleWebView* web_view) {
+void NativeViewAccessibility::UnregisterWebView(View* web_view) {
   AccessibleWebViewRegistry::GetInstance()->UnregisterWebView(web_view);
 }
 
 int32 NativeViewAccessibilityWin::MSAAEvent(AccessibilityTypes::Event event) {
   switch (event) {
     case AccessibilityTypes::EVENT_ALERT:
       return EVENT_SYSTEM_ALERT;
     case AccessibilityTypes::EVENT_FOCUS:
       return EVENT_OBJECT_FOCUS;
     case AccessibilityTypes::EVENT_MENUSTART:
@@ skipping 224 matching lines @@
     LONG start_offset,
     ui::TextBoundaryDirection direction) {
   HandleSpecialTextOffset(text, &start_offset);
   ui::TextBoundaryType boundary = IA2TextBoundaryToTextBoundary(ia2_boundary);
   std::vector<int32> line_breaks;
   return ui::FindAccessibleTextBoundary(
       text, line_breaks, boundary, start_offset, direction);
 }
 
 }  // namespace views