/*
 * Copyright (C) 2005, 2006, 2008, 2009 Apple Inc. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "third_party/blink/renderer/core/editing/commands/apply_style_command.h"

#include "mojo/public/mojom/base/text_direction.mojom-blink.h"
#include "third_party/blink/renderer/core/css/css_computed_style_declaration.h"
#include "third_party/blink/renderer/core/css/css_numeric_literal_value.h"
#include "third_party/blink/renderer/core/css/css_primitive_value.h"
#include "third_party/blink/renderer/core/css/css_property_names.h"
#include "third_party/blink/renderer/core/css/css_property_value_set.h"
#include "third_party/blink/renderer/core/css_value_keywords.h"
#include "third_party/blink/renderer/core/dom/document.h"
#include "third_party/blink/renderer/core/dom/node_list.h"
#include "third_party/blink/renderer/core/dom/node_traversal.h"
#include "third_party/blink/renderer/core/dom/range.h"
#include "third_party/blink/renderer/core/dom/text.h"
#include "third_party/blink/renderer/core/editing/commands/editing_commands_utilities.h"
#include "third_party/blink/renderer/core/editing/editing_style.h"
#include "third_party/blink/renderer/core/editing/editing_style_utilities.h"
#include "third_party/blink/renderer/core/editing/editing_utilities.h"
#include "third_party/blink/renderer/core/editing/ephemeral_range.h"
#include "third_party/blink/renderer/core/editing/iterators/text_iterator.h"
#include "third_party/blink/renderer/core/editing/plain_text_range.h"
#include "third_party/blink/renderer/core/editing/relocatable_position.h"
#include "third_party/blink/renderer/core/editing/selection_template.h"
#include "third_party/blink/renderer/core/editing/serializers/html_interchange.h"
#include "third_party/blink/renderer/core/editing/visible_position.h"
#include "third_party/blink/renderer/core/editing/visible_selection.h"
#include "third_party/blink/renderer/core/editing/visible_units.h"
#include "third_party/blink/renderer/core/html/html_font_element.h"
#include "third_party/blink/renderer/core/html/html_span_element.h"
#include "third_party/blink/renderer/core/html_names.h"
#include "third_party/blink/renderer/core/layout/layout_object.h"
#include "third_party/blink/renderer/core/layout/layout_text.h"
#include "third_party/blink/renderer/platform/heap/handle.h"
#include "third_party/blink/renderer/platform/heap/heap.h"
#include "third_party/blink/renderer/platform/instrumentation/use_counter.h"
#include "third_party/blink/renderer/platform/wtf/std_lib_extras.h"
#include "third_party/blink/renderer/platform/wtf/text/string_builder.h"

namespace blink {

static bool HasNoAttributeOrOnlyStyleAttribute(
    const HTMLElement* element,
    ShouldStyleAttributeBeEmpty should_style_attribute_be_empty) {
  AttributeCollection attributes = element->Attributes();
  if (attributes.IsEmpty())
    return true;

  unsigned matched_attributes = 0;
  if (element->hasAttribute(html_names::kStyleAttr) &&
      (should_style_attribute_be_empty == kAllowNonEmptyStyleAttribute ||
       !element->InlineStyle() || element->InlineStyle()->IsEmpty()))
    matched_attributes++;

  DCHECK_LE(matched_attributes, attributes.size());
  return matched_attributes == attributes.size();
}

bool IsStyleSpanOrSpanWithOnlyStyleAttribute(const Element* element) {
  if (auto* span = DynamicTo<HTMLSpanElement>(element)) {
    return HasNoAttributeOrOnlyStyleAttribute(span,
                                              kAllowNonEmptyStyleAttribute);
  }
  return false;
}

static inline bool IsSpanWithoutAttributesOrUnstyledStyleSpan(
    const Node* node) {
  if (auto* span = DynamicTo<HTMLSpanElement>(node)) {
    return HasNoAttributeOrOnlyStyleAttribute(span,
                                              kStyleAttributeShouldBeEmpty);
  }
  return false;
}

bool IsEmptyFontTag(
    const Element* element,
    ShouldStyleAttributeBeEmpty should_style_attribute_be_empty) {
  if (auto* font = DynamicTo<HTMLFontElement>(element)) {
    return HasNoAttributeOrOnlyStyleAttribute(font,
                                              should_style_attribute_be_empty);
  }
  return false;
}

static bool OffsetIsBeforeLastNodeOffset(int offset, Node* anchor_node) {
  if (auto* character_data = DynamicTo<CharacterData>(anchor_node))
    return offset < static_cast<int>(character_data->length());
  int current_offset = 0;
  for (Node* node = NodeTraversal::FirstChild(*anchor_node);
       node && current_offset < offset;
       node = NodeTraversal::NextSibling(*node))
    current_offset++;
  return offset < current_offset;
}

ApplyStyleCommand::ApplyStyleCommand(Document& document,
                                     const EditingStyle* style,
                                     InputEvent::InputType input_type,
                                     PropertyLevel property_level)
    : CompositeEditCommand(document),
      style_(style->Copy()),
      input_type_(input_type),
      property_level_(property_level),
      start_(MostForwardCaretPosition(EndingSelection().Start())),
      end_(MostBackwardCaretPosition(EndingSelection().End())),
      use_ending_selection_(true),
      styled_inline_element_(nullptr),
      remove_only_(false),
      is_inline_element_to_remove_function_(nullptr) {}

ApplyStyleCommand::ApplyStyleCommand(Document& document,
                                     const EditingStyle* style,
                                     const Position& start,
                                     const Position& end)
    : CompositeEditCommand(document),
      style_(style->Copy()),
      input_type_(InputEvent::InputType::kNone),
      property_level_(kPropertyDefault),
      start_(start),
      end_(end),
      use_ending_selection_(false),
      styled_inline_element_(nullptr),
      remove_only_(false),
      is_inline_element_to_remove_function_(nullptr) {}

ApplyStyleCommand::ApplyStyleCommand(Element* element, bool remove_only)
    : CompositeEditCommand(element->GetDocument()),
      style_(MakeGarbageCollected<EditingStyle>()),
      input_type_(InputEvent::InputType::kNone),
      property_level_(kPropertyDefault),
      start_(MostForwardCaretPosition(EndingSelection().Start())),
      end_(MostBackwardCaretPosition(EndingSelection().End())),
      use_ending_selection_(true),
      styled_inline_element_(element),
      remove_only_(remove_only),
      is_inline_element_to_remove_function_(nullptr) {}

ApplyStyleCommand::ApplyStyleCommand(
    Document& document,
    const EditingStyle* style,
    IsInlineElementToRemoveFunction is_inline_element_to_remove_function,
    InputEvent::InputType input_type)
    : CompositeEditCommand(document),
      style_(style->Copy()),
      input_type_(input_type),
      property_level_(kPropertyDefault),
      start_(MostForwardCaretPosition(EndingSelection().Start())),
      end_(MostBackwardCaretPosition(EndingSelection().End())),
      use_ending_selection_(true),
      styled_inline_element_(nullptr),
      remove_only_(true),
      is_inline_element_to_remove_function_(
          is_inline_element_to_remove_function) {}

void ApplyStyleCommand::UpdateStartEnd(const EphemeralRange& range) {
  if (!use_ending_selection_ &&
      (range.StartPosition() != start_ || range.EndPosition() != end_))
    use_ending_selection_ = true;
  GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);
  const bool was_base_first =
      StartingSelection().IsBaseFirst() || !SelectionIsDirectional();
  SelectionInDOMTree::Builder builder;
  if (was_base_first)
    builder.SetAsForwardSelection(range);
  else
    builder.SetAsBackwardSelection(range);
  const VisibleSelection& visible_selection =
      CreateVisibleSelection(builder.Build());
  SetEndingSelection(
      SelectionForUndoStep::From(visible_selection.AsSelection()));
  start_ = range.StartPosition();
  end_ = range.EndPosition();
}

Position ApplyStyleCommand::StartPosition() {
  if (use_ending_selection_)
    return EndingSelection().Start();

  return start_;
}

Position ApplyStyleCommand::EndPosition() {
  if (use_ending_selection_)
    return EndingSelection().End();

  return end_;
}

void ApplyStyleCommand::DoApply(EditingState* editing_state) {
  DCHECK(StartPosition().IsNotNull());
  DCHECK(EndPosition().IsNotNull());
  switch (property_level_) {
    case kPropertyDefault: {
      // Apply the block-centric properties of the style.
      EditingStyle* block_style = style_->ExtractAndRemoveBlockProperties(
          GetDocument().GetExecutionContext());
      if (!block_style->IsEmpty()) {
        ApplyBlockStyle(block_style, editing_state);
        if (editing_state->IsAborted())
          return;
      }
      // Apply any remaining styles to the inline elements.
      if (!style_->IsEmpty() || styled_inline_element_ ||
          is_inline_element_to_remove_function_) {
        ApplyRelativeFontStyleChange(style_.Get(), editing_state);
        if (editing_state->IsAborted())
          return;
        ApplyInlineStyle(style_.Get(), editing_state);
        if (editing_state->IsAborted())
          return;
      }
      break;
    }
    case kForceBlockProperties:
      // Force all properties to be applied as block styles.
      ApplyBlockStyle(style_.Get(), editing_state);
      break;
  }
}

InputEvent::InputType ApplyStyleCommand::GetInputType() const {
  return input_type_;
}

void ApplyStyleCommand::ApplyBlockStyle(EditingStyle* style,
                                        EditingState* editing_state) {
  // update document layout once before removing styles
  // so that we avoid the expense of updating before each and every call
  // to check a computed style
  GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);

  // get positions we want to use for applying style
  Position start = StartPosition();
  Position end = EndPosition();
  if (ComparePositions(end, start) < 0) {
    Position swap = start;
    start = end;
    end = swap;
  }

  VisiblePosition visible_start = CreateVisiblePosition(start);
  VisiblePosition visible_end = CreateVisiblePosition(end);

  if (visible_start.IsNull() || visible_start.IsOrphan() ||
      visible_end.IsNull() || visible_end.IsOrphan())
    return;

  // Save and restore the selection endpoints using their indices in the
  // document, since addBlockStyleIfNeeded may moveParagraphs, which can remove
  // these endpoints. Calculate start and end indices from the start of the tree
  // that they're in.
  const Node& scope = NodeTraversal::HighestAncestorOrSelf(
      *visible_start.DeepEquivalent().AnchorNode());
  const EphemeralRange start_range(
      Position::FirstPositionInNode(scope),
      visible_start.DeepEquivalent().ParentAnchoredEquivalent());
  const EphemeralRange end_range(
      Position::FirstPositionInNode(scope),
      visible_end.DeepEquivalent().ParentAnchoredEquivalent());

  const TextIteratorBehavior behavior =
      TextIteratorBehavior::AllVisiblePositionsRangeLengthBehavior();

  const int start_index = TextIterator::RangeLength(start_range, behavior);
  const int end_index = TextIterator::RangeLength(end_range, behavior);

  VisiblePosition paragraph_start(StartOfParagraph(visible_start));
  Position beyond_end =
      NextPositionOf(EndOfParagraph(visible_end)).DeepEquivalent();
  while (
      paragraph_start.IsNotNull() &&
      (beyond_end.IsNull() || paragraph_start.DeepEquivalent() < beyond_end)) {
    DCHECK(paragraph_start.IsValidFor(GetDocument())) << paragraph_start;
    RelocatablePosition next_paragraph_start(
        NextPositionOf(EndOfParagraph(paragraph_start)).DeepEquivalent());
    // RelocatablePosition turns the position into ParentAnchoredEquivalent(),
    // which can affect the result of CreateVisiblePosition().
    // To avoid an infinite loop, reconvert into a VisiblePosition and check
    // that it's after the current paragraph_start.
    bool will_advance =
        next_paragraph_start.GetPosition().IsNull() ||
        CreateVisiblePosition(next_paragraph_start.GetPosition())
                .DeepEquivalent() > paragraph_start.DeepEquivalent();
    StyleChange style_change(style, paragraph_start.DeepEquivalent());
    if (style_change.CssStyle().length() || remove_only_) {
      Element* block =
          EnclosingBlock(paragraph_start.DeepEquivalent().AnchorNode());
      const Position& paragraph_start_to_move =
          paragraph_start.DeepEquivalent();
      if (!remove_only_ && IsEditablePosition(paragraph_start_to_move)) {
        HTMLElement* new_block = MoveParagraphContentsToNewBlockIfNecessary(
            paragraph_start_to_move, editing_state);
        if (editing_state->IsAborted())
          return;
        if (new_block)
          block = new_block;
      }
      if (auto* html_element = DynamicTo<HTMLElement>(block)) {
        RemoveCSSStyle(style, html_element, editing_state);
        if (editing_state->IsAborted())
          return;
        if (!remove_only_)
          AddBlockStyle(style_change, html_element);
      }

      GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);
    }

    if (!will_advance)
      break;
    paragraph_start = CreateVisiblePosition(next_paragraph_start.GetPosition());
  }

  // Update style and layout again, since added or removed styles could have
  // affected the layout. We need clean layout in order to compute
  // plain-text ranges below.
  GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);

  EphemeralRange start_ephemeral_range =
      PlainTextRange(start_index)
          .CreateRangeForSelection(To<ContainerNode>(scope));
  if (start_ephemeral_range.IsNull())
    return;
  EphemeralRange end_ephemeral_range =
      PlainTextRange(end_index).CreateRangeForSelection(
          To<ContainerNode>(scope));
  if (end_ephemeral_range.IsNull())
    return;
  UpdateStartEnd(EphemeralRange(start_ephemeral_range.StartPosition(),
                                end_ephemeral_range.StartPosition()));
}

static MutableCSSPropertyValueSet* CopyStyleOrCreateEmpty(
    const CSSPropertyValueSet* style) {
  if (!style)
    return MakeGarbageCollected<MutableCSSPropertyValueSet>(kHTMLQuirksMode);
  return style->MutableCopy();
}

void ApplyStyleCommand::ApplyRelativeFontStyleChange(
    EditingStyle* style,
    EditingState* editing_state) {
  static const float kMinimumFontSize = 0.1f;

  if (!style || !style->HasFontSizeDelta())
    return;

  Position start = StartPosition();
  Position end = EndPosition();
  if (ComparePositions(end, start) < 0) {
    Position swap = start;
    start = end;
    end = swap;
  }

  // Join up any adjacent text nodes.
  if (start.AnchorNode()->IsTextNode()) {
    JoinChildTextNodes(start.AnchorNode()->parentNode(), start, end);
    start = StartPosition();
    end = EndPosition();
  }

  if (start.IsNull() || end.IsNull())
    return;

  if (end.AnchorNode()->IsTextNode() &&
      start.AnchorNode()->parentNode() != end.AnchorNode()->parentNode()) {
    JoinChildTextNodes(end.AnchorNode()->parentNode(), start, end);
    start = StartPosition();
    end = EndPosition();
  }

  if (start.IsNull() || end.IsNull())
    return;

  // Split the start text nodes if needed to apply style.
  if (IsValidCaretPositionInTextNode(start)) {
    SplitTextAtStart(start, end);
    start = StartPosition();
    end = EndPosition();
  }

  if (IsValidCaretPositionInTextNode(end)) {
    SplitTextAtEnd(start, end);
    start = StartPosition();
    end = EndPosition();
  }

  DCHECK(start.AnchorNode());
  DCHECK(end.AnchorNode());
  // Calculate loop end point.
  // If the end node is before the start node (can only happen if the end node
  // is an ancestor of the start node), we gather nodes up to the next sibling
  // of the end node
  const Node* const beyond_end = end.NodeAsRangePastLastNode();
  // Move upstream to ensure we do not add redundant spans.
  start = MostBackwardCaretPosition(start);
  Node* start_node = start.AnchorNode();
  DCHECK(start_node);

  // Make sure we're not already at the end or the next NodeTraversal::next()
  // will traverse past it.
  if (start_node == beyond_end)
    return;

  if (start_node->IsTextNode() &&
      start.ComputeOffsetInContainerNode() >= CaretMaxOffset(start_node)) {
    // Move out of text node if range does not include its characters.
    start_node = NodeTraversal::Next(*start_node);
    if (!start_node)
      return;
  }

  // Store away font size before making any changes to the document.
  // This ensures that changes to one node won't effect another.
  HeapHashMap<Member<Node>, float> starting_font_sizes;
  for (Node* node = start_node; node != beyond_end;
       node = NodeTraversal::Next(*node)) {
    DCHECK(node);
    starting_font_sizes.Set(node, ComputedFontSize(node));
  }

  // These spans were added by us. If empty after font size changes, they can be
  // removed.
  HeapVector<Member<HTMLElement>> unstyled_spans;

  Node* last_styled_node = nullptr;
  Node* node = start_node;
  while (node != beyond_end) {
    DCHECK(node);
    Node* const next_node = NodeTraversal::Next(*node);
    auto* element = DynamicTo<HTMLElement>(node);
    if (element) {
      // Only work on fully selected nodes.
      if (!ElementFullySelected(*element, start, end)) {
        node = next_node;
        continue;
      }
    } else if (node->IsTextNode() && node->GetLayoutObject() &&
               node->parentNode() != last_styled_node) {
      // Last styled node was not parent node of this text node, but we wish to
      // style this text node. To make this possible, add a style span to
      // surround this text node.
      auto* span = MakeGarbageCollected<HTMLSpanElement>(GetDocument());
      SurroundNodeRangeWithElement(node, node, span, editing_state);
      if (editing_state->IsAborted())
        return;
      element = span;
    } else {
      node = next_node;
      // Only handle HTML elements and text nodes.
      continue;
    }
    last_styled_node = node;

    MutableCSSPropertyValueSet* inline_style =
        CopyStyleOrCreateEmpty(element->InlineStyle());
    float current_font_size = ComputedFontSize(node);
    float desired_font_size =
        max(kMinimumFontSize,
            starting_font_sizes.at(node) + style->FontSizeDelta());
    const CSSValue* value =
        inline_style->GetPropertyCSSValue(CSSPropertyID::kFontSize);
    if (value) {
      element->RemoveInlineStyleProperty(CSSPropertyID::kFontSize);
      current_font_size = ComputedFontSize(node);
    }
    if (current_font_size != desired_font_size) {
      inline_style->SetProperty(
          CSSPropertyID::kFontSize,
          *CSSNumericLiteralValue::Create(desired_font_size,
                                          CSSPrimitiveValue::UnitType::kPixels),
          false);
      SetNodeAttribute(element, html_names::kStyleAttr,
                       AtomicString(inline_style->AsText()));
    }
    if (inline_style->IsEmpty()) {
      RemoveElementAttribute(element, html_names::kStyleAttr);
      if (IsSpanWithoutAttributesOrUnstyledStyleSpan(element))
        unstyled_spans.push_back(element);
    }
    node = next_node;
  }

  for (const auto& unstyled_span : unstyled_spans) {
    RemoveNodePreservingChildren(unstyled_span, editing_state);
    if (editing_state->IsAborted())
      return;
  }
}

static ContainerNode* DummySpanAncestorForNode(const Node* node) {
  if (!node)
    return nullptr;

  for (Node& current : NodeTraversal::InclusiveAncestorsOf(*node)) {
    if (IsStyleSpanOrSpanWithOnlyStyleAttribute(DynamicTo<Element>(current)))
      return current.parentNode();
  }
  return nullptr;
}

void ApplyStyleCommand::CleanupUnstyledAppleStyleSpans(
    ContainerNode* dummy_span_ancestor,
    EditingState* editing_state) {
  if (!dummy_span_ancestor)
    return;

  // Dummy spans are created when text node is split, so that style information
  // can be propagated, which can result in more splitting. If a dummy span gets
  // cloned/split, the new node is always a sibling of it. Therefore, we scan
  // all the children of the dummy's parent
  Node* next;
  for (Node* node = dummy_span_ancestor->firstChild(); node; node = next) {
    next = node->nextSibling();
    if (IsSpanWithoutAttributesOrUnstyledStyleSpan(node)) {
      RemoveNodePreservingChildren(node, editing_state);
      if (editing_state->IsAborted())
        return;
    }
  }
}

HTMLElement* ApplyStyleCommand::SplitAncestorsWithUnicodeBidi(
    Node* node,
    bool before,
    mojo_base::mojom::blink::TextDirection allowed_direction) {
  // We are allowed to leave the highest ancestor with unicode-bidi unsplit if
  // it is unicode-bidi: embed and direction: allowedDirection. In that case, we
  // return the unsplit ancestor. Otherwise, we return 0.
  Element* block = EnclosingBlock(node);
  if (!block)
    return nullptr;

  ContainerNode* highest_ancestor_with_unicode_bidi = nullptr;
  ContainerNode* next_highest_ancestor_with_unicode_bidi = nullptr;
  CSSValueID highest_ancestor_unicode_bidi = CSSValueID::kInvalid;
  for (Node& runner : NodeTraversal::AncestorsOf(*node)) {
    if (runner == block)
      break;
    CSSValueID unicode_bidi = GetIdentifierValue(
        MakeGarbageCollected<CSSComputedStyleDeclaration>(&runner),
        CSSPropertyID::kUnicodeBidi);
    if (IsValidCSSValueID(unicode_bidi) &&
        unicode_bidi != CSSValueID::kNormal) {
      highest_ancestor_unicode_bidi = unicode_bidi;
      next_highest_ancestor_with_unicode_bidi =
          highest_ancestor_with_unicode_bidi;
      highest_ancestor_with_unicode_bidi = static_cast<ContainerNode*>(&runner);
    }
  }

  if (!highest_ancestor_with_unicode_bidi)
    return nullptr;

  HTMLElement* unsplit_ancestor = nullptr;

  mojo_base::mojom::blink::TextDirection highest_ancestor_direction;
  auto* highest_ancestor_html_element =
      DynamicTo<HTMLElement>(highest_ancestor_with_unicode_bidi);
  if (allowed_direction !=
          mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION &&
      highest_ancestor_unicode_bidi != CSSValueID::kBidiOverride &&
      highest_ancestor_html_element &&
      MakeGarbageCollected<EditingStyle>(highest_ancestor_with_unicode_bidi,
                                         EditingStyle::kAllProperties)
          ->GetTextDirection(highest_ancestor_direction) &&
      highest_ancestor_direction == allowed_direction) {
    if (!next_highest_ancestor_with_unicode_bidi)
      return highest_ancestor_html_element;

    unsplit_ancestor = highest_ancestor_html_element;
    highest_ancestor_with_unicode_bidi =
        next_highest_ancestor_with_unicode_bidi;
  }

  // Split every ancestor through highest ancestor with embedding.
  Node* current_node = node;
  while (current_node) {
    auto* parent = To<Element>(current_node->parentNode());
    if (before ? current_node->previousSibling() : current_node->nextSibling())
      SplitElement(parent, before ? current_node : current_node->nextSibling());
    if (parent == highest_ancestor_with_unicode_bidi)
      break;
    current_node = parent;
  }
  return unsplit_ancestor;
}

void ApplyStyleCommand::RemoveEmbeddingUpToEnclosingBlock(
    Node* node,
    HTMLElement* unsplit_ancestor,
    EditingState* editing_state) {
  Element* block = EnclosingBlock(node);
  if (!block)
    return;

  for (Node& runner : NodeTraversal::AncestorsOf(*node)) {
    if (runner == block || runner == unsplit_ancestor)
      break;
    if (!runner.IsStyledElement())
      continue;

    auto* element = To<Element>(&runner);
    CSSValueID unicode_bidi = GetIdentifierValue(
        MakeGarbageCollected<CSSComputedStyleDeclaration>(element),
        CSSPropertyID::kUnicodeBidi);
    if (!IsValidCSSValueID(unicode_bidi) || unicode_bidi == CSSValueID::kNormal)
      continue;

    // FIXME: This code should really consider the mapped attribute 'dir', the
    // inline style declaration, and all matching style rules in order to
    // determine how to best set the unicode-bidi property to 'normal'. For now,
    // it assumes that if the 'dir' attribute is present, then removing it will
    // suffice, and otherwise it sets the property in the inline style
    // declaration.
    if (element->FastHasAttribute(html_names::kDirAttr)) {
      // FIXME: If this is a BDO element, we should probably just remove it if
      // it has no other attributes, like we (should) do with B and I elements.
      RemoveElementAttribute(element, html_names::kDirAttr);
    } else {
      MutableCSSPropertyValueSet* inline_style =
          CopyStyleOrCreateEmpty(element->InlineStyle());
      inline_style->SetProperty(CSSPropertyID::kUnicodeBidi,
                                CSSValueID::kNormal);
      inline_style->RemoveProperty(CSSPropertyID::kDirection);
      SetNodeAttribute(element, html_names::kStyleAttr,
                       AtomicString(inline_style->AsText()));
      if (IsSpanWithoutAttributesOrUnstyledStyleSpan(element)) {
        RemoveNodePreservingChildren(element, editing_state);
        if (editing_state->IsAborted())
          return;
      }
    }
  }
}

static HTMLElement* HighestEmbeddingAncestor(Node* start_node,
                                             Node* enclosing_node) {
  for (Node* n = start_node; n && n != enclosing_node; n = n->parentNode()) {
    auto* html_element = DynamicTo<HTMLElement>(n);
    if (html_element &&
        EditingStyleUtilities::IsEmbedOrIsolate(GetIdentifierValue(
            MakeGarbageCollected<CSSComputedStyleDeclaration>(n),
            CSSPropertyID::kUnicodeBidi))) {
      return html_element;
    }
  }

  return nullptr;
}

void ApplyStyleCommand::ApplyInlineStyle(EditingStyle* style,
                                         EditingState* editing_state) {
  ContainerNode* start_dummy_span_ancestor = nullptr;
  ContainerNode* end_dummy_span_ancestor = nullptr;

  // update document layout once before removing styles
  // so that we avoid the expense of updating before each and every call
  // to check a computed style
  GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);

  // adjust to the positions we want to use for applying style
  Position start = StartPosition();
  Position end = EndPosition();

  if (start.IsNull() || end.IsNull())
    return;

  if (ComparePositions(end, start) < 0) {
    Position swap = start;
    start = end;
    end = swap;
  }

  // split the start node and containing element if the selection starts inside
  // of it
  bool split_start = IsValidCaretPositionInTextNode(start);
  if (split_start) {
    if (ShouldSplitTextElement(start.AnchorNode()->parentElement(), style))
      SplitTextElementAtStart(start, end);
    else
      SplitTextAtStart(start, end);
    start = StartPosition();
    end = EndPosition();
    if (start.IsNull() || end.IsNull())
      return;
    start_dummy_span_ancestor = DummySpanAncestorForNode(start.AnchorNode());
  }

  // split the end node and containing element if the selection ends inside of
  // it
  bool split_end = IsValidCaretPositionInTextNode(end);
  if (split_end) {
    if (ShouldSplitTextElement(end.AnchorNode()->parentElement(), style))
      SplitTextElementAtEnd(start, end);
    else
      SplitTextAtEnd(start, end);
    start = StartPosition();
    end = EndPosition();
    if (start.IsNull() || end.IsNull())
      return;
    end_dummy_span_ancestor = DummySpanAncestorForNode(end.AnchorNode());
  }

  // Remove style from the selection.
  // Use the upstream position of the start for removing style.
  // This will ensure we remove all traces of the relevant styles from the
  // selection and prevent us from adding redundant ones, as described in:
  // <rdar://problem/3724344> Bolding and unbolding creates extraneous tags
  Position remove_start = MostBackwardCaretPosition(start);
  mojo_base::mojom::blink::TextDirection text_direction =
      mojo_base::mojom::blink::TextDirection::UNKNOWN_DIRECTION;
  bool has_text_direction = style->GetTextDirection(text_direction);
  EditingStyle* style_without_embedding = nullptr;
  EditingStyle* embedding_style = nullptr;
  if (has_text_direction) {
    // Leave alone an ancestor that provides the desired single level embedding,
    // if there is one.
    HTMLElement* start_unsplit_ancestor =
        SplitAncestorsWithUnicodeBidi(start.AnchorNode(), true, text_direction);
    HTMLElement* end_unsplit_ancestor =
        SplitAncestorsWithUnicodeBidi(end.AnchorNode(), false, text_direction);
    RemoveEmbeddingUpToEnclosingBlock(start.AnchorNode(),
                                      start_unsplit_ancestor, editing_state);
    if (editing_state->IsAborted())
      return;
    RemoveEmbeddingUpToEnclosingBlock(end.AnchorNode(), end_unsplit_ancestor,
                                      editing_state);
    if (editing_state->IsAborted())
      return;

    // Avoid removing the dir attribute and the unicode-bidi and direction
    // properties from the unsplit ancestors.
    Position embedding_remove_start = remove_start;
    if (start_unsplit_ancestor &&
        ElementFullySelected(*start_unsplit_ancestor, remove_start, end))
      embedding_remove_start =
          Position::InParentAfterNode(*start_unsplit_ancestor);

    Position embedding_remove_end = end;
    if (end_unsplit_ancestor &&
        ElementFullySelected(*end_unsplit_ancestor, remove_start, end))
      embedding_remove_end = MostForwardCaretPosition(
          Position::InParentBeforeNode(*end_unsplit_ancestor));

    if (embedding_remove_end != remove_start || embedding_remove_end != end) {
      style_without_embedding = style->Copy();
      embedding_style = style_without_embedding->ExtractAndRemoveTextDirection(
          GetDocument().GetExecutionContext()->GetSecureContextMode());

      if (ComparePositions(embedding_remove_start, embedding_remove_end) <= 0) {
        RemoveInlineStyle(
            embedding_style,
            EphemeralRange(embedding_remove_start, embedding_remove_end),
            editing_state);
        if (editing_state->IsAborted())
          return;
      }
    }
  }

  RemoveInlineStyle(style_without_embedding ? style_without_embedding : style,
                    EphemeralRange(remove_start, end), editing_state);
  if (editing_state->IsAborted())
    return;
  start = StartPosition();
  end = EndPosition();
  if (start.IsNull() || start.IsOrphan() || end.IsNull() || end.IsOrphan())
    return;

  if (split_start) {
    bool merge_result =
        MergeStartWithPreviousIfIdentical(start, end, editing_state);
    if (editing_state->IsAborted())
      return;
    if (split_start && merge_result) {
      start = StartPosition();
      end = EndPosition();
    }
  }

  if (split_end) {
    MergeEndWithNextIfIdentical(start, end, editing_state);
    if (editing_state->IsAborted())
      return;
    start = StartPosition();
    end = EndPosition();
  }

  // update document layout once before running the rest of the function
  // so that we avoid the expense of updating before each and every call
  // to check a computed style
  GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);

  EditingStyle* style_to_apply = style;
  if (has_text_direction) {
    // Avoid applying the unicode-bidi and direction properties beneath
    // ancestors that already have them.
    HTMLElement* embedding_start_element = HighestEmbeddingAncestor(
        start.AnchorNode(), EnclosingBlock(start.AnchorNode()));
    HTMLElement* embedding_end_element = HighestEmbeddingAncestor(
        end.AnchorNode(), EnclosingBlock(end.AnchorNode()));

    if (embedding_start_element || embedding_end_element) {
      Position embedding_apply_start =
          embedding_start_element
              ? Position::InParentAfterNode(*embedding_start_element)
              : start;
      Position embedding_apply_end =
          embedding_end_element
              ? Position::InParentBeforeNode(*embedding_end_element)
              : end;
      DCHECK(embedding_apply_start.IsNotNull());
      DCHECK(embedding_apply_end.IsNotNull());

      if (!embedding_style) {
        style_without_embedding = style->Copy();
        embedding_style =
            style_without_embedding->ExtractAndRemoveTextDirection(
                GetDocument().GetExecutionContext()->GetSecureContextMode());
      }
      FixRangeAndApplyInlineStyle(embedding_style, embedding_apply_start,
                                  embedding_apply_end, editing_state);
      if (editing_state->IsAborted())
        return;

      style_to_apply = style_without_embedding;
    }
  }

  GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);
  FixRangeAndApplyInlineStyle(style_to_apply, start, end, editing_state);
  if (editing_state->IsAborted())
    return;

  // Remove dummy style spans created by splitting text elements.
  CleanupUnstyledAppleStyleSpans(start_dummy_span_ancestor, editing_state);
  if (editing_state->IsAborted())
    return;
  if (end_dummy_span_ancestor != start_dummy_span_ancestor)
    CleanupUnstyledAppleStyleSpans(end_dummy_span_ancestor, editing_state);
}

void ApplyStyleCommand::FixRangeAndApplyInlineStyle(
    EditingStyle* style,
    const Position& start,
    const Position& end,
    EditingState* editing_state) {
  Node* start_node = start.AnchorNode();
  DCHECK(start_node);

  if (start.ComputeEditingOffset() >= CaretMaxOffset(start.AnchorNode())) {
    start_node = NodeTraversal::Next(*start_node);
    if (!start_node ||
        ComparePositions(end, FirstPositionInOrBeforeNode(*start_node)) < 0)
      return;
  }

  Node* past_end_node = end.AnchorNode();
  if (end.ComputeEditingOffset() >= CaretMaxOffset(end.AnchorNode()))
    past_end_node = NodeTraversal::NextSkippingChildren(*end.AnchorNode());

  // FIXME: Callers should perform this operation on a Range that includes the
  // br if they want style applied to the empty line.
  if (start == end && IsA<HTMLBRElement>(*start.AnchorNode()))
    past_end_node = NodeTraversal::Next(*start.AnchorNode());

  // Start from the highest fully selected ancestor so that we can modify the
  // fully selected node. e.g. When applying font-size: large on <font
  // color="blue">hello</font>, we need to include the font element in our run
  // to generate <font color="blue" size="4">hello</font> instead of <font
  // color="blue"><font size="4">hello</font></font>
  Element* editable_root = RootEditableElement(*start_node);
  if (start_node != editable_root) {
    // TODO(editing-dev): Investigate why |start| can be after |end| here in
    // some cases. For example, in web test
    // editing/style/make-text-writing-direction-inline-{mac,win}.html
    // blink::Range object will collapse to end in this case but EphemeralRange
    // will trigger DCHECK, so we have to explicitly handle this.
    const EphemeralRange& range =
        start <= end ? EphemeralRange(start, end) : EphemeralRange(end, start);
    while (editable_root && start_node->parentNode() != editable_root &&
           IsNodeVisiblyContainedWithin(*start_node->parentNode(), range))
      start_node = start_node->parentNode();
  }

  ApplyInlineStyleToNodeRange(style, start_node, past_end_node, editing_state);
}

static bool ContainsNonEditableRegion(Node& node) {
  if (!HasEditableStyle(node))
    return true;

  Node* sibling = NodeTraversal::NextSkippingChildren(node);
  for (Node* descendent = node.firstChild();
       descendent && descendent != sibling;
       descendent = NodeTraversal::Next(*descendent)) {
    if (!HasEditableStyle(*descendent))
      return true;
  }

  return false;
}

class InlineRunToApplyStyle {
  DISALLOW_NEW();

 public:
  InlineRunToApplyStyle(Node* start, Node* end, Node* past_end_node)
      : start(start), end(end), past_end_node(past_end_node) {
    DCHECK_EQ(start->parentNode(), end->parentNode());
  }

  bool StartAndEndAreStillInDocument() {
    return start && end && start->isConnected() && end->isConnected();
  }

  void Trace(Visitor* visitor) const {
    visitor->Trace(start);
    visitor->Trace(end);
    visitor->Trace(past_end_node);
    visitor->Trace(position_for_style_computation);
    visitor->Trace(dummy_element);
  }

  Member<Node> start;
  Member<Node> end;
  Member<Node> past_end_node;
  Position position_for_style_computation;
  Member<HTMLSpanElement> dummy_element;
  StyleChange change;
};

}  // namespace blink

WTF_ALLOW_INIT_WITH_MEM_FUNCTIONS(blink::InlineRunToApplyStyle)

namespace blink {

void ApplyStyleCommand::ApplyInlineStyleToNodeRange(
    EditingStyle* style,
    Node* start_node,
    Node* past_end_node,
    EditingState* editing_state) {
  if (remove_only_)
    return;

  GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);

  HeapVector<InlineRunToApplyStyle> runs;
  Node* node = start_node;
  for (Node* next; node && node != past_end_node; node = next) {
    next = NodeTraversal::Next(*node);

    if (!node->GetLayoutObject() || !HasEditableStyle(*node))
      continue;

    auto* element = DynamicTo<HTMLElement>(node);
    if (!HasRichlyEditableStyle(*node) && element) {
      // This is a plaintext-only region. Only proceed if it's fully selected.
      // pastEndNode is the node after the last fully selected node, so if it's
      // inside node then node isn't fully selected.
      if (past_end_node && past_end_node->IsDescendantOf(element))
        break;
      // Add to this element's inline style and skip over its contents.
      next = NodeTraversal::NextSkippingChildren(*node);
      if (!style->Style())
        continue;
      MutableCSSPropertyValueSet* inline_style =
          CopyStyleOrCreateEmpty(element->InlineStyle());
      inline_style->MergeAndOverrideOnConflict(style->Style());
      SetNodeAttribute(element, html_names::kStyleAttr,
                       AtomicString(inline_style->AsText()));
      continue;
    }

    if (IsEnclosingBlock(node))
      continue;

    if (node->hasChildren()) {
      if (node->contains(past_end_node) || ContainsNonEditableRegion(*node) ||
          !HasEditableStyle(*node->parentNode()))
        continue;
      if (EditingIgnoresContent(*node)) {
        next = NodeTraversal::NextSkippingChildren(*node);
        continue;
      }
    }

    Node* run_start = node;
    Node* run_end = node;
    Node* sibling = node->nextSibling();
    while (sibling && sibling != past_end_node &&
           !sibling->contains(past_end_node) &&
           (!IsEnclosingBlock(sibling) || IsA<HTMLBRElement>(*sibling)) &&
           !ContainsNonEditableRegion(*sibling)) {
      run_end = sibling;
      sibling = run_end->nextSibling();
    }
    DCHECK(run_end);
    next = NodeTraversal::NextSkippingChildren(*run_end);

    Node* past_run_end_node = NodeTraversal::NextSkippingChildren(*run_end);
    if (!ShouldApplyInlineStyleToRun(style, run_start, past_run_end_node))
      continue;

    runs.push_back(
        InlineRunToApplyStyle(run_start, run_end, past_run_end_node));
  }

  for (auto& run : runs) {
    RemoveConflictingInlineStyleFromRun(style, run.start, run.end,
                                        run.past_end_node, editing_state);
    if (editing_state->IsAborted())
      return;
    if (run.StartAndEndAreStillInDocument()) {
      run.position_for_style_computation = PositionToComputeInlineStyleChange(
          run.start, run.dummy_element, editing_state);
      if (editing_state->IsAborted())
        return;
    }
  }

  GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);

  for (auto& run : runs) {
    if (run.position_for_style_computation.IsNotNull())
      run.change = StyleChange(style, run.position_for_style_computation);
  }

  for (auto& run : runs) {
    if (run.dummy_element) {
      RemoveNode(run.dummy_element, editing_state);
      if (editing_state->IsAborted())
        return;
    }
    if (run.StartAndEndAreStillInDocument()) {
      ApplyInlineStyleChange(run.start.Release(), run.end.Release(), run.change,
                             kAddStyledElement, editing_state);
      if (editing_state->IsAborted())
        return;
    }
  }
}

bool ApplyStyleCommand::IsStyledInlineElementToRemove(Element* element) const {
  return (styled_inline_element_ &&
          element->HasTagName(styled_inline_element_->TagQName())) ||
         (is_inline_element_to_remove_function_ &&
          is_inline_element_to_remove_function_(element));
}

bool ApplyStyleCommand::ShouldApplyInlineStyleToRun(EditingStyle* style,
                                                    Node* run_start,
                                                    Node* past_end_node) {
  DCHECK(style);
  DCHECK(run_start);

  for (Node* node = run_start; node && node != past_end_node;
       node = NodeTraversal::Next(*node)) {
    if (node->hasChildren())
      continue;
    // We don't consider is_inline_element_to_remove_function_ here because we
    // never apply style when is_inline_element_to_remove_function_ is specified
    if (!style->StyleIsPresentInComputedStyleOfNode(node))
      return true;
    if (styled_inline_element_ &&
        !EnclosingElementWithTag(Position::BeforeNode(*node),
                                 styled_inline_element_->TagQName()))
      return true;
  }
  return false;
}

void ApplyStyleCommand::RemoveConflictingInlineStyleFromRun(
    EditingStyle* style,
    Member<Node>& run_start,
    Member<Node>& run_end,
    Node* past_end_node,
    EditingState* editing_state) {
  DCHECK(run_start);
  DCHECK(run_end);
  Node* next = run_start;
  for (Node* node = next; node && node->isConnected() && node != past_end_node;
       node = next) {
    if (EditingIgnoresContent(*node)) {
      DCHECK(!node->contains(past_end_node)) << node << " " << past_end_node;
      next = NodeTraversal::NextSkippingChildren(*node);
    } else {
      next = NodeTraversal::Next(*node);
    }

    auto* element = DynamicTo<HTMLElement>(*node);
    if (!element)
      continue;

    Node* previous_sibling = element->previousSibling();
    Node* next_sibling = element->nextSibling();
    ContainerNode* parent = element->parentNode();
    RemoveInlineStyleFromElement(style, element, editing_state, kRemoveAlways);
    if (editing_state->IsAborted())
      return;
    if (!element->isConnected()) {
      // FIXME: We might need to update the start and the end of current
      // selection here but need a test.
      if (run_start == *element)
        run_start = previous_sibling ? previous_sibling->nextSibling()
                                     : parent->firstChild();
      if (run_end == *element)
        run_end = next_sibling ? next_sibling->previousSibling()
                               : parent->lastChild();
    }
  }
}

bool ApplyStyleCommand::RemoveInlineStyleFromElement(
    EditingStyle* style,
    HTMLElement* element,
    EditingState* editing_state,
    InlineStyleRemovalMode mode,
    EditingStyle* extracted_style) {
  DCHECK(element);
  GetDocument().UpdateStyleAndLayoutTree();
  if (!element->parentNode() || !HasEditableStyle(*element->parentNode()))
    return false;

  if (IsStyledInlineElementToRemove(element)) {
    if (mode == kRemoveNone)
      return true;
    if (extracted_style)
      extracted_style->MergeInlineStyleOfElement(element,
                                                 EditingStyle::kOverrideValues);
    RemoveNodePreservingChildren(element, editing_state);
    if (editing_state->IsAborted())
      return false;
    return true;
  }

  bool removed = RemoveImplicitlyStyledElement(style, element, mode,
                                               extracted_style, editing_state);
  if (editing_state->IsAborted())
    return false;

  if (!element->isConnected())
    return removed;

  // If the node was converted to a span, the span may still contain relevant
  // styles which must be removed (e.g. <b style='font-weight: bold'>)
  if (RemoveCSSStyle(style, element, editing_state, mode, extracted_style))
    removed = true;
  if (editing_state->IsAborted())
    return false;

  return removed;
}

void ApplyStyleCommand::ReplaceWithSpanOrRemoveIfWithoutAttributes(
    HTMLElement* elem,
    EditingState* editing_state) {
  if (HasNoAttributeOrOnlyStyleAttribute(elem, kStyleAttributeShouldBeEmpty))
    RemoveNodePreservingChildren(elem, editing_state);
  else
    ReplaceElementWithSpanPreservingChildrenAndAttributes(elem);
}

bool ApplyStyleCommand::RemoveImplicitlyStyledElement(
    EditingStyle* style,
    HTMLElement* element,
    InlineStyleRemovalMode mode,
    EditingStyle* extracted_style,
    EditingState* editing_state) {
  DCHECK(style);
  if (mode == kRemoveNone) {
    DCHECK(!extracted_style);
    return style->ConflictsWithImplicitStyleOfElement(element) ||
           style->ConflictsWithImplicitStyleOfAttributes(element);
  }

  DCHECK(mode == kRemoveIfNeeded || mode == kRemoveAlways);
  if (style->ConflictsWithImplicitStyleOfElement(
          element, extracted_style,
          mode == kRemoveAlways ? EditingStyle::kExtractMatchingStyle
                                : EditingStyle::kDoNotExtractMatchingStyle)) {
    ReplaceWithSpanOrRemoveIfWithoutAttributes(element, editing_state);
    if (editing_state->IsAborted())
      return false;
    return true;
  }

  // unicode-bidi and direction are pushed down separately so don't push down
  // with other styles
  Vector<QualifiedName> attributes;
  if (!style->ExtractConflictingImplicitStyleOfAttributes(
          element,
          extracted_style ? EditingStyle::kPreserveWritingDirection
                          : EditingStyle::kDoNotPreserveWritingDirection,
          extracted_style, attributes,
          mode == kRemoveAlways ? EditingStyle::kExtractMatchingStyle
                                : EditingStyle::kDoNotExtractMatchingStyle))
    return false;

  for (const auto& attribute : attributes)
    RemoveElementAttribute(element, attribute);

  if (IsEmptyFontTag(element) ||
      IsSpanWithoutAttributesOrUnstyledStyleSpan(element)) {
    RemoveNodePreservingChildren(element, editing_state);
    if (editing_state->IsAborted())
      return false;
  }

  return true;
}

bool ApplyStyleCommand::RemoveCSSStyle(EditingStyle* style,
                                       HTMLElement* element,
                                       EditingState* editing_state,
                                       InlineStyleRemovalMode mode,
                                       EditingStyle* extracted_style) {
  DCHECK(style);
  DCHECK(element);

  if (mode == kRemoveNone)
    return style->ConflictsWithInlineStyleOfElement(element);

  Vector<CSSPropertyID> properties;
  if (!style->ConflictsWithInlineStyleOfElement(element, extracted_style,
                                                properties))
    return false;

  // FIXME: We should use a mass-removal function here but we don't have an
  // undoable one yet.
  for (const auto& property : properties)
    RemoveCSSProperty(element, property);

  if (IsSpanWithoutAttributesOrUnstyledStyleSpan(element))
    RemoveNodePreservingChildren(element, editing_state);

  return true;
}

// Finds the enclosing element until which the tree can be split.
// When a user hits ENTER, they won't expect this element to be split into two.
// You may pass it as the second argument of splitTreeToNode.
static Element* UnsplittableElementForPosition(const Position& p) {
  // Since enclosingNodeOfType won't search beyond the highest root editable
  // node, this code works even if the closest table cell was outside of the
  // root editable node.
  auto* enclosing_cell = To<Element>(EnclosingNodeOfType(p, &IsTableCell));
  if (enclosing_cell)
    return enclosing_cell;

  return RootEditableElementOf(p);
}

HTMLElement* ApplyStyleCommand::HighestAncestorWithConflictingInlineStyle(
    EditingStyle* style,
    Node* node) {
  if (!node)
    return nullptr;

  Node* unsplittable_element =
      UnsplittableElementForPosition(FirstPositionInOrBeforeNode(*node));
  HTMLElement* result = nullptr;
  for (Node* n = node; n; n = n->parentNode()) {
    auto* html_element = DynamicTo<HTMLElement>(n);
    if (html_element && ShouldRemoveInlineStyleFromElement(style, html_element))
      result = html_element;
    // Should stop at the editable root (cannot cross editing boundary) and
    // also stop at the unsplittable element to be consistent with other UAs
    if (n == unsplittable_element)
      break;
  }

  return result;
}

void ApplyStyleCommand::ApplyInlineStyleToPushDown(
    Node* node,
    EditingStyle* style,
    EditingState* editing_state) {
  DCHECK(node);

  node->GetDocument().UpdateStyleAndLayoutTree();

  if (!style || style->IsEmpty() || !node->GetLayoutObject() ||
      IsA<HTMLIFrameElement>(*node))
    return;

  EditingStyle* new_inline_style = style;
  auto* html_element = DynamicTo<HTMLElement>(node);
  if (html_element && html_element->InlineStyle()) {
    new_inline_style = style->Copy();
    new_inline_style->MergeInlineStyleOfElement(html_element,
                                                EditingStyle::kOverrideValues);
  }

  const auto* layout_object = node->GetLayoutObject();
  // Since addInlineStyleIfNeeded can't add styles to block-flow layout objects,
  // add style attribute instead.
  // FIXME: applyInlineStyleToRange should be used here instead.
  if ((layout_object->IsLayoutBlockFlow() || node->hasChildren()) &&
      html_element) {
    SetNodeAttribute(html_element, html_names::kStyleAttr,
                     AtomicString(new_inline_style->Style()->AsText()));
    return;
  }

  if (layout_object->IsText() &&
      To<LayoutText>(layout_object)->IsAllCollapsibleWhitespace())
    return;

  // We can't wrap node with the styled element here because new styled element
  // will never be removed if we did. If we modified the child pointer in
  // pushDownInlineStyleAroundNode to point to new style element then we fall
  // into an infinite loop where we keep removing and adding styled element
  // wrapping node.
  AddInlineStyleIfNeeded(new_inline_style, node, node, editing_state);
}

void ApplyStyleCommand::PushDownInlineStyleAroundNode(
    EditingStyle* style,
    Node* target_node,
    EditingState* editing_state) {
  HTMLElement* highest_ancestor =
      HighestAncestorWithConflictingInlineStyle(style, target_node);
  if (!highest_ancestor)
    return;

  // The outer loop is traversing the tree vertically from highestAncestor to
  // targetNode
  Node* current = highest_ancestor;
  // Along the way, styled elements that contain targetNode are removed and
  // accumulated into elementsToPushDown. Each child of the removed element,
  // exclusing ancestors of targetNode, is then wrapped by clones of elements in
  // elementsToPushDown.
  HeapVector<Member<Element>> elements_to_push_down;
  while (current && current != target_node && current->contains(target_node)) {
    NodeVector current_children;
    GetChildNodes(To<ContainerNode>(*current), current_children);
    Element* styled_element = nullptr;
    if (current->IsStyledElement() &&
        IsStyledInlineElementToRemove(To<Element>(current))) {
      styled_element = To<Element>(current);
      elements_to_push_down.push_back(styled_element);
    }

    EditingStyle* style_to_push_down = MakeGarbageCollected<EditingStyle>();
    if (auto* html_element = DynamicTo<HTMLElement>(current)) {
      RemoveInlineStyleFromElement(style, html_element, editing_state,
                                   kRemoveIfNeeded, style_to_push_down);
      if (editing_state->IsAborted())
        return;
    }

    // The inner loop will go through children on each level
    // FIXME: we should aggregate inline child elements together so that we
    // don't wrap each child separately.
    for (const auto& current_child : current_children) {
      Node* child = current_child;
      if (!child->parentNode())
        continue;
      if (!child->contains(target_node) && elements_to_push_down.size()) {
        for (const auto& element : elements_to_push_down) {
          Element& wrapper = element->CloneWithoutChildren();
          wrapper.removeAttribute(html_names::kStyleAttr);
          // Delete id attribute from the second element because the same id
          // cannot be used for more than one element
          element->removeAttribute(html_names::kIdAttr);
          if (IsA<HTMLAnchorElement>(element.Get()))
            element->removeAttribute(html_names::kNameAttr);
          SurroundNodeRangeWithElement(child, child, &wrapper, editing_state);
          if (editing_state->IsAborted())
            return;
        }
      }

      // Apply style to all nodes containing targetNode and their siblings but
      // NOT to targetNode But if we've removed styledElement then go ahead and
      // always apply the style.
      if (child != target_node || styled_element) {
        ApplyInlineStyleToPushDown(child, style_to_push_down, editing_state);
        if (editing_state->IsAborted())
          return;
      }

      // We found the next node for the outer loop (contains targetNode)
      // When reached targetNode, stop the outer loop upon the completion of the
      // current inner loop
      if (child == target_node || child->contains(target_node))
        current = child;
    }
  }
}

void ApplyStyleCommand::RemoveInlineStyle(EditingStyle* style,
                                          const EphemeralRange& range,
                                          EditingState* editing_state) {
  const Position& start = range.StartPosition();
  const Position& end = range.EndPosition();
  DCHECK(Position::CommonAncestorTreeScope(start, end)) << start << " " << end;
  // FIXME: We should assert that start/end are not in the middle of a text
  // node.

  // TODO(editing-dev): Use of UpdateStyleAndLayout
  // needs to be audited.  See http://crbug.com/590369 for more details.
  GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);

  Position push_down_start = MostForwardCaretPosition(start);
  // If the pushDownStart is at the end of a text node, then this node is not
  // fully selected. Move it to the next deep quivalent position to avoid
  // removing the style from this node. e.g. if pushDownStart was at
  // Position("hello", 5) in <b>hello<div>world</div></b>, we want
  // Position("world", 0) instead.
  const unsigned push_down_start_offset =
      push_down_start.ComputeOffsetInContainerNode();
  auto* push_down_start_container =
      DynamicTo<Text>(push_down_start.ComputeContainerNode());
  if (push_down_start_container &&
      push_down_start_offset == push_down_start_container->length())
    push_down_start = NextVisuallyDistinctCandidate(push_down_start);

  // TODO(editing-dev): Use of UpdateStyleAndLayout
  // needs to be audited.  See http://crbug.com/590369 for more details.
  GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);

  Position push_down_end = MostBackwardCaretPosition(end);
  // If pushDownEnd is at the start of a text node, then this node is not fully
  // selected. Move it to the previous deep equivalent position to avoid
  // removing the style from this node.
  Node* push_down_end_container = push_down_end.ComputeContainerNode();
  if (push_down_end_container && push_down_end_container->IsTextNode() &&
      !push_down_end.ComputeOffsetInContainerNode())
    push_down_end = PreviousVisuallyDistinctCandidate(push_down_end);

  PushDownInlineStyleAroundNode(style, push_down_start.AnchorNode(),
                                editing_state);
  if (editing_state->IsAborted())
    return;
  PushDownInlineStyleAroundNode(style, push_down_end.AnchorNode(),
                                editing_state);
  if (editing_state->IsAborted())
    return;

  // The s and e variables store the positions used to set the ending selection
  // after style removal takes place. This will help callers to recognize when
  // either the start node or the end node are removed from the document during
  // the work of this function.
  // If pushDownInlineStyleAroundNode has pruned start.anchorNode() or
  // end.anchorNode(), use pushDownStart or pushDownEnd instead, which
  // pushDownInlineStyleAroundNode won't prune.
  Position s = start.IsNull() || start.IsOrphan() ? push_down_start : start;
  Position e = end.IsNull() || end.IsOrphan() ? push_down_end : end;

  // Current ending selection resetting algorithm assumes |start| and |end|
  // are in a same DOM tree even if they are not in document.
  if (!Position::CommonAncestorTreeScope(start, end))
    return;

  Node* node = start.AnchorNode();
  while (node) {
    Node* next_to_process = nullptr;
    if (EditingIgnoresContent(*node)) {
      DCHECK(node == end.AnchorNode() || !node->contains(end.AnchorNode()))
          << node << " " << end;
      next_to_process = NodeTraversal::NextSkippingChildren(*node);
    } else {
      next_to_process = NodeTraversal::Next(*node);
    }
    auto* elem = DynamicTo<HTMLElement>(node);
    if (elem && ElementFullySelected(*elem, start, end)) {
      Node* prev = NodeTraversal::PreviousPostOrder(*elem);
      Node* next = NodeTraversal::Next(*elem);
      EditingStyle* style_to_push_down = nullptr;
      Node* child_node = nullptr;
      if (IsStyledInlineElementToRemove(elem)) {
        style_to_push_down = MakeGarbageCollected<EditingStyle>();
        child_node = elem->firstChild();
      }

      RemoveInlineStyleFromElement(style, elem, editing_state, kRemoveIfNeeded,
                                   style_to_push_down);
      if (editing_state->IsAborted())
        return;
      if (!elem->isConnected()) {
        if (s.AnchorNode() == elem) {
          // Since elem must have been fully selected, and it is at the start
          // of the selection, it is clear we can set the new s offset to 0.
          DCHECK(s.IsBeforeAnchor() || s.IsBeforeChildren() ||
                 s.OffsetInContainerNode() <= 0)
              << s;
          s = next ? FirstPositionInOrBeforeNode(*next) : Position();
        }
        if (e.AnchorNode() == elem) {
          // Since elem must have been fully selected, and it is at the end
          // of the selection, it is clear we can set the new e offset to
          // the max range offset of prev.
          DCHECK(s.IsAfterAnchor() ||
                 !OffsetIsBeforeLastNodeOffset(s.OffsetInContainerNode(),
                                               s.ComputeContainerNode()))
              << s;
          e = prev ? LastPositionInOrAfterNode(*prev) : Position();
        }
      }

      if (style_to_push_down) {
        for (; child_node; child_node = child_node->nextSibling()) {
          ApplyInlineStyleToPushDown(child_node, style_to_push_down,
                                     editing_state);
          if (editing_state->IsAborted())
            return;
        }
      }
    }
    if (node == end.AnchorNode())
      break;
    node = next_to_process;
  }

  UpdateStartEnd(EphemeralRange(s, e));
}

bool ApplyStyleCommand::ElementFullySelected(const HTMLElement& element,
                                             const Position& start,
                                             const Position& end) const {
  // The tree may have changed and Position::upstream() relies on an up-to-date
  // layout.
  element.GetDocument().UpdateStyleAndLayout(DocumentUpdateReason::kEditing);

  return ComparePositions(FirstPositionInOrBeforeNode(element), start) >= 0 &&
         ComparePositions(
             MostBackwardCaretPosition(LastPositionInOrAfterNode(element)),
             end) <= 0;
}

void ApplyStyleCommand::SplitTextAtStart(const Position& start,
                                         const Position& end) {
  DCHECK(start.ComputeContainerNode()->IsTextNode()) << start;

  Position new_end;
  if (end.IsOffsetInAnchor() &&
      start.ComputeContainerNode() == end.ComputeContainerNode())
    new_end =
        Position(end.ComputeContainerNode(),
                 end.OffsetInContainerNode() - start.OffsetInContainerNode());
  else
    new_end = end;

  auto* text = To<Text>(start.ComputeContainerNode());
  SplitTextNode(text, start.OffsetInContainerNode());
  UpdateStartEnd(EphemeralRange(Position::FirstPositionInNode(*text), new_end));
}

void ApplyStyleCommand::SplitTextAtEnd(const Position& start,
                                       const Position& end) {
  DCHECK(end.ComputeContainerNode()->IsTextNode()) << end;

  bool should_update_start =
      start.IsOffsetInAnchor() &&
      start.ComputeContainerNode() == end.ComputeContainerNode();
  auto* text = To<Text>(end.AnchorNode());
  SplitTextNode(text, end.OffsetInContainerNode());

  auto* prev_text_node = DynamicTo<Text>(text->previousSibling());
  if (!prev_text_node)
    return;

  Position new_start =
      should_update_start
          ? Position(prev_text_node, start.OffsetInContainerNode())
          : start;
  UpdateStartEnd(
      EphemeralRange(new_start, Position::LastPositionInNode(*prev_text_node)));
}

void ApplyStyleCommand::SplitTextElementAtStart(const Position& start,
                                                const Position& end) {
  DCHECK(start.ComputeContainerNode()->IsTextNode()) << start;

  Position new_end;
  if (start.ComputeContainerNode() == end.ComputeContainerNode())
    new_end =
        Position(end.ComputeContainerNode(),
                 end.OffsetInContainerNode() - start.OffsetInContainerNode());
  else
    new_end = end;

  SplitTextNodeContainingElement(To<Text>(start.ComputeContainerNode()),
                                 start.OffsetInContainerNode());
  UpdateStartEnd(EphemeralRange(
      Position::BeforeNode(*start.ComputeContainerNode()), new_end));
}

void ApplyStyleCommand::SplitTextElementAtEnd(const Position& start,
                                              const Position& end) {
  DCHECK(end.ComputeContainerNode()->IsTextNode()) << end;

  bool should_update_start =
      start.ComputeContainerNode() == end.ComputeContainerNode();
  SplitTextNodeContainingElement(To<Text>(end.ComputeContainerNode()),
                                 end.OffsetInContainerNode());

  Node* parent_element = end.ComputeContainerNode()->parentNode();
  if (!parent_element || !parent_element->previousSibling())
    return;

  auto* first_text_node =
      DynamicTo<Text>(parent_element->previousSibling()->lastChild());
  if (!first_text_node)
    return;

  Position new_start =
      should_update_start
          ? Position(first_text_node, start.OffsetInContainerNode())
          : start;
  UpdateStartEnd(
      EphemeralRange(new_start, Position::AfterNode(*first_text_node)));
}

bool ApplyStyleCommand::ShouldSplitTextElement(Element* element,
                                               EditingStyle* style) {
  auto* html_element = DynamicTo<HTMLElement>(element);
  if (!html_element)
    return false;

  return ShouldRemoveInlineStyleFromElement(style, html_element);
}

bool ApplyStyleCommand::IsValidCaretPositionInTextNode(
    const Position& position) {
  DCHECK(position.IsNotNull());

  Node* node = position.ComputeContainerNode();
  if (!position.IsOffsetInAnchor() || !node->IsTextNode())
    return false;
  int offset_in_text = position.OffsetInContainerNode();
  return offset_in_text > CaretMinOffset(node) &&
         offset_in_text < CaretMaxOffset(node);
}

bool ApplyStyleCommand::MergeStartWithPreviousIfIdentical(
    const Position& start,
    const Position& end,
    EditingState* editing_state) {
  Node* start_node = start.ComputeContainerNode();
  int start_offset = start.ComputeOffsetInContainerNode();
  if (start_offset)
    return false;

  if (IsAtomicNode(start_node)) {
    // note: prior siblings could be unrendered elements. it's silly to miss the
    // merge opportunity just for that.
    if (start_node->previousSibling())
      return false;

    start_node = start_node->parentNode();
  }

  if (!start_node->IsElementNode())
    return false;

  Node* previous_sibling = start_node->previousSibling();

  if (previous_sibling &&
      AreIdenticalElements(*start_node, *previous_sibling)) {
    auto* previous_element = To<Element>(previous_sibling);
    auto* element = To<Element>(start_node);
    Node* start_child = element->firstChild();
    DCHECK(start_child);
    MergeIdenticalElements(previous_element, element, editing_state);
    if (editing_state->IsAborted())
      return false;

    int start_offset_adjustment = start_child->NodeIndex();
    int end_offset_adjustment =
        start_node == end.AnchorNode() ? start_offset_adjustment : 0;
    UpdateStartEnd(EphemeralRange(
        Position(start_node, start_offset_adjustment),
        Position(end.AnchorNode(),
                 end.ComputeEditingOffset() + end_offset_adjustment)));
    return true;
  }

  return false;
}

bool ApplyStyleCommand::MergeEndWithNextIfIdentical(
    const Position& start,
    const Position& end,
    EditingState* editing_state) {
  Node* end_node = end.ComputeContainerNode();

  if (IsAtomicNode(end_node)) {
    int end_offset = end.ComputeOffsetInContainerNode();
    if (OffsetIsBeforeLastNodeOffset(end_offset, end_node))
      return false;

    if (end.AnchorNode()->nextSibling())
      return false;

    end_node = end.AnchorNode()->parentNode();
  }

  if (!end_node->IsElementNode() || IsA<HTMLBRElement>(*end_node))
    return false;

  Node* next_sibling = end_node->nextSibling();
  if (next_sibling && AreIdenticalElements(*end_node, *next_sibling)) {
    auto* next_element = To<Element>(next_sibling);
    auto* element = To<Element>(end_node);
    Node* next_child = next_element->firstChild();

    MergeIdenticalElements(element, next_element, editing_state);
    if (editing_state->IsAborted())
      return false;

    bool should_update_start = start.ComputeContainerNode() == end_node;
    int end_offset = next_child ? next_child->NodeIndex()
                                : next_element->childNodes()->length();
    UpdateStartEnd(EphemeralRange(
        should_update_start
            ? Position(next_element, start.OffsetInContainerNode())
            : start,
        Position(next_element, end_offset)));
    return true;
  }

  return false;
}

void ApplyStyleCommand::SurroundNodeRangeWithElement(
    Node* passed_start_node,
    Node* end_node,
    Element* element_to_insert,
    EditingState* editing_state) {
  DCHECK(passed_start_node);
  DCHECK(end_node);
  DCHECK(element_to_insert);
  Node* node = passed_start_node;
  Element* element = element_to_insert;

  InsertNodeBefore(element, node, editing_state);
  if (editing_state->IsAborted())
    return;

  GetDocument().UpdateStyleAndLayoutTree();
  while (node) {
    Node* next = node->nextSibling();
    if (HasEditableStyle(*node)) {
      RemoveNode(node, editing_state);
      if (editing_state->IsAborted())
        return;
      AppendNode(node, element, editing_state);
      if (editing_state->IsAborted())
        return;
    }
    if (node == end_node)
      break;
    node = next;
  }

  Node* next_sibling = element->nextSibling();
  Node* previous_sibling = element->previousSibling();
  auto* next_sibling_element = DynamicTo<Element>(next_sibling);
  if (next_sibling_element && HasEditableStyle(*next_sibling) &&
      AreIdenticalElements(*element, *next_sibling_element)) {
    MergeIdenticalElements(element, next_sibling_element, editing_state);
    if (editing_state->IsAborted())
      return;
  }

  auto* previous_sibling_element = DynamicTo<Element>(previous_sibling);
  if (previous_sibling_element && HasEditableStyle(*previous_sibling)) {
    auto* merged_element = DynamicTo<Element>(previous_sibling->nextSibling());
    if (merged_element &&
        HasEditableStyle(*(previous_sibling->nextSibling())) &&
        AreIdenticalElements(*previous_sibling_element, *merged_element)) {
      MergeIdenticalElements(previous_sibling_element, merged_element,
                             editing_state);
      if (editing_state->IsAborted())
        return;
    }
  }

  // FIXME: We should probably call updateStartEnd if the start or end was in
  // the node range so that the endingSelection() is canonicalized.  See the
  // comments at the end of VisibleSelection::validate().
}

void ApplyStyleCommand::AddBlockStyle(const StyleChange& style_change,
                                      HTMLElement* block) {
  // Do not check for legacy styles here. Those styles, like <B> and <I>, only
  // apply for inline content.
  if (!block)
    return;

  String css_style = style_change.CssStyle();
  StringBuilder css_text;
  css_text.Append(css_style);
  if (const CSSPropertyValueSet* decl = block->InlineStyle()) {
    if (!css_style.IsEmpty())
      css_text.Append(' ');
    css_text.Append(decl->AsText());
  }
  SetNodeAttribute(block, html_names::kStyleAttr, css_text.ToAtomicString());
}

void ApplyStyleCommand::AddInlineStyleIfNeeded(EditingStyle* style,
                                               Node* passed_start,
                                               Node* passed_end,
                                               EditingState* editing_state) {
  if (!passed_start || !passed_end || !passed_start->isConnected() ||
      !passed_end->isConnected())
    return;

  Node* start = passed_start;
  Member<HTMLSpanElement> dummy_element = nullptr;
  StyleChange style_change(style, PositionToComputeInlineStyleChange(
                                      start, dummy_element, editing_state));
  if (editing_state->IsAborted())
    return;

  if (dummy_element) {
    RemoveNode(dummy_element, editing_state);
    if (editing_state->IsAborted())
      return;
  }

  ApplyInlineStyleChange(start, passed_end, style_change,
                         kDoNotAddStyledElement, editing_state);
}

Position ApplyStyleCommand::PositionToComputeInlineStyleChange(
    Node* start_node,
    Member<HTMLSpanElement>& dummy_element,
    EditingState* editing_state) {
  DCHECK(start_node);
  // It's okay to obtain the style at the startNode because we've removed all
  // relevant styles from the current run.
  if (!start_node->IsElementNode()) {
    dummy_element = MakeGarbageCollected<HTMLSpanElement>(GetDocument());
    InsertNodeAt(dummy_element, Position::BeforeNode(*start_node),
                 editing_state);
    if (editing_state->IsAborted())
      return Position();
    return Position::BeforeNode(*dummy_element);
  }

  return FirstPositionInOrBeforeNode(*start_node);
}

void ApplyStyleCommand::ApplyInlineStyleChange(
    Node* passed_start,
    Node* passed_end,
    StyleChange& style_change,
    AddStyledElement add_styled_element,
    EditingState* editing_state) {
  Node* start_node = passed_start;
  Node* end_node = passed_end;
  DCHECK(start_node->isConnected()) << start_node;
  DCHECK(end_node->isConnected()) << end_node;

  // Find appropriate font and span elements top-down.
  HTMLFontElement* font_container = nullptr;
  HTMLElement* style_container = nullptr;
  for (Node* container = start_node; container && start_node == end_node;
       container = container->firstChild()) {
    if (auto* font = DynamicTo<HTMLFontElement>(container))
      font_container = font;
    bool style_container_is_not_span = !IsA<HTMLSpanElement>(style_container);
    auto* container_element = DynamicTo<HTMLElement>(container);
    if (container_element) {
      if (IsA<HTMLSpanElement>(*container_element) ||
          (style_container_is_not_span && container_element->HasChildren()))
        style_container = container_element;
    }
    if (!container->hasChildren())
      break;
    start_node = container->firstChild();
    end_node = container->lastChild();
  }

  // Font tags need to go outside of CSS so that CSS font sizes override leagcy
  // font sizes.
  if (style_change.ApplyFontColor() || style_change.ApplyFontFace() ||
      style_change.ApplyFontSize()) {
    if (font_container) {
      if (style_change.ApplyFontColor())
        SetNodeAttribute(font_container, html_names::kColorAttr,
                         AtomicString(style_change.FontColor()));
      if (style_change.ApplyFontFace())
        SetNodeAttribute(font_container, html_names::kFaceAttr,
                         AtomicString(style_change.FontFace()));
      if (style_change.ApplyFontSize())
        SetNodeAttribute(font_container, html_names::kSizeAttr,
                         AtomicString(style_change.FontSize()));
    } else {
      auto* font_element = MakeGarbageCollected<HTMLFontElement>(GetDocument());
      if (style_change.ApplyFontColor())
        font_element->setAttribute(html_names::kColorAttr,
                                   AtomicString(style_change.FontColor()));
      if (style_change.ApplyFontFace())
        font_element->setAttribute(html_names::kFaceAttr,
                                   AtomicString(style_change.FontFace()));
      if (style_change.ApplyFontSize())
        font_element->setAttribute(html_names::kSizeAttr,
                                   AtomicString(style_change.FontSize()));
      SurroundNodeRangeWithElement(start_node, end_node, font_element,
                                   editing_state);
      if (editing_state->IsAborted())
        return;
    }
  }

  if (style_change.CssStyle().length()) {
    if (style_container) {
      if (const CSSPropertyValueSet* existing_style =
              style_container->InlineStyle()) {
        String existing_text = existing_style->AsText();
        StringBuilder css_text;
        css_text.Append(existing_text);
        if (!existing_text.IsEmpty())
          css_text.Append(' ');
        css_text.Append(style_change.CssStyle());
        SetNodeAttribute(style_container, html_names::kStyleAttr,
                         css_text.ToAtomicString());
      } else {
        SetNodeAttribute(style_container, html_names::kStyleAttr,
                         AtomicString(style_change.CssStyle()));
      }
    } else {
      auto* style_element =
          MakeGarbageCollected<HTMLSpanElement>(GetDocument());
      style_element->setAttribute(html_names::kStyleAttr,
                                  AtomicString(style_change.CssStyle()));
      SurroundNodeRangeWithElement(start_node, end_node, style_element,
                                   editing_state);
      if (editing_state->IsAborted())
        return;
    }
  }

  if (style_change.ApplyBold()) {
    SurroundNodeRangeWithElement(
        start_node, end_node,
        MakeGarbageCollected<HTMLElement>(html_names::kBTag, GetDocument()),
        editing_state);
    if (editing_state->IsAborted())
      return;
  }

  if (style_change.ApplyItalic()) {
    SurroundNodeRangeWithElement(
        start_node, end_node,
        MakeGarbageCollected<HTMLElement>(html_names::kITag, GetDocument()),
        editing_state);
    if (editing_state->IsAborted())
      return;
  }

  if (style_change.ApplyUnderline()) {
    SurroundNodeRangeWithElement(
        start_node, end_node,
        MakeGarbageCollected<HTMLElement>(html_names::kUTag, GetDocument()),
        editing_state);
    if (editing_state->IsAborted())
      return;
  }

  if (style_change.ApplyLineThrough()) {
    SurroundNodeRangeWithElement(start_node, end_node,
                                 MakeGarbageCollected<HTMLElement>(
                                     html_names::kStrikeTag, GetDocument()),
                                 editing_state);
    if (editing_state->IsAborted())
      return;
  }

  if (style_change.ApplySubscript()) {
    SurroundNodeRangeWithElement(
        start_node, end_node,
        MakeGarbageCollected<HTMLElement>(html_names::kSubTag, GetDocument()),
        editing_state);
    if (editing_state->IsAborted())
      return;
  } else if (style_change.ApplySuperscript()) {
    SurroundNodeRangeWithElement(
        start_node, end_node,
        MakeGarbageCollected<HTMLElement>(html_names::kSupTag, GetDocument()),
        editing_state);
    if (editing_state->IsAborted())
      return;
  }

  if (styled_inline_element_ && add_styled_element == kAddStyledElement) {
    SurroundNodeRangeWithElement(
        start_node, end_node, &styled_inline_element_->CloneWithoutChildren(),
        editing_state);
  }
}

float ApplyStyleCommand::ComputedFontSize(Node* node) {
  if (!node)
    return 0;

  auto* style = MakeGarbageCollected<CSSComputedStyleDeclaration>(node);
  if (!style)
    return 0;

  const auto* value = To<CSSPrimitiveValue>(
      style->GetPropertyCSSValue(CSSPropertyID::kFontSize));
  if (!value)
    return 0;

  // TODO(yosin): We should have printer for |CSSPrimitiveValue::UnitType|.
  DCHECK(value->IsPx());
  return value->GetFloatValue();
}

void ApplyStyleCommand::JoinChildTextNodes(ContainerNode* node,
                                           const Position& start,
                                           const Position& end) {
  if (!node)
    return;

  Position new_start = start;
  Position new_end = end;

  HeapVector<Member<Text>> text_nodes;
  for (Node& child : NodeTraversal::ChildrenOf(*node)) {
    if (auto* child_text = DynamicTo<Text>(child))
      text_nodes.push_back(child_text);
  }

  for (const auto& text_node : text_nodes) {
    Text* child_text = text_node;
    Node* next = child_text->nextSibling();
    auto* next_text = DynamicTo<Text>(next);
    if (!next_text)
      continue;

    if (start.IsOffsetInAnchor() && next == start.ComputeContainerNode())
      new_start = Position(
          child_text, child_text->length() + start.OffsetInContainerNode());
    if (end.IsOffsetInAnchor() && next == end.ComputeContainerNode())
      new_end = Position(child_text,
                         child_text->length() + end.OffsetInContainerNode());
    String text_to_move = next_text->data();
    InsertTextIntoNode(child_text, child_text->length(), text_to_move);
    // Removing a Text node doesn't dispatch synchronous events.
    RemoveNode(next, ASSERT_NO_EDITING_ABORT);
    // don't move child node pointer. it may want to merge with more text nodes.
  }

  UpdateStartEnd(EphemeralRange(new_start, new_end));
}

void ApplyStyleCommand::Trace(Visitor* visitor) const {
  visitor->Trace(style_);
  visitor->Trace(start_);
  visitor->Trace(end_);
  visitor->Trace(styled_inline_element_);
  CompositeEditCommand::Trace(visitor);
}

}  // namespace blink