Use unique IDs for accessibility nodes on Android

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 60 matching lines @@
     if (!IsValidId(var_id)) return E_INVALIDARG; \
     if (!arg1) return E_INVALIDARG; \
     if (!arg2) return E_INVALIDARG; \
     if (!arg3) return E_INVALIDARG; \
     if (!arg4) return E_INVALIDARG
 
 namespace ui {
 
 namespace {
 
-typedef base::hash_map<LONG, AXPlatformNodeWin*> UniqueIdWinMap;
-// Map from each AXPlatformNodeWin's unique id to its instance.
-base::LazyInstance<UniqueIdWinMap> g_unique_id_win_map =
-    LAZY_INSTANCE_INITIALIZER;
-
 typedef base::hash_set<AXPlatformNodeWin*> AXPlatformNodeWinSet;
 // Set of all AXPlatformNodeWin objects that were the target of an
 // alert event.
 base::LazyInstance<AXPlatformNodeWinSet> g_alert_targets =
     LAZY_INSTANCE_INITIALIZER;
 
-LONG GetNextNegativeUniqueIdForWinAccessibility(AXPlatformNodeWin* obj) {
-  static LONG next_unique_id = -1;
-  LONG unique_id = next_unique_id;
-  if (next_unique_id == LONG_MIN)
-    next_unique_id = -1;
-  else
-    next_unique_id--;
-
-  g_unique_id_win_map.Get().insert(std::make_pair(unique_id, obj));
-
-  return unique_id;
-}
-
-void UnregisterNegativeUniqueId(LONG unique_id) {
-  g_unique_id_win_map.Get().erase(unique_id);
-}
-
 base::LazyInstance<base::ObserverList<IAccessible2UsageObserver>>
     g_iaccessible2_usage_observer_list = LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 //
 // IAccessible2UsageObserver
 //
 
 IAccessible2UsageObserver::IAccessible2UsageObserver() {
@@ skipping 30 matching lines @@
     gfx::NativeViewAccessible accessible) {
   base::win::ScopedComPtr<AXPlatformNodeWin> ax_platform_node;
   accessible->QueryInterface(ax_platform_node.Receive());
   return ax_platform_node.get();
 }
 
 //
 // AXPlatformNodeWin
 //
 
-AXPlatformNodeWin::AXPlatformNodeWin()
-    : unique_id_win_(GetNextNegativeUniqueIdForWinAccessibility(this)) {
+AXPlatformNodeWin::AXPlatformNodeWin() {
 }
 
 AXPlatformNodeWin::~AXPlatformNodeWin() {
   CHECK(!delegate_);
 }
 
 //
 // AXPlatformNode implementation.
 //
 
 void AXPlatformNodeWin::Destroy() {
   delegate_ = nullptr;
-  UnregisterNegativeUniqueId(unique_id_win_);
   RemoveAlertTarget();
   Release();
 }
 
 gfx::NativeViewAccessible AXPlatformNodeWin::GetNativeViewAccessible() {
   return this;
 }
 
 void AXPlatformNodeWin::NotifyAccessibilityEvent(ui::AXEvent event_type) {
   HWND hwnd = delegate_->GetTargetForNativeAccessibilityEvent();
   if (!hwnd)
     return;
 
   // Menu items fire selection events but Windows screen readers work reliably
   // with focus events. Remap here.
   if (event_type == ui::AX_EVENT_SELECTION &&
       GetData().role == ui::AX_ROLE_MENU_ITEM)
     event_type = ui::AX_EVENT_FOCUS;
 
   int native_event = MSAAEvent(event_type);
   if (native_event < EVENT_MIN)
     return;
 
-  ::NotifyWinEvent(native_event, hwnd, OBJID_CLIENT, unique_id_win_);
+  ::NotifyWinEvent(native_event, hwnd, OBJID_CLIENT, -unique_id_);
 
   // Keep track of objects that are a target of an alert event.
   if (event_type == ui::AX_EVENT_ALERT)
     AddAlertTarget();
 }
 
 int AXPlatformNodeWin::GetIndexInParent() {
   base::win::ScopedComPtr<IDispatch> parent_dispatch;
   base::win::ScopedComPtr<IAccessible> parent_accessible;
   if (S_OK != get_accParent(parent_dispatch.Receive()))
@@ skipping 151 matching lines @@
     if (!(*disp_child))
       return E_FAIL;
     (*disp_child)->AddRef();
     return S_OK;
   }
 
   if (child_id >= 0)
     return E_FAIL;
 
   // Negative child ids can be used to map to any descendant.
-  UniqueIdWinMap* unique_ids = g_unique_id_win_map.Pointer();
-  auto iter = unique_ids->find(child_id);
-  if (iter != unique_ids->end()) {
-    *disp_child = iter->second;
+  AXPlatformNodeWin* child = static_cast<AXPlatformNodeWin*>(
+      GetFromUniqueId(-child_id));
+  if (child) {
+    *disp_child = child;
     (*disp_child)->AddRef();
     return S_OK;
   }
 
   *disp_child = nullptr;
   return E_FAIL;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_accChildCount(LONG* child_count) {
   COM_OBJECT_VALIDATE_1_ARG(child_count);
@@ skipping 141 matching lines @@
   // add a helper function like MSAAState.
   *states = IA2_STATE_OPAQUE;
   if (GetData().state & (1 << ui::AX_STATE_EDITABLE))
     *states |= IA2_STATE_EDITABLE;
 
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_uniqueID(LONG* unique_id) {
   COM_OBJECT_VALIDATE_1_ARG(unique_id);
-  *unique_id = unique_id_win_;
+  *unique_id = -unique_id_;
   return S_OK;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_windowHandle(HWND* window_handle) {
   COM_OBJECT_VALIDATE_1_ARG(window_handle);
   *window_handle = delegate_->GetTargetForNativeAccessibilityEvent();
   return *window_handle ? S_OK : S_FALSE;
 }
 
 STDMETHODIMP AXPlatformNodeWin::get_relationTargetsOfType(
@@ skipping 606 matching lines @@
     LONG start_offset,
     ui::TextBoundaryDirection direction) {
   HandleSpecialTextOffset(text, &start_offset);
   ui::TextBoundaryType boundary = IA2TextBoundaryToTextBoundary(ia2_boundary);
   std::vector<int32_t> line_breaks;
   return static_cast<LONG>(ui::FindAccessibleTextBoundary(
       text, line_breaks, boundary, start_offset, direction));
 }
 
 }  // namespace ui