Keep a cache of caret painters to avoid recomputing all the time.

Source/core/paint/BlockPainter.cpp

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "config.h"
 #include "core/paint/BlockPainter.h"
 
 #include "core/editing/FrameSelection.h"
 #include "core/frame/Settings.h"
 #include "core/layout/LayoutFlexibleBox.h"
 #include "core/layout/LayoutInline.h"
 #include "core/page/Page.h"
 #include "core/paint/BoxClipper.h"
 #include "core/paint/BoxPainter.h"
 #include "core/paint/DeprecatedPaintLayer.h"
 #include "core/paint/InlinePainter.h"
 #include "core/paint/LayoutObjectDrawingRecorder.h"
 #include "core/paint/LineBoxListPainter.h"
+#include "core/paint/PaintDataCache.h"
 #include "core/paint/PaintInfo.h"
 #include "core/paint/ScopeRecorder.h"
 #include "core/paint/ScrollRecorder.h"
 #include "core/paint/ScrollableAreaPainter.h"
 #include "platform/graphics/paint/ClipRecorder.h"
 #include "wtf/Optional.h"
 
 namespace blink {
 
 void BlockPainter::paint(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
@@ skipping 17 matching lines @@
             if (!overflowBox.intersects(LayoutRect(localPaintInfo.rect)))
                 return;
         }
     } else {
         RELEASE_ASSERT(!m_layoutBlock.isDocumentElement());
     }
 
     // There are some cases where not all clipped visual overflow is accounted for.
     // FIXME: reduce the number of such cases.
     ContentsClipBehavior contentsClipBehavior = ForceContentsClip;
-    if (m_layoutBlock.hasOverflowClip() && !m_layoutBlock.hasControlClip() && !(m_layoutBlock.shouldPaintSelectionGaps() && originalPhase == PaintPhaseForeground) && !hasCaret())
+    if (m_layoutBlock.hasOverflowClip()
+        && !m_layoutBlock.hasControlClip()
+        && !(m_layoutBlock.shouldPaintSelectionGaps() && originalPhase == PaintPhaseForeground)
+        && !hasCaret(paintInfo.paintDataCache()))
         contentsClipBehavior = SkipContentsClipIfPossible;
 
     if (localPaintInfo.phase == PaintPhaseOutline) {
         localPaintInfo.phase = PaintPhaseChildOutlines;
     } else if (localPaintInfo.phase == PaintPhaseChildBlockBackground) {
         localPaintInfo.phase = PaintPhaseBlockBackground;
         m_layoutBlock.paintObject(localPaintInfo, adjustedPaintOffset);
         localPaintInfo.phase = PaintPhaseChildBlockBackgrounds;
     }
 
@@ skipping 150 matching lines @@
         // inline element having outline-style:auto paints the whole focus ring.
         if (!m_layoutBlock.style()->outlineStyleIsAuto() || !m_layoutBlock.isAnonymousBlockContinuation())
             ObjectPainter(m_layoutBlock).paintOutline(paintInfo, LayoutRect(paintOffset, m_layoutBlock.size()), visualOverflowRectWithPaintOffset(m_layoutBlock, paintOffset));
     }
 
     if (paintPhase == PaintPhaseOutline || paintPhase == PaintPhaseChildOutlines)
         paintContinuationOutlines(paintInfo, paintOffset);
 
     // If the caret's node's layout object's containing block is this block, and the paint action is PaintPhaseForeground,
     // then paint the caret.
-    if (paintPhase == PaintPhaseForeground && hasCaret()) {
+    if (paintPhase == PaintPhaseForeground && hasCaret(paintInfo.paintDataCache())) {
         LayoutObjectDrawingRecorder recorder(*paintInfo.context, m_layoutBlock, DisplayItem::Caret, visualOverflowRectWithPaintOffset(m_layoutBlock, paintOffset));
         if (!recorder.canUseCachedDrawing())
             paintCarets(paintInfo, paintOffset);
     }
 }
 
-static inline bool caretBrowsingEnabled(const Frame* frame)
-{
-    Settings* settings = frame->settings();
-    return settings && settings->caretBrowsingEnabled();
-}
-
-static inline bool hasCursorCaret(const FrameSelection& selection, const LayoutBlock* block, bool caretBrowsing)
-{
-    return selection.caretLayoutObject() == block && (selection.hasEditableStyle() || caretBrowsing);
-}
-
-static inline bool hasDragCaret(const DragCaretController& dragCaretController, const LayoutBlock* block, bool caretBrowsing)
-{
-    return dragCaretController.caretLayoutObject() == block && (dragCaretController.isContentEditable() || caretBrowsing);
-}
-
 void BlockPainter::paintCarets(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
-    bool caretBrowsing = caretBrowsingEnabled(m_layoutBlock.frame());
+    bool hasCursorCaret = false;
+    bool hasDragCaret = false;
+    PaintDataCache localCache;
+    PaintDataCache* paintDataCache = paintInfo.paintDataCache() ? paintInfo.paintDataCache() : &localCache;
+    paintDataCache->getLayoutBlockCarets(m_layoutBlock, &hasCursorCaret, &hasDragCaret);
+    LocalFrame* frame = m_layoutBlock.frame();
 
-    FrameSelection& selection = m_layoutBlock.frame()->selection();
-    if (hasCursorCaret(selection, &m_layoutBlock, caretBrowsing)) {
-        selection.paintCaret(paintInfo.context, paintOffset, LayoutRect(paintInfo.rect));
-    }
-
-    DragCaretController& dragCaretController = m_layoutBlock.frame()->page()->dragCaretController();
-    if (hasDragCaret(dragCaretController, &m_layoutBlock, caretBrowsing)) {
-        dragCaretController.paintDragCaret(m_layoutBlock.frame(), paintInfo.context, paintOffset, LayoutRect(paintInfo.rect));
-    }
+    if (hasCursorCaret)
+        frame->selection().paintCaret(paintInfo.context, paintOffset, LayoutRect(paintInfo.rect));
+    if (hasDragCaret)
+        frame->page()->dragCaretController().paintDragCaret(frame, paintInfo.context, paintOffset, LayoutRect(paintInfo.rect));
 }
 
 LayoutRect BlockPainter::overflowRectForPaintRejection() const
 {
     LayoutRect overflowRect = m_layoutBlock.visualOverflowRect();
     if (!m_layoutBlock.hasOverflowModel() || !m_layoutBlock.usesCompositedScrolling())
         return overflowRect;
 
     overflowRect.unite(m_layoutBlock.layoutOverflowRect());
     overflowRect.move(-m_layoutBlock.scrolledContentOffset());
     return overflowRect;
 }
 
-bool BlockPainter::hasCaret() const
+bool BlockPainter::hasCaret(PaintDataCache* paintDataCache) const
 {
-    bool caretBrowsing = caretBrowsingEnabled(m_layoutBlock.frame());
-    return hasCursorCaret(m_layoutBlock.frame()->selection(), &m_layoutBlock, caretBrowsing)
-        || hasDragCaret(m_layoutBlock.frame()->page()->dragCaretController(), &m_layoutBlock, caretBrowsing);
+    if (paintDataCache)
+        return paintDataCache->layoutBlockHasCaret(m_layoutBlock);
+    return PaintDataCache().layoutBlockHasCaret(m_layoutBlock);
 }
 
 void BlockPainter::paintContents(const PaintInfo& paintInfo, const LayoutPoint& paintOffset)
 {
     // Avoid painting descendants of the root element when stylesheets haven't loaded. This eliminates FOUC.
     // It's ok not to draw, because later on, when all the stylesheets do load, styleResolverChanged() on the Document
     // will do a full paint invalidation.
     if (m_layoutBlock.document().didLayoutWithPendingStylesheets() && !m_layoutBlock.isLayoutView())
         return;
 
@@ skipping 55 matching lines @@
         LayoutBlock* block = flow->containingBlock();
         for ( ; block && block != &m_layoutBlock; block = block->containingBlock())
             accumulatedPaintOffset.moveBy(block->location());
         ASSERT(block);
         InlinePainter(*flow).paintOutline(info, accumulatedPaintOffset);
     }
 }
 
 
 } // namespace blink