Delete RenderSelectionInfo and other selection rect paint invalidation code.

sky/engine/core/rendering/RenderView.cpp

 /*
  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)
  * Copyright (C) 2004, 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved.
  *
  * This library is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Library General Public
  * License as published by the Free Software Foundation; either
  * version 2 of the License, or (at your option) any later version.
  *
  * This library is distributed in the hope that it will be useful,
@@ skipping 12 matching lines @@
 
 #include "gen/sky/platform/RuntimeEnabledFeatures.h"
 #include "sky/engine/core/dom/Document.h"
 #include "sky/engine/core/dom/Element.h"
 #include "sky/engine/core/frame/LocalFrame.h"
 #include "sky/engine/core/page/Page.h"
 #include "sky/engine/core/rendering/GraphicsContextAnnotator.h"
 #include "sky/engine/core/rendering/HitTestResult.h"
 #include "sky/engine/core/rendering/RenderGeometryMap.h"
 #include "sky/engine/core/rendering/RenderLayer.h"
-#include "sky/engine/core/rendering/RenderSelectionInfo.h"
 #include "sky/engine/platform/TraceEvent.h"
 #include "sky/engine/platform/geometry/FloatQuad.h"
 #include "sky/engine/platform/geometry/TransformState.h"
 #include "sky/engine/platform/graphics/GraphicsContext.h"
 
 namespace blink {
 
 RenderView::RenderView(Document* document)
     : RenderBlockFlow(document)
     , m_frameView(document->view())
@@ skipping 252 matching lines @@
 {
     if (!object)
         return 0;
 
     RenderObject* child = object->childAt(offset);
     return child ? child : object->nextInPreOrderAfterChildren();
 }
 
 IntRect RenderView::selectionBounds() const
 {
-    typedef HashMap<RawPtr<RenderObject>, OwnPtr<RenderSelectionInfo> > SelectionMap;
-    SelectionMap selectedObjects;
+    HashSet<RenderObject*> selectedObjects;
 
     RenderObject* os = m_selectionStart;
     RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
     while (os && os != stop) {
         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
             // Blocks are responsible for painting line gaps and margin gaps. They must be examined as well.
-            selectedObjects.set(os, adoptPtr(new RenderSelectionInfo(os, false)));
+            selectedObjects.add(os);
             RenderBlock* cb = os->containingBlock();
             while (cb && !cb->isRenderView()) {
-                OwnPtr<RenderSelectionInfo>& blockInfo = selectedObjects.add(cb, nullptr).storedValue->value;
-                if (blockInfo)
+                if (!selectedObjects.add(cb).isNewEntry)
                     break;
-                blockInfo = adoptPtr(new RenderSelectionInfo(cb, false));
                 cb = cb->containingBlock();
             }
         }
 
         os = os->nextInPreOrder();
     }
 
     // Now create a single bounding box rect that encloses the whole selection.
     LayoutRect selRect;
-    SelectionMap::iterator end = selectedObjects.end();
-    for (SelectionMap::iterator i = selectedObjects.begin(); i != end; ++i) {
-        RenderSelectionInfo* info = i->value.get();
-        // RenderSelectionInfo::rect() is in the coordinates of the paintInvalidationContainer, so map to page coordinates.
-        LayoutRect currRect = info->rect();
-        if (const RenderLayerModelObject* paintInvalidationContainer = info->paintInvalidationContainer()) {
-            FloatQuad absQuad = paintInvalidationContainer->localToAbsoluteQuad(FloatRect(currRect));
-            currRect = absQuad.enclosingBoundingBox();
-        }
-        selRect.unite(currRect);
+
+    for (auto& renderer : selectedObjects) {
+        const RenderLayerModelObject* paintInvalidationContainer = renderer->containerForPaintInvalidation();
+        ASSERT(paintInvalidationContainer);

[ojan, 2015/01/13 00:40:47]

paintInvalidationContainer is only null if the renderer isn't rooted. I don't
see how that could be the case for a renderer whose selection we're trying to
get the bounds of (which is what this function is used for).

[esprehn, 2015/01/13 00:54:48]

Yeah that should never happen.

+        // selectionRectForPaintInvalidation is in the coordinates of the paintInvalidationContainer, so map to page coordinates.
+        bool clipToVisibleContent = false;
+        LayoutRect rect = renderer->selectionRectForPaintInvalidation(paintInvalidationContainer, clipToVisibleContent);
+        FloatQuad absQuad = paintInvalidationContainer->localToAbsoluteQuad(FloatRect(rect));
+        selRect.unite(absQuad.enclosingBoundingBox());
     }
     return pixelSnappedIntRect(selRect);
 }
 
 // When exploring the RenderTree looking for the nodes involved in the Selection, sometimes it's
 // required to change the traversing direction because the "start" position is below the "end" one.
 static inline RenderObject* getNextOrPrevRenderObjectBasedOnDirection(const RenderObject* o, const RenderObject* stop, bool& continueExploring, bool& exploringBackwards)
 {
     RenderObject* next;
     if (exploringBackwards) {
@@ skipping 22 matching lines @@
     // Make sure both our start and end objects are defined.
     // Check www.msnbc.com and try clicking around to find the case where this happened.
     if ((start && !end) || (end && !start))
         return;
 
     // Just return if the selection hasn't changed.
     if (m_selectionStart == start && m_selectionStartPos == startPos &&
         m_selectionEnd == end && m_selectionEndPos == endPos)
         return;
 
-    // Record the old selected objects.  These will be used later
-    // when we compare against the new selected objects.
-    int oldStartPos = m_selectionStartPos;
-    int oldEndPos = m_selectionEndPos;
-
-    // Objects each have a single selection rect to examine.
-    typedef HashMap<RawPtr<RenderObject>, OwnPtr<RenderSelectionInfo> > SelectedObjectMap;
-    SelectedObjectMap oldSelectedObjects;
-    SelectedObjectMap newSelectedObjects;
-
-    // Blocks contain selected objects and fill gaps between them, either on the left, right, or in between lines and blocks.
-    // In order to get the paint invalidation rect right, we have to examine left, middle, and right rects individually, since otherwise
-    // the union of those rects might remain the same even when changes have occurred.
-    typedef HashMap<RawPtr<RenderBlock>, OwnPtr<RenderBlockSelectionInfo> > SelectedBlockMap;
-    SelectedBlockMap oldSelectedBlocks;
-    SelectedBlockMap newSelectedBlocks;
-
     RenderObject* os = m_selectionStart;
     RenderObject* stop = rendererAfterPosition(m_selectionEnd, m_selectionEndPos);
     bool exploringBackwards = false;
     bool continueExploring = os && (os != stop);
     while (continueExploring) {
         if ((os->canBeSelectionLeaf() || os == m_selectionStart || os == m_selectionEnd) && os->selectionState() != SelectionNone) {
-            // Blocks are responsible for painting line gaps and margin gaps.  They must be examined as well.
-            oldSelectedObjects.set(os, adoptPtr(new RenderSelectionInfo(os, true)));
-            if (blockPaintInvalidationMode == PaintInvalidationNewXOROld) {
-                RenderBlock* cb = os->containingBlock();
-                while (cb && !cb->isRenderView()) {
-                    OwnPtr<RenderBlockSelectionInfo>& blockInfo = oldSelectedBlocks.add(cb, nullptr).storedValue->value;
-                    if (blockInfo)
-                        break;
-                    blockInfo = adoptPtr(new RenderBlockSelectionInfo(cb));
-                    cb = cb->containingBlock();
-                }
-            }
+            os->setSelectionStateIfNeeded(SelectionNone);

[ojan, 2015/01/13 00:40:47]

This is from line 425 below. Not sure why the old code did it as a separate
loop. I went back as far as
https://chromium.googlesource.com/chromium/blink/+/11ba7de6d9937c720f8e3356cf...
before giving up trying to find who added the extra loop.

         }
 
         os = getNextOrPrevRenderObjectBasedOnDirection(os, stop, continueExploring, exploringBackwards);
     }
 
-    // Now clear the selection.
-    SelectedObjectMap::iterator oldObjectsEnd = oldSelectedObjects.end();
-    for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i)
-        i->key->setSelectionStateIfNeeded(SelectionNone);
-
     // set selection start and end
     m_selectionStart = start;
     m_selectionStartPos = startPos;
     m_selectionEnd = end;
     m_selectionEndPos = endPos;
 
     // Update the selection status of all objects between m_selectionStart and m_selectionEnd
-    if (start && start == end)
+    if (start && start == end) {
         start->setSelectionStateIfNeeded(SelectionBoth);
-    else {
+    } else {
         if (start)
             start->setSelectionStateIfNeeded(SelectionStart);
         if (end)
             end->setSelectionStateIfNeeded(SelectionEnd);
     }
 
     RenderObject* o = start;
     stop = rendererAfterPosition(end, endPos);
 
     while (o && o != stop) {
         if (o != start && o != end && o->canBeSelectionLeaf())
             o->setSelectionStateIfNeeded(SelectionInside);
         o = o->nextInPreOrder();
     }
-
-    if (blockPaintInvalidationMode != PaintInvalidationNothing)
-        layer()->clearBlockSelectionGapsBounds();
-
-    // Now that the selection state has been updated for the new objects, walk them again and
-    // put them in the new objects list.
-    o = start;
-    exploringBackwards = false;
-    continueExploring = o && (o != stop);
-    while (continueExploring) {
-        if ((o->canBeSelectionLeaf() || o == start || o == end) && o->selectionState() != SelectionNone) {
-            newSelectedObjects.set(o, adoptPtr(new RenderSelectionInfo(o, true)));
-            RenderBlock* cb = o->containingBlock();
-            while (cb && !cb->isRenderView()) {
-                OwnPtr<RenderBlockSelectionInfo>& blockInfo = newSelectedBlocks.add(cb, nullptr).storedValue->value;
-                if (blockInfo)
-                    break;
-                blockInfo = adoptPtr(new RenderBlockSelectionInfo(cb));
-                cb = cb->containingBlock();
-            }
-        }
-
-        o = getNextOrPrevRenderObjectBasedOnDirection(o, stop, continueExploring, exploringBackwards);
-    }
-
-    if (!m_frameView || blockPaintInvalidationMode == PaintInvalidationNothing)
-        return;
-
-    // Have any of the old selected objects changed compared to the new selection?
-    for (SelectedObjectMap::iterator i = oldSelectedObjects.begin(); i != oldObjectsEnd; ++i) {
-        RenderObject* obj = i->key;
-        RenderSelectionInfo* newInfo = newSelectedObjects.get(obj);
-        RenderSelectionInfo* oldInfo = i->value.get();
-        if (!newInfo || oldInfo->rect() != newInfo->rect() || oldInfo->state() != newInfo->state() ||
-            (m_selectionStart == obj && oldStartPos != m_selectionStartPos) ||
-            (m_selectionEnd == obj && oldEndPos != m_selectionEndPos)) {
-            oldInfo->invalidatePaint();
-            if (newInfo) {
-                newInfo->invalidatePaint();
-                newSelectedObjects.remove(obj);
-            }
-        }
-    }
-
-    // Any new objects that remain were not found in the old objects dict, and so they need to be updated.
-    SelectedObjectMap::iterator newObjectsEnd = newSelectedObjects.end();
-    for (SelectedObjectMap::iterator i = newSelectedObjects.begin(); i != newObjectsEnd; ++i)
-        i->value->invalidatePaint();
-
-    // Have any of the old blocks changed?
-    SelectedBlockMap::iterator oldBlocksEnd = oldSelectedBlocks.end();
-    for (SelectedBlockMap::iterator i = oldSelectedBlocks.begin(); i != oldBlocksEnd; ++i) {
-        RenderBlock* block = i->key;
-        RenderBlockSelectionInfo* newInfo = newSelectedBlocks.get(block);
-        RenderBlockSelectionInfo* oldInfo = i->value.get();
-        if (!newInfo || oldInfo->rects() != newInfo->rects() || oldInfo->state() != newInfo->state()) {
-            oldInfo->invalidatePaint();
-            if (newInfo) {
-                newInfo->invalidatePaint();
-                newSelectedBlocks.remove(block);
-            }
-        }
-    }
-
-    // Any new blocks that remain were not found in the old blocks dict, and so they need to be updated.
-    SelectedBlockMap::iterator newBlocksEnd = newSelectedBlocks.end();
-    for (SelectedBlockMap::iterator i = newSelectedBlocks.begin(); i != newBlocksEnd; ++i)
-        i->value->invalidatePaint();
 }
 
 void RenderView::getSelection(RenderObject*& startRenderer, int& startOffset, RenderObject*& endRenderer, int& endOffset) const
 {
     startRenderer = m_selectionStart;
     startOffset = m_selectionStartPos;
     endRenderer = m_selectionEnd;
     endOffset = m_selectionEndPos;
 }
 
@@ skipping 127 matching lines @@
     m_iframes.remove(iframe);
 }
 
 void RenderView::updateIFramesAfterLayout()
 {
     for (auto& iframe: m_iframes)
         iframe->updateWidgetBounds();
 }
 
 } // namespace blink