Convert first letter into a pseudo element.

Source/core/editing/TextIterator.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2012 Apple Inc. All rights reserved.
  * Copyright (C) 2005 Alexey Proskuryakov.
  *
  * 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
@@ skipping 12 matching lines @@
  * (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 "config.h"
 #include "core/editing/TextIterator.h"
 
 #include "bindings/core/v8/ExceptionStatePlaceholder.h"
 #include "core/HTMLNames.h"
 #include "core/dom/Document.h"
+#include "core/dom/FirstLetterPseudoElement.h"
 #include "core/dom/NodeTraversal.h"
 #include "core/dom/shadow/ShadowRoot.h"
 #include "core/editing/VisiblePosition.h"
 #include "core/editing/VisibleUnits.h"
 #include "core/editing/htmlediting.h"
 #include "core/frame/FrameView.h"
 #include "core/html/HTMLElement.h"
 #include "core/html/HTMLTextFormControlElement.h"
 #include "core/rendering/InlineTextBox.h"
 #include "core/rendering/RenderImage.h"
@@ skipping 711 matching lines @@
     }
     if (!m_textBox && m_remainingTextBox) {
         m_textBox = m_remainingTextBox;
         m_remainingTextBox = 0;
         m_firstLetterText = nullptr;
         m_offset = 0;
         handleTextBox();
     }
 }
 
-static inline RenderText* firstRenderTextInFirstLetter(RenderBoxModelObject* firstLetter)
-{
-    if (!firstLetter)
-        return 0;
-
-    // FIXME: Should this check descendent objects?
-    for (RenderObject* current = firstLetter->slowFirstChild(); current; current = current->nextSibling()) {
-        if (current->isText())
-            return toRenderText(current);
-    }
-    return 0;
-}
-
 void TextIterator::handleTextNodeFirstLetter(RenderTextFragment* renderer)
 {
-    if (renderer->firstLetter()) {
-        RenderBoxModelObject* r = renderer->firstLetter();
-        if (r->style()->visibility() != VISIBLE && !m_ignoresStyleVisibility)
+    if (renderer->firstLetterPseudoElement()) {

[Julien - ping for review, 2014/10/09 18:24:48]

if (FirstLetterPseudoElement* firstLetterElement =
renderer->firstLetterPseudoElement()) {

[dsinclair, 2014/10/09 21:14:22]

Done.

+        RenderObject* pseudoRenderer = renderer->firstLetterPseudoElement()->renderer();
+        if (pseudoRenderer->style()->visibility() != VISIBLE && !m_ignoresStyleVisibility)
             return;
-        if (RenderText* firstLetter = firstRenderTextInFirstLetter(r)) {
+        // First letter pseudo elements only have one child which is the text.

[Julien - ping for review, 2014/10/09 18:24:48]

This comment sounds like the following 'if' is not needed but AFAICT
:first-letter may not apply so it's not unconditional.

[dsinclair, 2014/10/09 21:14:22]

Changed it to an ASSERT as it should always exist.

+        if (RenderObject* firstLetter = pseudoRenderer->slowFirstChild()) {
             m_handledFirstLetter = true;
             m_remainingTextBox = m_textBox;
-            m_textBox = firstLetter->firstTextBox();
+            m_textBox = toRenderText(firstLetter)->firstTextBox();
             m_sortedTextBoxes.clear();
-            m_firstLetterText = firstLetter;
+            m_firstLetterText = toRenderText(firstLetter);
         }
     }
     m_handledFirstLetter = true;
 }
 
 bool TextIterator::handleReplacedElement()
 {
     if (m_fullyClippedStack.top())
         return false;
 
@@ skipping 44 matching lines @@
     m_textLength = 0;
     m_lastCharacter = 0;
 
     return true;
 }
 
 bool TextIterator::hasVisibleTextNode(RenderText* renderer)
 {
     if (renderer->style()->visibility() == VISIBLE)
         return true;
-    if (renderer->isTextFragment()) {
-        RenderTextFragment* fragment = toRenderTextFragment(renderer);
-        if (fragment->firstLetter() && fragment->firstLetter()->style()->visibility() == VISIBLE)
+    if (renderer->isTextFragment() && toRenderTextFragment(renderer)->firstLetterPseudoElement()) {
+        RenderObject* pseudoElement = toRenderTextFragment(renderer)->firstLetterPseudoElement()->renderer();

[Julien - ping for review, 2014/10/09 18:24:48]

We do a lot of NULL-check against the :first-letter's renderer but do we have
coverage of that? I am assuming the following would trigger that:

:first-letter {
    display: none;
}

[dsinclair, 2014/10/09 21:14:22]

The spec doesn't list display as valid in first-letter
(http://www.w3.org/TR/CSS2/selector.html#first-letter).

This check, probably, isn't necessary but I'm begin paranoid.

+        if (pseudoElement && pseudoElement->style()->visibility() == VISIBLE)
             return true;
     }
     return false;
 }
 
 static bool shouldEmitTabBeforeNode(Node* node)
 {
     RenderObject* r = node->renderer();
 
     // Table cells are delimited by tabs.
@@ skipping 655 matching lines @@
     }
 
     if (!m_shouldHandleFirstLetter && offsetAfterFirstLetter < m_offset) {
         m_shouldHandleFirstLetter = true;
         offsetInNode = offsetAfterFirstLetter;
         return renderer;
     }
 
     m_shouldHandleFirstLetter = false;
     offsetInNode = 0;
-    RenderText* firstLetterRenderer = firstRenderTextInFirstLetter(fragment->firstLetter());
+
+    ASSERT(fragment->firstLetterPseudoElement());
+
+    RenderObject* pseudoElement = fragment->firstLetterPseudoElement()->renderer();

[Julien - ping for review, 2014/10/09 18:24:48]

s/pseudoElement/pseudoElementRenderer/

[dsinclair, 2014/10/09 21:14:22]

Done.

+    ASSERT(pseudoElement && pseudoElement->slowFirstChild());
+    RenderText* firstLetterRenderer = toRenderText(pseudoElement->slowFirstChild());
 
     m_offset = firstLetterRenderer->caretMaxOffset();
     m_offset += collapsedSpaceLength(firstLetterRenderer, m_offset);
 
     return firstLetterRenderer;
 }
 
 bool SimplifiedBackwardsTextIterator::handleReplacedElement()
 {
     unsigned index = m_node->nodeIndex();
@@ skipping 879 matching lines @@
             resultEnd = collapseTo;
             return;
         }
     }
 
     CharacterIterator computeRangeIterator(inputStart, inputEnd, iteratorFlagsForFindPlainText);
     calculateCharacterSubrange(computeRangeIterator, matchStart, matchLength, resultStart, resultEnd);
 }
 
 }