Adds a new selection test fixture that makes selections more readable in tests

R=dmazzoni@chromium.org

Change-Id: I8598961fa8007bac98164dfe4ce96cf52e655a5e
Reviewed-on: https://chromium-review.googlesource.com/1091148Reviewed-by: Aaron Leventhal <aleventhal@chromium.org>
Reviewed-by: Kentaro Hara <haraken@chromium.org>
Reviewed-by: Nektarios Paisios <nektar@chromium.org>
Commit-Queue: Nektarios Paisios <nektar@chromium.org>
Cr-Commit-Position: refs/heads/master@{#565661}

third_party/blink/renderer/modules/BUILD.gn

@@ -230,6 +230,8 @@ jumbo_source_set("unit_tests") {
     "accessibility/ax_position_test.cc",
     "accessibility/ax_range_test.cc",
     "accessibility/ax_selection_test.cc",
+    "accessibility/testing/accessibility_selection_test.cc",
+    "accessibility/testing/accessibility_selection_test.h",
     "accessibility/testing/accessibility_test.cc",
     "accessibility/testing/accessibility_test.h",
     "animationworklet/animation_worklet_global_scope_test.cc",

third_party/blink/renderer/modules/accessibility/ax_selection_test.cc

@@ -10,7 +10,7 @@
 #include "third_party/blink/renderer/core/editing/selection_template.h"
 #include "third_party/blink/renderer/modules/accessibility/ax_object.h"
 #include "third_party/blink/renderer/modules/accessibility/ax_position.h"
-#include "third_party/blink/renderer/modules/accessibility/testing/accessibility_test.h"
+#include "third_party/blink/renderer/modules/accessibility/testing/accessibility_selection_test.h"
 
 namespace blink {
 
@@ -18,13 +18,14 @@ namespace blink {
 // Basic tests.
 //
 
-TEST_F(AccessibilityTest, SetSelectionInText) {
+TEST_F(AccessibilitySelectionTest, SetSelectionInText) {
   SetBodyInnerHTML(R"HTML(<p id='paragraph'>Hello</p>)HTML");
   const Node* text = GetElementById("paragraph")->firstChild();
   ASSERT_NE(nullptr, text);
   const AXObject* ax_static_text =
       GetAXObjectByElementId("paragraph")->FirstChild();
   ASSERT_NE(nullptr, ax_static_text);
+
   const auto ax_base =
       AXPosition::CreatePositionInTextObject(*ax_static_text, 3);
   const auto ax_extent = AXPosition::CreatePositionAfterObject(*ax_static_text);
@@ -37,15 +38,18 @@ TEST_F(AccessibilityTest, SetSelectionInText) {
   EXPECT_EQ(3, dom_selection.Base().OffsetInContainerNode());
   EXPECT_EQ(text, dom_selection.Extent().AnchorNode());
   EXPECT_EQ(5, dom_selection.Extent().OffsetInContainerNode());
+  EXPECT_EQ("<Paragraph: ><StaticText: Hel^lo|>",
+            GetSelectionText(ax_selection));
 }
 
-TEST_F(AccessibilityTest, SetSelectionInTextWithWhiteSpace) {
+TEST_F(AccessibilitySelectionTest, SetSelectionInTextWithWhiteSpace) {
   SetBodyInnerHTML(R"HTML(<p id='paragraph'>     Hello</p>)HTML");
   const Node* text = GetElementById("paragraph")->firstChild();
   ASSERT_NE(nullptr, text);
   const AXObject* ax_static_text =
       GetAXObjectByElementId("paragraph")->FirstChild();
   ASSERT_NE(nullptr, ax_static_text);
+
   const auto ax_base =
       AXPosition::CreatePositionInTextObject(*ax_static_text, 3);
   const auto ax_extent = AXPosition::CreatePositionAfterObject(*ax_static_text);
@@ -58,6 +62,8 @@ TEST_F(AccessibilityTest, SetSelectionInTextWithWhiteSpace) {
   EXPECT_EQ(8, dom_selection.Base().OffsetInContainerNode());
   EXPECT_EQ(text, dom_selection.Extent().AnchorNode());
   EXPECT_EQ(10, dom_selection.Extent().OffsetInContainerNode());
+  EXPECT_EQ("<Paragraph: ><StaticText: Hel^lo|>",
+            GetSelectionText(ax_selection));
 }
 
 //

third_party/blink/renderer/modules/accessibility/testing/accessibility_selection_test.cc

+// Copyright 2018 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 "third_party/blink/renderer/modules/accessibility/testing/accessibility_selection_test.h"
+
+#include "third_party/blink/renderer/modules/accessibility/ax_object.h"
+#include "third_party/blink/renderer/modules/accessibility/ax_position.h"
+#include "third_party/blink/renderer/modules/accessibility/ax_selection.h"
+#include "third_party/blink/renderer/platform/wtf/text/string_builder.h"
+
+namespace blink {
+
+namespace {
+
+// Serialize accessibility subtree to selection text.
+// Adds a '^' at the selection anchor offset and a '|' at the focus offset.
+class AXSelectionSerializer final {
+  STACK_ALLOCATED();
+
+ public:
+  explicit AXSelectionSerializer(const AXSelection& selection)
+      : selection_(selection) {}
+
+  std::string Serialize(const AXObject& subtree) {
+    if (!selection_.IsValid())
+      return {};
+    SerializeSubtree(subtree);
+    return builder_.ToString().Utf8().data();
+  }
+
+ private:
+  void HandleTextObject(const AXObject& text_object) {
+    builder_.Append('<');
+    builder_.Append(AXObject::InternalRoleName(text_object.RoleValue()));
+    builder_.Append(": ");
+    const String name = text_object.ComputedName() + '>';
+    const AXObject& base_container = *selection_.Base().ContainerObject();
+    const AXObject& extent_container = *selection_.Extent().ContainerObject();
+
+    if (base_container == text_object && extent_container == text_object) {
+      DCHECK(selection_.Base().IsTextPosition() &&
+             selection_.Extent().IsTextPosition());
+      const int base_offset = selection_.Base().TextOffset();
+      const int extent_offset = selection_.Extent().TextOffset();
+
+      if (base_offset == extent_offset) {
+        builder_.Append(name.Left(base_offset));
+        builder_.Append('|');
+        builder_.Append(name.Substring(base_offset));
+        return;
+      }
+
+      if (base_offset < extent_offset) {
+        builder_.Append(name.Left(base_offset));
+        builder_.Append('^');
+        builder_.Append(
+            name.Substring(base_offset, extent_offset - base_offset));
+        builder_.Append('|');
+        builder_.Append(name.Substring(extent_offset));
+        return;
+      }
+
+      builder_.Append(name.Left(extent_offset));
+      builder_.Append('|');
+      builder_.Append(
+          name.Substring(extent_offset, base_offset - extent_offset));
+      builder_.Append('^');
+      builder_.Append(name.Substring(base_offset));
+      return;
+    }
+
+    if (base_container == text_object) {
+      DCHECK(selection_.Base().IsTextPosition());
+      const int base_offset = selection_.Base().TextOffset();
+
+      builder_.Append(name.Left(base_offset));
+      builder_.Append('^');
+      builder_.Append(name.Substring(base_offset));
+      return;
+    }
+
+    if (extent_container == text_object) {
+      DCHECK(selection_.Extent().IsTextPosition());
+      const int extent_offset = selection_.Extent().TextOffset();
+
+      builder_.Append(name.Left(extent_offset));
+      builder_.Append('|');
+      builder_.Append(name.Substring(extent_offset));
+      return;
+    }
+
+    builder_.Append(name);
+  }
+
+  void HandleObject(const AXObject& object) {
+    builder_.Append('<');
+    builder_.Append(AXObject::InternalRoleName(object.RoleValue()));
+    builder_.Append(": ");
+    builder_.Append(object.ComputedName());
+    builder_.Append('>');
+    SerializeSubtree(object);
+  }
+
+  void HandleSelection(const AXPosition& position) {
+    if (!position.IsValid())
+      return;
+
+    if (selection_.Extent() == position) {
+      builder_.Append('|');
+      return;
+    }
+
+    if (selection_.Base() != position)
+      return;
+
+    builder_.Append('^');
+  }
+
+  void SerializeSubtree(const AXObject& subtree) {
+    for (const Member<AXObject>& child : subtree.Children()) {
+      if (!child)
+        continue;
+      const auto position = AXPosition::CreatePositionBeforeObject(*child);
+      HandleSelection(position);
+      if (position.IsTextPosition()) {
+        HandleTextObject(*child);
+      } else {
+        HandleObject(*child);
+      }
+    }
+    HandleSelection(AXPosition::CreateLastPositionInObject(subtree));
+  }
+
+  StringBuilder builder_;
+  AXSelection selection_;
+};
+
+}  // namespace
+
+AccessibilitySelectionTest::AccessibilitySelectionTest(
+    LocalFrameClient* local_frame_client)
+    : AccessibilityTest(local_frame_client) {}
+
+std::string AccessibilitySelectionTest::GetSelectionText(
+    const AXSelection& selection) const {
+  const AXObject* root = GetAXRootObject();
+  if (!root)
+    return {};
+  return AXSelectionSerializer(selection).Serialize(*root);
+}
+
+std::string AccessibilitySelectionTest::GetSelectionText(
+    const AXSelection& selection,
+    const AXObject& subtree) const {
+  return AXSelectionSerializer(selection).Serialize(subtree);
+}
+
+}  // namespace blink

third_party/blink/renderer/modules/accessibility/testing/accessibility_selection_test.h

+// Copyright 2018 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.
+
+#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_ACCESSIBILITY_TESTING_ACCESSIBILITY_SELECTION_TEST_H_
+#define THIRD_PARTY_BLINK_RENDERER_MODULES_ACCESSIBILITY_TESTING_ACCESSIBILITY_SELECTION_TEST_H_
+
+#include <string>
+
+#include "third_party/blink/renderer/modules/accessibility/testing/accessibility_test.h"
+#include "third_party/blink/renderer/platform/wtf/allocator.h"
+
+namespace blink {
+
+class AXObject;
+class AXSelection;
+class LocalFrameClient;
+
+// Makes writing and debugging selection tests easier.
+class AccessibilitySelectionTest : public AccessibilityTest {
+  USING_FAST_MALLOC(AccessibilitySelectionTest);
+
+ public:
+  AccessibilitySelectionTest(LocalFrameClient* local_frame_client = nullptr);
+
+ protected:
+  std::string GetSelectionText(const AXSelection& selection) const;
+  std::string GetSelectionText(const AXSelection& selection,
+                               const AXObject& subtree) const;
+};
+
+}  // namespace blink
+
+#endif  // THIRD_PARTY_BLINK_RENDERER_MODULES_ACCESSIBILITY_TESTING_ACCESSIBILITY_SELECTION_TEST_H_

third_party/blink/renderer/modules/accessibility/testing/accessibility_test.cc

@@ -13,6 +13,9 @@
 
 namespace blink {
 
+AccessibilityTest::AccessibilityTest(LocalFrameClient* local_frame_client)
+    : RenderingTest(local_frame_client) {}
+
 void AccessibilityTest::SetUp() {
   RenderingTest::SetUp();
   DCHECK(GetDocument().GetSettings());

third_party/blink/renderer/modules/accessibility/testing/accessibility_test.h

@@ -22,8 +22,7 @@ class AccessibilityTest : public RenderingTest {
   USING_FAST_MALLOC(AccessibilityTest);
 
  public:
-  AccessibilityTest(LocalFrameClient* local_frame_client = nullptr)
-      : RenderingTest(local_frame_client) {}
+  AccessibilityTest(LocalFrameClient* local_frame_client = nullptr);
 
  protected:
   void SetUp() override;