Forward AXPlatformNodeWin calls to the right child.

ui/accessibility/platform/ax_platform_node_win.cc

 // Copyright 2015 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 <atlbase.h>
 #include <atlcom.h>
 #include <limits.h>
 #include <oleacc.h>
 #include <stdint.h>
 
@@ skipping 15 matching lines @@
 // a COM interface. Because COM objects are reference counted and clients
 // are completely untrusted, it's important to always first check that our
 // object is still valid, and then check that all pointer arguments are
 // not NULL.
 //
 
 #define COM_OBJECT_VALIDATE() \
     if (!delegate_) \
       return E_FAIL;
 #define COM_OBJECT_VALIDATE_1_ARG(arg) \
-    if (!delegate_) return E_FAIL; \
-    if (!arg) return E_INVALIDARG
+  if (!delegate_)                      \
+    return E_FAIL;                     \
+  if (!arg)                            \
+    return E_INVALIDARG;
 #define COM_OBJECT_VALIDATE_2_ARGS(arg1, arg2) \
-    if (!delegate_) return E_FAIL; \
-    if (!arg1) return E_INVALIDARG; \
-    if (!arg2) return E_INVALIDARG
+  if (!delegate_)                              \
+    return E_FAIL;                             \
+  if (!arg1)                                   \
+    return E_INVALIDARG;                       \
+  if (!arg2)                                   \
+    return E_INVALIDARG;
 #define COM_OBJECT_VALIDATE_3_ARGS(arg1, arg2, arg3) \
-    if (!delegate_) return E_FAIL; \
-    if (!arg1) return E_INVALIDARG; \
-    if (!arg2) return E_INVALIDARG; \
-    if (!arg3) return E_INVALIDARG
+  if (!delegate_)                                    \
+    return E_FAIL;                                   \
+  if (!arg1)                                         \
+    return E_INVALIDARG;                             \
+  if (!arg2)                                         \
+    return E_INVALIDARG;                             \
+  if (!arg3)                                         \
+    return E_INVALIDARG;
 #define COM_OBJECT_VALIDATE_4_ARGS(arg1, arg2, arg3, arg4) \
-    if (!delegate_) return E_FAIL; \
-    if (!arg1) return E_INVALIDARG; \
-    if (!arg2) return E_INVALIDARG; \
-    if (!arg3) return E_INVALIDARG; \
-    if (!arg4) return E_INVALIDARG
-#define COM_OBJECT_VALIDATE_VAR_ID(var_id) \
-    if (!delegate_) return E_FAIL; \
-    if (!IsValidId(var_id)) return E_INVALIDARG
-#define COM_OBJECT_VALIDATE_VAR_ID_1_ARG(var_id, arg) \
-    if (!delegate_) return E_FAIL; \
-    if (!IsValidId(var_id)) return E_INVALIDARG; \
-    if (!arg) return E_INVALIDARG
-#define COM_OBJECT_VALIDATE_VAR_ID_2_ARGS(var_id, arg1, arg2) \
-    if (!delegate_) return E_FAIL; \
-    if (!IsValidId(var_id)) return E_INVALIDARG; \
-    if (!arg1) return E_INVALIDARG; \
-    if (!arg2) return E_INVALIDARG
-#define COM_OBJECT_VALIDATE_VAR_ID_3_ARGS(var_id, arg1, arg2, arg3) \
-    if (!delegate_) return E_FAIL; \
-    if (!IsValidId(var_id)) return E_INVALIDARG; \
-    if (!arg1) return E_INVALIDARG; \
-    if (!arg2) return E_INVALIDARG; \
-    if (!arg3) return E_INVALIDARG
-#define COM_OBJECT_VALIDATE_VAR_ID_4_ARGS(var_id, arg1, arg2, arg3, arg4) \
-    if (!delegate_) return E_FAIL; \
-    if (!IsValidId(var_id)) return E_INVALIDARG; \
-    if (!arg1) return E_INVALIDARG; \
-    if (!arg2) return E_INVALIDARG; \
-    if (!arg3) return E_INVALIDARG; \
-    if (!arg4) return E_INVALIDARG
+  if (!delegate_)                                          \
+    return E_FAIL;                                         \
+  if (!arg1)                                               \
+    return E_INVALIDARG;                                   \
+  if (!arg2)                                               \
+    return E_INVALIDARG;                                   \
+  if (!arg3)                                               \
+    return E_INVALIDARG;                                   \
+  if (!arg4)                                               \
+    return E_INVALIDARG;
+#define COM_OBJECT_VALIDATE_VAR_ID_AND_GET_TARGET(var_id, target) \
+  if (!delegate_)                                                 \
+    return E_FAIL;                                                \
+  target = GetTargetFromChildID(var_id);                          \
+  if (!target)                                                    \
+    return E_INVALIDARG;                                          \
+  if (!target->delegate_)                                         \
+    return E_INVALIDARG;
+#define COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, arg, target) \
+  if (!delegate_)                                                            \
+    return E_FAIL;                                                           \
+  if (!arg)                                                                  \
+    return E_INVALIDARG;                                                     \
+  target = GetTargetFromChildID(var_id);                                     \
+  if (!target)                                                               \
+    return E_INVALIDARG;                                                     \
+  if (!target->delegate_)                                                    \
+    return E_INVALIDARG;
+#define COM_OBJECT_VALIDATE_VAR_ID_2_ARGS_AND_GET_TARGET(var_id, arg1, arg2, \
+                                                         target)             \
+  if (!delegate_)                                                            \
+    return E_FAIL;                                                           \
+  if (!arg1)                                                                 \
+    return E_INVALIDARG;                                                     \
+  if (!arg2)                                                                 \
+    return E_INVALIDARG;                                                     \
+  target = GetTargetFromChildID(var_id);                                     \
+  if (!target)                                                               \
+    return E_INVALIDARG;                                                     \
+  if (!target->delegate_)                                                    \
+    return E_INVALIDARG;
+#define COM_OBJECT_VALIDATE_VAR_ID_3_ARGS_AND_GET_TARGET(var_id, arg1, arg2, \
+                                                         arg3, target)       \
+  if (!delegate_)                                                            \
+    return E_FAIL;                                                           \
+  if (!arg1)                                                                 \
+    return E_INVALIDARG;                                                     \
+  if (!arg2)                                                                 \
+    return E_INVALIDARG;                                                     \
+  if (!arg3)                                                                 \
+    return E_INVALIDARG;                                                     \
+  target = GetTargetFromChildID(var_id);                                     \
+  if (!target)                                                               \
+    return E_INVALIDARG;                                                     \
+  if (!target->delegate_)                                                    \
+    return E_INVALIDARG;
+#define COM_OBJECT_VALIDATE_VAR_ID_4_ARGS_AND_GET_TARGET(var_id, arg1, arg2, \
+                                                         arg3, arg4, target) \
+  if (!delegate_)                                                            \
+    return E_FAIL;                                                           \
+  if (!arg1)                                                                 \
+    return E_INVALIDARG;                                                     \
+  if (!arg2)                                                                 \
+    return E_INVALIDARG;                                                     \
+  if (!arg3)                                                                 \
+    return E_INVALIDARG;                                                     \
+  if (!arg4)                                                                 \
+    return E_INVALIDARG;                                                     \
+  target = GetTargetFromChildID(var_id);                                     \
+  if (!target)                                                               \
+    return E_INVALIDARG;                                                     \
+  if (!target->delegate_)                                                    \
+    return E_INVALIDARG;
 
 namespace ui {
 
 namespace {
 
 typedef base::hash_set<AXPlatformNodeWin*> AXPlatformNodeWinSet;
 // Set of all AXPlatformNodeWin objects that were the target of an
 // alert event.
 base::LazyInstance<AXPlatformNodeWinSet>::DestructorAtExit g_alert_targets =
     LAZY_INSTANCE_INITIALIZER;
@@ skipping 33 matching lines @@
   HRESULT hr = CComObject<AXPlatformNodeWin>::CreateInstance(&instance);
   DCHECK(SUCCEEDED(hr));
   instance->Init(delegate);
   instance->AddRef();
   return instance;
 }
 
 // static
 AXPlatformNode* AXPlatformNode::FromNativeViewAccessible(
     gfx::NativeViewAccessible accessible) {
+  if (!accessible)
+    return nullptr;
   base::win::ScopedComPtr<AXPlatformNodeWin> ax_platform_node;
   accessible->QueryInterface(ax_platform_node.Receive());
   return ax_platform_node.get();
 }
 
 //
 // AXPlatformNodeWin
 //
 
 AXPlatformNodeWin::AXPlatformNodeWin() {
@@ skipping 104 matching lines @@
   if (S_OK == result && child->vt == VT_I4 && child->lVal == CHILDID_SELF) {
     child->vt = VT_DISPATCH;
     child->pdispVal = hit_child;
     // Always increment ref when returning a reference to a COM object.
     child->pdispVal->AddRef();
   }
   return result;
 }
 
 HRESULT AXPlatformNodeWin::accDoDefaultAction(VARIANT var_id) {
-  COM_OBJECT_VALIDATE_VAR_ID(var_id);
+  AXPlatformNodeWin* target;
+  COM_OBJECT_VALIDATE_VAR_ID_AND_GET_TARGET(var_id, target);
   AXActionData data;
   data.action = ui::AX_ACTION_DO_DEFAULT;
-  if (delegate_->AccessibilityPerformAction(data))
+
+  if (target->delegate_->AccessibilityPerformAction(data))
     return S_OK;
   return E_FAIL;
 }
 
 STDMETHODIMP AXPlatformNodeWin::accLocation(
     LONG* x_left, LONG* y_top, LONG* width, LONG* height, VARIANT var_id) {
-  COM_OBJECT_VALIDATE_VAR_ID_4_ARGS(var_id, x_left, y_top, width, height);
-  gfx::Rect bounds = delegate_->GetScreenBoundsRect();
+  AXPlatformNodeWin* target;
+  COM_OBJECT_VALIDATE_VAR_ID_4_ARGS_AND_GET_TARGET(var_id, x_left, y_top, width,
+                                                   height, target);
+
+  gfx::Rect bounds = target->delegate_->GetScreenBoundsRect();
   *x_left = bounds.x();
   *y_top = bounds.y();
   *width  = bounds.width();
   *height = bounds.height();
 
   if (bounds.IsEmpty())
     return S_FALSE;
 
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::accNavigate(
     LONG nav_dir, VARIANT start, VARIANT* end) {
-  COM_OBJECT_VALIDATE_VAR_ID_1_ARG(start, end);
+  AXPlatformNodeWin* target;
+  COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(start, end, target);
   IAccessible* result = nullptr;
 
   if ((nav_dir == NAVDIR_LASTCHILD || nav_dir == NAVDIR_FIRSTCHILD) &&
       start.lVal != CHILDID_SELF) {
     // MSAA states that navigating to first/last child can only be from self.
     return E_INVALIDARG;
   }
 
   switch (nav_dir) {
     case NAVDIR_DOWN:
@@ skipping 39 matching lines @@
   end->vt = VT_DISPATCH;
   end->pdispVal = result;
   // Always increment ref when returning a reference to a COM object.
   end->pdispVal->AddRef();
 
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accChild(VARIANT var_child,
                                              IDispatch** disp_child) {
-  COM_OBJECT_VALIDATE_1_ARG(disp_child);
-  LONG child_id = V_I4(&var_child);
-  if (child_id == CHILDID_SELF) {
-    *disp_child = this;
-    (*disp_child)->AddRef();
-    return S_OK;
-  }
+  *disp_child = nullptr;
+  AXPlatformNodeWin* target;
+  COM_OBJECT_VALIDATE_VAR_ID_AND_GET_TARGET(var_child, target);
 
-  if (child_id >= 1 && child_id <= delegate_->GetChildCount()) {
-    // Positive child ids are a 1-based child index, used by clients
-    // that want to enumerate all immediate children.
-    *disp_child = delegate_->ChildAtIndex(child_id - 1);
-    if (!(*disp_child))
-      return E_INVALIDARG;
-    (*disp_child)->AddRef();
-    return S_OK;
-  }
-
-  if (child_id >= 0)
-    return E_INVALIDARG;
-
-  // Negative child ids can be used to map to any descendant.
-  AXPlatformNodeWin* child = static_cast<AXPlatformNodeWin*>(
-      GetFromUniqueId(-child_id));
-  if (child && !IsDescendant(child))
-    child = nullptr;
-
-  if (child) {
-    *disp_child = child;
-    (*disp_child)->AddRef();
-    return S_OK;
-  }
-
-  *disp_child = nullptr;
-  return E_INVALIDARG;
+  *disp_child = target;
+  (*disp_child)->AddRef();
+  return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accChildCount(LONG* child_count) {
   COM_OBJECT_VALIDATE_1_ARG(child_count);
   *child_count = delegate_->GetChildCount();
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accDefaultAction(
     VARIANT var_id, BSTR* def_action) {
-  COM_OBJECT_VALIDATE_VAR_ID_1_ARG(var_id, def_action);
+  AXPlatformNodeWin* target;
+  COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, def_action, target);
+
   int action;
-  if (!GetIntAttribute(AX_ATTR_ACTION, &action)) {
+  if (!target->GetIntAttribute(AX_ATTR_ACTION, &action)) {
     *def_action = nullptr;
     return S_FALSE;
   }
 
   base::string16 action_verb =
       ActionToString(static_cast<AXSupportedAction>(action));
   if (action_verb.empty()) {
     *def_action = nullptr;
     return S_FALSE;
   }
 
   *def_action = SysAllocString(action_verb.c_str());
   DCHECK(def_action);
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accDescription(
     VARIANT var_id, BSTR* desc) {
-  COM_OBJECT_VALIDATE_VAR_ID_1_ARG(var_id, desc);
-  return GetStringAttributeAsBstr(ui::AX_ATTR_DESCRIPTION, desc);
+  AXPlatformNodeWin* target;
+  COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, desc, target);
+
+  return target->GetStringAttributeAsBstr(ui::AX_ATTR_DESCRIPTION, desc);
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accFocus(VARIANT* focus_child) {
   COM_OBJECT_VALIDATE_1_ARG(focus_child);
   gfx::NativeViewAccessible focus_accessible = delegate_->GetFocus();
   if (focus_accessible == this) {
     focus_child->vt = VT_I4;
     focus_child->lVal = CHILDID_SELF;
   } else if (focus_accessible) {
     focus_child->vt = VT_DISPATCH;
     focus_child->pdispVal = focus_accessible;
     focus_child->pdispVal->AddRef();
     return S_OK;
   } else {
     focus_child->vt = VT_EMPTY;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accKeyboardShortcut(
     VARIANT var_id, BSTR* acc_key) {
-  COM_OBJECT_VALIDATE_VAR_ID_1_ARG(var_id, acc_key);
-  return GetStringAttributeAsBstr(ui::AX_ATTR_SHORTCUT, acc_key);
+  AXPlatformNodeWin* target;
+  COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, acc_key, target);
+
+  return target->GetStringAttributeAsBstr(ui::AX_ATTR_SHORTCUT, acc_key);
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accName(
     VARIANT var_id, BSTR* name) {
-  COM_OBJECT_VALIDATE_VAR_ID_1_ARG(var_id, name);
-  return GetStringAttributeAsBstr(ui::AX_ATTR_NAME, name);
+  AXPlatformNodeWin* target;
+  COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, name, target);
+
+  return target->GetStringAttributeAsBstr(ui::AX_ATTR_NAME, name);
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accParent(
     IDispatch** disp_parent) {
   COM_OBJECT_VALIDATE_1_ARG(disp_parent);
   *disp_parent = GetParent();
   if (*disp_parent) {
     (*disp_parent)->AddRef();
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accRole(
     VARIANT var_id, VARIANT* role) {
-  COM_OBJECT_VALIDATE_VAR_ID_1_ARG(var_id, role);
+  AXPlatformNodeWin* target;
+  COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, role, target);
   role->vt = VT_I4;
-  role->lVal = MSAARole();
+  role->lVal = target->MSAARole();
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accState(
     VARIANT var_id, VARIANT* state) {
-  COM_OBJECT_VALIDATE_VAR_ID_1_ARG(var_id, state);
+  AXPlatformNodeWin* target;
+  COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, state, target);
   state->vt = VT_I4;
-  state->lVal = MSAAState();
+  state->lVal = target->MSAAState();
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accHelp(
     VARIANT var_id, BSTR* help) {
-  COM_OBJECT_VALIDATE_VAR_ID_1_ARG(var_id, help);
   return S_FALSE;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accValue(VARIANT var_id, BSTR* value) {
-  COM_OBJECT_VALIDATE_VAR_ID_1_ARG(var_id, value);
-  return GetStringAttributeAsBstr(ui::AX_ATTR_VALUE, value);
+  AXPlatformNodeWin* target;
+  COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, value, target);
+  return target->GetStringAttributeAsBstr(ui::AX_ATTR_VALUE, value);
 }
 
 STDMETHODIMP AXPlatformNodeWin::put_accValue(VARIANT var_id,
                                              BSTR new_value) {
+  AXPlatformNodeWin* target;
+  COM_OBJECT_VALIDATE_VAR_ID_AND_GET_TARGET(var_id, target);
+
   AXActionData data;
   data.action = ui::AX_ACTION_SET_VALUE;
   data.value = new_value;
-  COM_OBJECT_VALIDATE_VAR_ID(var_id);
-  if (delegate_->AccessibilityPerformAction(data))
+  if (target->delegate_->AccessibilityPerformAction(data))
     return S_OK;
   return E_FAIL;
 }
 
 // IAccessible functions not supported.
 
 STDMETHODIMP AXPlatformNodeWin::get_accSelection(VARIANT* selected) {
   COM_OBJECT_VALIDATE_1_ARG(selected);
   if (selected)
     selected->vt = VT_EMPTY;
   return E_NOTIMPL;
 }
 
 STDMETHODIMP AXPlatformNodeWin::accSelect(
     LONG flagsSelect, VARIANT var_id) {
-  COM_OBJECT_VALIDATE_VAR_ID(var_id);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accHelpTopic(
     BSTR* help_file, VARIANT var_id, LONG* topic_id) {
-  COM_OBJECT_VALIDATE_VAR_ID_2_ARGS(var_id, help_file, topic_id);
+  AXPlatformNodeWin* target;
+  COM_OBJECT_VALIDATE_VAR_ID_2_ARGS_AND_GET_TARGET(var_id, help_file, topic_id,
+                                                   target);
   if (help_file) {
     *help_file = nullptr;
   }
   if (topic_id) {
     *topic_id = static_cast<LONG>(-1);
   }
   return E_NOTIMPL;
 }
 
 STDMETHODIMP AXPlatformNodeWin::put_accName(
     VARIANT var_id, BSTR put_name) {
-  COM_OBJECT_VALIDATE_VAR_ID(var_id);
   // Deprecated.
   return E_NOTIMPL;
 }
 
 //
 // IAccessible2 implementation.
 //
 
 STDMETHODIMP AXPlatformNodeWin::role(LONG* role) {
   COM_OBJECT_VALIDATE_1_ARG(role);
@@ skipping 437 matching lines @@
     return QueryInterface(riid, object);
   }
 
   *object = nullptr;
   return E_FAIL;
 }
 
 //
 // Private member functions.
 //
-
-bool AXPlatformNodeWin::IsValidId(const VARIANT& child) const {
-  // Since we have a separate IAccessible COM object for each node, we only
-  // support the CHILDID_SELF id.
-  return (VT_I4 == child.vt) && (CHILDID_SELF == child.lVal);
-}
-
 int AXPlatformNodeWin::MSAARole() {
   switch (GetData().role) {
     case ui::AX_ROLE_ALERT:
       return ROLE_SYSTEM_ALERT;
     case ui::AX_ROLE_APPLICATION:
       return ROLE_SYSTEM_APPLICATION;
     case ui::AX_ROLE_BUTTON_DROP_DOWN:
       return ROLE_SYSTEM_BUTTONDROPDOWN;
     case ui::AX_ROLE_POP_UP_BUTTON:
       return ROLE_SYSTEM_BUTTONMENU;
@@ skipping 205 matching lines @@
     LONG start_offset,
     ui::TextBoundaryDirection direction) {
   HandleSpecialTextOffset(&start_offset);
   ui::TextBoundaryType boundary = IA2TextBoundaryToTextBoundary(ia2_boundary);
   std::vector<int32_t> line_breaks;
   return static_cast<LONG>(ui::FindAccessibleTextBoundary(
       text, line_breaks, boundary, start_offset, direction,
       AX_TEXT_AFFINITY_DOWNSTREAM));
 }
 
+AXPlatformNodeWin* AXPlatformNodeWin::GetTargetFromChildID(
+    const VARIANT& var_id) {
+  LONG child_id = V_I4(&var_id);
+  if (child_id == CHILDID_SELF) {
+    return this;
+  }
+
+  if (child_id >= 1 && child_id <= delegate_->GetChildCount()) {
+    // Positive child ids are a 1-based child index, used by clients
+    // that want to enumerate all immediate children.
+    AXPlatformNodeBase* base =
+        FromNativeViewAccessible(delegate_->ChildAtIndex(child_id - 1));
+    return static_cast<AXPlatformNodeWin*>(base);
+  }
+
+  if (child_id >= 0)
+    return nullptr;
+
+  // Negative child ids can be used to map to any descendant.
+  AXPlatformNode* node = GetFromUniqueId(-child_id);
+  if (!node)
+    return nullptr;
+
+  AXPlatformNodeBase* base =
+      FromNativeViewAccessible(node->GetNativeViewAccessible());
+  if (base && !IsDescendant(base))
+    base = nullptr;
+
+  return static_cast<AXPlatformNodeWin*>(base);
+}
+
 }  // namespace ui