Track usage of Windows accessibility APIs with a UMA histogram

content/browser/accessibility/browser_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 "content/browser/accessibility/browser_accessibility_win.h"
 
 #include <UIAutomationClient.h>
 #include <UIAutomationCoreApi.h>
 
 #include <algorithm>
 #include <iterator>
 #include <utility>
 
+#include "base/metrics/histogram_macros.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/enum_variant.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/windows_version.h"
 #include "content/browser/accessibility/browser_accessibility_event_win.h"
 #include "content/browser/accessibility/browser_accessibility_manager_win.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/common/accessibility_messages.h"
 #include "content/public/common/content_client.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/accessibility/ax_text_utils.h"
 #include "ui/base/win/accessibility_ids_win.h"
 #include "ui/base/win/accessibility_misc_utils.h"
 #include "ui/base/win/atl_module.h"
 
+namespace {
+
+// IMPORTANT!
+// These values are written to logs.  Do not renumber or delete
+// existing items; add new entries to the end of the list.
+enum {
+  UMA_API_ACC_DO_DEFAULT_ACTION = 0,
+  UMA_API_ACC_HIT_TEST = 1,
+  UMA_API_ACC_LOCATION = 2,
+  UMA_API_ACC_NAVIGATE = 3,
+  UMA_API_ACC_SELECT = 4,
+  UMA_API_ADD_SELECTION = 5,
+  UMA_API_CONVERT_RETURNED_ELEMENT = 6,
+  UMA_API_DO_ACTION = 7,
+  UMA_API_GET_ACCESSIBLE_AT = 8,
+  UMA_API_GET_ACC_CHILD = 9,
+  UMA_API_GET_ACC_CHILD_COUNT = 10,
+  UMA_API_GET_ACC_DEFAULT_ACTION = 11,
+  UMA_API_GET_ACC_DESCRIPTION = 12,
+  UMA_API_GET_ACC_FOCUS = 13,
+  UMA_API_GET_ACC_HELP = 14,
+  UMA_API_GET_ACC_HELP_TOPIC = 15,
+  UMA_API_GET_ACC_KEYBOARD_SHORTCUT = 16,
+  UMA_API_GET_ACC_NAME = 17,
+  UMA_API_GET_ACC_PARENT = 18,
+  UMA_API_GET_ACC_ROLE = 19,
+  UMA_API_GET_ACC_SELECTION = 20,
+  UMA_API_GET_ACC_STATE = 21,
+  UMA_API_GET_ACC_VALUE = 22,
+  UMA_API_GET_ANCHOR = 23,
+  UMA_API_GET_ANCHOR_TARGET = 24,
+  UMA_API_GET_APP_NAME = 25,
+  UMA_API_GET_APP_VERSION = 26,
+  UMA_API_GET_ATTRIBUTES_FOR_NAMES = 27,
+  UMA_API_GET_CAPTION = 28,
+  UMA_API_GET_CARET_OFFSET = 29,
+  UMA_API_GET_CELL_AT = 30,
+  UMA_API_GET_CHARACTER_EXTENTS = 31,
+  UMA_API_GET_CHILD_AT = 32,
+  UMA_API_GET_CHILD_INDEX = 33,
+  UMA_API_GET_CLIPPED_SUBSTRING_BOUNDS = 34,
+  UMA_API_GET_COLUMN_DESCRIPTION = 35,
+  UMA_API_GET_COLUMN_EXTENT = 36,
+  UMA_API_GET_COLUMN_EXTENT_AT = 37,
+  UMA_API_GET_COLUMN_HEADER = 38,
+  UMA_API_GET_COLUMN_HEADER_CELLS = 39,
+  UMA_API_GET_COLUMN_INDEX = 40,
+  UMA_API_GET_COMPUTED_STYLE = 41,
+  UMA_API_GET_COMPUTED_STYLE_FOR_PROPERTIES = 42,
+  UMA_API_GET_CURRENT_VALUE = 43,
+  UMA_API_GET_DESCRIPTION = 44,
+  UMA_API_GET_DOC_TYPE = 45,
+  UMA_API_GET_DOM_TEXT = 46,
+  UMA_API_GET_END_INDEX = 47,
+  UMA_API_GET_EXTENDED_ROLE = 48,
+  UMA_API_GET_EXTENDED_STATES = 49,
+  UMA_API_GET_FIRST_CHILD = 50,
+  UMA_API_GET_FONT_FAMILY = 51,
+  UMA_API_GET_GROUP_POSITION = 52,
+  UMA_API_GET_HOST_RAW_ELEMENT_PROVIDER = 53,
+  UMA_API_GET_HYPERLINK = 54,
+  UMA_API_GET_HYPERLINK_INDEX = 55,
+  UMA_API_GET_IACCESSIBLE_PAIR = 56,
+  UMA_API_GET_IMAGE_POSITION = 57,
+  UMA_API_GET_IMAGE_SIZE = 58,
+  UMA_API_GET_INDEX_IN_PARENT = 59,
+  UMA_API_GET_INNER_HTML = 60,
+  UMA_API_GET_IS_COLUMN_SELECTED = 61,
+  UMA_API_GET_IS_ROW_SELECTED = 62,
+  UMA_API_GET_IS_SELECTED = 63,
+  UMA_API_GET_KEY_BINDING = 64,
+  UMA_API_GET_LANGUAGE = 65,
+  UMA_API_GET_LAST_CHILD = 66,
+  UMA_API_GET_LOCALE = 67,
+  UMA_API_GET_LOCALIZED_EXTENDED_ROLE = 68,
+  UMA_API_GET_LOCALIZED_EXTENDED_STATES = 69,
+  UMA_API_GET_LOCALIZED_NAME = 70,
+  UMA_API_GET_LOCAL_INTERFACE = 71,
+  UMA_API_GET_MAXIMUM_VALUE = 72,
+  UMA_API_GET_MIME_TYPE = 73,
+  UMA_API_GET_MINIMUM_VALUE = 74,
+  UMA_API_GET_NAME = 75,
+  UMA_API_GET_NAMESPACE_URI_FOR_ID = 76,
+  UMA_API_GET_NEW_TEXT = 77,
+  UMA_API_GET_NEXT_SIBLING = 78,
+  UMA_API_GET_NODE_INFO = 79,
+  UMA_API_GET_N_CHARACTERS = 80,
+  UMA_API_GET_N_COLUMNS = 81,
+  UMA_API_GET_N_EXTENDED_STATES = 82,
+  UMA_API_GET_N_HYPERLINKS = 83,
+  UMA_API_GET_N_RELATIONS = 84,
+  UMA_API_GET_N_ROWS = 85,
+  UMA_API_GET_N_SELECTED_CELLS = 86,
+  UMA_API_GET_N_SELECTED_CHILDREN = 87,
+  UMA_API_GET_N_SELECTED_COLUMNS = 88,
+  UMA_API_GET_N_SELECTED_ROWS = 89,
+  UMA_API_GET_N_SELECTIONS = 90,
+  UMA_API_GET_OBJECT_FOR_CHILD = 91,
+  UMA_API_GET_OFFSET_AT_POINT = 92,
+  UMA_API_GET_OLD_TEXT = 93,
+  UMA_API_GET_PARENT_NODE = 94,
+  UMA_API_GET_PATTERN_PROVIDER = 95,
+  UMA_API_GET_PREVIOUS_SIBLING = 96,
+  UMA_API_GET_PROPERTY_VALUE = 97,
+  UMA_API_GET_PROVIDER_OPTIONS = 98,
+  UMA_API_GET_RELATION = 99,
+  UMA_API_GET_RELATIONS = 100,
+  UMA_API_GET_ROW_COLUMN_EXTENTS = 101,
+  UMA_API_GET_ROW_COLUMN_EXTENTS_AT_INDEX = 102,
+  UMA_API_GET_ROW_DESCRIPTION = 103,
+  UMA_API_GET_ROW_EXTENT = 104,
+  UMA_API_GET_ROW_EXTENT_AT = 105,
+  UMA_API_GET_ROW_HEADER = 106,
+  UMA_API_GET_ROW_HEADER_CELLS = 107,
+  UMA_API_GET_ROW_INDEX = 108,
+  UMA_API_GET_RUNTIME_ID = 109,
+  UMA_API_GET_SELECTED_CELLS = 110,
+  UMA_API_GET_SELECTED_CHILDREN = 111,
+  UMA_API_GET_SELECTED_COLUMNS = 112,
+  UMA_API_GET_SELECTED_ROWS = 113,
+  UMA_API_GET_SELECTION = 114,
+  UMA_API_GET_START_INDEX = 115,
+  UMA_API_GET_STATES = 116,
+  UMA_API_GET_SUMMARY = 117,
+  UMA_API_GET_TABLE = 118,
+  UMA_API_GET_TEXT = 119,
+  UMA_API_GET_TEXT_AFTER_OFFSET = 120,
+  UMA_API_GET_TEXT_AT_OFFSET = 121,
+  UMA_API_GET_TEXT_BEFORE_OFFSET = 122,
+  UMA_API_GET_TITLE = 123,
+  UMA_API_GET_TOOLKIT_NAME = 124,
+  UMA_API_GET_TOOLKIT_VERSION = 125,
+  UMA_API_GET_UNCLIPPED_SUBSTRING_BOUNDS = 126,
+  UMA_API_GET_UNIQUE_ID = 127,
+  UMA_API_GET_URL = 128,
+  UMA_API_GET_VALID = 129,
+  UMA_API_GET_WINDOW_HANDLE = 130,
+  UMA_API_IA2_GET_ATTRIBUTES = 131,
+  UMA_API_IA2_SCROLL_TO = 132,
+  UMA_API_IAACTION_GET_DESCRIPTION = 133,
+  UMA_API_IATEXT_GET_ATTRIBUTES = 134,
+  UMA_API_ISIMPLEDOMNODE_GET_ATTRIBUTES = 135,
+  UMA_API_ISIMPLEDOMNODE_SCROLL_TO = 136,
+  UMA_API_N_ACTIONS = 137,
+  UMA_API_PUT_ALTERNATE_VIEW_MEDIA_TYPES = 138,
+  UMA_API_QUERY_SERVICE = 139,
+  UMA_API_REMOVE_SELECTION = 140,
+  UMA_API_ROLE = 141,
+  UMA_API_SCROLL_SUBSTRING_TO = 142,
+  UMA_API_SCROLL_SUBSTRING_TO_POINT = 143,
+  UMA_API_SCROLL_TO_POINT = 144,
+  UMA_API_SCROLL_TO_SUBSTRING = 145,
+  UMA_API_SELECT_COLUMN = 146,
+  UMA_API_SELECT_ROW = 147,
+  UMA_API_SET_CARET_OFFSET = 148,
+  UMA_API_SET_CURRENT_VALUE = 149,
+  UMA_API_SET_SELECTION = 150,
+  UMA_API_TABLE2_GET_SELECTED_COLUMNS = 151,
+  UMA_API_TABLE2_GET_SELECTED_ROWS = 152,
+  UMA_API_TABLECELL_GET_COLUMN_INDEX = 153,
+  UMA_API_TABLECELL_GET_IS_SELECTED = 154,
+  UMA_API_TABLECELL_GET_ROW_INDEX = 155,
+  UMA_API_UNSELECT_COLUMN = 156,
+  UMA_API_UNSELECT_ROW = 157,
+
+  // This must always be the last enum. It's okay for its value to
+  // increase, but none of the other enum values may change.
+  UMA_API_MAX
+};
+
+#define WIN_ACCESSIBILITY_API_HISTOGRAM(enum_value) \
+    UMA_HISTOGRAM_ENUMERATION("Accessibility.WinAPIs", enum_value, UMA_API_MAX)
+
+}  // namespace
+
 namespace content {
 
 // These nonstandard GUIDs are taken directly from the Mozilla sources
 // (accessible/src/msaa/nsAccessNodeWrap.cpp); some documentation is here:
 // http://developer.mozilla.org/en/Accessibility/AT-APIs/ImplementationFeatures/MSAA
 const GUID GUID_ISimpleDOM = {0x0c539790,
                               0x12e4,
                               0x11cf,
                               {0xb6, 0x61, 0x00, 0xaa, 0x00, 0x4c, 0xd6, 0xd8}};
 const GUID GUID_IAccessibleContentDocument = {
@@ skipping 187 matching lines @@
 //
 // IAccessible methods.
 //
 // Conventions:
 // * Always test for instance_active() first and return E_FAIL if it's false.
 // * Always check for invalid arguments first, even if they're unused.
 // * Return S_FALSE if the only output is a string argument and it's empty.
 //
 
 HRESULT BrowserAccessibilityWin::accDoDefaultAction(VARIANT var_id) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_DO_DEFAULT_ACTION);
   if (!instance_active())
     return E_FAIL;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   // Return an error if it's not clickable.
   if (!target->HasStringAttribute(ui::AX_ATTR_ACTION))
     return DISP_E_MEMBERNOTFOUND;
 
   manager()->DoDefaultAction(*target);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::accHitTest(LONG x_left,
                                                  LONG y_top,
                                                  VARIANT* child) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_HIT_TEST);
   if (!instance_active())
     return E_FAIL;
 
   if (!child)
     return E_INVALIDARG;
 
   gfx::Point point(x_left, y_top);
   if (!GetScreenBoundsRect().Contains(point)) {
     // Return S_FALSE and VT_EMPTY when outside the object's boundaries.
     child->vt = VT_EMPTY;
@@ skipping 10 matching lines @@
     child->pdispVal = ToBrowserAccessibilityWin(result)->NewReference();
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::accLocation(LONG* x_left,
                                                   LONG* y_top,
                                                   LONG* width,
                                                   LONG* height,
                                                   VARIANT var_id) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_LOCATION);
   if (!instance_active())
     return E_FAIL;
 
   if (!x_left || !y_top || !width || !height)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   gfx::Rect bounds = target->GetScreenBoundsRect();
   *x_left = bounds.x();
   *y_top  = bounds.y();
   *width  = bounds.width();
   *height = bounds.height();
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::accNavigate(LONG nav_dir,
                                                   VARIANT start,
                                                   VARIANT* end) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_NAVIGATE);
   BrowserAccessibilityWin* target = GetTargetFromChildID(start);
   if (!target)
     return E_INVALIDARG;
 
   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;
   }
 
@@ skipping 28 matching lines @@
     return S_FALSE;
   }
 
   end->vt = VT_DISPATCH;
   end->pdispVal = ToBrowserAccessibilityWin(result)->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accChild(VARIANT var_child,
                                                    IDispatch** disp_child) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_CHILD);
   if (!instance_active())
     return E_FAIL;
 
   if (!disp_child)
     return E_INVALIDARG;
 
   *disp_child = NULL;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_child);
   if (!target)
     return E_INVALIDARG;
 
   (*disp_child) = target->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accChildCount(LONG* child_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_CHILD_COUNT);
   if (!instance_active())
     return E_FAIL;
 
   if (!child_count)
     return E_INVALIDARG;
 
   *child_count = PlatformChildCount();
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accDefaultAction(VARIANT var_id,
                                                            BSTR* def_action) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_DEFAULT_ACTION);
   if (!instance_active())
     return E_FAIL;
 
   if (!def_action)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   return target->GetStringAttributeAsBstr(
       ui::AX_ATTR_ACTION, def_action);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accDescription(VARIANT var_id,
                                                          BSTR* desc) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_DESCRIPTION);
   if (!instance_active())
     return E_FAIL;
 
   if (!desc)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   base::string16 description_str = target->description();
   if (description_str.empty())
     return S_FALSE;
 
   *desc = SysAllocString(description_str.c_str());
 
   DCHECK(*desc);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accFocus(VARIANT* focus_child) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_FOCUS);
   if (!instance_active())
     return E_FAIL;
 
   if (!focus_child)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* focus = static_cast<BrowserAccessibilityWin*>(
       manager()->GetFocus());
   if (focus == this) {
     focus_child->vt = VT_I4;
     focus_child->lVal = CHILDID_SELF;
   } else if (focus == NULL) {
     focus_child->vt = VT_EMPTY;
   } else {
     focus_child->vt = VT_DISPATCH;
     focus_child->pdispVal = focus->NewReference();
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accHelp(VARIANT var_id, BSTR* help) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_HELP);
   if (!instance_active())
     return E_FAIL;
 
   if (!help)
     return E_INVALIDARG;
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accKeyboardShortcut(VARIANT var_id,
                                                               BSTR* acc_key) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_KEYBOARD_SHORTCUT);
   if (!instance_active())
     return E_FAIL;
 
   if (!acc_key)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   return target->GetStringAttributeAsBstr(
       ui::AX_ATTR_SHORTCUT, acc_key);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accName(VARIANT var_id, BSTR* name) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_NAME);
   if (!instance_active())
     return E_FAIL;
 
   if (!name)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   base::string16 name_str = target->name();
   if (name_str.empty()) {
     if (target->ia2_role() == 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
       name_str = L" ";
     } else {
       return S_FALSE;
     }
   }
 
   *name = SysAllocString(name_str.c_str());
 
   DCHECK(*name);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accParent(IDispatch** disp_parent) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_PARENT);
   if (!instance_active())
     return E_FAIL;
 
   if (!disp_parent)
     return E_INVALIDARG;
 
   IAccessible* parent_obj = ToBrowserAccessibilityWin(GetParent());
   if (parent_obj == NULL) {
     // This happens if we're the root of the tree;
     // return the IAccessible for the window.
@@ skipping 10 matching lines @@
       return E_FAIL;
     }
   }
   parent_obj->AddRef();
   *disp_parent = parent_obj;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accRole(VARIANT var_id,
                                                   VARIANT* role) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_ROLE);
   if (!instance_active())
     return E_FAIL;
 
   if (!role)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   if (!target->role_name().empty()) {
     role->vt = VT_BSTR;
     role->bstrVal = SysAllocString(target->role_name().c_str());
   } else {
     role->vt = VT_I4;
     role->lVal = target->ia_role();
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accState(VARIANT var_id,
                                                    VARIANT* state) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_STATE);
   if (!instance_active())
     return E_FAIL;
 
   if (!state)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
   state->vt = VT_I4;
   state->lVal = target->ia_state();
   if (manager()->GetFocus() == this)
     state->lVal |= STATE_SYSTEM_FOCUSED;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accValue(VARIANT var_id,
                                                    BSTR* value) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_VALUE);
   if (!instance_active())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   BrowserAccessibilityWin* target = GetTargetFromChildID(var_id);
   if (!target)
     return E_INVALIDARG;
 
@@ skipping 23 matching lines @@
   }
 
   *value = SysAllocString(target->value().c_str());
   DCHECK(*value);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accHelpTopic(BSTR* help_file,
                                                        VARIANT var_id,
                                                        LONG* topic_id) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_HELP_TOPIC);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_accSelection(VARIANT* selected) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACC_SELECTION);
   if (!instance_active())
     return E_FAIL;
 
   if (GetRole() != ui::AX_ROLE_LIST_BOX)
     return E_NOTIMPL;
 
   unsigned long selected_count = 0;
   for (size_t i = 0; i < InternalChildCount(); ++i) {
     if (InternalGetChild(i)->HasState(ui::AX_STATE_SELECTED))
       ++selected_count;
@@ skipping 29 matching lines @@
     }
   }
   selected->vt = VT_UNKNOWN;
   selected->punkVal = static_cast<IUnknown*>(
       static_cast<base::win::IUnknownImpl*>(enum_variant));
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::accSelect(
     LONG flags_sel, VARIANT var_id) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ACC_SELECT);
   if (!instance_active())
     return E_FAIL;
 
   if (flags_sel & SELFLAG_TAKEFOCUS) {
     manager()->SetFocus(*this);
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP
 BrowserAccessibilityWin::put_accName(VARIANT var_id, BSTR put_name) {
   return E_NOTIMPL;
 }
 STDMETHODIMP
 BrowserAccessibilityWin::put_accValue(VARIANT var_id, BSTR put_val) {
   return E_NOTIMPL;
 }
 
 //
 // IAccessible2 methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::role(LONG* role) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ROLE);
   if (!instance_active())
     return E_FAIL;
 
   if (!role)
     return E_INVALIDARG;
 
   *role = ia2_role();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_attributes(BSTR* attributes) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IA2_GET_ATTRIBUTES);
   if (!attributes)
     return E_INVALIDARG;
   *attributes = nullptr;
 
   if (!instance_active())
     return E_FAIL;
 
   base::string16 str;
   for (const base::string16& attribute : ia2_attributes())
     str += attribute + L';';
 
   if (str.empty())
     return S_FALSE;
 
   *attributes = SysAllocString(str.c_str());
   DCHECK(*attributes);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_states(AccessibleStates* states) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_STATES);
   if (!instance_active())
     return E_FAIL;
 
   if (!states)
     return E_INVALIDARG;
 
   *states = ia2_state();
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_uniqueID(LONG* unique_id) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_UNIQUE_ID);
   if (!instance_active())
     return E_FAIL;
 
   if (!unique_id)
     return E_INVALIDARG;
 
   *unique_id = -this->unique_id();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_windowHandle(HWND* window_handle) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_WINDOW_HANDLE);
   if (!instance_active())
     return E_FAIL;
 
   if (!window_handle)
     return E_INVALIDARG;
 
   *window_handle =
       manager()->ToBrowserAccessibilityManagerWin()->GetParentHWND();
   if (!*window_handle)
     return E_FAIL;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_indexInParent(LONG* index_in_parent) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_INDEX_IN_PARENT);
   if (!instance_active())
     return E_FAIL;
 
   if (!index_in_parent)
     return E_INVALIDARG;
 
   *index_in_parent = this->GetIndexInParent();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nRelations(LONG* n_relations) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_RELATIONS);
   if (!instance_active())
     return E_FAIL;
 
   if (!n_relations)
     return E_INVALIDARG;
 
   *n_relations = relations_.size();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_relation(
     LONG relation_index,
     IAccessibleRelation** relation) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_RELATION);
   if (!instance_active())
     return E_FAIL;
 
   if (relation_index < 0 ||
       relation_index >= static_cast<long>(relations_.size())) {
     return E_INVALIDARG;
   }
 
   if (!relation)
     return E_INVALIDARG;
 
   relations_[relation_index]->AddRef();
   *relation = relations_[relation_index];
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_relations(
     LONG max_relations,
     IAccessibleRelation** relations,
     LONG* n_relations) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_RELATIONS);
   if (!instance_active())
     return E_FAIL;
 
   if (!relations || !n_relations)
     return E_INVALIDARG;
 
   long count = static_cast<long>(relations_.size());
   *n_relations = count;
   if (count == 0)
     return S_FALSE;
 
   for (long i = 0; i < count; ++i) {
     relations_[i]->AddRef();
     relations[i] = relations_[i];
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::scrollTo(IA2ScrollType scroll_type) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IA2_SCROLL_TO);
   if (!instance_active())
     return E_FAIL;
 
   gfx::Rect r = GetFrameBoundsRect();
   switch(scroll_type) {
     case IA2_SCROLL_TYPE_TOP_LEFT:
       manager()->ScrollToMakeVisible(*this, gfx::Rect(r.x(), r.y(), 0, 0));
       break;
     case IA2_SCROLL_TYPE_BOTTOM_RIGHT:
       manager()->ScrollToMakeVisible(
@@ skipping 22 matching lines @@
   }
 
   manager()->ToBrowserAccessibilityManagerWin()->TrackScrollingObject(this);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::scrollToPoint(
     IA2CoordinateType coordinate_type,
     LONG x,
     LONG y) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SCROLL_TO_POINT);
   if (!instance_active())
     return E_FAIL;
 
   gfx::Point scroll_to(x, y);
 
   if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
     scroll_to -= manager()->GetViewBounds().OffsetFromOrigin();
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
     if (GetParent())
       scroll_to += GetParent()->GetFrameBoundsRect().OffsetFromOrigin();
   } else {
     return E_INVALIDARG;
   }
 
   manager()->ScrollToPoint(*this, scroll_to);
   manager()->ToBrowserAccessibilityManagerWin()->TrackScrollingObject(this);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_groupPosition(
     LONG* group_level,
     LONG* similar_items_in_group,
     LONG* position_in_group) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_GROUP_POSITION);
   if (!instance_active())
     return E_FAIL;
 
   if (!group_level || !similar_items_in_group || !position_in_group)
     return E_INVALIDARG;
 
   *group_level = GetIntAttribute(ui::AX_ATTR_HIERARCHICAL_LEVEL);
   *similar_items_in_group = GetIntAttribute(ui::AX_ATTR_SET_SIZE);
   *position_in_group = GetIntAttribute(ui::AX_ATTR_POS_IN_SET);
 
   if (*group_level == *similar_items_in_group == *position_in_group == 0)
     return S_FALSE;
   return S_OK;
 }
 
 //
 // IAccessibleEx methods not implemented.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_extendedRole(BSTR* extended_role) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_EXTENDED_ROLE);
   return E_NOTIMPL;
 }
 STDMETHODIMP
 BrowserAccessibilityWin::get_localizedExtendedRole(
     BSTR* localized_extended_role) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCALIZED_EXTENDED_ROLE);
   return E_NOTIMPL;
 }
 STDMETHODIMP
 BrowserAccessibilityWin::get_nExtendedStates(LONG* n_extended_states) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_EXTENDED_STATES);
   return E_NOTIMPL;
 }
 STDMETHODIMP
 BrowserAccessibilityWin::get_extendedStates(LONG max_extended_states,
                                             BSTR** extended_states,
                                             LONG* n_extended_states) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_EXTENDED_STATES);
   return E_NOTIMPL;
 }
 STDMETHODIMP
 BrowserAccessibilityWin::get_localizedExtendedStates(
     LONG max_localized_extended_states,
     BSTR** localized_extended_states,
     LONG* n_localized_extended_states) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCALIZED_EXTENDED_STATES);
   return E_NOTIMPL;
 }
 STDMETHODIMP BrowserAccessibilityWin::get_locale(IA2Locale* locale) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCALE);
   return E_NOTIMPL;
 }
 
 //
 // IAccessibleApplication methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_appName(BSTR* app_name) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_APP_NAME);
   // No need to check |instance_active()| because this interface is
   // global, and doesn't depend on any local state.
 
   if (!app_name)
     return E_INVALIDARG;
 
   // GetProduct() returns a string like "Chrome/aa.bb.cc.dd", split out
   // the part before the "/".
   std::vector<std::string> product_components = base::SplitString(
       GetContentClient()->GetProduct(), "/",
       base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   DCHECK_EQ(2U, product_components.size());
   if (product_components.size() != 2)
     return E_FAIL;
   *app_name = SysAllocString(base::UTF8ToUTF16(product_components[0]).c_str());
   DCHECK(*app_name);
   return *app_name ? S_OK : E_FAIL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_appVersion(BSTR* app_version) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_APP_VERSION);
   // No need to check |instance_active()| because this interface is
   // global, and doesn't depend on any local state.
 
   if (!app_version)
     return E_INVALIDARG;
 
   // GetProduct() returns a string like "Chrome/aa.bb.cc.dd", split out
   // the part after the "/".
   std::vector<std::string> product_components = base::SplitString(
       GetContentClient()->GetProduct(), "/",
       base::TRIM_WHITESPACE, base::SPLIT_WANT_ALL);
   DCHECK_EQ(2U, product_components.size());
   if (product_components.size() != 2)
     return E_FAIL;
   *app_version =
       SysAllocString(base::UTF8ToUTF16(product_components[1]).c_str());
   DCHECK(*app_version);
   return *app_version ? S_OK : E_FAIL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_toolkitName(BSTR* toolkit_name) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TOOLKIT_NAME);
   // No need to check |instance_active()| because this interface is
   // global, and doesn't depend on any local state.
 
   if (!toolkit_name)
     return E_INVALIDARG;
 
   // This is hard-coded; all products based on the Chromium engine
   // will have the same toolkit name, so that assistive technology can
   // detect any Chrome-based product.
   *toolkit_name = SysAllocString(L"Chrome");
   DCHECK(*toolkit_name);
   return *toolkit_name ? S_OK : E_FAIL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_toolkitVersion(
     BSTR* toolkit_version) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TOOLKIT_VERSION);
   // No need to check |instance_active()| because this interface is
   // global, and doesn't depend on any local state.
 
   if (!toolkit_version)
     return E_INVALIDARG;
 
   std::string user_agent = GetContentClient()->GetUserAgent();
   *toolkit_version = SysAllocString(base::UTF8ToUTF16(user_agent).c_str());
   DCHECK(*toolkit_version);
   return *toolkit_version ? S_OK : E_FAIL;
 }
 
 //
 // IAccessibleImage methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_description(BSTR* desc) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_DESCRIPTION);
   if (!instance_active())
     return E_FAIL;
 
   if (!desc)
     return E_INVALIDARG;
 
   if (description().empty())
     return S_FALSE;
 
   *desc = SysAllocString(description().c_str());
 
   DCHECK(*desc);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_imagePosition(
     IA2CoordinateType coordinate_type,
     LONG* x,
     LONG* y) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IMAGE_POSITION);
   if (!instance_active())
     return E_FAIL;
 
   if (!x || !y)
     return E_INVALIDARG;
 
   if (coordinate_type == IA2_COORDTYPE_SCREEN_RELATIVE) {
     gfx::Rect bounds = GetScreenBoundsRect();
     *x = bounds.x();
     *y = bounds.y();
   } else if (coordinate_type == IA2_COORDTYPE_PARENT_RELATIVE) {
     gfx::Rect bounds = GetPageBoundsRect();
     gfx::Rect parent_bounds =
         GetParent() ? GetParent()->GetPageBoundsRect() : gfx::Rect();
     *x = bounds.x() - parent_bounds.x();
     *y = bounds.y() - parent_bounds.y();
   } else {
     return E_INVALIDARG;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_imageSize(LONG* height, LONG* width) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IMAGE_SIZE);
   if (!instance_active())
     return E_FAIL;
 
   if (!height || !width)
     return E_INVALIDARG;
 
   *height = GetPageBoundsRect().height();
   *width = GetPageBoundsRect().width();
   return S_OK;
 }
 
 //
 // IAccessibleTable methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_accessibleAt(
     long row,
     long column,
     IUnknown** accessible) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ACCESSIBLE_AT);
   if (!instance_active())
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   int columns;
   int rows;
   if (!GetIntAttribute(
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
@@ skipping 16 matching lines @@
   if (cell) {
     *accessible = static_cast<IAccessible*>(cell->NewReference());
     return S_OK;
   }
 
   *accessible = NULL;
   return E_INVALIDARG;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_caption(IUnknown** accessible) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CAPTION);
   if (!instance_active())
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_childIndex(long row,
                                                      long column,
                                                      long* cell_index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHILD_INDEX);
   if (!instance_active())
     return E_FAIL;
 
   if (!cell_index)
     return E_INVALIDARG;
 
   int columns;
   int rows;
   if (!GetIntAttribute(
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
@@ skipping 18 matching lines @@
       *cell_index = (long)i;
       return S_OK;
     }
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_columnDescription(long column,
                                                             BSTR* description) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_DESCRIPTION);
   if (!instance_active())
     return E_FAIL;
 
   if (!description)
     return E_INVALIDARG;
 
   int columns;
   int rows;
   if (!GetIntAttribute(
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
@@ skipping 26 matching lines @@
     }
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_columnExtentAt(
     long row,
     long column,
     long* n_columns_spanned) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_EXTENT_AT);
   if (!instance_active())
     return E_FAIL;
 
   if (!n_columns_spanned)
     return E_INVALIDARG;
 
   int columns;
   int rows;
   if (!GetIntAttribute(
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
@@ skipping 18 matching lines @@
     *n_columns_spanned = colspan;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::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 BrowserAccessibilityWin::get_columnIndex(long cell_index,
                                                       long* column_index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_INDEX);
   if (!instance_active())
     return E_FAIL;
 
   if (!column_index)
     return E_INVALIDARG;
 
   const std::vector<int32_t>& unique_cell_ids =
       GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
   int cell_id_count = static_cast<int>(unique_cell_ids.size());
   if (cell_index < 0)
     return E_INVALIDARG;
   if (cell_index >= cell_id_count)
     return S_FALSE;
 
   int cell_id = unique_cell_ids[cell_index];
   BrowserAccessibilityWin* cell = GetFromID(cell_id);
   int col_index;
   if (cell &&
       cell->GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &col_index)) {
     *column_index = col_index;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nColumns(long* column_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_COLUMNS);
   if (!instance_active())
     return E_FAIL;
 
   if (!column_count)
     return E_INVALIDARG;
 
   int columns;
   if (GetIntAttribute(
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns)) {
     *column_count = columns;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nRows(long* row_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_ROWS);
   if (!instance_active())
     return E_FAIL;
 
   if (!row_count)
     return E_INVALIDARG;
 
   int rows;
   if (GetIntAttribute(ui::AX_ATTR_TABLE_ROW_COUNT, &rows)) {
     *row_count = rows;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nSelectedChildren(long* cell_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_CHILDREN);
   if (!instance_active())
     return E_FAIL;
 
   if (!cell_count)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): add support for selected cells/rows/columns in tables.
   *cell_count = 0;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nSelectedColumns(long* column_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_COLUMNS);
   if (!instance_active())
     return E_FAIL;
 
   if (!column_count)
     return E_INVALIDARG;
 
   *column_count = 0;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nSelectedRows(long* row_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_ROWS);
   if (!instance_active())
     return E_FAIL;
 
   if (!row_count)
     return E_INVALIDARG;
 
   *row_count = 0;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_rowDescription(long row,
                                                          BSTR* description) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_DESCRIPTION);
   if (!instance_active())
     return E_FAIL;
 
   if (!description)
     return E_INVALIDARG;
 
   int columns;
   int rows;
   if (!GetIntAttribute(
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
@@ skipping 25 matching lines @@
       }
     }
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_rowExtentAt(long row,
                                                       long column,
                                                       long* n_rows_spanned) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_EXTENT_AT);
   if (!instance_active())
     return E_FAIL;
 
   if (!n_rows_spanned)
     return E_INVALIDARG;
 
   int columns;
   int rows;
   if (!GetIntAttribute(
           ui::AX_ATTR_TABLE_COLUMN_COUNT, &columns) ||
@@ skipping 18 matching lines @@
     *n_rows_spanned = rowspan;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::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 BrowserAccessibilityWin::get_rowIndex(long cell_index,
                                                    long* row_index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_INDEX);
   if (!instance_active())
     return E_FAIL;
 
   if (!row_index)
     return E_INVALIDARG;
 
   const std::vector<int32_t>& unique_cell_ids =
       GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
   int cell_id_count = static_cast<int>(unique_cell_ids.size());
   if (cell_index < 0)
@@ skipping 10 matching lines @@
     *row_index = cell_row_index;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_selectedChildren(long max_children,
                                                            long** children,
                                                            long* n_children) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_CHILDREN);
   if (!instance_active())
     return E_FAIL;
 
   if (!children || !n_children)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_children = 0;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_selectedColumns(long max_columns,
                                                           long** columns,
                                                           long* n_columns) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_COLUMNS);
   if (!instance_active())
     return E_FAIL;
 
   if (!columns || !n_columns)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_columns = 0;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_selectedRows(long max_rows,
                                                        long** rows,
                                                        long* n_rows) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_ROWS);
   if (!instance_active())
     return E_FAIL;
 
   if (!rows || !n_rows)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_rows = 0;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_summary(IUnknown** accessible) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SUMMARY);
   if (!instance_active())
     return E_FAIL;
 
   if (!accessible)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_isColumnSelected(
     long column,
     boolean* is_selected) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IS_COLUMN_SELECTED);
   if (!instance_active())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_isRowSelected(long row,
                                                         boolean* is_selected) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IS_ROW_SELECTED);
   if (!instance_active())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_isSelected(long row,
                                                      long column,
                                                      boolean* is_selected) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IS_SELECTED);
   if (!instance_active())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *is_selected = false;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_rowColumnExtentsAtIndex(
     long index,
     long* row,
     long* column,
     long* row_extents,
     long* column_extents,
     boolean* is_selected) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_COLUMN_EXTENTS_AT_INDEX);
   if (!instance_active())
     return E_FAIL;
 
   if (!row || !column || !row_extents || !column_extents || !is_selected)
     return E_INVALIDARG;
 
   const std::vector<int32_t>& unique_cell_ids =
       GetIntListAttribute(ui::AX_ATTR_UNIQUE_CELL_IDS);
   int cell_id_count = static_cast<int>(unique_cell_ids.size());
   if (index < 0)
@@ skipping 14 matching lines @@
       colspan >= 1) {
     *row_extents = rowspan;
     *column_extents = colspan;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::selectRow(long row) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SELECT_ROW);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::selectColumn(long column) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SELECT_COLUMN);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::unselectRow(long row) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_UNSELECT_ROW);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::unselectColumn(long column) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_UNSELECT_COLUMN);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP
 BrowserAccessibilityWin::get_modelChange(IA2TableModelChange* model_change) {
   return E_NOTIMPL;
 }
 
 //
 // IAccessibleTable2 methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_cellAt(long row,
                                                  long column,
                                                  IUnknown** cell) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CELL_AT);
   return get_accessibleAt(row, column, cell);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nSelectedCells(long* cell_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTED_CELLS);
   return get_nSelectedChildren(cell_count);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_selectedCells(
     IUnknown*** cells,
     long* n_selected_cells) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTED_CELLS);
   if (!instance_active())
     return E_FAIL;
 
   if (!cells || !n_selected_cells)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_selected_cells = 0;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_selectedColumns(long** columns,
                                                           long* n_columns) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLE2_GET_SELECTED_COLUMNS);
   if (!instance_active())
     return E_FAIL;
 
   if (!columns || !n_columns)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_columns = 0;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_selectedRows(long** rows,
                                                        long* n_rows) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLE2_GET_SELECTED_ROWS);
   if (!instance_active())
     return E_FAIL;
 
   if (!rows || !n_rows)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): Implement this.
   *n_rows = 0;
   return S_OK;
 }
 
 
 //
 // IAccessibleTableCell methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_columnExtent(
     long* n_columns_spanned) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_EXTENT);
   if (!instance_active())
     return E_FAIL;
 
   if (!n_columns_spanned)
     return E_INVALIDARG;
 
   int colspan;
   if (GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_COLUMN_SPAN, &colspan) &&
       colspan >= 1) {
     *n_columns_spanned = colspan;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_columnHeaderCells(
     IUnknown*** cell_accessibles,
     long* n_column_header_cells) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COLUMN_HEADER_CELLS);
   if (!instance_active())
     return E_FAIL;
 
   if (!cell_accessibles || !n_column_header_cells)
     return E_INVALIDARG;
 
   *n_column_header_cells = 0;
 
   int column;
   if (!GetIntAttribute(
@@ skipping 40 matching lines @@
       (*cell_accessibles)[index] = static_cast<IAccessible*>(
           ToBrowserAccessibilityWin(cell)->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_columnIndex(long* column_index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_COLUMN_INDEX);
   if (!instance_active())
     return E_FAIL;
 
   if (!column_index)
     return E_INVALIDARG;
 
   int column;
   if (GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_COLUMN_INDEX, &column)) {
     *column_index = column;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_rowExtent(long* n_rows_spanned) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_EXTENT);
   if (!instance_active())
     return E_FAIL;
 
   if (!n_rows_spanned)
     return E_INVALIDARG;
 
   int rowspan;
   if (GetIntAttribute(
           ui::AX_ATTR_TABLE_CELL_ROW_SPAN, &rowspan) &&
       rowspan >= 1) {
     *n_rows_spanned = rowspan;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_rowHeaderCells(
     IUnknown*** cell_accessibles,
     long* n_row_header_cells) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_HEADER_CELLS);
   if (!instance_active())
     return E_FAIL;
 
   if (!cell_accessibles || !n_row_header_cells)
     return E_INVALIDARG;
 
   *n_row_header_cells = 0;
 
   int row;
   if (!GetIntAttribute(
@@ skipping 40 matching lines @@
       (*cell_accessibles)[index] = static_cast<IAccessible*>(
           ToBrowserAccessibilityWin(cell)->NewReference());
       ++index;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_rowIndex(long* row_index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_ROW_INDEX);
   if (!instance_active())
     return E_FAIL;
 
   if (!row_index)
     return E_INVALIDARG;
 
   int row;
   if (GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &row)) {
     *row_index = row;
     return S_OK;
   }
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_isSelected(boolean* is_selected) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_TABLECELL_GET_IS_SELECTED);
   if (!instance_active())
     return E_FAIL;
 
   if (!is_selected)
     return E_INVALIDARG;
 
   *is_selected = false;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_rowColumnExtents(
     long* row_index,
     long* column_index,
     long* row_extents,
     long* column_extents,
     boolean* is_selected) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ROW_COLUMN_EXTENTS);
   if (!instance_active())
     return E_FAIL;
 
   if (!row_index ||
       !column_index ||
       !row_extents ||
       !column_extents ||
       !is_selected) {
     return E_INVALIDARG;
   }
@@ skipping 14 matching lines @@
     *row_extents = rowspan;
     *column_extents = colspan;
     *is_selected = false;
     return S_OK;
   }
 
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_table(IUnknown** table) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TABLE);
   if (!instance_active())
     return E_FAIL;
 
   if (!table)
     return E_INVALIDARG;
 
 
   int row;
   int column;
   GetIntAttribute(ui::AX_ATTR_TABLE_CELL_ROW_INDEX, &row);
@@ skipping 11 matching lines @@
       ToBrowserAccessibilityWin(find_table)->NewReference());
 
   return S_OK;
 }
 
 //
 // IAccessibleText methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_nCharacters(LONG* n_characters) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_CHARACTERS);
   if (!instance_active())
     return E_FAIL;
 
   if (!n_characters)
     return E_INVALIDARG;
 
   *n_characters = static_cast<LONG>(GetText().size());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_caretOffset(LONG* offset) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CARET_OFFSET);
   if (!instance_active())
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
   if (!HasCaret())
     return S_FALSE;
 
   int selection_start, selection_end;
   GetSelectionOffsets(&selection_start, &selection_end);
   // The caret is always at the end of the selection.
   *offset = selection_end;
   if (*offset < 0)
     return S_FALSE;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_characterExtents(
     LONG offset,
     IA2CoordinateType coordinate_type,
     LONG* out_x,
     LONG* out_y,
     LONG* out_width,
     LONG* out_height) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHARACTER_EXTENTS);
   if (!instance_active())
     return E_FAIL;
 
   if (!out_x || !out_y || !out_width || !out_height)
     return E_INVALIDARG;
 
   const base::string16& text_str = GetText();
   HandleSpecialTextOffset(text_str, &offset);
 
   if (offset < 0 || offset > static_cast<LONG>(text_str.size()))
@@ skipping 12 matching lines @@
 
   *out_x = character_bounds.x();
   *out_y = character_bounds.y();
   *out_width = character_bounds.width();
   *out_height = character_bounds.height();
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nSelections(LONG* n_selections) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_SELECTIONS);
   if (!instance_active())
     return E_FAIL;
 
   if (!n_selections)
     return E_INVALIDARG;
 
   *n_selections = 0;
   int selection_start, selection_end;
   GetSelectionOffsets(&selection_start, &selection_end);
   if (selection_start >= 0 && selection_end >= 0 &&
       selection_start != selection_end) {
     *n_selections = 1;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_selection(LONG selection_index,
                                                     LONG* start_offset,
                                                     LONG* end_offset) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_SELECTION);
   if (!instance_active())
     return E_FAIL;
 
   if (!start_offset || !end_offset || selection_index != 0)
     return E_INVALIDARG;
 
   LONG n_selections = 0;
   if (FAILED(get_nSelections(&n_selections)) || n_selections < 1)
     return E_INVALIDARG;
 
@@ skipping 12 matching lines @@
     *start_offset = selection_start;
     *end_offset = selection_end;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_text(LONG start_offset,
                                                LONG end_offset,
                                                BSTR* text) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT);
   if (!instance_active())
     return E_FAIL;
 
   if (!text)
     return E_INVALIDARG;
 
   const base::string16& text_str = GetText();
   HandleSpecialTextOffset(text_str, &start_offset);
   HandleSpecialTextOffset(text_str, &end_offset);
 
@@ skipping 22 matching lines @@
   DCHECK(*text);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_textAtOffset(
     LONG offset,
     IA2TextBoundaryType boundary_type,
     LONG* start_offset,
     LONG* end_offset,
     BSTR* text) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_AT_OFFSET);
   if (!instance_active())
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     return E_INVALIDARG;
 
   const base::string16& text_str = GetText();
   HandleSpecialTextOffset(text_str, &offset);
   if (offset < 0)
     return E_INVALIDARG;
@@ skipping 30 matching lines @@
       text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
   return get_text(*start_offset, *end_offset, text);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_textBeforeOffset(
     LONG offset,
     IA2TextBoundaryType boundary_type,
     LONG* start_offset,
     LONG* end_offset,
     BSTR* text) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_BEFORE_OFFSET);
   if (!instance_active())
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     return E_INVALIDARG;
 
   // The IAccessible2 spec says we don't have to implement the "sentence"
   // boundary type, we can just let the screenreader handle it.
   if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
     *start_offset = 0;
     *end_offset = 0;
     *text = NULL;
     return S_FALSE;
   }
 
   const base::string16& text_str = GetText();
 
   *start_offset = FindBoundary(
       text_str, boundary_type, offset, ui::BACKWARDS_DIRECTION);
   *end_offset = offset;
   return get_text(*start_offset, *end_offset, text);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_textAfterOffset(
     LONG offset,
     IA2TextBoundaryType boundary_type,
     LONG* start_offset,
     LONG* end_offset,
     BSTR* text) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TEXT_AFTER_OFFSET);
   if (!instance_active())
     return E_FAIL;
 
   if (!start_offset || !end_offset || !text)
     return E_INVALIDARG;
 
   // The IAccessible2 spec says we don't have to implement the "sentence"
   // boundary type, we can just let the screenreader handle it.
   if (boundary_type == IA2_TEXT_BOUNDARY_SENTENCE) {
     *start_offset = 0;
     *end_offset = 0;
     *text = NULL;
     return S_FALSE;
   }
 
   const base::string16& text_str = GetText();
 
   *start_offset = offset;
   *end_offset = FindBoundary(
       text_str, boundary_type, offset, ui::FORWARDS_DIRECTION);
   return get_text(*start_offset, *end_offset, text);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_newText(IA2TextSegment* new_text) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NEW_TEXT);
   if (!instance_active())
     return E_FAIL;
 
   if (!new_text)
     return E_INVALIDARG;
 
   if (!old_win_attributes_)
     return E_FAIL;
 
   int start, old_len, new_len;
   ComputeHypertextRemovedAndInserted(&start, &old_len, &new_len);
   if (new_len == 0)
     return E_FAIL;
 
   base::string16 substr = GetText().substr(start, new_len);
   new_text->text = SysAllocString(substr.c_str());
   new_text->start = static_cast<long>(start);
   new_text->end = static_cast<long>(start + new_len);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_oldText(IA2TextSegment* old_text) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_OLD_TEXT);
   if (!instance_active())
     return E_FAIL;
 
   if (!old_text)
     return E_INVALIDARG;
 
   if (!old_win_attributes_)
     return E_FAIL;
 
   int start, old_len, new_len;
   ComputeHypertextRemovedAndInserted(&start, &old_len, &new_len);
   if (old_len == 0)
     return E_FAIL;
 
   base::string16 old_hypertext = old_win_attributes_->hypertext;
   base::string16 substr = old_hypertext.substr(start, old_len);
   old_text->text = SysAllocString(substr.c_str());
   old_text->start = static_cast<long>(start);
   old_text->end = static_cast<long>(start + old_len);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_offsetAtPoint(
     LONG x,
     LONG y,
     IA2CoordinateType coord_type,
     LONG* offset) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_OFFSET_AT_POINT);
   if (!instance_active())
     return E_FAIL;
 
   if (!offset)
     return E_INVALIDARG;
 
   // TODO(dmazzoni): implement this. We're returning S_OK for now so that
   // screen readers still return partially accurate results rather than
   // completely failing.
   *offset = 0;
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::scrollSubstringTo(
     LONG start_index,
     LONG end_index,
     IA2ScrollType scroll_type) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SCROLL_SUBSTRING_TO);
   // TODO(dmazzoni): adjust this for the start and end index, too.
   return scrollTo(scroll_type);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::scrollSubstringToPoint(
     LONG start_index,
     LONG end_index,
     IA2CoordinateType coordinate_type,
     LONG x,
     LONG y) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SCROLL_SUBSTRING_TO_POINT);
   // TODO(dmazzoni): adjust this for the start and end index, too.
   return scrollToPoint(coordinate_type, x, y);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::addSelection(LONG start_offset,
                                                    LONG end_offset) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ADD_SELECTION);
   if (!instance_active())
     return E_FAIL;
 
   const base::string16& text_str = GetText();
   HandleSpecialTextOffset(text_str, &start_offset);
   HandleSpecialTextOffset(text_str, &end_offset);
 
   manager()->SetTextSelection(*this, start_offset, end_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::removeSelection(LONG selection_index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_REMOVE_SELECTION);
   if (!instance_active())
     return E_FAIL;
 
   if (selection_index != 0)
     return E_INVALIDARG;
 
   manager()->SetTextSelection(*this, 0, 0);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::setCaretOffset(LONG offset) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SET_CARET_OFFSET);
   if (!instance_active())
     return E_FAIL;
 
   const base::string16& text_str = GetText();
   HandleSpecialTextOffset(text_str, &offset);
   manager()->SetTextSelection(*this, offset, offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::setSelection(LONG selection_index,
                                                    LONG start_offset,
                                                    LONG end_offset) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SET_SELECTION);
   if (!instance_active())
     return E_FAIL;
 
   if (selection_index != 0)
     return E_INVALIDARG;
 
   const base::string16& text_str = GetText();
   HandleSpecialTextOffset(text_str, &start_offset);
   HandleSpecialTextOffset(text_str, &end_offset);
 
   manager()->SetTextSelection(*this, start_offset, end_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_attributes(LONG offset,
                                                      LONG* start_offset,
                                                      LONG* end_offset,
                                                      BSTR* text_attributes) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IATEXT_GET_ATTRIBUTES);
   if (!start_offset || !end_offset || !text_attributes)
     return E_INVALIDARG;
 
   *start_offset = *end_offset = 0;
   *text_attributes = nullptr;
   if (!instance_active())
     return E_FAIL;
 
   const base::string16& text = GetText();
   HandleSpecialTextOffset(text, &offset);
@@ skipping 17 matching lines @@
   *text_attributes = SysAllocString(attributes_str.c_str());
   DCHECK(*text_attributes);
   return S_OK;
 }
 
 //
 // IAccessibleHypertext methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_nHyperlinks(long* hyperlink_count) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_N_HYPERLINKS);
   if (!instance_active())
     return E_FAIL;
 
   if (!hyperlink_count)
     return E_INVALIDARG;
 
   *hyperlink_count = hyperlink_offset_to_index().size();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_hyperlink(
     long index,
     IAccessibleHyperlink** hyperlink) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_HYPERLINK);
   if (!instance_active())
     return E_FAIL;
 
   if (!hyperlink ||
       index < 0 ||
       index >= static_cast<long>(hyperlinks().size())) {
     return E_INVALIDARG;
   }
 
   int32_t id = hyperlinks()[index];
   BrowserAccessibilityWin* link =
       ToBrowserAccessibilityWin(GetFromUniqueID(id));
   if (!link)
     return E_FAIL;
 
   *hyperlink = static_cast<IAccessibleHyperlink*>(link->NewReference());
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_hyperlinkIndex(
     long char_index,
     long* hyperlink_index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_HYPERLINK_INDEX);
   if (!instance_active())
     return E_FAIL;
 
   if (!hyperlink_index)
     return E_INVALIDARG;
 
   if (char_index < 0 || char_index >= static_cast<long>(GetText().size())) {
     return E_INVALIDARG;
   }
 
   std::map<int32_t, int32_t>::iterator it =
       hyperlink_offset_to_index().find(char_index);
   if (it == hyperlink_offset_to_index().end()) {
     *hyperlink_index = -1;
     return S_FALSE;
   }
 
   *hyperlink_index = it->second;
   return S_OK;
 }
 
 //
 // IAccessibleHyperlink methods.
 //
 
 // Currently, only text links are supported.
 STDMETHODIMP BrowserAccessibilityWin::get_anchor(long index, VARIANT* anchor) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ANCHOR);
   if (!instance_active() || !IsHyperlink())
     return E_FAIL;
 
   // IA2 text links can have only one anchor, that is the text inside them.
   if (index != 0 || !anchor)
     return E_INVALIDARG;
 
   BSTR ia2_hypertext = SysAllocString(GetText().c_str());
   DCHECK(ia2_hypertext);
   anchor->vt = VT_BSTR;
   anchor->bstrVal = ia2_hypertext;
 
   // Returning S_FALSE is not mentioned in the IA2 Spec, but it might have been
   // an oversight.
   if (!SysStringLen(ia2_hypertext))
     return S_FALSE;
 
   return S_OK;
 }
 
 // Currently, only text links are supported.
 STDMETHODIMP BrowserAccessibilityWin::get_anchorTarget(long index,
                                                        VARIANT* anchor_target) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ANCHOR_TARGET);
   if (!instance_active() || !IsHyperlink())
     return E_FAIL;
 
   // IA2 text links can have at most one target, that is when they represent an
   // HTML hyperlink, i.e. an <a> element with a "href" attribute.
   if (index != 0 || !anchor_target)
     return E_INVALIDARG;
 
   BSTR target;
   if (!(ia_state() & STATE_SYSTEM_LINKED) ||
       FAILED(GetStringAttributeAsBstr(ui::AX_ATTR_URL, &target))) {
     target = SysAllocString(L"");
   }
   DCHECK(target);
   anchor_target->vt = VT_BSTR;
   anchor_target->bstrVal = target;
 
   // Returning S_FALSE is not mentioned in the IA2 Spec, but it might have been
   // an oversight.
   if (!SysStringLen(target))
     return S_FALSE;
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_startIndex(long* index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_START_INDEX);
   if (!instance_active() || !IsHyperlink())
     return E_FAIL;
 
   if (!index)
     return E_INVALIDARG;
 
   int32_t hypertext_offset = 0;
   auto* parent = GetParent();
   if (parent) {
     hypertext_offset =
         ToBrowserAccessibilityWin(parent)->GetHypertextOffsetFromChild(*this);
   }
   *index = static_cast<LONG>(hypertext_offset);
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_endIndex(long* index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_END_INDEX);
   LONG start_index;
   HRESULT hr = get_startIndex(&start_index);
   if (hr == S_OK)
     *index = start_index + 1;
   return hr;
 }
 
 // This method is deprecated in the IA2 Spec.
 STDMETHODIMP BrowserAccessibilityWin::get_valid(boolean* valid) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_VALID);
   return E_NOTIMPL;
 }
 
 //
 // IAccessibleAction partly implemented.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::nActions(long* n_actions) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_N_ACTIONS);
   if (!instance_active())
     return E_FAIL;
 
   if (!n_actions)
     return E_INVALIDARG;
 
   // |IsHyperlink| is required for |IAccessibleHyperlink::anchor/anchorTarget|
   // to work properly because the |IAccessibleHyperlink| interface inherits from
   // |IAccessibleAction|.
   if (IsHyperlink() || HasStringAttribute(ui::AX_ATTR_ACTION)) {
     *n_actions = 1;
   } else {
     *n_actions = 0;
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::doAction(long action_index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_DO_ACTION);
   if (!instance_active())
     return E_FAIL;
 
   if (!HasStringAttribute(ui::AX_ATTR_ACTION) || action_index != 0)
     return E_INVALIDARG;
 
   manager()->DoDefaultAction(*this);
   return S_OK;
 }
 
 STDMETHODIMP
 BrowserAccessibilityWin::get_description(long action_index, BSTR* description) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_IAACTION_GET_DESCRIPTION);
   return E_NOTIMPL;
 }
+
 STDMETHODIMP BrowserAccessibilityWin::get_keyBinding(long action_index,
                                                      long n_max_bindings,
                                                      BSTR** key_bindings,
                                                      long* n_bindings) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_KEY_BINDING);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_name(long action_index, BSTR* name) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NAME);
   if (!instance_active())
     return E_FAIL;
 
   if (!name)
     return E_INVALIDARG;
 
   base::string16 action_verb;
   if (!GetString16Attribute(ui::AX_ATTR_ACTION, &action_verb) ||
       action_index != 0) {
     *name = nullptr;
     return E_INVALIDARG;
   }
 
   *name = SysAllocString(action_verb.c_str());
   DCHECK(name);
   return S_OK;
 }
 
 STDMETHODIMP
 BrowserAccessibilityWin::get_localizedName(long action_index,
                                            BSTR* localized_name) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCALIZED_NAME);
   return E_NOTIMPL;
 }
 
 //
 // IAccessibleValue methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_currentValue(VARIANT* value) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CURRENT_VALUE);
   if (!instance_active())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   float float_val;
   if (GetFloatAttribute(
           ui::AX_ATTR_VALUE_FOR_RANGE, &float_val)) {
     value->vt = VT_R8;
     value->dblVal = float_val;
     return S_OK;
   }
 
   value->vt = VT_EMPTY;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_minimumValue(VARIANT* value) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_MINIMUM_VALUE);
   if (!instance_active())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   float float_val;
   if (GetFloatAttribute(ui::AX_ATTR_MIN_VALUE_FOR_RANGE,
                         &float_val)) {
     value->vt = VT_R8;
     value->dblVal = float_val;
     return S_OK;
   }
 
   value->vt = VT_EMPTY;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_maximumValue(VARIANT* value) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_MAXIMUM_VALUE);
   if (!instance_active())
     return E_FAIL;
 
   if (!value)
     return E_INVALIDARG;
 
   float float_val;
   if (GetFloatAttribute(ui::AX_ATTR_MAX_VALUE_FOR_RANGE,
                         &float_val)) {
     value->vt = VT_R8;
     value->dblVal = float_val;
     return S_OK;
   }
 
   value->vt = VT_EMPTY;
   return S_FALSE;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::setCurrentValue(VARIANT new_value) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SET_CURRENT_VALUE);
   // TODO(dmazzoni): Implement this.
   return E_NOTIMPL;
 }
 
 //
 // ISimpleDOMDocument methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_URL(BSTR* url) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_URL);
   if (!instance_active())
     return E_FAIL;
 
   if (!url)
     return E_INVALIDARG;
 
   if (this != manager()->GetRoot())
     return E_FAIL;
 
   std::string str = manager()->GetTreeData().url;
   if (str.empty())
     return S_FALSE;
 
   *url = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*url);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_title(BSTR* title) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_TITLE);
   if (!instance_active())
     return E_FAIL;
 
   if (!title)
     return E_INVALIDARG;
 
   std::string str = manager()->GetTreeData().title;
   if (str.empty())
     return S_FALSE;
 
   *title = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*title);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_mimeType(BSTR* mime_type) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_MIME_TYPE);
   if (!instance_active())
     return E_FAIL;
 
   if (!mime_type)
     return E_INVALIDARG;
 
   std::string str = manager()->GetTreeData().mimetype;
   if (str.empty())
     return S_FALSE;
 
   *mime_type = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*mime_type);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_docType(BSTR* doc_type) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_DOC_TYPE);
   if (!instance_active())
     return E_FAIL;
 
   if (!doc_type)
     return E_INVALIDARG;
 
   std::string str = manager()->GetTreeData().doctype;
   if (str.empty())
     return S_FALSE;
 
   *doc_type = SysAllocString(base::UTF8ToUTF16(str).c_str());
   DCHECK(*doc_type);
 
   return S_OK;
 }
 
 STDMETHODIMP
 BrowserAccessibilityWin::get_nameSpaceURIForID(short name_space_id,
                                                BSTR* name_space_uri) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NAMESPACE_URI_FOR_ID);
   return E_NOTIMPL;
 }
+
 STDMETHODIMP
 BrowserAccessibilityWin::put_alternateViewMediaTypes(
     BSTR* comma_separated_media_types) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_PUT_ALTERNATE_VIEW_MEDIA_TYPES);
   return E_NOTIMPL;
 }
 
 //
 // ISimpleDOMNode methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_nodeInfo(
     BSTR* node_name,
     short* name_space_id,
     BSTR* node_value,
     unsigned int* num_children,
     unsigned int* unique_id,
     unsigned short* node_type) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NODE_INFO);
   if (!instance_active())
     return E_FAIL;
 
   if (!node_name || !name_space_id || !node_value || !num_children ||
       !unique_id || !node_type) {
     return E_INVALIDARG;
   }
 
   base::string16 tag;
   if (GetString16Attribute(ui::AX_ATTR_HTML_TAG, &tag))
@@ skipping 17 matching lines @@
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_attributes(
     unsigned short max_attribs,
     BSTR* attrib_names,
     short* name_space_id,
     BSTR* attrib_values,
     unsigned short* num_attribs) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ISIMPLEDOMNODE_GET_ATTRIBUTES);
   if (!instance_active())
     return E_FAIL;
 
   if (!attrib_names || !name_space_id || !attrib_values || !num_attribs)
     return E_INVALIDARG;
 
   *num_attribs = max_attribs;
   if (*num_attribs > GetHtmlAttributes().size())
     *num_attribs = GetHtmlAttributes().size();
 
   for (unsigned short i = 0; i < *num_attribs; ++i) {
     attrib_names[i] = SysAllocString(
         base::UTF8ToUTF16(GetHtmlAttributes()[i].first).c_str());
     name_space_id[i] = 0;
     attrib_values[i] = SysAllocString(
         base::UTF8ToUTF16(GetHtmlAttributes()[i].second).c_str());
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_attributesForNames(
     unsigned short num_attribs,
     BSTR* attrib_names,
     short* name_space_id,
     BSTR* attrib_values) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_ATTRIBUTES_FOR_NAMES);
   if (!instance_active())
     return E_FAIL;
 
   if (!attrib_names || !name_space_id || !attrib_values)
     return E_INVALIDARG;
 
   for (unsigned short i = 0; i < num_attribs; ++i) {
     name_space_id[i] = 0;
     bool found = false;
     std::string name = base::UTF16ToUTF8((LPCWSTR)attrib_names[i]);
@@ skipping 11 matching lines @@
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_computedStyle(
     unsigned short max_style_properties,
     boolean use_alternate_view,
     BSTR* style_properties,
     BSTR* style_values,
     unsigned short *num_style_properties)  {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COMPUTED_STYLE);
   if (!instance_active())
     return E_FAIL;
 
   if (!style_properties || !style_values)
     return E_INVALIDARG;
 
   // We only cache a single style property for now: DISPLAY
 
   base::string16 display;
   if (max_style_properties == 0 ||
       !GetString16Attribute(ui::AX_ATTR_DISPLAY, &display)) {
     *num_style_properties = 0;
     return S_OK;
   }
 
   *num_style_properties = 1;
   style_properties[0] = SysAllocString(L"display");
   style_values[0] = SysAllocString(display.c_str());
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_computedStyleForProperties(
     unsigned short num_style_properties,
     boolean use_alternate_view,
     BSTR* style_properties,
     BSTR* style_values) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_COMPUTED_STYLE_FOR_PROPERTIES);
   if (!instance_active())
     return E_FAIL;
 
   if (!style_properties || !style_values)
     return E_INVALIDARG;
 
   // We only cache a single style property for now: DISPLAY
 
   for (unsigned short i = 0; i < num_style_properties; ++i) {
     base::string16 name = base::ToLowerASCII(
         reinterpret_cast<const base::char16*>(style_properties[i]));
     if (name == L"display") {
       base::string16 display = GetString16Attribute(
           ui::AX_ATTR_DISPLAY);
       style_values[i] = SysAllocString(display.c_str());
     } else {
       style_values[i] = NULL;
     }
   }
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::scrollTo(boolean placeTopLeft) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_ISIMPLEDOMNODE_SCROLL_TO);
   return scrollTo(placeTopLeft ?
       IA2_SCROLL_TYPE_TOP_LEFT : IA2_SCROLL_TYPE_ANYWHERE);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_parentNode(ISimpleDOMNode** node) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PARENT_NODE);
   if (!instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   *node = ToBrowserAccessibilityWin(GetParent())->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_firstChild(ISimpleDOMNode** node)  {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_FIRST_CHILD);
   if (!instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (PlatformChildCount() == 0) {
     *node = NULL;
     return S_FALSE;
   }
 
   *node = ToBrowserAccessibilityWin(PlatformGetChild(0))->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_lastChild(ISimpleDOMNode** node) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LAST_CHILD);
   if (!instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (PlatformChildCount() == 0) {
     *node = NULL;
     return S_FALSE;
   }
 
   *node = ToBrowserAccessibilityWin(
       PlatformGetChild(PlatformChildCount() - 1))->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_previousSibling(
     ISimpleDOMNode** node) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PREVIOUS_SIBLING);
   if (!instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (!GetParent() || GetIndexInParent() <= 0) {
     *node = NULL;
     return S_FALSE;
   }
 
   *node = ToBrowserAccessibilityWin(
       GetParent()->InternalGetChild(GetIndexInParent() - 1))->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_nextSibling(ISimpleDOMNode** node) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_NEXT_SIBLING);
   if (!instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (!GetParent() ||
       GetIndexInParent() < 0 ||
       GetIndexInParent() >= static_cast<int>(
           GetParent()->InternalChildCount()) - 1) {
     *node = NULL;
     return S_FALSE;
   }
 
   *node = ToBrowserAccessibilityWin(
       GetParent()->InternalGetChild(GetIndexInParent() + 1))->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_childAt(
     unsigned int child_index,
     ISimpleDOMNode** node) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CHILD_AT);
   if (!instance_active())
     return E_FAIL;
 
   if (!node)
     return E_INVALIDARG;
 
   if (child_index >= PlatformChildCount())
     return E_INVALIDARG;
 
   BrowserAccessibility* child = PlatformGetChild(child_index);
   if (!child) {
     *node = NULL;
     return S_FALSE;
   }
 
   *node = ToBrowserAccessibilityWin(child)->NewReference();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_innerHTML(BSTR* innerHTML) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_INNER_HTML);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP
 BrowserAccessibilityWin::get_localInterface(void** local_interface) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LOCAL_INTERFACE);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_language(BSTR* language) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_LANGUAGE);
   if (!language)
     return E_INVALIDARG;
   *language = nullptr;
 
   if (!instance_active())
     return E_FAIL;
 
   base::string16 lang = GetInheritedString16Attribute(ui::AX_ATTR_LANGUAGE);
   if (lang.empty())
     lang = L"en-US";
 
   *language = SysAllocString(lang.c_str());
   DCHECK(*language);
   return S_OK;
 }
 
 //
 // ISimpleDOMText methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::get_domText(BSTR* dom_text) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_DOM_TEXT);
   if (!instance_active())
     return E_FAIL;
 
   if (!dom_text)
     return E_INVALIDARG;
 
   return GetStringAttributeAsBstr(
       ui::AX_ATTR_NAME, dom_text);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_clippedSubstringBounds(
     unsigned int start_index,
     unsigned int end_index,
     int* out_x,
     int* out_y,
     int* out_width,
     int* out_height) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_CLIPPED_SUBSTRING_BOUNDS);
   // TODO(dmazzoni): fully support this API by intersecting the
   // rect with the container's rect.
   return get_unclippedSubstringBounds(
       start_index, end_index, out_x, out_y, out_width, out_height);
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_unclippedSubstringBounds(
     unsigned int start_index,
     unsigned int end_index,
     int* out_x,
     int* out_y,
     int* out_width,
     int* out_height) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_UNCLIPPED_SUBSTRING_BOUNDS);
   if (!instance_active())
     return E_FAIL;
 
   if (!out_x || !out_y || !out_width || !out_height)
     return E_INVALIDARG;
 
   unsigned int text_length = static_cast<unsigned int>(GetText().size());
   if (start_index > text_length || end_index > text_length ||
       start_index > end_index) {
     return E_INVALIDARG;
   }
 
   gfx::Rect bounds = GetScreenBoundsForRange(
       start_index, end_index - start_index);
   *out_x = bounds.x();
   *out_y = bounds.y();
   *out_width = bounds.width();
   *out_height = bounds.height();
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::scrollToSubstring(
     unsigned int start_index,
     unsigned int end_index) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_SCROLL_TO_SUBSTRING);
   if (!instance_active())
     return E_FAIL;
 
   unsigned int text_length = static_cast<unsigned int>(GetText().size());
   if (start_index > text_length || end_index > text_length ||
       start_index > end_index) {
     return E_INVALIDARG;
   }
 
   manager()->ScrollToMakeVisible(*this, GetPageBoundsForRange(
       start_index, end_index - start_index));
   manager()->ToBrowserAccessibilityManagerWin()->TrackScrollingObject(this);
 
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_fontFamily(BSTR* font_family) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_FONT_FAMILY);
   if (!font_family)
     return E_INVALIDARG;
   *font_family = nullptr;
 
   if (!instance_active())
     return E_FAIL;
 
   base::string16 family =
       GetInheritedString16Attribute(ui::AX_ATTR_FONT_FAMILY);
   if (family.empty())
     return S_FALSE;
 
   *font_family = SysAllocString(family.c_str());
   DCHECK(*font_family);
   return S_OK;
 }
 
 //
 // IServiceProvider methods.
 //
 
 STDMETHODIMP BrowserAccessibilityWin::QueryService(REFGUID guid_service,
                                                    REFIID riid,
                                                    void** object) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_QUERY_SERVICE);
   if (!instance_active())
     return E_FAIL;
 
   // The system uses IAccessible APIs for many purposes, but only
   // assistive technology like screen readers uses IAccessible2.
   // Enable full accessibility support when IAccessible2 APIs are queried.
   if (riid == IID_IAccessible2)
     BrowserAccessibilityStateImpl::GetInstance()->EnableAccessibility();
 
   if (guid_service == GUID_IAccessibleContentDocument) {
@@ skipping 34 matching lines @@
       base::win::GetVersion() >= base::win::VERSION_WIN8) {
     return QueryInterface(riid, object);
   }
 
   *object = NULL;
   return E_FAIL;
 }
 
 STDMETHODIMP
 BrowserAccessibilityWin::GetObjectForChild(long child_id, IAccessibleEx** ret) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_OBJECT_FOR_CHILD);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP
 BrowserAccessibilityWin::GetIAccessiblePair(IAccessible** acc, long* child_id) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_IACCESSIBLE_PAIR);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::GetRuntimeId(SAFEARRAY** runtime_id) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_RUNTIME_ID);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP
 BrowserAccessibilityWin::ConvertReturnedElement(
     IRawElementProviderSimple* element,
     IAccessibleEx** acc) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_CONVERT_RETURNED_ELEMENT);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::GetPatternProvider(PATTERNID id,
                                                          IUnknown** provider) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PATTERN_PROVIDER);
   DVLOG(1) << "In Function: " << __func__ << " for pattern id: " << id;
   if (id == UIA_ValuePatternId || id == UIA_TextPatternId) {
     if (HasState(ui::AX_STATE_EDITABLE)) {
       DVLOG(1) << "Returning UIA text provider";
       base::win::UIATextProvider::CreateTextProvider(
           GetValueText(), true, provider);
       return S_OK;
     }
   }
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::GetPropertyValue(PROPERTYID id,
                                                        VARIANT* ret) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PROPERTY_VALUE);
   DVLOG(1) << "In Function: " << __func__ << " for property id: " << id;
   V_VT(ret) = VT_EMPTY;
   if (id == UIA_ControlTypePropertyId) {
     if (HasState(ui::AX_STATE_EDITABLE)) {
       V_VT(ret) = VT_I4;
       ret->lVal = UIA_EditControlTypeId;
       DVLOG(1) << "Returning Edit control type";
     } else {
       DVLOG(1) << "Returning empty control type";
     }
   }
   return S_OK;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_ProviderOptions(
     ProviderOptions* ret) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_PROVIDER_OPTIONS);
   return E_NOTIMPL;
 }
 
 STDMETHODIMP BrowserAccessibilityWin::get_HostRawElementProvider(
     IRawElementProviderSimple** provider) {
+  WIN_ACCESSIBILITY_API_HISTOGRAM(UMA_API_GET_HOST_RAW_ELEMENT_PROVIDER);
   return E_NOTIMPL;
 }
 
 //
 // CComObjectRootEx methods.
 //
 
 // static
 HRESULT WINAPI BrowserAccessibilityWin::InternalQueryInterface(
     void* this_ptr,
@@ skipping 1934 matching lines @@
   return static_cast<BrowserAccessibilityWin*>(obj);
 }
 
 const BrowserAccessibilityWin*
 ToBrowserAccessibilityWin(const BrowserAccessibility* obj) {
   DCHECK(!obj || obj->IsNative());
   return static_cast<const BrowserAccessibilityWin*>(obj);
 }
 
 }  // namespace content