Clean up htmlediting

Source/core/editing/htmlediting.cpp

 /*
  * 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
@@ skipping 30 matching lines @@
 #include "core/editing/PlainTextRange.h"
 #include "core/editing/TextIterator.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/VisibleSelection.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/frame/LocalFrame.h"
 #include "core/frame/UseCounter.h"
 #include "core/html/HTMLBRElement.h"
 #include "core/html/HTMLDivElement.h"
 #include "core/html/HTMLLIElement.h"
-#include "core/html/HTMLOListElement.h"
 #include "core/html/HTMLParagraphElement.h"
 #include "core/html/HTMLSpanElement.h"
 #include "core/html/HTMLTableCellElement.h"
 #include "core/html/HTMLUListElement.h"
 #include "core/rendering/RenderObject.h"
 #include "core/rendering/RenderTableCell.h"
 #include "wtf/Assertions.h"
 #include "wtf/StdLibExtras.h"
 #include "wtf/text/StringBuilder.h"
 
@@ skipping 475 matching lines @@
 // Returns the visible position at the ending of a node
 VisiblePosition visiblePositionAfterNode(Node& node)
 {
     if (node.hasChildren())
         return VisiblePosition(lastPositionInOrAfterNode(&node), DOWNSTREAM);
     ASSERT(node.parentNode());
     ASSERT(!node.parentNode()->isShadowRoot());
     return VisiblePosition(positionInParentAfterNode(node));
 }
 
-// Create a range object with two visible positions, start and end.
-// create(Document*, const Position&, const Position&); will use deprecatedEditingOffset
-// Use this function instead of create a regular range object (avoiding editing offset).
-PassRefPtrWillBeRawPtr<Range> createRange(Document& document, const VisiblePosition& start, const VisiblePosition& end, ExceptionState& exceptionState)
-{
-    RefPtrWillBeRawPtr<Range> selectedRange = Range::create(document);
-    selectedRange->setStart(start.deepEquivalent().containerNode(), start.deepEquivalent().computeOffsetInContainerNode(), exceptionState);
-    if (!exceptionState.hadException())
-        selectedRange->setEnd(end.deepEquivalent().containerNode(), end.deepEquivalent().computeOffsetInContainerNode(), exceptionState);
-    return selectedRange.release();
-}
-
 bool isHTMLListElement(Node* n)
 {
     return (n && (isHTMLUListElement(*n) || isHTMLOListElement(*n) || isHTMLDListElement(*n)));
 }
 
 bool isListItem(const Node* n)
 {
     return n && n->renderer() && n->renderer()->isListItem();
 }
 
@@ skipping 160 matching lines @@
 
     while (HTMLElement* nextList = enclosingList(list)) {
         if (nextList == rootList)
             break;
         list = nextList;
     }
 
     return list;
 }
 
+// Determines whether two positions are visibly next to each other (first then second)
+// while ignoring whitespaces and unrendered nodes
+static bool isVisiblyAdjacent(const Position& first, const Position& second)
+{
+    return VisiblePosition(first) == VisiblePosition(second.upstream());
+}
+
 bool canMergeLists(Element* firstList, Element* secondList)
 {
     if (!firstList || !secondList || !firstList->isHTMLElement() || !secondList->isHTMLElement())
         return false;
 
     return firstList->hasTagName(secondList->tagQName()) // make sure the list types match (ol vs. ul)
     && firstList->hasEditableStyle() && secondList->hasEditableStyle() // both lists are editable
     && firstList->rootEditableElement() == secondList->rootEditableElement() // don't cross editing boundaries
     && isVisiblyAdjacent(positionInParentAfterNode(*firstList), positionInParentBeforeNode(*secondList));
     // Make sure there is no visible content between this li and the previous list
@@ skipping 64 matching lines @@
 
     ASSERT_NOT_REACHED();
     return nullptr;
 }
 
 PassRefPtrWillBeRawPtr<HTMLBRElement> createBreakElement(Document& document)
 {
     return HTMLBRElement::create(document);
 }
 
-PassRefPtrWillBeRawPtr<HTMLOListElement> createOrderedListElement(Document& document)
-{
-    return HTMLOListElement::create(document);
-}
-
 PassRefPtrWillBeRawPtr<HTMLUListElement> createUnorderedListElement(Document& document)
 {
     return HTMLUListElement::create(document);
 }
 
 PassRefPtrWillBeRawPtr<HTMLLIElement> createListItemElement(Document& document)
 {
     return HTMLLIElement::create(document);
 }
 
 PassRefPtrWillBeRawPtr<HTMLElement> createHTMLElement(Document& document, const QualifiedName& name)
 {
-    return createHTMLElement(document, name.localName());
-}
-
-PassRefPtrWillBeRawPtr<HTMLElement> createHTMLElement(Document& document, const AtomicString& tagName)
-{
-    return HTMLElementFactory::createHTMLElement(tagName, document, 0, false);
+    return HTMLElementFactory::createHTMLElement(name.localName(), document, 0, false);
 }
 
 bool isTabHTMLSpanElement(const Node* node)
 {
     if (!isHTMLSpanElement(node) || toHTMLSpanElement(node)->getAttribute(classAttr) != AppleTabSpanClass)
         return false;
     UseCounter::count(node->document(), UseCounter::EditingAppleTabSpanClass);
     return true;
 }
 
 bool isTabHTMLSpanElementTextNode(const Node* node)
 {
     return node && node->isTextNode() && node->parentNode() && isTabHTMLSpanElement(node->parentNode());
 }
 
 HTMLSpanElement* tabSpanElement(const Node* node)
 {
     return isTabHTMLSpanElementTextNode(node) ? toHTMLSpanElement(node->parentNode()) : 0;
 }
 
-PassRefPtrWillBeRawPtr<HTMLSpanElement> createTabSpanElement(Document& document, PassRefPtrWillBeRawPtr<Text> prpTabTextNode)
+static PassRefPtrWillBeRawPtr<HTMLSpanElement> createTabSpanElement(Document& document, PassRefPtrWillBeRawPtr<Text> prpTabTextNode)
 {
     RefPtrWillBeRawPtr<Text> tabTextNode = prpTabTextNode;
 
     // Make the span to hold the tab.
     RefPtrWillBeRawPtr<HTMLSpanElement> spanElement = toHTMLSpanElement(document.createElement(spanTag, false).get());
     spanElement->setAttribute(classAttr, AppleTabSpanClass);
     spanElement->setAttribute(styleAttr, "white-space:pre");
 
     // Add tab text to that span.
     if (!tabTextNode)
@@ skipping 12 matching lines @@
 PassRefPtrWillBeRawPtr<HTMLSpanElement> createTabSpanElement(Document& document)
 {
     return createTabSpanElement(document, PassRefPtrWillBeRawPtr<Text>(nullptr));
 }
 
 PassRefPtrWillBeRawPtr<HTMLBRElement> createBlockPlaceholderElement(Document& document)
 {
     return toHTMLBRElement(document.createElement(brTag, false).get());
 }
 
-bool isNodeRendered(const Node *node)
+bool isNodeRendered(const Node &node)

[Yuta Kitamura, 2014/11/27 08:38:39]

Plaese attach "&" to the type name, not the argument name.
The original code got the style wrong.

 {
-    if (!node)
-        return false;
-
-    RenderObject* renderer = node->renderer();
+    RenderObject* renderer = node.renderer();
     if (!renderer)
         return false;
 
     return renderer->style()->visibility() == VISIBLE;
 }
 
 // return first preceding DOM position rendered at a different location, or "this"
 static Position previousCharacterPosition(const Position& position, EAffinity affinity)
 {
     if (position.isNull())
@@ skipping 209 matching lines @@
     if (!scope)
         return VisiblePosition();
     RefPtrWillBeRawPtr<Range> range = PlainTextRange(index).createRangeForSelection(*scope);
     // Check for an invalid index. Certain editing operations invalidate indices because
     // of problems with TextIteratorEmitsCharactersBetweenAllVisiblePositions.
     if (!range)
         return VisiblePosition();
     return VisiblePosition(range->startPosition());
 }
 
-// Determines whether two positions are visibly next to each other (first then second)
-// while ignoring whitespaces and unrendered nodes
-bool isVisiblyAdjacent(const Position& first, const Position& second)
-{
-    return VisiblePosition(first) == VisiblePosition(second.upstream());
-}
-
 // Determines whether a node is inside a range or visibly starts and ends at the boundaries of the range.
 // Call this function to determine whether a node is visibly fit inside selectedRange
 bool isNodeVisiblyContainedWithin(Node& node, const Range& selectedRange)
 {
     // If the node is inside the range, then it surely is contained within
     if (selectedRange.compareNode(&node, IGNORE_EXCEPTION) == Range::NODE_INSIDE)
         return true;
 
     bool startIsVisuallySame = visiblePositionBeforeNode(node) == VisiblePosition(selectedRange.startPosition());
     if (startIsVisuallySame && comparePositions(positionInParentAfterNode(node), selectedRange.endPosition()) < 0)
@@ skipping 71 matching lines @@
     // if the selection starts just before a paragraph break, skip over it
     if (isEndOfParagraph(visiblePosition))
         return visiblePosition.next().deepEquivalent().downstream();
 
     // otherwise, make sure to be at the start of the first selected node,
     // instead of possibly at the end of the last node before the selection
     return visiblePosition.deepEquivalent().downstream();
 }
 
 } // namespace blink