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 237 matching lines @@
     // 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);
   AXActionData data;
   data.action = ui::AX_ACTION_DO_DEFAULT;
-  if (delegate_->AccessibilityPerformAction(data))
+
+  auto* target = GetTargetFromChildID(var_id);

[dmazzoni, 2017/04/10 07:20:19]

What do you think about putting GetTargetFromChildID in the
COM_OBJECT_VALIDATE_VAR_ID macro?

    auto* target = COM_OBJECT_VALIDATE_VAR_ID(var_id);

That cuts down on the boilerplate a lot.

+  if (!target)
+    return E_INVALIDARG;
+
+  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();
+
+  auto* target = GetTargetFromChildID(var_id);
+  if (!target)
+    return E_INVALIDARG;
+
+  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;
 }
@@ skipping 48 matching lines @@
   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;
+  auto* target = GetTargetFromChildID(var_child);
+  if (!target) {
+    *disp_child = nullptr;
+    return E_INVALIDARG;
   }
 
-  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);
+
+  auto* target = GetTargetFromChildID(var_id);
+  if (!target)
+    return E_INVALIDARG;
+
   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);
+
+  auto* target = GetTargetFromChildID(var_id);
+  if (!target)
+    return E_INVALIDARG;
+
+  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);
+
+  auto* target = GetTargetFromChildID(var_id);
+  if (!target)
+    return E_INVALIDARG;
+
+  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);
+  auto* target = GetTargetFromChildID(var_id);
+  if (!target)
+    return E_INVALIDARG;
+
+  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);
+  auto* target = GetTargetFromChildID(var_id);
+  if (!target)
+    return E_INVALIDARG;
+
   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);
+  auto* target = GetTargetFromChildID(var_id);
+  if (!target)
+    return E_INVALIDARG;
+
   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);
+
+  auto* target = GetTargetFromChildID(var_id);
+  if (!target)
+    return E_INVALIDARG;
+  return target->GetStringAttributeAsBstr(ui::AX_ATTR_VALUE, value);
 }
 
 STDMETHODIMP AXPlatformNodeWin::put_accValue(VARIANT var_id,
                                              BSTR new_value) {
   AXActionData data;
   data.action = ui::AX_ACTION_SET_VALUE;
   data.value = new_value;
   COM_OBJECT_VALIDATE_VAR_ID(var_id);
-  if (delegate_->AccessibilityPerformAction(data))
+
+  auto* target = GetTargetFromChildID(var_id);
+  if (!target)
+    return E_INVALIDARG;
+
+  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;
@@ skipping 703 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.
+    return static_cast<AXPlatformNodeWin*>(

[dmazzoni, 2017/04/10 07:20:19]

Note that a child may not necessarily be an AXPlatformNodeWin, so this
cast isn't safe. In particular, right now the child of an AXPlatformNodeWin
may be a BrowserAccessibilityWin.

Instead, use FromNativeViewAccessible(), which will check if the object
is the right type and cast it if so.

If you get a AXPlatformNodeBase, it is safe to cast that to an
AXPlatformNodeWIn.

+        delegate_->ChildAtIndex(child_id - 1));
+  }
+
+  if (child_id >= 0)
+    return nullptr;
+
+  // Negative child ids can be used to map to any descendant.
+  auto* child = static_cast<AXPlatformNodeWin*>(GetFromUniqueId(-child_id));
+  if (child && !IsDescendant(child))
+    child = nullptr;
+
+  return child;
+}
+
 }  // namespace ui