Migrate BrowserAccessibility windows unique id handling to AXPlatformNodeWin.

content/browser/accessibility/browser_accessibility_win_unittest.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 <objbase.h>
 #include <stdint.h>
 
 #include <memory>
 #include <utility>
 
 #include "base/macros.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/win/scoped_bstr.h"
 #include "base/win/scoped_comptr.h"
 #include "base/win/scoped_variant.h"
 #include "content/browser/accessibility/browser_accessibility_manager.h"
 #include "content/browser/accessibility/browser_accessibility_manager_win.h"
 #include "content/browser/accessibility/browser_accessibility_state_impl.h"
 #include "content/browser/renderer_host/legacy_render_widget_host_win.h"
 #include "content/common/accessibility_messages.h"
 #include "content/public/test/test_browser_thread_bundle.h"
 #include "testing/gtest/include/gtest/gtest.h"
+#include "ui/accessibility/platform/ax_platform_node_win.h"
 #include "ui/base/win/atl_module.h"
 
 namespace content {
 
 // BrowserAccessibilityTest ---------------------------------------------------
 
 class BrowserAccessibilityTest : public testing::Test {
  public:
   BrowserAccessibilityTest();
   ~BrowserAccessibilityTest() override;
@@ skipping 662 matching lines @@
   EXPECT_NE(root, manager->GetRoot());
 
   // And the new child exists.
   EXPECT_EQ(ui::AX_ROLE_BUTTON, acc2_2->GetRole());
   EXPECT_EQ(3, acc2_2->GetId());
 
   // Ensure we properly cleaned up.
   manager.reset();
 }
 
+int32_t GetUniqueId(BrowserAccessibility* accessibility) {
+  BrowserAccessibilityWin* win_root = ToBrowserAccessibilityWin(accessibility);
+  return win_root->GetCOM()->unique_id();
+}
+
 // This is a regression test for a bug where the initial empty document
 // loaded by a BrowserAccessibilityManagerWin couldn't be looked up by
 // its UniqueIDWin, because the AX Tree was loaded in
 // BrowserAccessibilityManager code before BrowserAccessibilityManagerWin
 // was initialized.
 TEST_F(BrowserAccessibilityTest, EmptyDocHasUniqueIdWin) {
   std::unique_ptr<BrowserAccessibilityManagerWin> manager(
       new BrowserAccessibilityManagerWin(
           BrowserAccessibilityManagerWin::GetEmptyDocument(), nullptr,
           new BrowserAccessibilityFactory()));
 
   // Verify the root is as we expect by default.
   BrowserAccessibility* root = manager->GetRoot();
   EXPECT_EQ(0, root->GetId());
   EXPECT_EQ(ui::AX_ROLE_ROOT_WEB_AREA, root->GetRole());
   EXPECT_EQ(1 << ui::AX_STATE_BUSY, root->GetState());
 
-  int32_t unique_id = ToBrowserAccessibilityWin(root)->unique_id();
-  ASSERT_EQ(root, BrowserAccessibility::GetFromUniqueID(unique_id));
+  BrowserAccessibilityWin* win_root = ToBrowserAccessibilityWin(root);
+
+  ui::AXPlatformNode* node = static_cast<ui::AXPlatformNode*>(
+      ui::AXPlatformNodeWin::GetFromUniqueId(GetUniqueId(win_root)));
+
+  ui::AXPlatformNode* other_node =
+      static_cast<ui::AXPlatformNode*>(win_root->GetCOM());
+  ASSERT_EQ(node, other_node);
 }
 
 TEST_F(BrowserAccessibilityTest, TestIA2Attributes) {
   ui::AXNodeData pseudo_before;
   pseudo_before.id = 2;
   pseudo_before.role = ui::AX_ROLE_GENERIC_CONTAINER;
   pseudo_before.AddStringAttribute(ui::AX_ATTR_HTML_TAG, "<pseudo:before>");
   pseudo_before.AddStringAttribute(ui::AX_ATTR_DISPLAY, "none");
 
   ui::AXNodeData checkbox;
@@ skipping 1434 matching lines @@
   ui::AXNodeData child_node;
   child_node.id = 2;
   root_node.child_ids.push_back(2);
 
   std::unique_ptr<BrowserAccessibilityManagerWin> manager(
       new BrowserAccessibilityManagerWin(
           MakeAXTreeUpdate(root_node, child_node), nullptr,
           new BrowserAccessibilityFactory()));
 
   BrowserAccessibility* root = manager->GetRoot();
-  int32_t root_unique_id = root->unique_id();
+  int32_t root_unique_id = GetUniqueId(root);
   BrowserAccessibility* child = root->PlatformGetChild(0);
-  int32_t child_unique_id = child->unique_id();
+  int32_t child_unique_id = GetUniqueId(child);
 
   // Now destroy that original tree and create a new tree.
   manager.reset(new BrowserAccessibilityManagerWin(
       MakeAXTreeUpdate(root_node, child_node), nullptr,
       new BrowserAccessibilityFactory()));
   root = manager->GetRoot();
-  int32_t root_unique_id_2 = root->unique_id();
+  int32_t root_unique_id_2 = GetUniqueId(root);
   child = root->PlatformGetChild(0);
-  int32_t child_unique_id_2 = child->unique_id();
+  int32_t child_unique_id_2 = GetUniqueId(child);
 
   // The nodes in the new tree should not have the same ids.
   EXPECT_NE(root_unique_id, root_unique_id_2);
   EXPECT_NE(child_unique_id, child_unique_id_2);
 
   // Trying to access the unique IDs of the old, deleted objects should fail.
   base::win::ScopedVariant old_root_variant(-root_unique_id);
   base::win::ScopedComPtr<IDispatch> old_root_dispatch;
   HRESULT hr = ToBrowserAccessibilityWin(root)->GetCOM()->get_accChild(
       old_root_variant, old_root_dispatch.GetAddressOf());
@@ skipping 29 matching lines @@
   root_node.child_ids.push_back(2);
 
   std::unique_ptr<BrowserAccessibilityManagerWin> manager(
       new BrowserAccessibilityManagerWin(
           MakeAXTreeUpdate(root_node, child_node), nullptr,
           new BrowserAccessibilityFactory()));
 
   BrowserAccessibility* root = manager->GetRoot();
   BrowserAccessibility* child = root->PlatformGetChild(0);
 
-  base::win::ScopedVariant root_unique_id_variant(-root->unique_id());
+  base::win::ScopedVariant root_unique_id_variant(-GetUniqueId(root));
   base::win::ScopedComPtr<IDispatch> result;
   EXPECT_EQ(E_INVALIDARG,
             ToBrowserAccessibilityWin(child)->GetCOM()->get_accChild(
                 root_unique_id_variant, result.GetAddressOf()));
 
-  base::win::ScopedVariant child_unique_id_variant(-child->unique_id());
+  base::win::ScopedVariant child_unique_id_variant(-GetUniqueId(child));
   EXPECT_EQ(S_OK, ToBrowserAccessibilityWin(root)->GetCOM()->get_accChild(
                       child_unique_id_variant, result.GetAddressOf()));
 }
 
 TEST_F(BrowserAccessibilityTest, TestIAccessible2Relations) {
   ui::AXNodeData root;
   root.id = 1;
   root.role = ui::AX_ROLE_ROOT_WEB_AREA;
   // Reflexive relations should be ignored.
   std::vector<int32_t> describedby_ids = {1, 2, 3};
@@ skipping 43 matching lines @@
   EXPECT_EQ(L"describedBy", base::string16(relation_type));
   relation_type.Reset();
 
   EXPECT_HRESULT_SUCCEEDED(describedby_relation->get_nTargets(&n_targets));
   EXPECT_EQ(2, n_targets);
 
   EXPECT_HRESULT_SUCCEEDED(
       describedby_relation->get_target(0, target.GetAddressOf()));
   target.CopyTo(ax_target.GetAddressOf());
   EXPECT_HRESULT_SUCCEEDED(ax_target->get_uniqueID(&unique_id));
-  EXPECT_EQ(-ax_child1->unique_id(), unique_id);
+  EXPECT_EQ(-GetUniqueId(ax_child1), unique_id);
   ax_target.Reset();
   target.Reset();
 
   EXPECT_HRESULT_SUCCEEDED(
       describedby_relation->get_target(1, target.GetAddressOf()));
   target.CopyTo(ax_target.GetAddressOf());
   EXPECT_HRESULT_SUCCEEDED(ax_target->get_uniqueID(&unique_id));
-  EXPECT_EQ(-ax_child2->unique_id(), unique_id);
+  EXPECT_EQ(-GetUniqueId(ax_child2), unique_id);
   ax_target.Reset();
   target.Reset();
   describedby_relation.Reset();
 
   // Test the reverse relations.
   EXPECT_HRESULT_SUCCEEDED(ax_child1->GetCOM()->get_nRelations(&n_relations));
   EXPECT_EQ(1, n_relations);
 
   EXPECT_HRESULT_SUCCEEDED(ax_child1->GetCOM()->get_relation(
       0, description_for_relation.GetAddressOf()));
   EXPECT_HRESULT_SUCCEEDED(
       description_for_relation->get_relationType(relation_type.Receive()));
   EXPECT_EQ(L"descriptionFor", base::string16(relation_type));
   relation_type.Reset();
 
   EXPECT_HRESULT_SUCCEEDED(description_for_relation->get_nTargets(&n_targets));
   EXPECT_EQ(1, n_targets);
 
   EXPECT_HRESULT_SUCCEEDED(
       description_for_relation->get_target(0, target.GetAddressOf()));
   target.CopyTo(ax_target.GetAddressOf());
   EXPECT_HRESULT_SUCCEEDED(ax_target->get_uniqueID(&unique_id));
-  EXPECT_EQ(-ax_root->unique_id(), unique_id);
+  EXPECT_EQ(-GetUniqueId(ax_root), unique_id);
   ax_target.Reset();
   target.Reset();
   description_for_relation.Reset();
 
   EXPECT_HRESULT_SUCCEEDED(ax_child2->GetCOM()->get_nRelations(&n_relations));
   EXPECT_EQ(1, n_relations);
 
   EXPECT_HRESULT_SUCCEEDED(ax_child2->GetCOM()->get_relation(
       0, description_for_relation.GetAddressOf()));
   EXPECT_HRESULT_SUCCEEDED(
       description_for_relation->get_relationType(relation_type.Receive()));
   EXPECT_EQ(L"descriptionFor", base::string16(relation_type));
   relation_type.Reset();
 
   EXPECT_HRESULT_SUCCEEDED(description_for_relation->get_nTargets(&n_targets));
   EXPECT_EQ(1, n_targets);
 
   EXPECT_HRESULT_SUCCEEDED(
       description_for_relation->get_target(0, target.GetAddressOf()));
   target.CopyTo(ax_target.GetAddressOf());
   EXPECT_HRESULT_SUCCEEDED(ax_target->get_uniqueID(&unique_id));
-  EXPECT_EQ(-ax_root->unique_id(), unique_id);
+  EXPECT_EQ(-GetUniqueId(ax_root), unique_id);
   ax_target.Reset();
   target.Reset();
 
   // Try adding one more relation.
   std::vector<int32_t> labelledby_ids = {3};
   child1.AddIntListAttribute(ui::AX_ATTR_LABELLEDBY_IDS, labelledby_ids);
   AXEventNotificationDetails event;
   event.event_type = ui::AX_EVENT_ARIA_ATTRIBUTE_CHANGED;
   event.update.nodes.push_back(child1);
   event.id = child1.id;
   std::vector<AXEventNotificationDetails> events = {event};
   manager->OnAccessibilityEvents(events);
 
   EXPECT_HRESULT_SUCCEEDED(ax_child1->GetCOM()->get_nRelations(&n_relations));
   EXPECT_EQ(2, n_relations);
   EXPECT_HRESULT_SUCCEEDED(ax_child2->GetCOM()->get_nRelations(&n_relations));
   EXPECT_EQ(2, n_relations);
 }
 
 }  // namespace content