Make first-letter style to work with editing

Source/core/editing/FrameSelection.cpp

 /*
  * Copyright (C) 2004, 2008, 2009, 2010 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 158 matching lines @@
 
 void FrameSelection::moveTo(const Position &base, const Position &extent, EAffinity affinity, EUserTriggered userTriggered)
 {
     const bool selectionHasDirection = true;
     SetSelectionOptions options = CloseTyping | ClearTypingStyle | userTriggered;
     setSelection(VisibleSelection(base, extent, affinity, selectionHasDirection), options);
 }
 
 void DragCaretController::setCaretPosition(const VisiblePosition& position)
 {
-    if (Node* node = m_position.deepEquivalent().deprecatedNode())
-        invalidateCaretRect(node);
+    if (m_position.isNotNull())
+        invalidateCaretRect(m_position.deepEquivalent());
     m_position = position;
     setCaretRectNeedsUpdate();
-    Document* document = 0;
-    if (Node* node = m_position.deepEquivalent().deprecatedNode()) {
-        invalidateCaretRect(node);
-        document = node->document();
-    }
+    if (m_position.isNotNull())
+        invalidateCaretRect(m_position.deepEquivalent());
     if (m_position.isNull() || m_position.isOrphan())
         clearCaretRect();
     else
-        updateCaretRect(document, m_position);
+        updateCaretRect(m_position.deepEquivalent().document(), m_position);
 }
 
 static void adjustEndpointsAtBidiBoundary(VisiblePosition& visibleBase, VisiblePosition& visibleExtent)
 {
     RenderedPosition base(visibleBase);
     RenderedPosition extent(visibleExtent);
 
     if (base.isNull() || extent.isNull() || base.isEquivalent(extent))
         return;
 
@@ skipping 995 matching lines @@
 {
     m_granularity = CharacterGranularity;
 
     m_caretBlinkTimer.stop();
 
     RenderView* view = m_frame->contentRenderer();
     if (view)
         view->clearSelection();
 
     setSelection(VisibleSelection(), CloseTyping | ClearTypingStyle | DoNotUpdateAppearance);
-    m_previousCaretNode.clear();
+    m_previousCaretPosition.clear();
 }
 
 void FrameSelection::setStart(const VisiblePosition &pos, EUserTriggered trigger)
 {
     if (m_selection.isBaseFirst())
         setBase(pos, trigger);
     else
         setExtent(pos, trigger);
 }
 
@@ skipping 32 matching lines @@
 void CaretBase::clearCaretRect()
 {
     m_caretLocalRect = LayoutRect();
 }
 
 static inline bool caretRendersInsideNode(Node* node)
 {
     return node && !isTableElement(node) && !editingIgnoresContent(node);
 }
 
-static RenderObject* caretRenderer(Node* node)
+static RenderObject* caretRenderer(RenderObject* renderer)
 {
-    if (!node)
-        return 0;
-
-    RenderObject* renderer = node->renderer();
     if (!renderer)
         return 0;
 
     // if caretNode is a block and caret is inside it then caret should be painted by that block
-    bool paintedByBlock = renderer->isBlockFlow() && caretRendersInsideNode(node);
+    bool paintedByBlock = renderer->isBlockFlow() && caretRendersInsideNode(renderer->node());
     return paintedByBlock ? renderer : renderer->containingBlock();
 }
 
+static RenderObject* caretRenderer(const Position& position)
+{
+    return caretRenderer(position.renderer());
+}
+
 bool CaretBase::updateCaretRect(Document* document, const VisiblePosition& caretPosition)
 {
     document->updateStyleIfNeeded();
     m_caretLocalRect = LayoutRect();
 
     m_caretRectNeedsUpdate = false;
 
     if (caretPosition.isNull())
         return false;
 
-    ASSERT(caretPosition.deepEquivalent().deprecatedNode()->renderer());
+    ASSERT(caretPosition.deepEquivalent().renderer());
 
     // First compute a rect local to the renderer at the selection start.
     RenderObject* renderer;
     LayoutRect localRect = caretPosition.localCaretRect(renderer);
 
     // Get the renderer that will be responsible for painting the caret
     // (which is either the renderer we just found, or one of its containers).
-    RenderObject* caretPainter = caretRenderer(caretPosition.deepEquivalent().deprecatedNode());
+    RenderObject* caretPainter = caretRenderer(caretPosition.deepEquivalent());
 
     // Compute an offset between the renderer and the caretPainter.
     bool unrooted = false;
     while (renderer != caretPainter) {
         RenderObject* containerObject = renderer->container();
         if (!containerObject) {
             unrooted = true;
             break;
         }
         localRect.move(renderer->offsetFromContainer(containerObject, localRect.location()));
         renderer = containerObject;
     }
 
     if (!unrooted)
         m_caretLocalRect = localRect;
 
     return true;
 }
 
 RenderObject* FrameSelection::caretRenderer() const
 {
-    return WebCore::caretRenderer(m_selection.start().deprecatedNode());
+    return WebCore::caretRenderer(m_selection.start());
 }
 
 RenderObject* DragCaretController::caretRenderer() const
 {
-    return WebCore::caretRenderer(m_position.deepEquivalent().deprecatedNode());
+    return WebCore::caretRenderer(m_position.deepEquivalent());
 }
 
 static bool isNonOrphanedCaret(const VisibleSelection& selection)
 {
     return selection.isCaret() && !selection.start().isOrphan() && !selection.end().isOrphan();
 }
 
 LayoutRect FrameSelection::localCaretRect()
 {
     if (shouldUpdateCaretRect()) {
         if (!isNonOrphanedCaret(m_selection))
             clearCaretRect();
         else if (updateCaretRect(m_frame->document(), VisiblePosition(m_selection.start(), m_selection.affinity())))
             m_absCaretBoundsDirty = true;
     }
 
     return localCaretRectWithoutUpdate();
 }
 
-IntRect CaretBase::absoluteBoundsForLocalRect(Node* node, const LayoutRect& rect) const
+IntRect CaretBase::absoluteBoundsForLocalRect(const Position& position, const LayoutRect& rect) const
 {
-    RenderObject* caretPainter = caretRenderer(node);
+    RenderObject* caretPainter = caretRenderer(position);
     if (!caretPainter)
         return IntRect();
 
     LayoutRect localRect(rect);
     if (caretPainter->isBox())
         toRenderBox(caretPainter)->flipForWritingMode(localRect);
     return caretPainter->localToAbsoluteQuad(FloatRect(localRect)).enclosingBoundingBox();
 }
 
 IntRect FrameSelection::absoluteCaretBounds()
 {
     recomputeCaretRect();
     return m_absCaretBounds;
 }
 
-static void repaintCaretForLocalRect(Node* node, const LayoutRect& rect)
+static void repaintCaretForLocalRect(const Position& position, const LayoutRect& rect)
 {
-    RenderObject* caretPainter = caretRenderer(node);
+    RenderObject* caretPainter = caretRenderer(position);
     if (!caretPainter)
         return;
 
     // FIXME: Need to over-paint 1 pixel to workaround some rounding problems.
     // https://bugs.webkit.org/show_bug.cgi?id=108283
     LayoutRect inflatedRect = rect;
     inflatedRect.inflate(1);
 
     caretPainter->repaintRectangle(inflatedRect);
 }
 
 bool FrameSelection::recomputeCaretRect()
 {
     if (!shouldUpdateCaretRect())
         return false;
 
     if (!m_frame)
         return false;
 
     FrameView* v = m_frame->document()->view();
     if (!v)
         return false;
 
     LayoutRect oldRect = localCaretRectWithoutUpdate();
     LayoutRect newRect = localCaretRect();
     if (oldRect == newRect && !m_absCaretBoundsDirty)
         return false;
 
     IntRect oldAbsCaretBounds = m_absCaretBounds;
-    m_absCaretBounds = absoluteBoundsForLocalRect(m_selection.start().deprecatedNode(), localCaretRectWithoutUpdate());
+    m_absCaretBounds = absoluteBoundsForLocalRect(m_selection.start(), localCaretRectWithoutUpdate());
     m_absCaretBoundsDirty = false;
 
     if (oldAbsCaretBounds == m_absCaretBounds)
         return false;
 
     if (RenderView* view = m_frame->document()->renderView()) {
-        Node* node = m_selection.start().deprecatedNode();
-        if (m_previousCaretNode)
-            repaintCaretForLocalRect(m_previousCaretNode.get(), oldRect);
-        m_previousCaretNode = node;
+        if (m_previousCaretPosition.isNotNull())
+            repaintCaretForLocalRect(m_previousCaretPosition, oldRect);
+        m_previousCaretPosition = m_selection.start();
         if (shouldRepaintCaret(view, isContentEditable()))
-            repaintCaretForLocalRect(node, newRect);
+            repaintCaretForLocalRect(m_previousCaretPosition, newRect);
     }
 
     return true;
 }
 
 bool CaretBase::shouldRepaintCaret(const RenderView* view, bool isContentEditable) const
 {
     ASSERT(view);
     Frame* frame = view->frameView() ? view->frameView()->frame() : 0; // The frame where the selection started.
     bool caretBrowsing = frame && frame->settings() && frame->settings()->caretBrowsingEnabled();
     return (caretBrowsing || isContentEditable);
 }
 
 void FrameSelection::invalidateCaretRect()
 {
     if (!isCaret())
         return;
 
-    CaretBase::invalidateCaretRect(m_selection.start().deprecatedNode(), recomputeCaretRect());
+    CaretBase::invalidateCaretRect(m_selection.start(), recomputeCaretRect());
 }
 
-void CaretBase::invalidateCaretRect(Node* node, bool caretRectChanged)
+void CaretBase::invalidateCaretRect(const Position& position, bool caretRectChanged)
 {
     // EDIT FIXME: This is an unfortunate hack.
     // Basically, we can't trust this layout position since we
     // can't guarantee that the check to see if we are in unrendered
     // content will work at this point. We may have to wait for
     // a layout and re-render of the document to happen. So, resetting this
     // flag will cause another caret layout to happen the first time
     // that we try to paint the caret after this call. That one will work since
     // it happens after the document has accounted for any editing
     // changes which may have been done.
     // And, we need to leave this layout here so the caret moves right
     // away after clicking.
     m_caretRectNeedsUpdate = true;
 
     if (caretRectChanged)
         return;
 
-    if (RenderView* view = node->document()->renderView()) {
-        if (shouldRepaintCaret(view, node->isContentEditable(Node::UserSelectAllIsAlwaysNonEditable)))
-            repaintCaretForLocalRect(node, localCaretRectWithoutUpdate());
+    if (RenderView* view = position.document()->renderView()) {
+        if (shouldRepaintCaret(view, position.anchorNode()->isContentEditable(Node::UserSelectAllIsAlwaysNonEditable)))
+            repaintCaretForLocalRect(position, localCaretRectWithoutUpdate());
     }
 }
 
 void FrameSelection::paintCaret(GraphicsContext* context, const LayoutPoint& paintOffset, const LayoutRect& clipRect)
 {
     if (m_selection.isCaret() && m_caretPaint)
-        CaretBase::paintCaret(m_selection.start().deprecatedNode(), context, paintOffset, clipRect);
+        CaretBase::paintCaret(m_selection.start(), context, paintOffset, clipRect);
 }
 
-void CaretBase::paintCaret(Node* node, GraphicsContext* context, const LayoutPoint& paintOffset, const LayoutRect& clipRect) const
+void CaretBase::paintCaret(const Position& position, GraphicsContext* context, const LayoutPoint& paintOffset, const LayoutRect& clipRect) const
 {
     if (m_caretVisibility == Hidden)
         return;
 
     LayoutRect drawingRect = localCaretRectWithoutUpdate();
-    RenderObject* renderer = caretRenderer(node);
+    RenderObject* renderer = caretRenderer(position);
     if (renderer && renderer->isBox())
         toRenderBox(renderer)->flipForWritingMode(drawingRect);
     drawingRect.moveBy(roundedIntPoint(paintOffset));
     LayoutRect caret = intersection(drawingRect, clipRect);
     if (caret.isEmpty())
         return;
 
     Color caretColor = Color::black;
 
-    Element* element;
-    if (node->isElementNode())
-        element = toElement(node);
-    else
-        element = node->parentElement();
-
+    Element* element = position.element();
     if (element && element->renderer())
         caretColor = element->renderer()->resolveColor(CSSPropertyColor);
 
     context->fillRect(caret, caretColor);
 }
 
 void FrameSelection::debugRenderer(RenderObject *r, bool selected) const
 {
     if (r->node()->isElementNode()) {
         Element* element = toElement(r->node());
@@ skipping 64 matching lines @@
 
     // Treat a collapsed selection like no selection.
     if (!isRange())
         return false;
     if (!document->renderer())
         return false;
 
     HitTestRequest request(HitTestRequest::ReadOnly | HitTestRequest::Active | HitTestRequest::DisallowShadowContent);
     HitTestResult result(point);
     document->renderView()->hitTest(request, result);
-    Node* innerNode = result.innerNode();
-    if (!innerNode || !innerNode->renderer())
+    RenderObject* renderer = result.renderer();
+    if (!renderer)
         return false;
 
-    VisiblePosition visiblePos(innerNode->renderer()->positionForPoint(result.localPoint()));
+    VisiblePosition visiblePos(renderer->positionForPoint(result.localPoint()));
     if (visiblePos.isNull())
         return false;
 
     if (m_selection.visibleStart().isNull() || m_selection.visibleEnd().isNull())
         return false;
 
     Position start(m_selection.visibleStart().deepEquivalent());
     Position end(m_selection.visibleEnd().deepEquivalent());
     Position p(visiblePos.deepEquivalent());
 
@@ skipping 256 matching lines @@
     Position candidate = startPos.downstream();
     if (candidate.isCandidate())
         startPos = candidate;
     Position endPos = selection.end();
     candidate = endPos.upstream();
     if (candidate.isCandidate())
         endPos = candidate;
 
     // We can get into a state where the selection endpoints map to the same VisiblePosition when a selection is deleted
     // because we don't yet notify the FrameSelection of text removal.
-    if (startPos.isNotNull() && endPos.isNotNull() && selection.visibleStart() != selection.visibleEnd()) {
-        RenderObject* startRenderer = startPos.deprecatedNode()->renderer();
-        RenderObject* endRenderer = endPos.deprecatedNode()->renderer();
-        view->setSelection(startRenderer, startPos.deprecatedEditingOffset(), endRenderer, endPos.deprecatedEditingOffset());
-    }
+    if (startPos.isNotNull() && endPos.isNotNull() && selection.visibleStart() != selection.visibleEnd())
+        view->setSelection(startPos.renderer(), startPos.offsetInRenderer(), endPos.renderer(), endPos.offsetInRenderer());
 }
 
 void FrameSelection::setCaretVisibility(CaretVisibility visibility)
 {
     if (caretVisibility() == visibility)
         return;
 
     m_frame->document()->updateLayoutIgnorePendingStylesheets();
     if (m_caretPaint) {
         m_caretPaint = false;
@@ skipping 83 matching lines @@
         m_frame->document()->setFocusedElement(0);
     }
 
     if (caretBrowsing)
         m_frame->page()->focusController()->setFocusedElement(0, m_frame);
 }
 
 void DragCaretController::paintDragCaret(Frame* frame, GraphicsContext* p, const LayoutPoint& paintOffset, const LayoutRect& clipRect) const
 {
     if (m_position.deepEquivalent().deprecatedNode()->document()->frame() == frame)
-        paintCaret(m_position.deepEquivalent().deprecatedNode(), p, paintOffset, clipRect);
+        paintCaret(m_position.deepEquivalent(), p, paintOffset, clipRect);
 }
 
 PassRefPtr<MutableStylePropertySet> FrameSelection::copyTypingStyle() const
 {
     if (!m_typingStyle || !m_typingStyle->style())
         return 0;
     return m_typingStyle->style()->mutableCopy();
 }
 
 bool FrameSelection::shouldDeleteSelection(const VisibleSelection& selection) const
@@ skipping 82 matching lines @@
     case VisibleSelection::CaretSelection:
         rect = absoluteCaretBounds();
         break;
     case VisibleSelection::RangeSelection:
         rect = revealExtentOption == RevealExtent ? VisiblePosition(extent()).absoluteCaretBounds() : enclosingIntRect(bounds(false));
         break;
     }
 
     Position start = this->start();
     ASSERT(start.deprecatedNode());
-    if (start.deprecatedNode() && start.deprecatedNode()->renderer()) {
+    if (start.renderer()) {
         // FIXME: This code only handles scrolling the startContainer's layer, but
         // the selection rect could intersect more than just that.
         // See <rdar://problem/4799899>.
-        if (start.deprecatedNode()->renderer()->scrollRectToVisible(rect, alignment, alignment))
+        if (start.renderer()->scrollRectToVisible(rect, alignment, alignment))
             updateAppearance();
     }
 }
 
 void FrameSelection::setSelectionFromNone()
 {
     // Put a caret inside the body if the entire frame is editable (either the
     // entire WebView is editable or designMode is on for this document).
 
     Document* document = m_frame->document();
@@ skipping 60 matching lines @@
     sel.showTreeForThis();
 }
 
 void showTree(const WebCore::FrameSelection* sel)
 {
     if (sel)
         sel->showTreeForThis();
 }
 
 #endif