Make first-letter style to work with editing

Source/core/editing/VisibleUnits.cpp

 /*
  * Copyright (C) 2004, 2005, 2006, 2007, 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
@@ skipping 466 matching lines @@
 
     searchRange->setStart(start.deprecatedNode(), start.deprecatedEditingOffset(), ec);
     searchRange->setEnd(end.deprecatedNode(), end.deprecatedEditingOffset(), ec);
 
     ASSERT(!ec);
     if (ec)
         return VisiblePosition();
 
     SimplifiedBackwardsTextIterator it(searchRange.get());
     unsigned next = 0;
-    bool inTextSecurityMode = start.deprecatedNode() && start.deprecatedNode()->renderer() && start.deprecatedNode()->renderer()->style()->textSecurity() != TSNONE;
+    bool inTextSecurityMode = start.deprecatedNode() && start.renderer() && start.renderer()->style()->textSecurity() != TSNONE;
     bool needMoreContext = false;
     while (!it.atEnd()) {
         // iterate to get chunks until the searchFunction returns a non-zero value.
         if (!inTextSecurityMode)
             it.prependTextTo(string);
         else {
             // Treat bullets used in the text security mode as regular characters when looking for boundaries
             Vector<UChar, 1024> iteratorString;
             iteratorString.fill('x', it.length());
             string.prepend(iteratorString.data(), iteratorString.size());
@@ skipping 53 matching lines @@
             if (i > 0)
                 break;
             backwardsIterator.advance();
         }
     }
 
     searchRange->selectNodeContents(boundary, IGNORE_EXCEPTION);
     searchRange->setStart(start.deprecatedNode(), start.deprecatedEditingOffset(), IGNORE_EXCEPTION);
     TextIterator it(searchRange.get(), TextIteratorEmitsCharactersBetweenAllVisiblePositions);
     unsigned next = 0;
-    bool inTextSecurityMode = start.deprecatedNode() && start.deprecatedNode()->renderer() && start.deprecatedNode()->renderer()->style()->textSecurity() != TSNONE;
+    bool inTextSecurityMode = start.deprecatedNode() && start.renderer() && start.renderer()->style()->textSecurity() != TSNONE;
     bool needMoreContext = false;
     while (!it.atEnd()) {
         // Keep asking the iterator for chunks until the search function
         // returns an end value not equal to the length of the string passed to it.
         if (!inTextSecurityMode)
             it.appendTextTo(string);
         else {
             // Treat bullets used in the text security mode as regular characters when looking for boundaries
             Vector<UChar, 1024> iteratorString;
             iteratorString.fill('x', it.length());
@@ skipping 139 matching lines @@
 static VisiblePosition startPositionForLine(const VisiblePosition& c, LineEndpointComputationMode mode)
 {
     if (c.isNull())
         return VisiblePosition();
 
     RootInlineBox* rootBox = RenderedPosition(c).rootBox();
     if (!rootBox) {
         // There are VisiblePositions at offset 0 in blocks without
         // RootInlineBoxes, like empty editable blocks and bordered blocks.
         Position p = c.deepEquivalent();
-        if (p.deprecatedNode()->renderer() && p.deprecatedNode()->renderer()->isRenderBlock() && !p.deprecatedEditingOffset())
+        if (p.renderer() && p.renderer()->isRenderBlock() && !p.deprecatedEditingOffset())
             return c;
 
         return VisiblePosition();
     }
 
     Node* startNode;
     InlineBox* startBox;
     if (mode == UseLogicalOrdering) {
         startNode = rootBox->getLogicalStartBoxWithNode(startBox);
         if (!startNode)
@@ skipping 52 matching lines @@
 static VisiblePosition endPositionForLine(const VisiblePosition& c, LineEndpointComputationMode mode)
 {
     if (c.isNull())
         return VisiblePosition();
 
     RootInlineBox* rootBox = RenderedPosition(c).rootBox();
     if (!rootBox) {
         // There are VisiblePositions at offset 0 in blocks without
         // RootInlineBoxes, like empty editable blocks and bordered blocks.
         Position p = c.deepEquivalent();
-        if (p.deprecatedNode()->renderer() && p.deprecatedNode()->renderer()->isRenderBlock() && !p.deprecatedEditingOffset())
+        if (p.renderer() && p.renderer()->isRenderBlock() && !p.deprecatedEditingOffset())
             return c;
         return VisiblePosition();
     }
 
     Node* endNode;
     InlineBox* endBox;
     if (mode == UseLogicalOrdering) {
         endNode = rootBox->getLogicalEndBoxWithNode(endBox);
         if (!endNode)
             return VisiblePosition();
@@ skipping 323 matching lines @@
         if (style->visibility() != VISIBLE) {
             n = NodeTraversal::previousPostOrder(n, startBlock);
             continue;
         }
 
         if (r->isBR() || isBlock(n))
             break;
 
         if (r->isText() && toRenderText(r)->renderedTextLength()) {
             ASSERT_WITH_SECURITY_IMPLICATION(n->isTextNode());
+            RenderText* text = toRenderText(r);
             type = Position::PositionIsOffsetInAnchor;
             if (style->preserveNewline()) {
-                RenderText* text = toRenderText(r);
                 int i = text->textLength();
                 int o = offset;
                 if (n == startNode && o < i)
                     i = max(0, o);
                 while (--i >= 0) {
                     if ((*text)[i] == '\n')
-                        return VisiblePosition(Position(toText(n), i + 1), DOWNSTREAM);
+                        return VisiblePosition(Position(toText(n), i + text->textStartOffset() + 1), DOWNSTREAM);
                 }
             }
             node = n;
             offset = 0;
             n = NodeTraversal::previousPostOrder(n, startBlock);
         } else if (editingIgnoresContent(n) || isTableElement(n)) {
             node = n;
             type = Position::PositionIsBeforeAnchor;
             n = n->previousSibling() ? n->previousSibling() : NodeTraversal::previousPostOrder(n, startBlock);
         } else
@@ skipping 52 matching lines @@
             n = NodeTraversal::next(n, stayInsideBlock);
             continue;
         }
 
         if (r->isBR() || isBlock(n))
             break;
 
         // FIXME: We avoid returning a position where the renderer can't accept the caret.
         if (r->isText() && toRenderText(r)->renderedTextLength()) {
             ASSERT_WITH_SECURITY_IMPLICATION(n->isTextNode());
-            int length = toRenderText(r)->textLength();
+            RenderText* text = toRenderText(r);
+            int length = text->textLength();
             type = Position::PositionIsOffsetInAnchor;
             if (style->preserveNewline()) {
-                RenderText* text = toRenderText(r);
                 int o = n == startNode ? offset : 0;
                 for (int i = o; i < length; ++i) {
                     if ((*text)[i] == '\n')
-                        return VisiblePosition(Position(toText(n), i), DOWNSTREAM);
+                        return VisiblePosition(Position(toText(n), i + text->textStartOffset()), DOWNSTREAM);
                 }
             }
             node = n;
-            offset = r->caretMaxOffset();
+            offset = r->caretMaxOffset() + text->textStartOffset();
             n = NodeTraversal::next(n, stayInsideBlock);
         } else if (editingIgnoresContent(n) || isTableElement(n)) {
             node = n;
             type = Position::PositionIsAfterAnchor;
             n = NodeTraversal::nextSkippingChildren(n, stayInsideBlock);
         } else
             n = NodeTraversal::next(n, stayInsideBlock);
     }
 
     if (type == Position::PositionIsOffsetInAnchor)
@@ skipping 170 matching lines @@
 {
     return direction == LTR ? logicalStartOfLine(c) : logicalEndOfLine(c);
 }
 
 VisiblePosition rightBoundaryOfLine(const VisiblePosition& c, TextDirection direction)
 {
     return direction == LTR ? logicalEndOfLine(c) : logicalStartOfLine(c);
 }
 
 }