De-templatize ui::AXPosition

ui/accessibility/ax_node_position_unittest.cc

 // Copyright 2016 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 <stdint.h>
 
 #include <memory>
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/callback.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/accessibility/ax_enums.h"
 #include "ui/accessibility/ax_node.h"
 #include "ui/accessibility/ax_node_data.h"
 #include "ui/accessibility/ax_node_position.h"
 #include "ui/accessibility/ax_range.h"
 #include "ui/accessibility/ax_serializable_tree.h"
 #include "ui/accessibility/ax_tree_serializer.h"
 #include "ui/accessibility/ax_tree_update.h"
 
 namespace ui {
 
-using TestPositionType = std::unique_ptr<AXPosition<AXNodePosition, AXNode>>;
+using ConcretePositionType =
+    std::unique_ptr<AXPosition<AXNodePosition, AXNode>>;
+using TestPositionType = std::unique_ptr<AXPositionBase>;
 
 namespace {
 
 int32_t ROOT_ID = 1;
 int32_t BUTTON_ID = 2;
 int32_t CHECK_BOX_ID = 3;
 int32_t TEXT_FIELD_ID = 4;
 int32_t STATIC_TEXT1_ID = 5;
 int32_t INLINE_BOX1_ID = 6;
 int32_t LINE_BREAK_ID = 7;
@@ skipping 165 matching lines @@
   AXTreeUpdate update;
   serializer.SerializeChanges(src_tree.root(), &update);
   ASSERT_TRUE(tree_.Unserialize(update));
   AXNodePosition::SetTreeForTesting(&tree_);
 }
 
 void AXPositionTest::TearDown() {
   AXNodePosition::SetTreeForTesting(nullptr);
 }
 
+TestPositionType AsBase(ConcretePositionType concrete) {
+  return base::WrapUnique<AXPositionBase>(concrete.release());
+}
+
+TestPositionType CreateNullPosition() {
+  return AsBase(AXNodePosition::CreateConcreteNullPosition());
+}
+
+TestPositionType CreateTreePosition(int tree_id,
+                                    int32_t anchor_id,
+                                    int child_index) {
+  return AsBase(AXNodePosition::CreateConcreteTreePosition(tree_id, anchor_id,
+                                                           child_index));
+}
+
+TestPositionType CreateTextPosition(int tree_id,
+                                    int32_t anchor_id,
+                                    int text_offset,
+                                    AXTextAffinity affinity) {
+  return AsBase(AXNodePosition::CreateConcreteTextPosition(
+      tree_id, anchor_id, text_offset, affinity));
+}
+
 }  // namespace
 
 TEST_F(AXPositionTest, Clone) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   TestPositionType copy_position = null_position->Clone();
   ASSERT_NE(nullptr, copy_position);
   EXPECT_TRUE(copy_position->IsNullPosition());
 
-  TestPositionType tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 1 /* child_index */);
+  TestPositionType tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 1 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   copy_position = tree_position->Clone();
   ASSERT_NE(nullptr, copy_position);
   EXPECT_TRUE(copy_position->IsTreePosition());
   EXPECT_EQ(root_.id, copy_position->anchor_id());
   EXPECT_EQ(1, copy_position->child_index());
   EXPECT_EQ(AXNodePosition::INVALID_OFFSET, copy_position->text_offset());
 
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, AXNodePosition::BEFORE_TEXT);
+  tree_position = CreateTreePosition(tree_.data().tree_id, root_.id,
+                                     AXNodePosition::BEFORE_TEXT);
   ASSERT_NE(nullptr, tree_position);
   copy_position = tree_position->Clone();
   ASSERT_NE(nullptr, copy_position);
   EXPECT_TRUE(copy_position->IsTreePosition());
   EXPECT_EQ(root_.id, copy_position->anchor_id());
   EXPECT_EQ(AXNodePosition::BEFORE_TEXT, copy_position->child_index());
   EXPECT_EQ(AXNodePosition::INVALID_OFFSET, copy_position->text_offset());
 
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, text_field_.id, 1 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, text_field_.id,
+                         1 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position);
   copy_position = text_position->Clone();
   ASSERT_NE(nullptr, copy_position);
   EXPECT_TRUE(copy_position->IsTextPosition());
   EXPECT_EQ(text_field_.id, copy_position->anchor_id());
   EXPECT_EQ(1, copy_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_UPSTREAM, copy_position->affinity());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, text_field_.id, 1 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, text_field_.id,
+                         1 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   copy_position = text_position->Clone();
   ASSERT_NE(nullptr, copy_position);
   EXPECT_TRUE(copy_position->IsTextPosition());
   EXPECT_EQ(text_field_.id, copy_position->anchor_id());
   EXPECT_EQ(1, copy_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, copy_position->affinity());
   EXPECT_EQ(AXNodePosition::INVALID_INDEX, copy_position->child_index());
 }
 
 TEST_F(AXPositionTest, AtStartOfAnchorWithNullPosition) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   EXPECT_FALSE(null_position->AtStartOfAnchor());
 }
 
 TEST_F(AXPositionTest, AtStartOfAnchorWithTreePosition) {
-  TestPositionType tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 0 /* child_index */);
+  TestPositionType tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 0 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   EXPECT_TRUE(tree_position->AtStartOfAnchor());
 
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 1 /* child_index */);
+  tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 1 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   EXPECT_FALSE(tree_position->AtStartOfAnchor());
 
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 3 /* child_index */);
+  tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 3 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   EXPECT_FALSE(tree_position->AtStartOfAnchor());
 
   // A "before text" position.
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, inline_box1_.id, AXNodePosition::BEFORE_TEXT);
+  tree_position = CreateTreePosition(tree_.data().tree_id, inline_box1_.id,
+                                     AXNodePosition::BEFORE_TEXT);
   ASSERT_NE(nullptr, tree_position);
   EXPECT_TRUE(tree_position->AtStartOfAnchor());
 
   // An "after text" position.
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* child_index */);
+  tree_position = CreateTreePosition(tree_.data().tree_id, inline_box1_.id,
+                                     0 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   EXPECT_FALSE(tree_position->AtStartOfAnchor());
 }
 
 TEST_F(AXPositionTest, AtStartOfAnchorWithTextPosition) {
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_TRUE(text_position->AtStartOfAnchor());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 1 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         1 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_FALSE(text_position->AtStartOfAnchor());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 6 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         6 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_FALSE(text_position->AtStartOfAnchor());
 }
 
 TEST_F(AXPositionTest, AtEndOfAnchorWithNullPosition) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   EXPECT_FALSE(null_position->AtEndOfAnchor());
 }
 
 TEST_F(AXPositionTest, AtEndOfAnchorWithTreePosition) {
-  TestPositionType tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 3 /* child_index */);
+  TestPositionType tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 3 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   EXPECT_TRUE(tree_position->AtEndOfAnchor());
 
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 2 /* child_index */);
+  tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 2 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   EXPECT_FALSE(tree_position->AtEndOfAnchor());
 
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 0 /* child_index */);
+  tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 0 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   EXPECT_FALSE(tree_position->AtEndOfAnchor());
 }
 
 TEST_F(AXPositionTest, AtEndOfAnchorWithTextPosition) {
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 6 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         6 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_TRUE(text_position->AtEndOfAnchor());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 5 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         5 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_FALSE(text_position->AtEndOfAnchor());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_FALSE(text_position->AtEndOfAnchor());
 }
 
 TEST_F(AXPositionTest, AtStartOfLineWithTextPosition) {
   // An upstream affinity should not affect the outcome since there is no soft
   // line break.
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_TRUE(text_position->AtStartOfLine());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 1 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         1 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_FALSE(text_position->AtStartOfLine());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, line_break_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, line_break_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_FALSE(text_position->AtStartOfLine());
 
   // An "after text" position anchored at the line break should visually be the
   // same as a text position at the start of the next line.
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, line_break_.id, 1 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, line_break_.id,
+                         1 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_TRUE(text_position->AtStartOfLine());
 
   // An upstream affinity should not affect the outcome since there is no soft
   // line break.
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box2_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box2_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_TRUE(text_position->AtStartOfLine());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box2_.id, 1 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box2_.id,
+                         1 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_FALSE(text_position->AtStartOfLine());
 }
 
 TEST_F(AXPositionTest, AtEndOfLineWithTextPosition) {
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 5 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         5 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_FALSE(text_position->AtEndOfLine());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 6 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         6 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_TRUE(text_position->AtEndOfLine());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, line_break_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, line_break_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_FALSE(text_position->AtEndOfLine());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box2_.id, 5 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box2_.id,
+                         5 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_FALSE(text_position->AtEndOfLine());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box2_.id, 6 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box2_.id,
+                         6 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   EXPECT_TRUE(text_position->AtEndOfLine());
 }
 
 TEST_F(AXPositionTest, LowestCommonAncestor) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   // An "after children" position.
-  TestPositionType root_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 3 /* child_index */);
+  TestPositionType root_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 3 /* child_index */);
   ASSERT_NE(nullptr, root_position);
   // A "before text" position.
-  TestPositionType button_position = AXNodePosition::CreateTreePosition(
+  TestPositionType button_position = CreateTreePosition(
       tree_.data().tree_id, button_.id, AXNodePosition::BEFORE_TEXT);
   ASSERT_NE(nullptr, button_position);
-  TestPositionType text_field_position = AXNodePosition::CreateTreePosition(
+  TestPositionType text_field_position = CreateTreePosition(
       tree_.data().tree_id, text_field_.id, 2 /* child_index */);
   ASSERT_NE(nullptr, text_field_position);
-  TestPositionType static_text1_position = AXNodePosition::CreateTreePosition(
+  TestPositionType static_text1_position = CreateTreePosition(
       tree_.data().tree_id, static_text1_.id, 0 /* child_index */);
   ASSERT_NE(nullptr, static_text1_position);
-  TestPositionType static_text2_position = AXNodePosition::CreateTreePosition(
+  TestPositionType static_text2_position = CreateTreePosition(
       tree_.data().tree_id, static_text2_.id, 0 /* child_index */);
   ASSERT_NE(nullptr, static_text2_position);
-  TestPositionType inline_box1_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType inline_box1_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, inline_box1_position);
-  TestPositionType inline_box2_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box2_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  TestPositionType inline_box2_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box2_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, inline_box2_position);
 
   TestPositionType test_position =
       root_position->LowestCommonAncestor(*null_position.get());
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 
   test_position = root_position->LowestCommonAncestor(*root_position.get());
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTreePosition());
@@ skipping 36 matching lines @@
   test_position =
       inline_box2_position->LowestCommonAncestor(*inline_box1_position.get());
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(text_field_.id, test_position->anchor_id());
   // The text offset should point to the second line.
   EXPECT_EQ(7, test_position->text_offset());
 }
 
 TEST_F(AXPositionTest, AsTreePositionWithNullPosition) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   TestPositionType test_position = null_position->AsTreePosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, AsTreePositionWithTreePosition) {
-  TestPositionType tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 1 /* child_index */);
+  TestPositionType tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 1 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   TestPositionType test_position = tree_position->AsTreePosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTreePosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(root_.id, test_position->anchor_id());
   EXPECT_EQ(1, test_position->child_index());
   EXPECT_EQ(AXNodePosition::INVALID_OFFSET, test_position->text_offset());
 }
 
 TEST_F(AXPositionTest, AsTreePositionWithTextPosition) {
   // Create a text position pointing to the last character in the text field.
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, text_field_.id, 12 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, text_field_.id,
+                         12 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   TestPositionType test_position = text_position->AsTreePosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTreePosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(text_field_.id, test_position->anchor_id());
   // The created tree position should point to the second static text node
   // inside the text field.
   EXPECT_EQ(2, test_position->child_index());
   // But its text offset should be unchanged.
   EXPECT_EQ(12, test_position->text_offset());
 
   // Test for a "before text" position.
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box2_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box2_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->AsTreePosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTreePosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(inline_box2_.id, test_position->anchor_id());
   EXPECT_EQ(AXNodePosition::BEFORE_TEXT, test_position->child_index());
   EXPECT_EQ(0, test_position->text_offset());
 
   // Test for an "after text" position.
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box2_.id, 6 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box2_.id,
+                         6 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->AsTreePosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTreePosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(inline_box2_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->child_index());
   EXPECT_EQ(6, test_position->text_offset());
 }
 
 TEST_F(AXPositionTest, AsTextPositionWithNullPosition) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   TestPositionType test_position = null_position->AsTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, AsTextPositionWithTreePosition) {
   // Create a tree position pointing to the line break node inside the text
   // field.
-  TestPositionType tree_position = AXNodePosition::CreateTreePosition(
+  TestPositionType tree_position = CreateTreePosition(
       tree_.data().tree_id, text_field_.id, 1 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   TestPositionType test_position = tree_position->AsTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(text_field_.id, test_position->anchor_id());
   // The created text position should point to the 6th character inside the text
   // field, i.e. the line break.
   EXPECT_EQ(6, test_position->text_offset());
   // But its child index should be unchanged.
   EXPECT_EQ(1, test_position->child_index());
 
   // Test for a "before text" position.
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, inline_box1_.id, AXNodePosition::BEFORE_TEXT);
+  tree_position = CreateTreePosition(tree_.data().tree_id, inline_box1_.id,
+                                     AXNodePosition::BEFORE_TEXT);
   ASSERT_NE(nullptr, tree_position);
   test_position = tree_position->AsTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
   EXPECT_EQ(AXNodePosition::BEFORE_TEXT, test_position->child_index());
 
   // Test for an "after text" position.
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* child_index */);
+  tree_position = CreateTreePosition(tree_.data().tree_id, inline_box1_.id,
+                                     0 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   test_position = tree_position->AsTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(6, test_position->text_offset());
   EXPECT_EQ(0, test_position->child_index());
 }
 
 TEST_F(AXPositionTest, AsTextPositionWithTextPosition) {
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, text_field_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, text_field_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   TestPositionType test_position = text_position->AsTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(text_field_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, test_position->affinity());
   EXPECT_EQ(AXNodePosition::INVALID_INDEX, test_position->child_index());
 }
 
 TEST_F(AXPositionTest, AsLeafTextPositionWithNullPosition) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   TestPositionType test_position = null_position->AsLeafTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, AsLeafTextPositionWithTreePosition) {
   // Create a tree position pointing to the first static text node inside the
   // text field.
-  TestPositionType tree_position = AXNodePosition::CreateTreePosition(
+  TestPositionType tree_position = CreateTreePosition(
       tree_.data().tree_id, text_field_.id, 0 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   TestPositionType test_position = tree_position->AsLeafTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, test_position->affinity());
 
   // Create a tree position pointing to the line break node inside the text
   // field.
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, text_field_.id, 1 /* child_index */);
+  tree_position = CreateTreePosition(tree_.data().tree_id, text_field_.id,
+                                     1 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   test_position = tree_position->AsLeafTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(line_break_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, test_position->affinity());
 
   // Create a text position pointing to the second static text node inside the
   // text field.
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, text_field_.id, 2 /* child_index */);
+  tree_position = CreateTreePosition(tree_.data().tree_id, text_field_.id,
+                                     2 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   test_position = tree_position->AsLeafTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(inline_box2_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, test_position->affinity());
 }
 
 TEST_F(AXPositionTest, AsLeafTextPositionWithTextPosition) {
   // Create a text position pointing to the end of the root (an "after text"
   // position).
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, root_.id, 28 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, root_.id, 28 /* text_offset */,
+                         AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   TestPositionType test_position = text_position->AsLeafTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(inline_box2_.id, test_position->anchor_id());
   EXPECT_EQ(6, test_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, test_position->affinity());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, text_field_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, text_field_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->AsLeafTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, test_position->affinity());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, text_field_.id, 1 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, text_field_.id,
+                         1 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->AsLeafTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(1, test_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_UPSTREAM, test_position->affinity());
 
   // Create a text position pointing to the line break character inside the text
   // field.
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, text_field_.id, 6 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, text_field_.id,
+                         6 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->AsLeafTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(line_break_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_UPSTREAM, test_position->affinity());
 
   // Create a text position pointing to the offset after the last character in
   // the text field, (an "after text" position).
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, text_field_.id, 13 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, text_field_.id,
+                         13 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->AsLeafTextPosition();
   ASSERT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(inline_box2_.id, test_position->anchor_id());
   EXPECT_EQ(6, test_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, test_position->affinity());
 }
 
 TEST_F(AXPositionTest, CreatePositionAtStartOfAnchorWithNullPosition) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   TestPositionType test_position =
       null_position->CreatePositionAtStartOfAnchor();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, CreatePositionAtStartOfAnchorWithTreePosition) {
-  TestPositionType tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 0 /* child_index */);
+  TestPositionType tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 0 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   TestPositionType test_position =
       tree_position->CreatePositionAtStartOfAnchor();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTreePosition());
   EXPECT_EQ(root_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->child_index());
 
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 1 /* child_index */);
+  tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 1 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   test_position = tree_position->CreatePositionAtStartOfAnchor();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTreePosition());
   EXPECT_EQ(root_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->child_index());
 
   // An "after text" position.
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* child_index */);
+  tree_position = CreateTreePosition(tree_.data().tree_id, inline_box1_.id,
+                                     0 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   test_position = tree_position->CreatePositionAtStartOfAnchor();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTreePosition());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(AXNodePosition::BEFORE_TEXT, test_position->child_index());
 }
 
 TEST_F(AXPositionTest, CreatePositionAtStartOfAnchorWithTextPosition) {
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   TestPositionType test_position =
       text_position->CreatePositionAtStartOfAnchor();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, test_position->affinity());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 1 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         1 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->CreatePositionAtStartOfAnchor();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
   // Affinity should have been reset to the default value.
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, test_position->affinity());
 }
 
 TEST_F(AXPositionTest, CreatePositionAtEndOfAnchorWithNullPosition) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   TestPositionType test_position = null_position->CreatePositionAtEndOfAnchor();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, CreatePositionAtEndOfAnchorWithTreePosition) {
-  TestPositionType tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 3 /* child_index */);
+  TestPositionType tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 3 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   TestPositionType test_position = tree_position->CreatePositionAtEndOfAnchor();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTreePosition());
   EXPECT_EQ(root_.id, test_position->anchor_id());
   EXPECT_EQ(3, test_position->child_index());
 
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 1 /* child_index */);
+  tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 1 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   test_position = tree_position->CreatePositionAtEndOfAnchor();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTreePosition());
   EXPECT_EQ(root_.id, test_position->anchor_id());
   EXPECT_EQ(3, test_position->child_index());
 }
 
 TEST_F(AXPositionTest, CreatePositionAtEndOfAnchorWithTextPosition) {
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 6 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         6 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   TestPositionType test_position = text_position->CreatePositionAtEndOfAnchor();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(6, test_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, test_position->affinity());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 5 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         5 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->CreatePositionAtEndOfAnchor();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(6, test_position->text_offset());
   // Affinity should have been reset to the default value.
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, test_position->affinity());
 }
 
 TEST_F(AXPositionTest, CreateChildPositionAtWithNullPosition) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   TestPositionType test_position = null_position->CreateChildPositionAt(0);
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, CreateChildPositionAtWithTreePosition) {
-  TestPositionType tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 2 /* child_index */);
+  TestPositionType tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 2 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   TestPositionType test_position = tree_position->CreateChildPositionAt(1);
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTreePosition());
   EXPECT_EQ(check_box_.id, test_position->anchor_id());
   // Since the anchor is a leaf node, |child_index| should signify that this is
   // a "before text" position.
   EXPECT_EQ(AXNodePosition::BEFORE_TEXT, test_position->child_index());
 
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, button_.id, 0 /* child_index */);
+  tree_position =
+      CreateTreePosition(tree_.data().tree_id, button_.id, 0 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   test_position = tree_position->CreateChildPositionAt(0);
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, CreateChildPositionAtWithTextPosition) {
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, static_text1_.id, 5 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, static_text1_.id,
+                         5 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   TestPositionType test_position = text_position->CreateChildPositionAt(0);
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, static_text2_.id, 4 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, static_text2_.id,
+                         4 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->CreateChildPositionAt(1);
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, CreateParentPositionWithNullPosition) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   TestPositionType test_position = null_position->CreateParentPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, CreateParentPositionWithTreePosition) {
-  TestPositionType tree_position = AXNodePosition::CreateTreePosition(
+  TestPositionType tree_position = CreateTreePosition(
       tree_.data().tree_id, check_box_.id, 0 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   TestPositionType test_position = tree_position->CreateParentPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTreePosition());
   EXPECT_EQ(root_.id, test_position->anchor_id());
   // |child_index| should point to the check box node.
   EXPECT_EQ(1, test_position->child_index());
 
-  tree_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 1 /* child_index */);
+  tree_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 1 /* child_index */);
   ASSERT_NE(nullptr, tree_position);
   test_position = tree_position->CreateParentPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, CreateParentPositionWithTextPosition) {
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box2_.id, 5 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box2_.id,
+                         5 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   TestPositionType test_position = text_position->CreateParentPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(static_text2_.id, test_position->anchor_id());
   EXPECT_EQ(5, test_position->text_offset());
 
   test_position = test_position->CreateParentPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(text_field_.id, test_position->anchor_id());
   // |text_offset| should point to the same offset on the second line where the
   // static text node position was pointing at.
   EXPECT_EQ(12, test_position->text_offset());
 }
 
 TEST_F(AXPositionTest,
        CreateNextAndPreviousTextAnchorPositionWithNullPosition) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   TestPositionType test_position =
       null_position->CreateNextTextAnchorPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
   test_position = null_position->CreatePreviousTextAnchorPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, CreateNextTextAnchorPosition) {
-  TestPositionType check_box_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 1 /* child_index */);
+  TestPositionType check_box_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 1 /* child_index */);
   ASSERT_NE(nullptr, check_box_position);
   TestPositionType test_position =
       check_box_position->CreateNextTextAnchorPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(check_box_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 
   // The text offset on the root points to the text coming from inside the check
   // box.
-  check_box_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, root_.id, 6 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  check_box_position =
+      CreateTextPosition(tree_.data().tree_id, root_.id, 6 /* text_offset */,
+                         AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, check_box_position);
   test_position = check_box_position->CreateNextTextAnchorPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(check_box_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 
-  TestPositionType button_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, button_.id, 1 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType button_position =
+      CreateTextPosition(tree_.data().tree_id, button_.id, 1 /* text_offset */,
+                         AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, button_position);
   test_position = button_position->CreateNextTextAnchorPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(check_box_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 
   test_position = test_position->CreateNextTextAnchorPosition();
   EXPECT_NE(nullptr, test_position);
@@ skipping 13 matching lines @@
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(inline_box2_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 
   test_position = test_position->CreateNextTextAnchorPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 
-  TestPositionType text_field_position = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 2 /* child_index */);
+  TestPositionType text_field_position =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 2 /* child_index */);
   ASSERT_NE(nullptr, text_field_position);
   test_position = text_field_position->CreateNextTextAnchorPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 }
 
 TEST_F(AXPositionTest, CreatePreviousTextAnchorPosition) {
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box2_.id, 5 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box2_.id,
+                         5 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   TestPositionType test_position =
       text_position->CreatePreviousTextAnchorPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(line_break_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 
   // Create a "before text" tree position on the second line of the text box.
-  TestPositionType before_text_position = AXNodePosition::CreateTreePosition(
+  TestPositionType before_text_position = CreateTreePosition(
       tree_.data().tree_id, inline_box2_.id, AXNodePosition::BEFORE_TEXT);
   ASSERT_NE(nullptr, before_text_position);
   test_position = before_text_position->CreatePreviousTextAnchorPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(line_break_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 
   test_position = test_position->CreatePreviousTextAnchorPosition();
@@ skipping 14 matching lines @@
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(button_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 
   test_position = test_position->CreatePreviousTextAnchorPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 
-  TestPositionType text_field_position = AXNodePosition::CreateTreePosition(
+  TestPositionType text_field_position = CreateTreePosition(
       tree_.data().tree_id, text_field_.id, 2 /* child_index */);
   ASSERT_NE(nullptr, text_field_position);
   test_position = text_field_position->CreatePreviousTextAnchorPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(check_box_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 
   // The text offset on the root points to the text coming from inside the check
   // box.
-  TestPositionType check_box_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, check_box_.id, 6 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType check_box_position =
+      CreateTextPosition(tree_.data().tree_id, check_box_.id,
+                         6 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, check_box_position);
   test_position = check_box_position->CreatePreviousTextAnchorPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(tree_.data().tree_id, test_position->tree_id());
   EXPECT_EQ(button_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 }
 
 TEST_F(AXPositionTest, CreateNextAndPreviousCharacterPositionWithNullPosition) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   TestPositionType test_position = null_position->CreateNextCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
   test_position = null_position->CreatePreviousCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, CreateNextCharacterPosition) {
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 4 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         4 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   TestPositionType test_position = text_position->CreateNextCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(5, test_position->text_offset());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 5 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         5 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->CreateNextCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(line_break_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 
   test_position = test_position->CreateNextCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(inline_box2_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 
   test_position = test_position->CreateNextCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(inline_box2_.id, test_position->anchor_id());
   EXPECT_EQ(1, test_position->text_offset());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, check_box_.id, 9 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, check_box_.id,
+                         9 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->CreateNextCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, text_field_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, text_field_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->CreateNextCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(text_field_.id, test_position->anchor_id());
   EXPECT_EQ(1, test_position->text_offset());
   // Affinity should have been reset to downstream.
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, test_position->affinity());
 }
 
 TEST_F(AXPositionTest, CreatePreviousCharacterPosition) {
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box2_.id, 5 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box2_.id,
+                         5 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   TestPositionType test_position =
       text_position->CreatePreviousCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(inline_box2_.id, test_position->anchor_id());
   EXPECT_EQ(4, test_position->text_offset());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box2_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box2_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->CreatePreviousCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(line_break_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
 
   test_position = test_position->CreatePreviousCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(5, test_position->text_offset());
 
   test_position = test_position->CreatePreviousCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(inline_box1_.id, test_position->anchor_id());
   EXPECT_EQ(4, test_position->text_offset());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->CreatePreviousCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(check_box_.id, test_position->anchor_id());
   EXPECT_EQ(8, test_position->text_offset());
 
-  text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, text_field_.id, 1 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position =
+      CreateTextPosition(tree_.data().tree_id, text_field_.id,
+                         1 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position);
   test_position = text_position->CreatePreviousCharacterPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsTextPosition());
   EXPECT_EQ(text_field_.id, test_position->anchor_id());
   EXPECT_EQ(0, test_position->text_offset());
   EXPECT_EQ(AX_TEXT_AFFINITY_DOWNSTREAM, test_position->affinity());
 }
 
 TEST_F(AXPositionTest, CreateNextAndPreviousWordStartPositionWithNullPosition) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   TestPositionType test_position = null_position->CreateNextWordStartPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
   test_position = null_position->CreatePreviousWordStartPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, CreateNextAndPreviousWordEndPositionWithNullPosition) {
-  TestPositionType null_position = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position = CreateNullPosition();
   ASSERT_NE(nullptr, null_position);
   TestPositionType test_position = null_position->CreateNextWordEndPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
   test_position = null_position->CreatePreviousWordEndPosition();
   EXPECT_NE(nullptr, test_position);
   EXPECT_TRUE(test_position->IsNullPosition());
 }
 
 TEST_F(AXPositionTest, OperatorEquals) {
-  TestPositionType null_position1 = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position1 = CreateNullPosition();
   ASSERT_NE(nullptr, null_position1);
-  TestPositionType null_position2 = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position2 = CreateNullPosition();
   ASSERT_NE(nullptr, null_position2);
   EXPECT_EQ(*null_position1, *null_position2);
 
   // Child indices must match.
-  TestPositionType button_position1 = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 0 /* child_index */);
+  TestPositionType button_position1 =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 0 /* child_index */);
   ASSERT_NE(nullptr, button_position1);
-  TestPositionType button_position2 = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 0 /* child_index */);
+  TestPositionType button_position2 =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 0 /* child_index */);
   ASSERT_NE(nullptr, button_position2);
   EXPECT_EQ(*button_position1, *button_position2);
 
   // Both child indices are invalid. It should result in equivalent null
   // positions.
-  TestPositionType tree_position1 = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 4 /* child_index */);
+  TestPositionType tree_position1 =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 4 /* child_index */);
   ASSERT_NE(nullptr, tree_position1);
-  TestPositionType tree_position2 = AXNodePosition::CreateTreePosition(
+  TestPositionType tree_position2 = CreateTreePosition(
       tree_.data().tree_id, root_.id, AXNodePosition::INVALID_INDEX);
   ASSERT_NE(nullptr, tree_position2);
   EXPECT_EQ(*tree_position1, *tree_position2);
 
   // An invalid position should not be equivalent to an "after children"
   // position.
-  tree_position1 = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 3 /* child_index */);
+  tree_position1 =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 3 /* child_index */);
   ASSERT_NE(nullptr, tree_position1);
-  tree_position2 = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, -1 /* child_index */);
+  tree_position2 =
+      CreateTreePosition(tree_.data().tree_id, root_.id, -1 /* child_index */);
   ASSERT_NE(nullptr, tree_position2);
   EXPECT_NE(*tree_position1, *tree_position2);
 
   // Two "after children" positions on the same node should be equivalent.
-  tree_position1 = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, text_field_.id, 3 /* child_index */);
+  tree_position1 = CreateTreePosition(tree_.data().tree_id, text_field_.id,
+                                      3 /* child_index */);
   ASSERT_NE(nullptr, tree_position1);
-  tree_position2 = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, text_field_.id, 3 /* child_index */);
+  tree_position2 = CreateTreePosition(tree_.data().tree_id, text_field_.id,
+                                      3 /* child_index */);
   ASSERT_NE(nullptr, tree_position2);
   EXPECT_EQ(*tree_position1, *tree_position2);
 
   // Two "before text" positions on the same node should be equivalent.
-  tree_position1 = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, inline_box1_.id, AXNodePosition::BEFORE_TEXT);
+  tree_position1 = CreateTreePosition(tree_.data().tree_id, inline_box1_.id,
+                                      AXNodePosition::BEFORE_TEXT);
   ASSERT_NE(nullptr, tree_position1);
-  tree_position2 = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, inline_box1_.id, AXNodePosition::BEFORE_TEXT);
+  tree_position2 = CreateTreePosition(tree_.data().tree_id, inline_box1_.id,
+                                      AXNodePosition::BEFORE_TEXT);
   ASSERT_NE(nullptr, tree_position2);
   EXPECT_EQ(*tree_position1, *tree_position2);
 
   // Both text offsets are invalid. It should result in equivalent null
   // positions.
-  TestPositionType text_position1 = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 15 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  TestPositionType text_position1 =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         15 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position1);
-  TestPositionType text_position2 = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, text_field_.id, -1 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  TestPositionType text_position2 =
+      CreateTextPosition(tree_.data().tree_id, text_field_.id,
+                         -1 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position2);
   EXPECT_EQ(*text_position1, *text_position2);
 
-  text_position1 = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position1 =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position1);
-  text_position2 = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  text_position2 =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position2);
   EXPECT_EQ(*text_position1, *text_position2);
 
   // Affinities should match.
-  text_position2 = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position2 =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position2);
   EXPECT_NE(*text_position1, *text_position2);
 
   // Text offsets should match.
-  text_position1 = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 5 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position1 =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         5 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position1);
   EXPECT_NE(*text_position1, *text_position2);
 
   // Two "after text" positions on the same node should be equivalent.
-  text_position1 = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, line_break_.id, 1 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position1 =
+      CreateTextPosition(tree_.data().tree_id, line_break_.id,
+                         1 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position1);
-  text_position2 = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, line_break_.id, 1 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position2 =
+      CreateTextPosition(tree_.data().tree_id, line_break_.id,
+                         1 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position2);
   EXPECT_EQ(*text_position1, *text_position2);
 }
 
 TEST_F(AXPositionTest, OperatorsLessThanAndGreaterThan) {
-  TestPositionType null_position1 = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position1 = CreateNullPosition();
   ASSERT_NE(nullptr, null_position1);
-  TestPositionType null_position2 = AXNodePosition::CreateNullPosition();
+  TestPositionType null_position2 = CreateNullPosition();
   ASSERT_NE(nullptr, null_position2);
   EXPECT_FALSE(*null_position1 < *null_position2);
   EXPECT_FALSE(*null_position1 > *null_position2);
 
-  TestPositionType button_position1 = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 0 /* child_index */);
+  TestPositionType button_position1 =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 0 /* child_index */);
   ASSERT_NE(nullptr, button_position1);
-  TestPositionType button_position2 = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 1 /* child_index */);
+  TestPositionType button_position2 =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 1 /* child_index */);
   ASSERT_NE(nullptr, button_position2);
   EXPECT_LT(*button_position1, *button_position2);
   EXPECT_GT(*button_position2, *button_position1);
 
-  TestPositionType tree_position1 = AXNodePosition::CreateTreePosition(
+  TestPositionType tree_position1 = CreateTreePosition(
       tree_.data().tree_id, text_field_.id, 2 /* child_index */);
   ASSERT_NE(nullptr, tree_position1);
   // An "after children" position.
-  TestPositionType tree_position2 = AXNodePosition::CreateTreePosition(
+  TestPositionType tree_position2 = CreateTreePosition(
       tree_.data().tree_id, text_field_.id, 3 /* child_index */);
   ASSERT_NE(nullptr, tree_position2);
   EXPECT_LT(*tree_position1, *tree_position2);
   EXPECT_GT(*tree_position2, *tree_position1);
 
   // A "before text" position.
-  tree_position1 = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, inline_box1_.id, AXNodePosition::BEFORE_TEXT);
+  tree_position1 = CreateTreePosition(tree_.data().tree_id, inline_box1_.id,
+                                      AXNodePosition::BEFORE_TEXT);
   ASSERT_NE(nullptr, tree_position1);
   // An "after text" position.
-  tree_position2 = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* child_index */);
+  tree_position2 = CreateTreePosition(tree_.data().tree_id, inline_box1_.id,
+                                      0 /* child_index */);
   ASSERT_NE(nullptr, tree_position2);
   EXPECT_LT(*tree_position1, *tree_position2);
   EXPECT_GT(*tree_position2, *tree_position1);
 
-  TestPositionType text_position1 = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 2 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position1 =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         2 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position1);
-  TestPositionType text_position2 = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position2 =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
   ASSERT_NE(nullptr, text_position2);
   EXPECT_GT(*text_position1, *text_position2);
   EXPECT_LT(*text_position2, *text_position1);
 
   // Affinities should not matter.
-  text_position2 = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, inline_box1_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position2 =
+      CreateTextPosition(tree_.data().tree_id, inline_box1_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position2);
   EXPECT_GT(*text_position1, *text_position2);
   EXPECT_LT(*text_position2, *text_position1);
 
   // An "after text" position.
-  text_position1 = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, line_break_.id, 1 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position1 =
+      CreateTextPosition(tree_.data().tree_id, line_break_.id,
+                         1 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position1);
   // A "before text" position.
-  text_position2 = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, line_break_.id, 0 /* text_offset */,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  text_position2 =
+      CreateTextPosition(tree_.data().tree_id, line_break_.id,
+                         0 /* text_offset */, AX_TEXT_AFFINITY_UPSTREAM);
   ASSERT_NE(nullptr, text_position2);
   EXPECT_GT(*text_position1, *text_position2);
   EXPECT_LT(*text_position2, *text_position1);
 }
 
 //
 // Parameterized tests.
 //
 
 TEST_P(AXPositionTestWithParam, TraverseTreeStartingWithAffinityDownstream) {
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, GetParam().start_node_id_, GetParam().start_offset_,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, GetParam().start_node_id_,
+                         GetParam().start_offset_, AX_TEXT_AFFINITY_DOWNSTREAM);
   for (const std::string& expectation : GetParam().expectations) {
     text_position = GetParam().TestMethod.Run(text_position);
     EXPECT_NE(nullptr, text_position);
     EXPECT_EQ(expectation, text_position->ToString());
   }
 }
 
 TEST_P(AXPositionTestWithParam, TraverseTreeStartingWithAffinityUpstream) {
-  TestPositionType text_position = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, GetParam().start_node_id_, GetParam().start_offset_,
-      AX_TEXT_AFFINITY_UPSTREAM);
+  TestPositionType text_position =
+      CreateTextPosition(tree_.data().tree_id, GetParam().start_node_id_,
+                         GetParam().start_offset_, AX_TEXT_AFFINITY_UPSTREAM);
   for (const std::string& expectation : GetParam().expectations) {
     text_position = GetParam().TestMethod.Run(text_position);
     EXPECT_NE(nullptr, text_position);
     EXPECT_EQ(expectation, text_position->ToString());
   }
 }
 
 //
 // Instantiations of parameterized tests.
 //
@@ skipping 484 matching lines @@
 // Tests for |AXRange|.
 //
 
 // TODO(nektar): Move these tests to their own file.
 
 TEST_F(AXPositionTest, AXRangeGetTextWithWholeObjects) {
   base::string16 all_text = base::UTF8ToUTF16("ButtonCheck boxLine 1\nLine 2");
   // Create a range starting from the button object and ending at the last
   // character of the root, i.e. at the last character of the second line in the
   // text field.
-  TestPositionType start = AXNodePosition::CreateTreePosition(
-      tree_.data().tree_id, root_.id, 0 /* child_index */);
-  TestPositionType end = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, root_.id, 28 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
-  AXRange<AXPosition<AXNodePosition, AXNode>> forward_range(start->Clone(),
-                                                            end->Clone());
+  TestPositionType start =
+      CreateTreePosition(tree_.data().tree_id, root_.id, 0 /* child_index */);
+  TestPositionType end =
+      CreateTextPosition(tree_.data().tree_id, root_.id, 28 /* text_offset */,
+                         AX_TEXT_AFFINITY_DOWNSTREAM);
+  ui::AXAbstractRange forward_range(start->Clone(), end->Clone());
   EXPECT_EQ(all_text, forward_range.GetText());
-  AXRange<AXPosition<AXNodePosition, AXNode>> backward_range(std::move(end),
-                                                             std::move(start));
+  ui::AXAbstractRange backward_range(std::move(end), std::move(start));
   EXPECT_EQ(all_text, backward_range.GetText());
 }
 
 TEST_F(AXPositionTest, AXRangeGetTextWithTextOffsets) {
   base::string16 most_text = base::UTF8ToUTF16("tonCheck boxLine 1\nLine");
   // Create a range starting from the third character in the button object and
   // ending two characters before the end of the root.
-  TestPositionType start = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, button_.id, 3 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
-  TestPositionType end = AXNodePosition::CreateTextPosition(
-      tree_.data().tree_id, static_text2_.id, 4 /* text_offset */,
-      AX_TEXT_AFFINITY_DOWNSTREAM);
-  AXRange<AXPosition<AXNodePosition, AXNode>> forward_range(start->Clone(),
-                                                            end->Clone());
+  TestPositionType start =
+      CreateTextPosition(tree_.data().tree_id, button_.id, 3 /* text_offset */,
+                         AX_TEXT_AFFINITY_DOWNSTREAM);
+  TestPositionType end =
+      CreateTextPosition(tree_.data().tree_id, static_text2_.id,
+                         4 /* text_offset */, AX_TEXT_AFFINITY_DOWNSTREAM);
+  ui::AXAbstractRange forward_range(start->Clone(), end->Clone());
   EXPECT_EQ(most_text, forward_range.GetText());
-  AXRange<AXPosition<AXNodePosition, AXNode>> backward_range(std::move(end),
-                                                             std::move(start));
+  ui::AXAbstractRange backward_range(std::move(end), std::move(start));
   EXPECT_EQ(most_text, backward_range.GetText());
 }
 
 }  // namespace ui