Move Win32 API Histogram code to AXPlatformNode so that it can be shared.

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 261 matching lines @@
 
   return -1;
 }
 
 //
 // IAccessible implementation.
 //
 
 STDMETHODIMP AXPlatformNodeWin::accHitTest(
     LONG x_left, LONG y_top, VARIANT* child) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_HIT_TEST);
   COM_OBJECT_VALIDATE_1_ARG(child);
 
   gfx::Point point(x_left, y_top);
   if (!delegate_->GetScreenBoundsRect().Contains(point)) {
     // Return S_FALSE and VT_EMPTY when outside the object's boundaries.
     child->vt = VT_EMPTY;
     return S_FALSE;
   }
 
   gfx::NativeViewAccessible hit_child = delegate_->HitTestSync(x_left, y_top);
@@ skipping 22 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) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_DO_DEFAULT_ACTION);
   AXPlatformNodeWin* target;
   COM_OBJECT_VALIDATE_VAR_ID_AND_GET_TARGET(var_id, target);
   AXActionData data;
   data.action = ui::AX_ACTION_DO_DEFAULT;
 
   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) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_LOCATION);
   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) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_NAVIGATE);
   AXPlatformNodeWin* target;
   COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(start, end, target);
   end->vt = VT_EMPTY;
   if ((nav_dir == NAVDIR_FIRSTCHILD || nav_dir == NAVDIR_LASTCHILD) &&
       V_VT(&start) == VT_I4 && V_I4(&start) != CHILDID_SELF) {
     // MSAA states that navigating to first/last child can only be from self.
     return E_INVALIDARG;
   }
 
   IAccessible* result = nullptr;
@@ skipping 91 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) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_CHILD);
+
   *disp_child = nullptr;
   AXPlatformNodeWin* target;
   COM_OBJECT_VALIDATE_VAR_ID_AND_GET_TARGET(var_child, target);
 
   *disp_child = target;
   (*disp_child)->AddRef();
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accChildCount(LONG* child_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_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) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_DEFAULT_ACTION);
   AXPlatformNodeWin* target;
   COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, def_action, target);
 
   int action;
   if (!target->GetIntAttribute(AX_ATTR_DEFAULT_ACTION_VERB, &action)) {
     *def_action = nullptr;
     return S_FALSE;
   }
 
   base::string16 action_verb =
       ActionVerbToLocalizedString(static_cast<AXDefaultActionVerb>(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) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_DESCRIPTION);
   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) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_FOCUS);
   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) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_KEYBOARD_SHORTCUT);
   AXPlatformNodeWin* target;
   COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, acc_key, target);
 
   return target->GetStringAttributeAsBstr(ui::AX_ATTR_KEY_SHORTCUTS, acc_key);
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accName(
     VARIANT var_id, BSTR* name) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_NAME);
   AXPlatformNodeWin* target;
   COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, name, target);
 
   HRESULT result = target->GetStringAttributeAsBstr(ui::AX_ATTR_NAME, name);
   if (FAILED(result) && MSAARole() == ROLE_SYSTEM_DOCUMENT && GetParent()) {
     // Hack: Some versions of JAWS crash if they get an empty name on
     // a document that's the child of an iframe, so always return a
     // nonempty string for this role.  https://crbug.com/583057
     base::string16 str = L" ";
 
     *name = SysAllocString(str.c_str());
     DCHECK(*name);
   }
 
   return result;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accParent(
     IDispatch** disp_parent) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_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) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_ROLE);
   AXPlatformNodeWin* target;
   COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, role, target);
 
   // For historical reasons, we return a string (typically
   // containing the HTML tag name) as the MSAA role, rather
   // than a int.
   std::string role_string =
       base::ToUpperASCII(target->StringOverrideForMSAARole());
   if (!role_string.empty()) {
     role->vt = VT_BSTR;
     std::wstring wsTmp(role_string.begin(), role_string.end());
     role->bstrVal = SysAllocString(wsTmp.c_str());
     return S_OK;
   }
 
   role->vt = VT_I4;
   role->lVal = target->MSAARole();
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accState(
     VARIANT var_id, VARIANT* state) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_STATE);
   AXPlatformNodeWin* target;
   COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, state, target);
   state->vt = VT_I4;
   state->lVal = target->MSAAState();
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accHelp(
     VARIANT var_id, BSTR* help) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_HELP);
   COM_OBJECT_VALIDATE_1_ARG(help);
   return S_FALSE;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accValue(VARIANT var_id, BSTR* value) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_VALUE);
   AXPlatformNodeWin* target;
   COM_OBJECT_VALIDATE_VAR_ID_1_ARG_AND_GET_TARGET(var_id, value, target);
 
   // get_accValue() has two sets of special cases depending on the node's role.
   // The first set apply without regard for the nodes |value| attribute. That is
   // the nodes value attribute isn't consider for the first set of special
   // cases. For example, if the node role is AX_ROLE_COLOR_WELL, we do not care
   // at all about the node's AX_ATTR_VALUE attribute. The second set of special
   // cases only apply if the value attribute for the node is empty.  That is, if
   // AX_ATTR_VALUE is empty, we do something special.
@@ skipping 78 matching lines @@
 
   AXActionData data;
   data.action = ui::AX_ACTION_SET_VALUE;
   data.value = new_value;
   if (target->delegate_->AccessibilityPerformAction(data))
     return S_OK;
   return E_FAIL;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accSelection(VARIANT* selected) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_SELECTION);
   COM_OBJECT_VALIDATE_1_ARG(selected);
 
   if (GetData().role != ui::AX_ROLE_LIST_BOX)
     return E_NOTIMPL;
 
   unsigned long selected_count = 0;
   for (auto i = 0; i < delegate_->GetChildCount(); ++i) {
     AXPlatformNodeWin* node = static_cast<AXPlatformNodeWin*>(
         FromNativeViewAccessible(delegate_->ChildAtIndex(i)));
 
@@ skipping 37 matching lines @@
     }
   }
   selected->vt = VT_UNKNOWN;
   selected->punkVal = static_cast<IUnknown*>(
       static_cast<base::win::IUnknownImpl*>(enum_variant));
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::accSelect(
     LONG flagsSelect, VARIANT var_id) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_SELECT);
   AXPlatformNodeWin* target;
   COM_OBJECT_VALIDATE_VAR_ID_AND_GET_TARGET(var_id, target);
 
   if (flagsSelect & SELFLAG_TAKEFOCUS) {
     ui::AXActionData action_data;
     action_data.action = ui::AX_ACTION_FOCUS;
     target->delegate_->AccessibilityPerformAction(action_data);
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accHelpTopic(
     BSTR* help_file, VARIANT var_id, LONG* topic_id) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_HELP_TOPIC);
   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) {
+  // TODO(dougt): We may want to collect an API histogram here.
   // Deprecated.
   return E_NOTIMPL;
 }
 
 //
 // IAccessible2 implementation.
 //
 
 STDMETHODIMP AXPlatformNodeWin::role(LONG* role) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ROLE);
   COM_OBJECT_VALIDATE_1_ARG(role);
 
   *role = IA2Role();
   // If we didn't explicitly set the IAccessible2 role, make it the same
   // as the MSAA role.
   if (!*role)
     *role = MSAARole();
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_states(AccessibleStates* states) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_STATES);
   COM_OBJECT_VALIDATE_1_ARG(states);
   *states = IA2State();
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_uniqueID(LONG* unique_id) {
   COM_OBJECT_VALIDATE_1_ARG(unique_id);
   *unique_id = -unique_id_;
   return S_OK;
 }
@@ skipping 141 matching lines @@
   return E_NOTIMPL;
 }
 
 //
 // IAccessibleTable methods.
 //
 
 STDMETHODIMP AXPlatformNodeWin::get_accessibleAt(long row,
                                                  long column,
                                                  IUnknown** accessible) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACCESSIBLE_AT);
   if (!accessible)
     return E_INVALIDARG;
 
   AXPlatformNodeBase* cell =
       GetTableCell(static_cast<int>(row), static_cast<int>(column));
   if (cell) {
     auto* node_win = static_cast<AXPlatformNodeWin*>(cell);
     node_win->AddRef();
 
     *accessible = static_cast<IAccessible*>(node_win);
     return S_OK;
   }
 
   *accessible = nullptr;
   return E_INVALIDARG;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_caption(IUnknown** accessible) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CAPTION);
   if (!accessible)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement
   *accessible = nullptr;
   return S_FALSE;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_childIndex(long row,
                                                long column,
                                                long* cell_index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHILD_INDEX);
   if (!cell_index)
     return E_INVALIDARG;
 
   auto* cell = GetTableCell(static_cast<int>(row), static_cast<int>(column));
   if (cell) {
     *cell_index = static_cast<LONG>(cell->GetTableCellIndex());
     return S_OK;
   }
 
   *cell_index = 0;
   return E_INVALIDARG;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_columnDescription(long column,
                                                       BSTR* description) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_DESCRIPTION);
   if (!description)
     return E_INVALIDARG;
 
   int columns = GetTableColumnCount();
   if (column < 0 || column >= columns)
     return E_INVALIDARG;
 
   int rows = GetTableRowCount();
   if (rows <= 0) {
     *description = nullptr;
@@ skipping 17 matching lines @@
     }
   }
 
   *description = nullptr;
   return S_FALSE;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_columnExtentAt(long row,
                                                    long column,
                                                    long* n_columns_spanned) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_EXTENT_AT);
   if (!n_columns_spanned)
     return E_INVALIDARG;
 
   auto* cell = GetTableCell(static_cast<int>(row), static_cast<int>(column));
   if (!cell)
     return E_INVALIDARG;
 
   *n_columns_spanned = cell->GetTableColumnSpan();
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_columnHeader(
     IAccessibleTable** accessible_table,
     long* starting_row_index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_HEADER);
   // TODO(dmazzoni): implement
   return E_NOTIMPL;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_columnIndex(long cell_index,
                                                 long* column_index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_INDEX);
   if (!column_index)
     return E_INVALIDARG;
 
   auto* cell = GetTableCell(cell_index);
   if (!cell)
     return E_INVALIDARG;
   *column_index = cell->GetTableColumn();
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_nColumns(long* column_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_COLUMNS);
   if (!column_count)
     return E_INVALIDARG;
 
   *column_count = GetTableColumnCount();
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_nRows(long* row_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_ROWS);
   if (!row_count)
     return E_INVALIDARG;
 
   *row_count = GetTableRowCount();
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_nSelectedChildren(long* cell_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_CHILDREN);
   if (!cell_count)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): add support for selected cells/rows/columns in tables.
   *cell_count = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_nSelectedColumns(long* column_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_COLUMNS);
   if (!column_count)
     return E_INVALIDARG;
 
   *column_count = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_nSelectedRows(long* row_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_ROWS);
   if (!row_count)
     return E_INVALIDARG;
 
   *row_count = 0;
   return S_FALSE;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_rowDescription(long row,
                                                    BSTR* description) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_DESCRIPTION);
   if (!description)
     return E_INVALIDARG;
 
   if (row < 0 || row >= GetTableRowCount())
     return E_INVALIDARG;
 
   int columns = GetTableColumnCount();
   if (columns <= 0) {
     *description = nullptr;
     return S_FALSE;
@@ skipping 15 matching lines @@
     }
   }
 
   *description = nullptr;
   return S_FALSE;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_rowExtentAt(long row,
                                                 long column,
                                                 long* n_rows_spanned) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_EXTENT_AT);
   if (!n_rows_spanned)
     return E_INVALIDARG;
 
   auto* cell = GetTableCell(row, column);
   if (!cell)
     return E_INVALIDARG;
 
   *n_rows_spanned = GetTableRowSpan();
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_rowHeader(
     IAccessibleTable** accessible_table,
     long* starting_column_index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_HEADER);
   // TODO(dmazzoni): implement
   return E_NOTIMPL;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_rowIndex(long cell_index, long* row_index) {
   if (!row_index)
     return E_INVALIDARG;
 
   auto* cell = GetTableCell(cell_index);
   if (!cell)
@@ skipping 1576 matching lines @@
   if (container && container->GetData().role == ui::AX_ROLE_GROUP)
     container = FromNativeViewAccessible(container->GetParent());
 
   if (!container)
     return false;
 
   return container->GetData().role == ui::AX_ROLE_TREE_GRID;
 }
 
 }  // namespace ui