// Copyright 2014 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/core/editing/visible_selection.h"

#include "third_party/blink/renderer/core/dom/range.h"
#include "third_party/blink/renderer/core/editing/ephemeral_range.h"
#include "third_party/blink/renderer/core/editing/frame_selection.h"
#include "third_party/blink/renderer/core/editing/selection_adjuster.h"
#include "third_party/blink/renderer/core/editing/selection_template.h"
#include "third_party/blink/renderer/core/editing/testing/editing_test_base.h"

#define LOREM_IPSUM                                                            \
  "Lorem ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod "  \
  "tempor "                                                                    \
  "incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, "     \
  "quis nostrud "                                                              \
  "exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. "     \
  "Duis aute irure "                                                           \
  "dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat "    \
  "nulla pariatur."                                                            \
  "Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia " \
  "deserunt "                                                                  \
  "mollit anim id est laborum."

namespace blink {

class VisibleSelectionTest : public EditingTestBase {
 protected:
  // Helper function to set the VisibleSelection base/extent.
  template <typename Strategy>
  void SetSelection(VisibleSelectionTemplate<Strategy>& selection, int base) {
    SetSelection(selection, base, base);
  }

  // Helper function to set the VisibleSelection base/extent.
  template <typename Strategy>
  void SetSelection(VisibleSelectionTemplate<Strategy>& selection,
                    int base,
                    int extend) {
    Node* node = GetDocument().body()->firstChild();
    selection = CreateVisibleSelection(
        typename SelectionTemplate<Strategy>::Builder(selection.AsSelection())
            .Collapse(PositionTemplate<Strategy>(node, base))
            .Extend(PositionTemplate<Strategy>(node, extend))
            .Build());
  }

  std::string GetWordSelectionText(const std::string&);

  std::string ComputeVisibleSelection(const std::string& selection_text) {
    Selection().SetSelection(SetSelectionTextToBody(selection_text),
                             SetSelectionOptions());
    const VisibleSelection& visible =
        Selection().ComputeVisibleSelectionInDOMTree();
    return GetSelectionTextFromBody(visible.AsSelection());
  }
};

std::string VisibleSelectionTest::GetWordSelectionText(
    const std::string& selection_text) {
  const PositionInFlatTree position =
      ToPositionInFlatTree(SetSelectionTextToBody(selection_text).Base());
  return GetSelectionTextInFlatTreeFromBody(
      CreateVisibleSelectionWithGranularity(
          SelectionInFlatTree::Builder().Collapse(position).Build(),
          TextGranularity::kWord)
          .AsSelection());
}

static void TestFlatTreePositionsToEqualToDOMTreePositions(
    const VisibleSelection& selection,
    const VisibleSelectionInFlatTree& selection_in_flat_tree) {
  // Since DOM tree positions can't be map to flat tree version, e.g.
  // shadow root, not distributed node, we map a position in flat tree
  // to DOM tree position.
  EXPECT_EQ(selection.Start(),
            ToPositionInDOMTree(selection_in_flat_tree.Start()));
  EXPECT_EQ(selection.End(), ToPositionInDOMTree(selection_in_flat_tree.End()));
  EXPECT_EQ(selection.Base(),
            ToPositionInDOMTree(selection_in_flat_tree.Base()));
  EXPECT_EQ(selection.Extent(),
            ToPositionInDOMTree(selection_in_flat_tree.Extent()));
}

template <typename Strategy>
VisibleSelectionTemplate<Strategy> ExpandUsingGranularity(
    const VisibleSelectionTemplate<Strategy>& selection,
    TextGranularity granularity) {
  return CreateVisibleSelectionWithGranularity(
      typename SelectionTemplate<Strategy>::Builder()
          .SetBaseAndExtent(selection.Base(), selection.Extent())
          .Build(),
      granularity);
}

TEST_F(VisibleSelectionTest, expandUsingGranularity) {
  const char* body_content =
      "<span id=host><a id=one>1</a><a id=two>22</a></span>";
  const char* shadow_content =
      "<p><b id=three>333</b><content select=#two></content><b "
      "id=four>4444</b><span id=space>  </span><content "
      "select=#one></content><b id=five>55555</b></p>";
  SetBodyContent(body_content);
  ShadowRoot* shadow_root = SetShadowContent(shadow_content, "host");

  Node* one = GetDocument().getElementById("one")->firstChild();
  Node* two = GetDocument().getElementById("two")->firstChild();
  Node* three = shadow_root->getElementById("three")->firstChild();
  Node* four = shadow_root->getElementById("four")->firstChild();
  Node* five = shadow_root->getElementById("five")->firstChild();

  VisibleSelection selection;
  VisibleSelectionInFlatTree selection_in_flat_tree;

  // From a position at distributed node
  selection = CreateVisibleSelection(
      SelectionInDOMTree::Builder().Collapse(Position(one, 1)).Build());
  selection = ExpandUsingGranularity(selection, TextGranularity::kWord);
  selection_in_flat_tree =
      CreateVisibleSelection(SelectionInFlatTree::Builder()
                                 .Collapse(PositionInFlatTree(one, 1))
                                 .Build());
  selection_in_flat_tree =
      ExpandUsingGranularity(selection_in_flat_tree, TextGranularity::kWord);

  EXPECT_EQ(selection.Start(), selection.Base());
  EXPECT_EQ(selection.End(), selection.Extent());
  EXPECT_EQ(Position(five, 5), selection.Start());
  EXPECT_EQ(Position(five, 5), selection.End());

  EXPECT_EQ(selection_in_flat_tree.Start(), selection_in_flat_tree.Base());
  EXPECT_EQ(selection_in_flat_tree.End(), selection_in_flat_tree.Extent());
  EXPECT_EQ(PositionInFlatTree(one, 0), selection_in_flat_tree.Start());
  EXPECT_EQ(PositionInFlatTree(five, 5), selection_in_flat_tree.End());

  // From a position at distributed node
  selection = CreateVisibleSelection(
      SelectionInDOMTree::Builder().Collapse(Position(two, 1)).Build());
  selection = ExpandUsingGranularity(selection, TextGranularity::kWord);
  selection_in_flat_tree =
      CreateVisibleSelection(SelectionInFlatTree::Builder()
                                 .Collapse(PositionInFlatTree(two, 1))
                                 .Build());
  selection_in_flat_tree =
      ExpandUsingGranularity(selection_in_flat_tree, TextGranularity::kWord);

  EXPECT_EQ(selection.Start(), selection.Base());
  EXPECT_EQ(selection.End(), selection.Extent());
  EXPECT_EQ(Position(three, 0), selection.Start());
  EXPECT_EQ(Position(four, 4), selection.End());

  EXPECT_EQ(selection_in_flat_tree.Start(), selection_in_flat_tree.Base());
  EXPECT_EQ(selection_in_flat_tree.End(), selection_in_flat_tree.Extent());
  EXPECT_EQ(PositionInFlatTree(three, 0), selection_in_flat_tree.Start());
  EXPECT_EQ(PositionInFlatTree(four, 4), selection_in_flat_tree.End());

  // From a position at node in shadow tree
  selection = CreateVisibleSelection(
      SelectionInDOMTree::Builder().Collapse(Position(three, 1)).Build());
  selection = ExpandUsingGranularity(selection, TextGranularity::kWord);
  selection_in_flat_tree =
      CreateVisibleSelection(SelectionInFlatTree::Builder()
                                 .Collapse(PositionInFlatTree(three, 1))
                                 .Build());
  selection_in_flat_tree =
      ExpandUsingGranularity(selection_in_flat_tree, TextGranularity::kWord);

  EXPECT_EQ(selection.Start(), selection.Base());
  EXPECT_EQ(selection.End(), selection.Extent());
  EXPECT_EQ(Position(three, 0), selection.Start());
  EXPECT_EQ(Position(four, 4), selection.End());

  EXPECT_EQ(selection_in_flat_tree.Start(), selection_in_flat_tree.Base());
  EXPECT_EQ(selection_in_flat_tree.End(), selection_in_flat_tree.Extent());
  EXPECT_EQ(PositionInFlatTree(three, 0), selection_in_flat_tree.Start());
  EXPECT_EQ(PositionInFlatTree(four, 4), selection_in_flat_tree.End());

  // From a position at node in shadow tree
  selection = CreateVisibleSelection(
      SelectionInDOMTree::Builder().Collapse(Position(four, 1)).Build());
  selection = ExpandUsingGranularity(selection, TextGranularity::kWord);
  selection_in_flat_tree =
      CreateVisibleSelection(SelectionInFlatTree::Builder()
                                 .Collapse(PositionInFlatTree(four, 1))
                                 .Build());
  selection_in_flat_tree =
      ExpandUsingGranularity(selection_in_flat_tree, TextGranularity::kWord);

  EXPECT_EQ(selection.Start(), selection.Base());
  EXPECT_EQ(selection.End(), selection.Extent());
  EXPECT_EQ(Position(three, 0), selection.Start());
  EXPECT_EQ(Position(four, 4), selection.End());

  EXPECT_EQ(selection_in_flat_tree.Start(), selection_in_flat_tree.Base());
  EXPECT_EQ(selection_in_flat_tree.End(), selection_in_flat_tree.Extent());
  EXPECT_EQ(PositionInFlatTree(three, 0), selection_in_flat_tree.Start());
  EXPECT_EQ(PositionInFlatTree(four, 4), selection_in_flat_tree.End());

  // From a position at node in shadow tree
  selection = CreateVisibleSelection(
      SelectionInDOMTree::Builder().Collapse(Position(five, 1)).Build());
  selection = ExpandUsingGranularity(selection, TextGranularity::kWord);
  selection_in_flat_tree =
      CreateVisibleSelection(SelectionInFlatTree::Builder()
                                 .Collapse(PositionInFlatTree(five, 1))
                                 .Build());
  selection_in_flat_tree =
      ExpandUsingGranularity(selection_in_flat_tree, TextGranularity::kWord);

  EXPECT_EQ(selection.Start(), selection.Base());
  EXPECT_EQ(selection.End(), selection.Extent());
  // DOM tree canonicalization moves position to a wrong place
  EXPECT_EQ(Position(five, 5), selection.Start());
  EXPECT_EQ(Position(five, 5), selection.End());

  EXPECT_EQ(selection_in_flat_tree.Start(), selection_in_flat_tree.Base());
  EXPECT_EQ(selection_in_flat_tree.End(), selection_in_flat_tree.Extent());
  EXPECT_EQ(PositionInFlatTree(one, 0), selection_in_flat_tree.Start());
  EXPECT_EQ(PositionInFlatTree(five, 5), selection_in_flat_tree.End());
}

// For http://wkb.ug/32622
TEST_F(VisibleSelectionTest, ExpandUsingGranularityWithEmptyCell) {
  const SelectionInDOMTree& selection_in_dom_tree = SetSelectionTextToBody(
      "<div contentEditable><table cellspacing=0><tr>"
      "<td id='first' width='50' height='25pt'>|</td>"
      "<td id='second' width='50' height='25pt'></td>"
      "</tr></table></div>");
  const VisibleSelectionInFlatTree& selection =
      CreateVisibleSelectionWithGranularity(
          ConvertToSelectionInFlatTree(selection_in_dom_tree),
          TextGranularity::kWord);
  EXPECT_EQ(
      "<div contenteditable><table cellspacing=\"0\"><tbody><tr>"
      "<td height=\"25pt\" id=\"first\" width=\"50\">|</td>"
      "<td height=\"25pt\" id=\"second\" width=\"50\"></td>"
      "</tr></tbody></table></div>",
      GetSelectionTextInFlatTreeFromBody(selection.AsSelection()));
}

TEST_F(VisibleSelectionTest, Initialisation) {
  SetBodyContent(LOREM_IPSUM);

  VisibleSelection selection;
  VisibleSelectionInFlatTree selection_in_flat_tree;
  SetSelection(selection, 0);
  SetSelection(selection_in_flat_tree, 0);

  EXPECT_FALSE(selection.IsNone());
  EXPECT_FALSE(selection_in_flat_tree.IsNone());
  EXPECT_TRUE(selection.IsCaret());
  EXPECT_TRUE(selection_in_flat_tree.IsCaret());

  Range* range = CreateRange(FirstEphemeralRangeOf(selection));
  EXPECT_EQ(0u, range->startOffset());
  EXPECT_EQ(0u, range->endOffset());
  EXPECT_EQ("", range->GetText());
  TestFlatTreePositionsToEqualToDOMTreePositions(selection,
                                                 selection_in_flat_tree);

  const VisibleSelection no_selection =
      CreateVisibleSelection(SelectionInDOMTree::Builder().Build());
  EXPECT_TRUE(no_selection.IsNone());
}

TEST_F(VisibleSelectionTest, FirstLetter) {
  SetBodyContent(
      "<style>p::first-letter { font-color: red; }</style>"
      "<p>abc def</p>");
  const Element* sample = GetDocument().QuerySelector("p");
  const SelectionInDOMTree selection =
      SelectionInDOMTree::Builder()
          .Collapse(Position(sample->firstChild(), 0))
          .Extend(Position(sample->firstChild(), 3))
          .Build();
  const VisibleSelection visible_selection = CreateVisibleSelection(selection);

  EXPECT_EQ(selection, visible_selection.AsSelection());
}

TEST_F(VisibleSelectionTest, FirstLetterCollapsedWhitespace) {
  SetBodyContent(
      "<style>p::first-letter { font-color: red; }</style>"
      "<p>  abc def</p>");
  const Element* sample = GetDocument().QuerySelector("p");
  const SelectionInDOMTree selection =
      SelectionInDOMTree::Builder()
          .Collapse(Position(sample->firstChild(), 0))
          .Extend(Position(sample->firstChild(), 5))
          .Build();
  const VisibleSelection visible_selection = CreateVisibleSelection(selection);

  EXPECT_EQ(SelectionInDOMTree::Builder()
                .Collapse(Position(sample->firstChild(), 2))
                .Extend(Position(sample->firstChild(), 5))
                .Build(),
            visible_selection.AsSelection())
      << "VisibleSelection doesn't contains collapsed whitespaces";
}

TEST_F(VisibleSelectionTest, FirstLetterPartial) {
  SetBodyContent(
      "<style>p::first-letter { font-color: red; }</style>"
      "<p>((a))bc def</p>");
  const Element* sample = GetDocument().QuerySelector("p");
  const SelectionInDOMTree selection =
      SelectionInDOMTree::Builder()
          .Collapse(Position(sample->firstChild(), 1))
          .Extend(Position(sample->firstChild(), 4))
          .Build();
  const VisibleSelection visible_selection = CreateVisibleSelection(selection);

  EXPECT_EQ(selection, visible_selection.AsSelection())
      << "Select '(a)' of '((a))";
}

TEST_F(VisibleSelectionTest, FirstLetterTextTransform) {
  SetBodyContent(
      "<style>p::first-letter { text-transform: uppercase; }</style>"
      "<p>\u00DFbc def</p>");  // uppercase(U+00DF) = "SS"
  const Element* sample = GetDocument().QuerySelector("p");
  const SelectionInDOMTree selection =
      SelectionInDOMTree::Builder()
          .Collapse(Position(sample->firstChild(), 0))
          .Extend(Position(sample->firstChild(), 3))
          .Build();
  const VisibleSelection visible_selection = CreateVisibleSelection(selection);

  EXPECT_EQ(selection, visible_selection.AsSelection());
}

TEST_F(VisibleSelectionTest, FirstLetterVisibilityHidden) {
  SetBodyContent(
      "<style>p::first-letter { visibility: hidden; }</style>"
      "<p>abc def</p>");
  const Element* sample = GetDocument().QuerySelector("p");
  const SelectionInDOMTree selection =
      SelectionInDOMTree::Builder()
          .Collapse(Position(sample->firstChild(), 0))
          .Extend(Position(sample->firstChild(), 3))
          .Build();
  const VisibleSelection visible_selection = CreateVisibleSelection(selection);

  EXPECT_EQ(SelectionInDOMTree::Builder()
                .Collapse(Position(sample->firstChild(), 1))
                .Extend(Position(sample->firstChild(), 3))
                .Build(),
            visible_selection.AsSelection())
      << "Exclude first-letter part since it is visibility::hidden";
}

// For http://crbug.com/695317
TEST_F(VisibleSelectionTest, SelectAllWithInputElement) {
  SetBodyContent("<input>123");
  Element* const html_element = GetDocument().documentElement();
  Element* const input = GetDocument().QuerySelector("input");
  Node* const last_child = GetDocument().body()->lastChild();

  const VisibleSelection& visible_selection_in_dom_tree =
      CreateVisibleSelection(
          SelectionInDOMTree::Builder()
              .Collapse(Position::FirstPositionInNode(*html_element))
              .Extend(Position::LastPositionInNode(*html_element))
              .Build());
  EXPECT_EQ(SelectionInDOMTree::Builder()
                .Collapse(Position::BeforeNode(*input))
                .Extend(Position(last_child, 3))
                .Build(),
            visible_selection_in_dom_tree.AsSelection());

  const VisibleSelectionInFlatTree& visible_selection_in_flat_tree =
      CreateVisibleSelection(
          SelectionInFlatTree::Builder()
              .Collapse(PositionInFlatTree::FirstPositionInNode(*html_element))
              .Extend(PositionInFlatTree::LastPositionInNode(*html_element))
              .Build());
  EXPECT_EQ(SelectionInFlatTree::Builder()
                .Collapse(PositionInFlatTree::BeforeNode(*input))
                .Extend(PositionInFlatTree(last_child, 3))
                .Build(),
            visible_selection_in_flat_tree.AsSelection());
}

TEST_F(VisibleSelectionTest, GetWordSelectionTextWithTextSecurity) {
  InsertStyleElement("s {-webkit-text-security:disc;}");
  // Note: |CreateVisibleSelectionWithGranularity()| considers security
  // characters as a sequence "x".
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("|abc<s>foo bar</s>baz"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("a|bc<s>foo bar</s>baz"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("abc|<s>foo bar</s>baz"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("abc<s>|foo bar</s>baz"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("abc<s>f|oo bar</s>baz"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("abc<s>fo|o bar</s>baz"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("abc<s>foo| bar</s>baz"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("abc<s>foo |bar</s>baz"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("abc<s>foo b|ar</s>baz"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("abc<s>foo ba|r</s>baz"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("abc<s>foo bar|</s>baz"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("abc<s>foo bar</s>|baz"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("abc<s>foo bar</s>b|az"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("abc<s>foo bar</s>ba|z"));
  EXPECT_EQ("^abc<s>foo bar</s>baz|",
            GetWordSelectionText("abc<s>foo bar</s>baz|"));
}

TEST_F(VisibleSelectionTest, ShadowCrossing) {
  const char* body_content =
      "<p id='host'>00<b id='one'>11</b><b id='two'>22</b>33</p>";
  const char* shadow_content =
      "<a><span id='s4'>44</span><content select=#two></content><span "
      "id='s5'>55</span><content select=#one></content><span "
      "id='s6'>66</span></a>";
  SetBodyContent(body_content);
  ShadowRoot* shadow_root = SetShadowContent(shadow_content, "host");

  Element* body = GetDocument().body();
  Element* host = body->QuerySelector("#host");
  Element* one = body->QuerySelector("#one");
  Element* six = shadow_root->QuerySelector("#s6");

  VisibleSelection selection = CreateVisibleSelection(
      SelectionInDOMTree::Builder()
          .Collapse(Position::FirstPositionInNode(*one))
          .Extend(Position::LastPositionInNode(*shadow_root))
          .Build());
  VisibleSelectionInFlatTree selection_in_flat_tree = CreateVisibleSelection(
      SelectionInFlatTree::Builder()
          .Collapse(PositionInFlatTree::FirstPositionInNode(*one))
          .Extend(PositionInFlatTree::LastPositionInNode(*host))
          .Build());

  EXPECT_EQ(Position(host, PositionAnchorType::kBeforeAnchor),
            selection.Start());
  EXPECT_EQ(Position(host, PositionAnchorType::kBeforeAnchor), selection.End());
  EXPECT_EQ(PositionInFlatTree(one->firstChild(), 0),
            selection_in_flat_tree.Start());
  EXPECT_EQ(PositionInFlatTree(six->firstChild(), 2),
            selection_in_flat_tree.End());
}

TEST_F(VisibleSelectionTest, ShadowV0DistributedNodes) {
  const char* body_content =
      "<p id='host'>00<b id='one'>11</b><b id='two'>22</b>33</p>";
  const char* shadow_content =
      "<a><span id='s4'>44</span><content select=#two></content><span "
      "id='s5'>55</span><content select=#one></content><span "
      "id='s6'>66</span></a>";
  SetBodyContent(body_content);
  ShadowRoot* shadow_root = SetShadowContent(shadow_content, "host");

  Element* body = GetDocument().body();
  Element* one = body->QuerySelector("#one");
  Element* two = body->QuerySelector("#two");
  Element* five = shadow_root->QuerySelector("#s5");

  VisibleSelection selection =
      CreateVisibleSelection(SelectionInDOMTree::Builder()
                                 .Collapse(Position::FirstPositionInNode(*one))
                                 .Extend(Position::LastPositionInNode(*two))
                                 .Build());
  VisibleSelectionInFlatTree selection_in_flat_tree = CreateVisibleSelection(
      SelectionInFlatTree::Builder()
          .Collapse(PositionInFlatTree::FirstPositionInNode(*one))
          .Extend(PositionInFlatTree::LastPositionInNode(*two))
          .Build());

  EXPECT_EQ(Position(one->firstChild(), 0), selection.Start());
  EXPECT_EQ(Position(two->firstChild(), 2), selection.End());
  EXPECT_EQ(PositionInFlatTree(five->firstChild(), 0),
            selection_in_flat_tree.Start());
  EXPECT_EQ(PositionInFlatTree(five->firstChild(), 2),
            selection_in_flat_tree.End());
}

TEST_F(VisibleSelectionTest, ShadowNested) {
  const char* body_content =
      "<p id='host'>00<b id='one'>11</b><b id='two'>22</b>33</p>";
  const char* shadow_content =
      "<a><span id='s4'>44</span><content select=#two></content><span "
      "id='s5'>55</span><content select=#one></content><span "
      "id='s6'>66</span></a>";
  const char* shadow_content2 =
      "<span id='s7'>77</span><content></content><span id='s8'>88</span>";
  SetBodyContent(body_content);
  ShadowRoot* shadow_root = SetShadowContent(shadow_content, "host");
  ShadowRoot* shadow_root2 = CreateShadowRootForElementWithIDAndSetInnerHTML(
      *shadow_root, "s5", shadow_content2);

  // Flat tree is something like below:
  //  <p id="host">
  //    <span id="s4">44</span>
  //    <b id="two">22</b>
  //    <span id="s5"><span id="s7">77>55</span id="s8">88</span>
  //    <b id="one">11</b>
  //    <span id="s6">66</span>
  //  </p>
  Element* body = GetDocument().body();
  Element* host = body->QuerySelector("#host");
  Element* one = body->QuerySelector("#one");
  Element* eight = shadow_root2->QuerySelector("#s8");

  VisibleSelection selection = CreateVisibleSelection(
      SelectionInDOMTree::Builder()
          .Collapse(Position::FirstPositionInNode(*one))
          .Extend(Position::LastPositionInNode(*shadow_root2))
          .Build());
  VisibleSelectionInFlatTree selection_in_flat_tree = CreateVisibleSelection(
      SelectionInFlatTree::Builder()
          .Collapse(PositionInFlatTree::FirstPositionInNode(*one))
          .Extend(PositionInFlatTree::AfterNode(*eight))
          .Build());

  EXPECT_EQ(Position(host, PositionAnchorType::kBeforeAnchor),
            selection.Start());
  EXPECT_EQ(Position(host, PositionAnchorType::kBeforeAnchor), selection.End());
  EXPECT_EQ(PositionInFlatTree(eight->firstChild(), 2),
            selection_in_flat_tree.Start());
  EXPECT_EQ(PositionInFlatTree(eight->firstChild(), 2),
            selection_in_flat_tree.End());
}

TEST_F(VisibleSelectionTest, WordGranularity) {
  SetBodyContent(LOREM_IPSUM);

  VisibleSelection selection;
  VisibleSelectionInFlatTree selection_in_flat_tree;

  // Beginning of a word.
  {
    SetSelection(selection, 0);
    SetSelection(selection_in_flat_tree, 0);
    selection = ExpandUsingGranularity(selection, TextGranularity::kWord);
    selection_in_flat_tree =
        ExpandUsingGranularity(selection_in_flat_tree, TextGranularity::kWord);

    Range* range = CreateRange(FirstEphemeralRangeOf(selection));
    EXPECT_EQ(0u, range->startOffset());
    EXPECT_EQ(5u, range->endOffset());
    EXPECT_EQ("Lorem", range->GetText());
    TestFlatTreePositionsToEqualToDOMTreePositions(selection,
                                                   selection_in_flat_tree);
  }

  // Middle of a word.
  {
    SetSelection(selection, 8);
    SetSelection(selection_in_flat_tree, 8);
    selection = ExpandUsingGranularity(selection, TextGranularity::kWord);
    selection_in_flat_tree =
        ExpandUsingGranularity(selection_in_flat_tree, TextGranularity::kWord);

    Range* range = CreateRange(FirstEphemeralRangeOf(selection));
    EXPECT_EQ(6u, range->startOffset());
    EXPECT_EQ(11u, range->endOffset());
    EXPECT_EQ("ipsum", range->GetText());
    TestFlatTreePositionsToEqualToDOMTreePositions(selection,
                                                   selection_in_flat_tree);
  }

  // End of a word.
  // FIXME: that sounds buggy, we might want to select the word _before_ instead
  // of the space...
  {
    SetSelection(selection, 5);
    SetSelection(selection_in_flat_tree, 5);
    selection = ExpandUsingGranularity(selection, TextGranularity::kWord);
    selection_in_flat_tree =
        ExpandUsingGranularity(selection_in_flat_tree, TextGranularity::kWord);

    Range* range = CreateRange(FirstEphemeralRangeOf(selection));
    EXPECT_EQ(5u, range->startOffset());
    EXPECT_EQ(6u, range->endOffset());
    EXPECT_EQ(" ", range->GetText());
    TestFlatTreePositionsToEqualToDOMTreePositions(selection,
                                                   selection_in_flat_tree);
  }

  // Before comma.
  // FIXME: that sounds buggy, we might want to select the word _before_ instead
  // of the comma.
  {
    SetSelection(selection, 26);
    SetSelection(selection_in_flat_tree, 26);
    selection = ExpandUsingGranularity(selection, TextGranularity::kWord);
    selection_in_flat_tree =
        ExpandUsingGranularity(selection_in_flat_tree, TextGranularity::kWord);

    Range* range = CreateRange(FirstEphemeralRangeOf(selection));
    EXPECT_EQ(26u, range->startOffset());
    EXPECT_EQ(27u, range->endOffset());
    EXPECT_EQ(",", range->GetText());
    TestFlatTreePositionsToEqualToDOMTreePositions(selection,
                                                   selection_in_flat_tree);
  }

  // After comma.
  {
    SetSelection(selection, 27);
    SetSelection(selection_in_flat_tree, 27);
    selection = ExpandUsingGranularity(selection, TextGranularity::kWord);
    selection_in_flat_tree =
        ExpandUsingGranularity(selection_in_flat_tree, TextGranularity::kWord);

    Range* range = CreateRange(FirstEphemeralRangeOf(selection));
    EXPECT_EQ(27u, range->startOffset());
    EXPECT_EQ(28u, range->endOffset());
    EXPECT_EQ(" ", range->GetText());
    TestFlatTreePositionsToEqualToDOMTreePositions(selection,
                                                   selection_in_flat_tree);
  }

  // When selecting part of a word.
  {
    SetSelection(selection, 0, 1);
    SetSelection(selection_in_flat_tree, 0, 1);
    selection = ExpandUsingGranularity(selection, TextGranularity::kWord);
    selection_in_flat_tree =
        ExpandUsingGranularity(selection_in_flat_tree, TextGranularity::kWord);

    Range* range = CreateRange(FirstEphemeralRangeOf(selection));
    EXPECT_EQ(0u, range->startOffset());
    EXPECT_EQ(5u, range->endOffset());
    EXPECT_EQ("Lorem", range->GetText());
    TestFlatTreePositionsToEqualToDOMTreePositions(selection,
                                                   selection_in_flat_tree);
  }

  // When selecting part of two words.
  {
    SetSelection(selection, 2, 8);
    SetSelection(selection_in_flat_tree, 2, 8);
    selection = ExpandUsingGranularity(selection, TextGranularity::kWord);
    selection_in_flat_tree =
        ExpandUsingGranularity(selection_in_flat_tree, TextGranularity::kWord);

    Range* range = CreateRange(FirstEphemeralRangeOf(selection));
    EXPECT_EQ(0u, range->startOffset());
    EXPECT_EQ(11u, range->endOffset());
    EXPECT_EQ("Lorem ipsum", range->GetText());
    TestFlatTreePositionsToEqualToDOMTreePositions(selection,
                                                   selection_in_flat_tree);
  }
}

// https://crbug.com/901492
TEST_F(VisibleSelectionTest, WordGranularityAfterTextControl) {
  const PositionInFlatTree position =
      ToPositionInFlatTree(SetCaretTextToBody("foo<input value=\"bla\">b|ar"));
  const VisibleSelectionInFlatTree selection =
      CreateVisibleSelectionWithGranularity(
          SelectionInFlatTree::Builder().Collapse(position).Build(),
          TextGranularity::kWord);
  EXPECT_EQ("foo<input value=\"bla\"><div>bla</div></input>^bar|",
            GetSelectionTextInFlatTreeFromBody(selection.AsSelection()));
}

// This is for crbug.com/627783, simulating restoring selection
// in undo stack.
TEST_F(VisibleSelectionTest, updateIfNeededWithShadowHost) {
  SetBodyContent("<div id=host></div><div id=sample>foo</div>");
  SetShadowContent("<content>", "host");
  Element* sample = GetDocument().getElementById("sample");

  // Simulates saving selection in undo stack.
  VisibleSelection selection =
      CreateVisibleSelection(SelectionInDOMTree::Builder()
                                 .Collapse(Position(sample->firstChild(), 0))
                                 .Build());
  EXPECT_EQ(Position(sample->firstChild(), 0), selection.Start());

  // Simulates modifying DOM tree to invalidate distribution.
  Element* host = GetDocument().getElementById("host");
  host->AppendChild(sample);
  GetDocument().UpdateStyleAndLayout();

  // Simulates to restore selection from undo stack.
  selection = CreateVisibleSelection(selection.AsSelection());
  EXPECT_EQ(Position(sample->firstChild(), 0), selection.Start());
}

// This is a regression test for https://crbug.com/825120
TEST_F(VisibleSelectionTest, BackwardSelectionWithMultipleEmptyBodies) {
  Element* body = GetDocument().body();
  Element* new_body = GetDocument().CreateRawElement(html_names::kBodyTag);
  body->appendChild(new_body);
  GetDocument().UpdateStyleAndLayout();

  const SelectionInDOMTree selection =
      SelectionInDOMTree::Builder()
          .Collapse(Position::BeforeNode(*new_body))
          .Extend(Position::BeforeNode(*body))
          .Build();
  const VisibleSelection visible_selection = CreateVisibleSelection(selection);

  EXPECT_EQ("^<body></body>", GetSelectionTextFromBody(selection));
  EXPECT_EQ("|<body></body>",
            GetSelectionTextFromBody(visible_selection.AsSelection()));
}

// Confirm canonicalization.
#define EXPECT_EQ_VS(input, expect) \
  EXPECT_EQ(ComputeVisibleSelection(input), expect)

TEST_F(VisibleSelectionTest, ComputeVisibleSelectionBasic) {
  EXPECT_EQ_VS("fo^o<br>ba|r", "fo^o<br>ba|r");
  EXPECT_EQ_VS("fo|o<br>ba^r", "fo|o<br>ba^r");
  EXPECT_EQ_VS("foo<!--|--><br><!--^-->bar", "foo|<br>^bar");
}

TEST_F(VisibleSelectionTest, ComputeVisibleSelectionBR) {
  EXPECT_EQ_VS("fo^o<br>|", "fo^o|<br>");
  EXPECT_EQ_VS("fo^o<br><br>|", "fo^o<br>|<br>");
  EXPECT_EQ_VS("foo<br>^<br>|", "foo<br>|<br>");
  EXPECT_EQ_VS("foo<!--|--><br>", "foo|<br>");
  EXPECT_EQ_VS("foo<br>|", "foo|<br>");
}

TEST_F(VisibleSelectionTest, ComputeVisibleSelectionCaret) {
  EXPECT_EQ_VS("fo|o", "fo|o");
  EXPECT_EQ_VS("<!--|-->foo", "|foo");
  EXPECT_EQ_VS("foo<!--|-->", "foo|");
  EXPECT_EQ_VS("<div>|</div>", "|<div></div>");
  EXPECT_EQ_VS("<div contenteditable><div>|</div></div>",
               "<div contenteditable><div></div></div>");
  EXPECT_EQ_VS("<div contenteditable>foo<div>|</div>bar</div>",
               "<div contenteditable>foo<div></div>|bar</div>");
  EXPECT_EQ_VS("<div contenteditable>|</div>", "<div contenteditable>|</div>");
}

TEST_F(VisibleSelectionTest, ComputeVisibleSelectionEdgeIsNone) {
  EXPECT_EQ_VS("fo|o<b style=\"display:none;\">b^ar</b>",
               "fo|o^<b style=\"display:none;\">bar</b>");
  EXPECT_EQ_VS("<b style=\"display:none;\">f^oo</b>ba|r",
               "<b style=\"display:none;\">foo</b>^ba|r");
  EXPECT_EQ_VS(
      "<b style=\"display:none;\">f^oo</b>"
      "bar<b style=\"display:none;\">b|az</b>",
      "<b style=\"display:none;\">foo</b>"
      "^bar|<b style=\"display:none;\">baz</b>");
}

TEST_F(VisibleSelectionTest, ComputeVisibleSelectionInsideNone) {
  EXPECT_EQ_VS("foo<b style=\"display:none;\">b^a|r</b>baz",
               "foo|<b style=\"display:none;\">bar</b>baz");
  EXPECT_EQ_VS("<b style=\"display:none;\">b|a^r</b>baz",
               "<b style=\"display:none;\">bar</b>|baz");
}

}  // namespace blink