/* * Copyright (C) 2004, 2005, 2006, 2007 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/editing_utilities.h" #include #include #include "base/compiler_specific.h" #include "base/trace_event/trace_event.h" #include "third_party/blink/renderer/core/clipboard/data_object.h" #include "third_party/blink/renderer/core/clipboard/data_transfer.h" #include "third_party/blink/renderer/core/clipboard/data_transfer_access_policy.h" #include "third_party/blink/renderer/core/clipboard/system_clipboard.h" #include "third_party/blink/renderer/core/dom/document.h" #include "third_party/blink/renderer/core/dom/element_traversal.h" #include "third_party/blink/renderer/core/dom/range.h" #include "third_party/blink/renderer/core/dom/shadow_root.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_strategy.h" #include "third_party/blink/renderer/core/editing/editor.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/ime/edit_context.h" #include "third_party/blink/renderer/core/editing/ime/input_method_controller.h" #include "third_party/blink/renderer/core/editing/iterators/text_iterator.h" #include "third_party/blink/renderer/core/editing/local_caret_rect.h" #include "third_party/blink/renderer/core/editing/plain_text_range.h" #include "third_party/blink/renderer/core/editing/position_iterator.h" #include "third_party/blink/renderer/core/editing/position_with_affinity.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/state_machines/backspace_state_machine.h" #include "third_party/blink/renderer/core/editing/state_machines/backward_grapheme_boundary_state_machine.h" #include "third_party/blink/renderer/core/editing/state_machines/forward_grapheme_boundary_state_machine.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/frame/local_frame.h" #include "third_party/blink/renderer/core/frame/local_frame_view.h" #include "third_party/blink/renderer/core/html/canvas/html_canvas_element.h" #include "third_party/blink/renderer/core/html/forms/html_input_element.h" #include "third_party/blink/renderer/core/html/forms/html_select_element.h" #include "third_party/blink/renderer/core/html/forms/html_text_area_element.h" #include "third_party/blink/renderer/core/html/forms/text_control_element.h" #include "third_party/blink/renderer/core/html/html_body_element.h" #include "third_party/blink/renderer/core/html/html_br_element.h" #include "third_party/blink/renderer/core/html/html_div_element.h" #include "third_party/blink/renderer/core/html/html_dlist_element.h" #include "third_party/blink/renderer/core/html/html_embed_element.h" #include "third_party/blink/renderer/core/html/html_image_element.h" #include "third_party/blink/renderer/core/html/html_li_element.h" #include "third_party/blink/renderer/core/html/html_object_element.h" #include "third_party/blink/renderer/core/html/html_olist_element.h" #include "third_party/blink/renderer/core/html/html_paragraph_element.h" #include "third_party/blink/renderer/core/html/html_span_element.h" #include "third_party/blink/renderer/core/html/html_table_caption_element.h" #include "third_party/blink/renderer/core/html/html_table_cell_element.h" #include "third_party/blink/renderer/core/html/html_table_col_element.h" #include "third_party/blink/renderer/core/html/html_table_element.h" #include "third_party/blink/renderer/core/html/html_table_row_element.h" #include "third_party/blink/renderer/core/html/html_table_section_element.h" #include "third_party/blink/renderer/core/html/html_ulist_element.h" #include "third_party/blink/renderer/core/html/image_document.h" #include "third_party/blink/renderer/core/html/parser/html_parser_idioms.h" #include "third_party/blink/renderer/core/html_element_factory.h" #include "third_party/blink/renderer/core/html_names.h" #include "third_party/blink/renderer/core/input_type_names.h" #include "third_party/blink/renderer/core/layout/hit_test_result.h" #include "third_party/blink/renderer/core/layout/layout_block.h" #include "third_party/blink/renderer/core/layout/layout_image.h" #include "third_party/blink/renderer/core/layout/layout_object.h" #include "third_party/blink/renderer/core/svg/svg_image_element.h" #include "third_party/blink/renderer/platform/graphics/static_bitmap_image.h" #include "third_party/blink/renderer/platform/heap/garbage_collected.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" #include "third_party/blink/renderer/platform/wtf/text/unicode.h" #include "third_party/blink/renderer/platform/wtf/wtf_size_t.h" #include "ui/base/clipboard/clipboard_constants.h" namespace blink { using mojom::blink::FormControlType; namespace { std::string_view ToString(PositionMoveType type) { static const std::array kTexts = { "CodeUnit", "BackwardDeletion", "GraphemeCluster"}; DCHECK_LT(static_cast(type), kTexts.size()) << "Unknown PositionMoveType value"; return kTexts[static_cast(type)]; } UChar WhitespaceRebalancingCharToAppend(const StringView& string, bool start_is_start_of_paragraph, bool should_emit_nbsp_before_end, wtf_size_t index, UChar previous) { DCHECK_LT(index, string.length()); if (!IsWhitespace(UNSAFE_TODO(string[index]))) { return UNSAFE_TODO(string[index]); } if (!index && start_is_start_of_paragraph) return uchar::kNoBreakSpace; if (index + 1 == string.length() && should_emit_nbsp_before_end) return uchar::kNoBreakSpace; // Generally, alternate between space and no-break space. if (previous == ' ') return uchar::kNoBreakSpace; if (previous == uchar::kNoBreakSpace) { return ' '; } // Run of two or more spaces starts with a no-break space (crbug.com/453042). // SAFETY: index checked before use in &&-expression. if (index + 1 < string.length() && IsWhitespace(UNSAFE_BUFFERS(string[index + 1]))) { return uchar::kNoBreakSpace; } return ' '; } } // namespace bool NeedsLayoutTreeUpdate(const Node& node) { const Document& document = node.GetDocument(); if (document.NeedsLayoutTreeUpdate()) return true; // TODO(yosin): We should make |document::needsLayoutTreeUpdate()| to // check |LayoutView::needsLayout()|. return document.View() && document.View()->NeedsLayout(); } template static bool NeedsLayoutTreeUpdateAlgorithm(const PositionType& position) { const Node* node = position.AnchorNode(); if (!node) return false; return NeedsLayoutTreeUpdate(*node); } bool NeedsLayoutTreeUpdate(const Position& position) { return NeedsLayoutTreeUpdateAlgorithm(position); } bool NeedsLayoutTreeUpdate(const PositionInFlatTree& position) { return NeedsLayoutTreeUpdateAlgorithm(position); } // Atomic means that the node has no children, or has children which are ignored // for the purposes of editing. bool IsAtomicNode(const Node* node) { return node && (!node->hasChildren() || EditingIgnoresContent(*node)); } bool IsAtomicNodeInFlatTree(const Node* node) { return node && (!FlatTreeTraversal::HasChildren(*node) || EditingIgnoresContent(*node)); } bool IsNodeFullyContained(const EphemeralRange& range, const Node& node) { if (range.IsNull()) return false; if (!NodeTraversal::CommonAncestor(*range.StartPosition().AnchorNode(), node)) return false; return range.StartPosition() <= Position::BeforeNode(node) && Position::AfterNode(node) <= range.EndPosition(); } bool EnsureNodeVisibility(HTMLElement* container) { bool style_changed = false; if (container->GetComputedStyle()->Visibility() == EVisibility::kHidden) { container->SetInlineStyleProperty(CSSPropertyID::kVisibility, CSSValueID::kVisible, true); style_changed = true; } if (container->GetComputedStyle()->Display() == EDisplay::kNone) { container->SetInlineStyleProperty(CSSPropertyID::kDisplay, CSSValueID::kInline, true); style_changed = true; } return style_changed; } // TODO(editing-dev): We should implement real version which refers // "user-select" CSS property. bool IsUserSelectContain(const Node& node) { return IsA(node) || IsA(node) || IsA(node); } enum EditableLevel { kEditable, kRichlyEditable }; static bool HasEditableLevel(const Node& node, EditableLevel editable_level) { DCHECK(node.GetDocument().IsActive()); // TODO(editing-dev): We should have this check: // DCHECK_GE(node.document().lifecycle().state(), // DocumentLifecycle::StyleClean); if (node.IsPseudoElement()) return false; // Ideally we'd call DCHECK(!needsStyleRecalc()) here, but // ContainerNode::setFocus() calls setNeedsStyleRecalc(), so the assertion // would fire in the middle of Document::setFocusedNode(). for (const Node& ancestor : NodeTraversal::InclusiveAncestorsOf(node)) { if (!(ancestor.IsHTMLElement() || ancestor.IsDocumentNode())) { continue; } // If the `ancestor` is a child of the shadow host and does not have a slot // assigned, it should use the style of the shadow host and therefore be // skipped. // See https://issues.chromium.org/issues/392725745 for more details. if (RuntimeEnabledFeatures::UseShadowHostStyleCheckEditableEnabled() && ancestor.IsChildOfShadowHost() && !ancestor.AssignedSlot()) { continue; } if (const ComputedStyle* style = GetComputedStyleForElementOrLayoutObject(ancestor)) { switch (style->UsedUserModify()) { case EUserModify::kReadOnly: return false; case EUserModify::kReadWrite: return true; case EUserModify::kReadWritePlaintextOnly: return editable_level != kRichlyEditable; } } // An inert subtree should not contain any content or controls which are // critical to understanding or using aspects of the page which are not in // the inert state. Content in an inert subtree will not be perceivable by // all users, or interactive. See // https://html.spec.whatwg.org/multipage/interaction.html#the-inert-attribute. // To prevent the invisible inert element being overlooked, the // inert attribute of the element is considered when style is not present. // See https://issues.chromium.org/issues/41490809. if (RuntimeEnabledFeatures::InertElementNonEditableEnabled()) { const Element* element = DynamicTo(ancestor); if (element && element->IsInertRoot()) { return false; } } } return false; } bool IsEditable(const Node& node) { // TODO(editing-dev): We shouldn't check editable style in inactive documents. // We should hoist this check in the call stack, replace it by a DCHECK of // active document and ultimately cleanup the code paths with inactive // documents. See crbug.com/667681 if (!node.GetDocument().IsActive()) return false; return HasEditableLevel(node, kEditable); } bool IsRichlyEditable(const Node& node) { // TODO(editing-dev): We shouldn't check editable style in inactive documents. // We should hoist this check in the call stack, replace it by a DCHECK of // active document and ultimately cleanup the code paths with inactive // documents. See crbug.com/667681 if (!node.GetDocument().IsActive()) return false; return HasEditableLevel(node, kRichlyEditable); } bool IsRootEditableElement(const Node& node) { return IsEditable(node) && node.IsElementNode() && (!node.parentNode() || !IsEditable(*node.parentNode()) || !node.parentNode()->IsElementNode() || &node == node.GetDocument().body()); } Element* RootEditableElement(const Node& node) { const Element* result = nullptr; for (const Node* n = &node; n && IsEditable(*n); n = n->parentNode()) { if (auto* element = DynamicTo(n)) result = element; if (node.GetDocument().body() == n) break; } return const_cast(result); } ContainerNode* HighestEditableRoot(const Position& position) { if (position.IsNull()) return nullptr; ContainerNode* highest_root = RootEditableElementOf(position); if (!highest_root) return nullptr; if (IsA(*highest_root)) return highest_root; ContainerNode* node = highest_root->parentNode(); while (node) { if (IsEditable(*node)) highest_root = node; if (IsA(*node)) break; node = node->parentNode(); } return highest_root; } ContainerNode* HighestEditableRoot(const PositionInFlatTree& position) { return HighestEditableRoot(ToPositionInDomTree(position)); } bool IsEditablePosition(const Position& position) { const Node* node = position.ComputeContainerNode(); if (!node) return false; DCHECK(node->GetDocument().IsActive()); if (node->GetDocument().Lifecycle().GetState() >= DocumentLifecycle::kInStyleRecalc) { // TODO(yosin): Update the condition and DCHECK here given that // https://codereview.chromium.org/2665823002/ avoided this function from // being called during InStyleRecalc. } else { DCHECK(!NeedsLayoutTreeUpdate(position)) << position; } if (IsDisplayInsideTable(node)) node = node->parentNode(); if (node->IsDocumentNode()) return false; return IsEditable(*node); } bool IsEditablePosition(const PositionInFlatTree& p) { return IsEditablePosition(ToPositionInDomTree(p)); } bool IsRichlyEditablePosition(const Position& p) { const Node* node = p.AnchorNode(); if (!node) return false; if (IsDisplayInsideTable(node)) node = node->parentNode(); return IsRichlyEditable(*node); } Element* RootEditableElementOf(const Position& p) { Node* node = p.ComputeContainerNode(); if (!node) return nullptr; if (IsDisplayInsideTable(node)) node = node->parentNode(); return RootEditableElement(*node); } Element* RootEditableElementOf(const PositionInFlatTree& p) { return RootEditableElementOf(ToPositionInDomTree(p)); } template PositionTemplate NextCandidateAlgorithm( const PositionTemplate& position) { TRACE_EVENT0("input", "EditingUtility::nextCandidateAlgorithm"); PositionIteratorAlgorithm p(position); p.Increment(); while (!p.AtEnd()) { PositionTemplate candidate = p.ComputePosition(); if (IsVisuallyEquivalentCandidate(candidate)) return candidate; p.Increment(); } return PositionTemplate(); } Position NextCandidate(const Position& position) { return NextCandidateAlgorithm(position); } PositionInFlatTree NextCandidate(const PositionInFlatTree& position) { return NextCandidateAlgorithm(position); } // |nextVisuallyDistinctCandidate| is similar to |nextCandidate| except // for returning position which |downstream()| not equal to initial position's // |downstream()|. template static PositionTemplate NextVisuallyDistinctCandidateAlgorithm( const PositionTemplate& position, EditingBoundaryCrossingRule rule) { TRACE_EVENT0("input", "EditingUtility::nextVisuallyDistinctCandidateAlgorithm"); if (position.IsNull()) return PositionTemplate(); PositionIteratorAlgorithm p(position); // Only skip non-editable content when explicitly requested via // kCanSkipOverEditingBoundary (used for caret navigation). const bool skip_non_editable = rule == kCanSkipOverEditingBoundary && IsEditablePosition(position); const EditingBoundaryCrossingRule boundary_rule = skip_non_editable ? kCanCrossEditingBoundary : rule; const PositionTemplate downstream_start = MostForwardCaretPosition(position, boundary_rule); const PositionTemplate upstream_start = MostBackwardCaretPosition(position, boundary_rule); p.Increment(); while (!p.AtEnd()) { PositionTemplate candidate = p.ComputePosition(); // Skip candidates inside non-editable content when starting from // an editable position, but only if the candidate is within the same // editable root. if (skip_non_editable && !IsEditablePosition(candidate)) { Element* start_root = RootEditableElementOf(position); Node* candidate_node = candidate.AnchorNode(); if (start_root && candidate_node && candidate_node->IsDescendantOf(start_root)) { p.Increment(); continue; } } if (IsVisuallyEquivalentCandidate(candidate) && MostForwardCaretPosition(candidate, boundary_rule) != downstream_start && MostBackwardCaretPosition(candidate, boundary_rule) != upstream_start) { return candidate; } p.Increment(); } return PositionTemplate(); } Position NextVisuallyDistinctCandidate(const Position& position, EditingBoundaryCrossingRule rule) { return NextVisuallyDistinctCandidateAlgorithm(position, rule); } PositionInFlatTree NextVisuallyDistinctCandidate( const PositionInFlatTree& position, EditingBoundaryCrossingRule rule) { return NextVisuallyDistinctCandidateAlgorithm( position, rule); } template PositionTemplate PreviousCandidateAlgorithm( const PositionTemplate& position) { TRACE_EVENT0("input", "EditingUtility::previousCandidateAlgorithm"); PositionIteratorAlgorithm p(position); p.Decrement(); while (!p.AtStart()) { PositionTemplate candidate = p.ComputePosition(); if (IsVisuallyEquivalentCandidate(candidate)) return candidate; p.Decrement(); } return PositionTemplate(); } Position PreviousCandidate(const Position& position) { return PreviousCandidateAlgorithm(position); } PositionInFlatTree PreviousCandidate(const PositionInFlatTree& position) { return PreviousCandidateAlgorithm(position); } // |previousVisuallyDistinctCandidate| is similar to |previousCandidate| except // for returning position which |downstream()| not equal to initial position's // |downstream()|. template PositionTemplate PreviousVisuallyDistinctCandidateAlgorithm( const PositionTemplate& position, EditingBoundaryCrossingRule rule) { TRACE_EVENT0("input", "EditingUtility::previousVisuallyDistinctCandidateAlgorithm"); if (position.IsNull()) return PositionTemplate(); PositionIteratorAlgorithm p(position); // Only skip non-editable content when explicitly requested via // kCanSkipOverEditingBoundary (used for caret navigation). const bool skip_non_editable = rule == kCanSkipOverEditingBoundary && IsEditablePosition(position); const EditingBoundaryCrossingRule boundary_rule = skip_non_editable ? kCanCrossEditingBoundary : rule; const PositionTemplate downstream_start = MostForwardCaretPosition(position, boundary_rule); const PositionTemplate upstream_start = MostBackwardCaretPosition(position, boundary_rule); p.Decrement(); while (!p.AtStart()) { PositionTemplate candidate = p.ComputePosition(); // Skip candidates inside non-editable content when starting from // an editable position, but only if the candidate is within the same // editable root. if (skip_non_editable && !IsEditablePosition(candidate)) { Element* start_root = RootEditableElementOf(position); Node* candidate_node = candidate.AnchorNode(); if (start_root && candidate_node && candidate_node->IsDescendantOf(start_root)) { p.Decrement(); continue; } } if (IsVisuallyEquivalentCandidate(candidate) && MostForwardCaretPosition(candidate, boundary_rule) != downstream_start && MostBackwardCaretPosition(candidate, boundary_rule) != upstream_start) { return candidate; } p.Decrement(); } return PositionTemplate(); } Position PreviousVisuallyDistinctCandidate(const Position& position, EditingBoundaryCrossingRule rule) { return PreviousVisuallyDistinctCandidateAlgorithm(position, rule); } PositionInFlatTree PreviousVisuallyDistinctCandidate( const PositionInFlatTree& position, EditingBoundaryCrossingRule rule) { return PreviousVisuallyDistinctCandidateAlgorithm( position, rule); } template PositionTemplate FirstEditablePositionAfterPositionInRootAlgorithm( const PositionTemplate& position, const Node& highest_root) { DCHECK(!NeedsLayoutTreeUpdate(highest_root)) << position << ' ' << highest_root; // position falls before highestRoot. if (position.CompareTo(PositionTemplate::FirstPositionInNode( highest_root)) == -1 && IsEditable(highest_root)) return PositionTemplate::FirstPositionInNode(highest_root); PositionTemplate editable_position = position; if (position.AnchorNode()->GetTreeScope() != highest_root.GetTreeScope()) { Node* shadow_ancestor = highest_root.GetTreeScope().AncestorInThisScope( editable_position.AnchorNode()); if (!shadow_ancestor) return PositionTemplate(); editable_position = PositionTemplate::AfterNode(*shadow_ancestor); } Node* non_editable_node = nullptr; while (editable_position.AnchorNode() && !IsEditablePosition(editable_position) && editable_position.AnchorNode()->IsDescendantOf(&highest_root)) { non_editable_node = editable_position.AnchorNode(); editable_position = IsAtomicNode(editable_position.AnchorNode()) ? PositionTemplate::InParentAfterNode( *editable_position.AnchorNode()) : NextVisuallyDistinctCandidate(editable_position); } if (editable_position.AnchorNode() && editable_position.AnchorNode() != &highest_root && !editable_position.AnchorNode()->IsDescendantOf(&highest_root)) return PositionTemplate(); // If `non_editable_node` is the last child of // `editable_position.AnchorNode()`, obtain the next sibling position. // - If we do not obtain the next sibling position, we will be unable to // access the next paragraph within the `InsertListCommand::DoApply` while // loop. See http://crbug.com/571420 for more details. // - If `non_editable_node` is not the last child, we will bypass the next // editable sibling position. See http://crbug.com/1334557 for more details. bool need_obtain_next = non_editable_node && editable_position.AnchorNode() && non_editable_node == editable_position.AnchorNode()->lastChild(); if (need_obtain_next) { // Make sure not to move out of |highest_root| const PositionTemplate boundary = PositionTemplate::LastPositionInNode(highest_root); // `NextVisuallyDistinctCandidate` is similar to `NextCandidate`, but // it skips the next visually equivalent of `editable_position`. // `editable_position` is already "visually distinct" relative to // `position`, so use `NextCandidate` here. // See http://crbug.com/1406207 for more details. const PositionTemplate next_candidate = NextCandidate(editable_position); editable_position = next_candidate.IsNotNull() ? std::min(boundary, next_candidate) : boundary; } return editable_position; } Position FirstEditablePositionAfterPositionInRoot(const Position& position, const Node& highest_root) { return FirstEditablePositionAfterPositionInRootAlgorithm( position, highest_root); } PositionInFlatTree FirstEditablePositionAfterPositionInRoot( const PositionInFlatTree& position, const Node& highest_root) { return FirstEditablePositionAfterPositionInRootAlgorithm< EditingInFlatTreeStrategy>(position, highest_root); } template PositionTemplate LastEditablePositionBeforePositionInRootAlgorithm( const PositionTemplate& position, const Node& highest_root) { DCHECK(!NeedsLayoutTreeUpdate(highest_root)) << position << ' ' << highest_root; // When position falls after highestRoot, the result is easy to compute. if (position.CompareTo( PositionTemplate::LastPositionInNode(highest_root)) == 1) return PositionTemplate::LastPositionInNode(highest_root); PositionTemplate editable_position = position; if (position.AnchorNode()->GetTreeScope() != highest_root.GetTreeScope()) { Node* shadow_ancestor = highest_root.GetTreeScope().AncestorInThisScope( editable_position.AnchorNode()); if (!shadow_ancestor) return PositionTemplate(); editable_position = PositionTemplate::FirstPositionInOrBeforeNode( *shadow_ancestor); } while (editable_position.AnchorNode() && !IsEditablePosition(editable_position) && editable_position.AnchorNode()->IsDescendantOf(&highest_root)) editable_position = IsAtomicNode(editable_position.AnchorNode()) ? PositionTemplate::InParentBeforeNode( *editable_position.AnchorNode()) : PreviousVisuallyDistinctCandidate(editable_position); if (editable_position.AnchorNode() && editable_position.AnchorNode() != &highest_root && !editable_position.AnchorNode()->IsDescendantOf(&highest_root)) return PositionTemplate(); return editable_position; } Position LastEditablePositionBeforePositionInRoot(const Position& position, const Node& highest_root) { return LastEditablePositionBeforePositionInRootAlgorithm( position, highest_root); } PositionInFlatTree LastEditablePositionBeforePositionInRoot( const PositionInFlatTree& position, const Node& highest_root) { return LastEditablePositionBeforePositionInRootAlgorithm< EditingInFlatTreeStrategy>(position, highest_root); } template wtf_size_t FindNextBoundaryOffset(const String& str, wtf_size_t current) { StateMachine machine; TextSegmentationMachineState state = TextSegmentationMachineState::kInvalid; for (wtf_size_t i = current; i > 0; --i) { state = machine.FeedPrecedingCodeUnit(str[i - 1]); if (state != TextSegmentationMachineState::kNeedMoreCodeUnit) break; } if (current == 0 || state == TextSegmentationMachineState::kNeedMoreCodeUnit) state = machine.TellEndOfPrecedingText(); if (state == TextSegmentationMachineState::kFinished) return current + machine.FinalizeAndGetBoundaryOffset(); const wtf_size_t length = str.length(); DCHECK_EQ(TextSegmentationMachineState::kNeedFollowingCodeUnit, state); for (wtf_size_t i = current; i < length; ++i) { state = machine.FeedFollowingCodeUnit(str[i]); if (state != TextSegmentationMachineState::kNeedMoreCodeUnit) break; } return current + machine.FinalizeAndGetBoundaryOffset(); } // Explicit instantiation to avoid link error for the usage in EditContext. template wtf_size_t FindNextBoundaryOffset< BackwardGraphemeBoundaryStateMachine>(const String& str, wtf_size_t current); template wtf_size_t FindNextBoundaryOffset( const String& str, wtf_size_t current); wtf_size_t PreviousGraphemeBoundaryOf(const Node& node, wtf_size_t current) { // TODO(yosin): Need to support grapheme crossing |Node| boundary. auto* text_node = DynamicTo(node); if (current <= 1 || !text_node) return current - 1; const String& text = text_node->data(); // TODO(yosin): Replace with DCHECK for out-of-range request. if (current > text.length()) { return current - 1; } return FindNextBoundaryOffset(text, current); } static wtf_size_t PreviousBackwardDeletionOffsetOf(const Node& node, wtf_size_t current) { if (current <= 1) return 0; auto* text_node = DynamicTo(node); if (!text_node) return current - 1; const String& text = text_node->data(); DCHECK_LT(current - 1, text.length()); return FindNextBoundaryOffset(text, current); } wtf_size_t NextGraphemeBoundaryOf(const Node& node, wtf_size_t current) { // TODO(yosin): Need to support grapheme crossing |Node| boundary. auto* text_node = DynamicTo(node); if (!text_node) return current + 1; const String& text = text_node->data(); const wtf_size_t length = text.length(); DCHECK_LE(current, length); if (current >= length - 1) return current + 1; return FindNextBoundaryOffset(text, current); } template PositionTemplate PreviousPositionOfAlgorithm( const PositionTemplate& position, PositionMoveType move_type) { Node* const node = position.AnchorNode(); if (!node) return position; const int offset = position.ComputeEditingOffset(); if (offset > 0) { if (EditingIgnoresContent(*node)) return PositionTemplate::BeforeNode(*node); if (Node* child = Strategy::ChildAt(*node, offset - 1)) { return PositionTemplate::LastPositionInOrAfterNode(*child); } // There are two reasons child might be 0: // 1) The node is node like a text node that is not an element, and // therefore has no children. Going backward one character at a // time is correct. // 2) The old offset was a bogus offset like (
, 1), and there is // no child. Going from 1 to 0 is correct. switch (move_type) { case PositionMoveType::kCodeUnit: return PositionTemplate(node, offset - 1); case PositionMoveType::kBackwardDeletion: return PositionTemplate( node, PreviousBackwardDeletionOffsetOf(*node, offset)); case PositionMoveType::kGraphemeCluster: return PositionTemplate( node, PreviousGraphemeBoundaryOf(*node, offset)); default: NOTREACHED() << "Unhandled moveType: " << ToString(move_type); } } if (ContainerNode* parent = Strategy::Parent(*node)) { if (EditingIgnoresContent(*parent)) return PositionTemplate::BeforeNode(*parent); // TODO(yosin) We should use |Strategy::index(Node&)| instead of // |Node::nodeIndex()|. return PositionTemplate(parent, node->NodeIndex()); } return position; } Position PreviousPositionOf(const Position& position, PositionMoveType move_type) { return PreviousPositionOfAlgorithm(position, move_type); } PositionInFlatTree PreviousPositionOf(const PositionInFlatTree& position, PositionMoveType move_type) { return PreviousPositionOfAlgorithm(position, move_type); } SelectionInDomTree NarrowSelectionToBackwardDeletionUnit( const SelectionInDomTree& selection) { if (!selection.IsRange()) { return selection; } const Position& anchor = selection.Anchor(); const Position& focus = selection.Focus(); if (anchor.ComputeContainerNode() != focus.ComputeContainerNode()) { return selection; } if (anchor.ComputeOffsetInContainerNode() - focus.ComputeOffsetInContainerNode() <= 1) { return selection; } const Position& end = selection.ComputeEndPosition(); return SelectionInDomTree::Builder() .SetAsBackwardSelection(EphemeralRange( PreviousPositionOf(end, PositionMoveType::kBackwardDeletion), end)) .Build(); } template PositionTemplate NextPositionOfAlgorithm( const PositionTemplate& position, PositionMoveType move_type) { // TODO(yosin): We should have printer for PositionMoveType. DCHECK(move_type != PositionMoveType::kBackwardDeletion); Node* node = position.AnchorNode(); if (!node) return position; const wtf_size_t offset = position.ComputeEditingOffset(); if (Node* child = Strategy::ChildAt(*node, offset)) { return PositionTemplate::FirstPositionInOrBeforeNode(*child); } // TODO(yosin) We should use |Strategy::lastOffsetForEditing()| instead of // DOM tree version. if (!Strategy::HasChildren(*node) && offset < EditingStrategy::LastOffsetForEditing(node)) { // There are two reasons child might be 0: // 1) The node is node like a text node that is not an element, and // therefore has no children. Going forward one character at a time // is correct. // 2) The new offset is a bogus offset like (
, 1), and there is no // child. Going from 0 to 1 is correct. switch (move_type) { case PositionMoveType::kCodeUnit: return PositionTemplate::EditingPositionOf(node, offset + 1); case PositionMoveType::kBackwardDeletion: NOTREACHED() << "BackwardDeletion is only available for prevPositionOf " << "functions."; case PositionMoveType::kGraphemeCluster: return PositionTemplate::EditingPositionOf( node, NextGraphemeBoundaryOf(*node, offset)); default: NOTREACHED() << "Unhandled moveType: " << ToString(move_type); } } if (ContainerNode* parent = Strategy::Parent(*node)) return PositionTemplate::EditingPositionOf( parent, Strategy::Index(*node) + 1); return position; } Position NextPositionOf(const Position& position, PositionMoveType move_type) { return NextPositionOfAlgorithm(position, move_type); } PositionInFlatTree NextPositionOf(const PositionInFlatTree& position, PositionMoveType move_type) { return NextPositionOfAlgorithm(position, move_type); } bool IsEnclosingBlock(const Node* node) { return node && node->GetLayoutObject() && !node->GetLayoutObject()->IsInline(); } // TODO(yosin) Deploy this in all of the places where |enclosingBlockFlow()| and // |enclosingBlockFlowOrTableElement()| are used. // TODO(yosin) Callers of |Node| version of |enclosingBlock()| should use // |Position| version The enclosing block of [table, x] for example, should be // the block that contains the table and not the table, and this function should // be the only one responsible for knowing about these kinds of special cases. Element* EnclosingBlock(const Node* node, EditingBoundaryCrossingRule rule) { if (!node) return nullptr; return EnclosingBlock(FirstPositionInOrBeforeNode(*node), rule); } template Element* EnclosingBlockAlgorithm(const PositionTemplate& position, EditingBoundaryCrossingRule rule) { Node* enclosing_node = EnclosingNodeOfType(position, IsEnclosingBlock, rule); return DynamicTo(enclosing_node); } Element* EnclosingBlock(const Position& position, EditingBoundaryCrossingRule rule) { return EnclosingBlockAlgorithm(position, rule); } Element* EnclosingBlock(const PositionInFlatTree& position, EditingBoundaryCrossingRule rule) { return EnclosingBlockAlgorithm(position, rule); } Element* EnclosingBlockFlowElement(const Node& node) { if (IsBlockFlowElement(node)) return const_cast(To(&node)); for (Node& runner : NodeTraversal::AncestorsOf(node)) { if (IsBlockFlowElement(runner) || IsA(runner)) return To(&runner); } return nullptr; } template TextDirection DirectionOfEnclosingBlockOfAlgorithm( const PositionTemplate& position) { DCHECK(position.IsNotNull()); Element* enclosing_block_element = EnclosingBlock(PositionTemplate::FirstPositionInOrBeforeNode( *position.ComputeContainerNode()), kCannotCrossEditingBoundary); if (!enclosing_block_element) return TextDirection::kLtr; LayoutObject* layout_object = enclosing_block_element->GetLayoutObject(); return layout_object ? layout_object->StyleRef().Direction() : TextDirection::kLtr; } TextDirection DirectionOfEnclosingBlockOf(const Position& position) { return DirectionOfEnclosingBlockOfAlgorithm(position); } TextDirection DirectionOfEnclosingBlockOf(const PositionInFlatTree& position) { return DirectionOfEnclosingBlockOfAlgorithm( position); } TextDirection PrimaryDirectionOf(const Node& node) { TextDirection primary_direction = TextDirection::kLtr; for (const LayoutObject* r = node.GetLayoutObject(); r; r = r->Parent()) { if (r->IsLayoutBlockFlow()) { primary_direction = r->StyleRef().Direction(); break; } } return primary_direction; } const ComputedStyle* GetComputedStyleForElementOrLayoutObject( const Node& node) { if (const auto* element = DynamicTo(node)) { return element->GetComputedStyle(); } // Text nodes and Document. if (const LayoutObject* layout_object = node.GetLayoutObject()) { return &layout_object->StyleRef(); } return nullptr; } String StringWithRebalancedWhitespace(const StringView& string, bool start_is_start_of_paragraph, bool should_emit_nbs_pbefore_end) { wtf_size_t length = string.length(); StringBuilder rebalanced_string; rebalanced_string.ReserveCapacity(length); UChar char_to_append = 0; for (wtf_size_t index = 0; index < length; index++) { char_to_append = WhitespaceRebalancingCharToAppend( string, start_is_start_of_paragraph, should_emit_nbs_pbefore_end, index, char_to_append); rebalanced_string.Append(char_to_append); } DCHECK_EQ(rebalanced_string.length(), length); return rebalanced_string.ToString(); } String RepeatString(const String& string, wtf_size_t count) { StringBuilder builder; builder.ReserveCapacity(string.length() * count); for (wtf_size_t counter = 0; counter < count; ++counter) { builder.Append(string); } return builder.ToString(); } template static Element* TableElementJustBeforeAlgorithm( const PositionTemplate& position) { const PositionTemplate upstream( MostBackwardCaretPosition(position)); if (IsDisplayInsideTable(upstream.AnchorNode()) && upstream.AtLastEditingPositionForNode()) return To(upstream.AnchorNode()); return nullptr; } Element* TableElementJustBefore(const Position& position) { return TableElementJustBeforeAlgorithm(position); } Element* TableElementJustBefore(const PositionInFlatTree& position) { return TableElementJustBeforeAlgorithm(position); } Element* TableElementJustBefore(const VisiblePosition& visible_position) { return TableElementJustBefore(visible_position.DeepEquivalent()); } Element* TableElementJustBefore( const VisiblePositionInFlatTree& visible_position) { return TableElementJustBefore(visible_position.DeepEquivalent()); } Element* EnclosingTableCell(const Position& p) { return To(EnclosingNodeOfType(p, IsTableCell)); } Element* EnclosingTableCell(const PositionInFlatTree& p) { return To(EnclosingNodeOfType(p, IsTableCell)); } Element* TableElementJustAfter(const Position& position) { Position downstream(MostForwardCaretPosition(position)); if (IsDisplayInsideTable(downstream.AnchorNode()) && downstream.AtFirstEditingPositionForNode()) return To(downstream.AnchorNode()); return nullptr; } Element* TableElementJustAfter(const VisiblePosition& visible_position) { return TableElementJustAfter(visible_position.DeepEquivalent()); } // Returns the position at the beginning of a node Position PositionBeforeNode(const Node& node) { DCHECK(!NeedsLayoutTreeUpdate(node)); if (node.hasChildren()) return FirstPositionInOrBeforeNode(node); DCHECK(node.parentNode()) << node; DCHECK(!node.parentNode()->IsShadowRoot()) << node.parentNode(); return Position::InParentBeforeNode(node); } // Returns the position at the ending of a node Position PositionAfterNode(const Node& node) { DCHECK(!NeedsLayoutTreeUpdate(node)); if (node.hasChildren()) return LastPositionInOrAfterNode(node); DCHECK(node.parentNode()) << node.parentNode(); DCHECK(!node.parentNode()->IsShadowRoot()) << node.parentNode(); return Position::InParentAfterNode(node); } bool IsHtmlListElement(const Node* n) { return (n && (IsA(*n) || IsA(*n) || IsA(*n))); } bool IsListItem(const Node* n) { return n && n->GetLayoutObject() && n->GetLayoutObject()->IsListItem(); } bool IsListItemTag(const Node* n) { return n && (n->HasTagName(html_names::kLiTag) || n->HasTagName(html_names::kDdTag) || n->HasTagName(html_names::kDtTag)); } bool IsListElementTag(const Node* n) { return n && (n->HasTagName(html_names::kUlTag) || n->HasTagName(html_names::kOlTag) || n->HasTagName(html_names::kDlTag)); } bool IsPresentationalHtmlElement(const Node* node) { const auto* element = DynamicTo(node); if (!element) return false; return element->HasTagName(html_names::kUTag) || element->HasTagName(html_names::kSTag) || element->HasTagName(html_names::kStrikeTag) || element->HasTagName(html_names::kITag) || element->HasTagName(html_names::kEmTag) || element->HasTagName(html_names::kBTag) || element->HasTagName(html_names::kStrongTag); } Element* AssociatedElementOf(const Position& position) { Node* node = position.AnchorNode(); if (!node) return nullptr; if (auto* element = DynamicTo(node)) return element; ContainerNode* parent = NodeTraversal::Parent(*node); return DynamicTo(parent); } Element* EnclosingElementWithTag(const Position& p, const QualifiedName& tag_name) { if (p.IsNull()) return nullptr; ContainerNode* root = HighestEditableRoot(p); for (Node& runner : NodeTraversal::InclusiveAncestorsOf(*p.AnchorNode())) { auto* ancestor = DynamicTo(runner); if (!ancestor) continue; if (root && !IsEditable(*ancestor)) continue; if (ancestor->HasTagName(tag_name)) return ancestor; if (ancestor == root) return nullptr; } return nullptr; } template static Node* EnclosingNodeOfTypeAlgorithm(const PositionTemplate& p, bool (*node_is_of_type)(const Node*), EditingBoundaryCrossingRule rule) { // TODO(yosin) support CanSkipCrossEditingBoundary DCHECK(rule == kCanCrossEditingBoundary || rule == kCannotCrossEditingBoundary) << rule; if (p.IsNull()) return nullptr; ContainerNode* const root = rule == kCannotCrossEditingBoundary ? RootEditableElementOf(p) : nullptr; for (Node* n = p.AnchorNode(); n; n = Strategy::Parent(*n)) { // Don't return a non-editable node if the input position was editable, // since the callers from editing will no doubt want to perform editing // inside the returned node. if (root && !IsEditable(*n)) continue; if (node_is_of_type(n)) return n; if (n == root) return nullptr; } return nullptr; } Node* EnclosingNodeOfType(const Position& p, bool (*node_is_of_type)(const Node*), EditingBoundaryCrossingRule rule) { return EnclosingNodeOfTypeAlgorithm(p, node_is_of_type, rule); } Node* EnclosingNodeOfType(const PositionInFlatTree& p, bool (*node_is_of_type)(const Node*), EditingBoundaryCrossingRule rule) { return EnclosingNodeOfTypeAlgorithm( p, node_is_of_type, rule); } Node* HighestEnclosingNodeOfType(const Position& p, bool (*node_is_of_type)(const Node*), EditingBoundaryCrossingRule rule, Node* stay_within) { Node* highest = nullptr; ContainerNode* root = rule == kCannotCrossEditingBoundary ? HighestEditableRoot(p) : nullptr; for (Node* n = p.ComputeContainerNode(); n && n != stay_within; n = n->parentNode()) { if (root && !IsEditable(*n)) continue; if (node_is_of_type(n)) highest = n; if (n == root) break; } return highest; } Element* EnclosingAnchorElement(const Position& p) { if (p.IsNull()) return nullptr; for (Element* ancestor = ElementTraversal::FirstAncestorOrSelf(*p.AnchorNode()); ancestor; ancestor = ElementTraversal::FirstAncestor(*ancestor)) { if (ancestor->IsLink()) return ancestor; } return nullptr; } bool IsDisplayInsideTable(const Node* node) { return node && node->GetLayoutObject() && IsA(node); } bool IsTableCell(const Node* node) { DCHECK(node); LayoutObject* r = node->GetLayoutObject(); return r ? r->IsTableCell() : IsA(*node); } bool IsTablePartElement(const Node* n) { return n && (IsA(*n) || IsA(*n) || IsA(*n) || IsA(*n) || IsA(*n)); } HTMLElement* CreateDefaultParagraphElement(Document& document) { switch (document.GetFrame()->GetEditor().DefaultParagraphSeparator()) { case EditorParagraphSeparator::kIsDiv: return MakeGarbageCollected(document); case EditorParagraphSeparator::kIsP: return MakeGarbageCollected(document); } NOTREACHED(); } bool IsTabSpanElement(const Node* node) { const auto* span = DynamicTo(node); if (!span) { return false; } const Node* const first_child = NodeTraversal::FirstChild(*span); auto* first_child_text_node = DynamicTo(first_child); if (!first_child_text_node) { return false; } if (!first_child_text_node->data().contains('\t')) { return false; } // TODO(editing-dev): Hoist the call of UpdateStyleAndLayoutTree to callers. // See crbug.com/590369 for details. span->GetDocument().UpdateStyleAndLayoutTree(); const ComputedStyle* style = span->GetComputedStyle(); return style && style->WhiteSpace() == EWhiteSpace::kPre; } bool IsTabSpanElementTextNode(const Node* node) { return node && node->IsTextNode() && node->parentNode() && IsTabSpanElement(node->parentNode()); } HTMLSpanElement* TabSpanElement(const Node* node) { return IsTabSpanElementTextNode(node) ? To(node->parentNode()) : nullptr; } static HTMLSpanElement* CreateTabSpanElement(Document& document, Text* tab_text_node) { // Make the span to hold the tab. auto* span_element = MakeGarbageCollected(document); span_element->setAttribute(html_names::kStyleAttr, AtomicString("white-space:pre")); // Add tab text to that span. if (!tab_text_node) tab_text_node = document.CreateEditingTextNode("\t"); span_element->AppendChild(tab_text_node); return span_element; } HTMLSpanElement* CreateTabSpanElement(Document& document, const String& tab_text) { return CreateTabSpanElement(document, document.createTextNode(tab_text)); } HTMLSpanElement* CreateTabSpanElement(Document& document) { return CreateTabSpanElement(document, nullptr); } static bool IsInPlaceholder(const TextControlElement& text_control, const Position& position) { const auto* const placeholder_element = text_control.PlaceholderElement(); if (!placeholder_element) return false; return placeholder_element->contains(position.ComputeContainerNode()); } // Returns user-select:contain boundary element of specified position. // Because of we've not yet implemented "user-select:contain", we consider // following elements having "user-select:contain" // - root editable // - inner editor of text control ( and