TEST_F(ScrollableAreaTest, InvalidatesNonCompositedScrollbarsWhenThumbMoves)
{
    ScrollbarThemeWithMockInvalidation theme;
    OwnPtrWillBeRawPtr<MockScrollableArea> scrollableArea = MockScrollableArea::create(IntPoint(100, 100));
    RefPtrWillBeRawPtr<Scrollbar> horizontalScrollbar = Scrollbar::createForTesting(scrollableArea.get(), HorizontalScrollbar, RegularScrollbar, &theme);
    RefPtrWillBeRawPtr<Scrollbar> verticalScrollbar = Scrollbar::createForTesting(scrollableArea.get(), VerticalScrollbar, RegularScrollbar, &theme);
    EXPECT_CALL(*scrollableArea, horizontalScrollbar()).WillRepeatedly(Return(horizontalScrollbar.get()));
    EXPECT_CALL(*scrollableArea, verticalScrollbar()).WillRepeatedly(Return(verticalScrollbar.get()));

    // Regardless of whether the theme invalidates any parts, non-composited
    // scrollbars have to be repainted if the thumb moves.
    EXPECT_CALL(*scrollableArea, layerForHorizontalScrollbar()).WillRepeatedly(Return(nullptr));
    EXPECT_CALL(*scrollableArea, layerForVerticalScrollbar()).WillRepeatedly(Return(nullptr));
    ASSERT_FALSE(scrollableArea->hasLayerForVerticalScrollbar());
    ASSERT_FALSE(scrollableArea->hasLayerForHorizontalScrollbar());
    EXPECT_CALL(theme, shouldRepaintAllPartsOnInvalidation()).WillRepeatedly(Return(false));
    EXPECT_CALL(theme, invalidateOnThumbPositionChange(_, _, _)).WillRepeatedly(Return(NoPart));

    // A scroll in each direction should only invalidate one scrollbar.
    scrollableArea->setScrollPosition(DoublePoint(0, 50), ProgrammaticScroll);
    EXPECT_FALSE(scrollableArea->horizontalScrollbarNeedsPaintInvalidation());
    EXPECT_TRUE(scrollableArea->verticalScrollbarNeedsPaintInvalidation());
    scrollableArea->clearNeedsPaintInvalidationForScrollControls();
    scrollableArea->setScrollPosition(DoublePoint(50, 50), ProgrammaticScroll);
    EXPECT_TRUE(scrollableArea->horizontalScrollbarNeedsPaintInvalidation());
    EXPECT_FALSE(scrollableArea->verticalScrollbarNeedsPaintInvalidation());
    scrollableArea->clearNeedsPaintInvalidationForScrollControls();

    // Forced GC in order to finalize objects depending on the mock object.
    Heap::collectAllGarbage();
}
Exemplo n.º 2
0
bool ScrollableArea::hasLayerForHorizontalScrollbar() const
{
#if USE(ACCELERATED_COMPOSITING)
    return layerForHorizontalScrollbar();
#else
    return false;
#endif
}
void PaintInvalidationCapableScrollableArea::willRemoveScrollbar(Scrollbar& scrollbar, ScrollbarOrientation orientation)
{
    if (!scrollbar.isCustomScrollbar()
        && !(orientation == HorizontalScrollbar ? layerForHorizontalScrollbar() : layerForVerticalScrollbar()))
        boxForScrollControlPaintInvalidation().invalidateDisplayItemClient(scrollbar);

    ScrollableArea::willRemoveScrollbar(scrollbar, orientation);
}
void PaintLayerCompositor::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase, const IntRect& interestRect) const
{
    if (graphicsLayer == layerForHorizontalScrollbar())
        paintScrollbar(m_layoutView.frameView()->horizontalScrollbar(), context, interestRect);
    else if (graphicsLayer == layerForVerticalScrollbar())
        paintScrollbar(m_layoutView.frameView()->verticalScrollbar(), context, interestRect);
    else if (graphicsLayer == layerForScrollCorner())
        FramePainter(*m_layoutView.frameView()).paintScrollCorner(context, interestRect);
}
TEST_F(ScrollableAreaTest, ScrollbarGraphicsLayerInvalidation)
{
    ScrollbarTheme::setMockScrollbarsEnabled(true);
    OwnPtrWillBeRawPtr<MockScrollableArea> scrollableArea = MockScrollableArea::create(IntPoint(0, 100));
    MockGraphicsLayerClient graphicsLayerClient;
    MockGraphicsLayer graphicsLayer(&graphicsLayerClient);
    graphicsLayer.setDrawsContent(true);
    graphicsLayer.setSize(FloatSize(111, 222));

    EXPECT_CALL(*scrollableArea, layerForHorizontalScrollbar()).WillRepeatedly(Return(&graphicsLayer));

    RefPtrWillBeRawPtr<Scrollbar> scrollbar = Scrollbar::create(scrollableArea.get(), HorizontalScrollbar, RegularScrollbar);
    graphicsLayer.resetTrackedPaintInvalidations();
    scrollbar->setNeedsPaintInvalidation();
    EXPECT_TRUE(graphicsLayer.hasTrackedPaintInvalidations());
}
Exemplo n.º 6
0
void ScrollableArea::invalidateScrollbar(Scrollbar* scrollbar, const IntRect& rect)
{
    if (scrollbar == horizontalScrollbar()) {
        if (GraphicsLayer* graphicsLayer = layerForHorizontalScrollbar()) {
            graphicsLayer->setNeedsDisplay();
            graphicsLayer->setContentsNeedsDisplay();
            return;
        }
    } else if (scrollbar == verticalScrollbar()) {
        if (GraphicsLayer* graphicsLayer = layerForVerticalScrollbar()) {
            graphicsLayer->setNeedsDisplay();
            graphicsLayer->setContentsNeedsDisplay();
            return;
        }
    }
    invalidateScrollbarRect(scrollbar, rect);
}
Exemplo n.º 7
0
void ScrollableArea::invalidateScrollbar(Scrollbar* scrollbar, const IntRect& rect)
{
#if USE(ACCELERATED_COMPOSITING)
    if (scrollbar == horizontalScrollbar()) {
        if (GraphicsLayer* graphicsLayer = layerForHorizontalScrollbar()) {
            graphicsLayer->setNeedsDisplay();
            return;
        }
    } else if (scrollbar == verticalScrollbar()) {
        if (GraphicsLayer* graphicsLayer = layerForVerticalScrollbar()) {
            graphicsLayer->setNeedsDisplay();
            return;
        }
    }
#endif
    invalidateScrollbarRect(scrollbar, rect);
}
void PaintInvalidationCapableScrollableArea::invalidatePaintOfScrollControlsIfNeeded(const PaintInvalidationState& paintInvalidationState, const LayoutBoxModelObject& paintInvalidationContainer)
{
    LayoutBox& box = boxForScrollControlPaintInvalidation();
    invalidatePaintOfScrollbarIfNeeded(horizontalScrollbar(), layerForHorizontalScrollbar(), m_horizontalScrollbarPreviouslyWasOverlay, m_horizontalScrollbarPreviousPaintInvalidationRect, horizontalScrollbarNeedsPaintInvalidation(), box, paintInvalidationState, paintInvalidationContainer);
    invalidatePaintOfScrollbarIfNeeded(verticalScrollbar(), layerForVerticalScrollbar(), m_verticalScrollbarPreviouslyWasOverlay, m_verticalScrollbarPreviousPaintInvalidationRect, verticalScrollbarNeedsPaintInvalidation(), box, paintInvalidationState, paintInvalidationContainer);

    LayoutRect scrollCornerPaintInvalidationRect = scrollControlPaintInvalidationRect(scrollCornerAndResizerRect(), box, paintInvalidationState, paintInvalidationContainer);
    if (invalidatePaintOfScrollControlIfNeeded(scrollCornerPaintInvalidationRect, m_scrollCornerAndResizerPreviousPaintInvalidationRect, scrollCornerNeedsPaintInvalidation(), box, paintInvalidationContainer)) {
        m_scrollCornerAndResizerPreviousPaintInvalidationRect = scrollCornerPaintInvalidationRect;
        if (LayoutScrollbarPart* scrollCorner = this->scrollCorner())
            scrollCorner->invalidateDisplayItemClientsIncludingNonCompositingDescendants(&paintInvalidationContainer, PaintInvalidationScroll);
        if (LayoutScrollbarPart* resizer = this->resizer())
            resizer->invalidateDisplayItemClientsIncludingNonCompositingDescendants(&paintInvalidationContainer, PaintInvalidationScroll);
    }

    clearNeedsPaintInvalidationForScrollControls();
}
TEST_F(ScrollableAreaTest, ScrollbarGraphicsLayerInvalidation)
{
    ScrollbarTheme::setMockScrollbarsEnabled(true);
    OwnPtrWillBeRawPtr<MockScrollableArea> scrollableArea = MockScrollableArea::create(IntPoint(0, 100));
    MockGraphicsLayerClient graphicsLayerClient;
    MockGraphicsLayer graphicsLayer(&graphicsLayerClient);
    graphicsLayer.setDrawsContent(true);
    graphicsLayer.setSize(FloatSize(111, 222));

    EXPECT_CALL(*scrollableArea, layerForHorizontalScrollbar()).WillRepeatedly(Return(&graphicsLayer));

    RefPtrWillBeRawPtr<Scrollbar> scrollbar = Scrollbar::create(scrollableArea.get(), HorizontalScrollbar, RegularScrollbar, nullptr);
    graphicsLayer.resetTrackedPaintInvalidations();
    scrollbar->setNeedsPaintInvalidation(NoPart);
    EXPECT_TRUE(graphicsLayer.hasTrackedPaintInvalidations());

    // Forced GC in order to finalize objects depending on the mock object.
    Heap::collectAllGarbage();
}
void ScrollableArea::invalidateScrollbar(Scrollbar* scrollbar, const IntRect& rect)
{
    if (scrollbar == horizontalScrollbar()) {
        if (GraphicsLayer* graphicsLayer = layerForHorizontalScrollbar()) {
            graphicsLayer->setNeedsDisplay();
            graphicsLayer->setContentsNeedsDisplay();
            return;
        }
        invalidateScrollbarRect(scrollbar, rect);
        return;
    }
    if (scrollbar == verticalScrollbar()) {
        if (GraphicsLayer* graphicsLayer = layerForVerticalScrollbar()) {
            graphicsLayer->setNeedsDisplay();
            graphicsLayer->setContentsNeedsDisplay();
            return;
        }
        invalidateScrollbarRect(scrollbar, rect);
        return;
    }
    // Otherwise the scrollbar is just created and has not been set as either
    // horizontalScrollbar() or verticalScrollbar().
}
Exemplo n.º 11
0
bool ScrollableArea::hasLayerForHorizontalScrollbar() const
{
    return layerForHorizontalScrollbar();
}
TEST_F(ScrollableAreaTest, InvalidatesCompositedScrollbarsIfPartsNeedRepaint)
{
    ScrollbarThemeWithMockInvalidation theme;
    OwnPtrWillBeRawPtr<MockScrollableArea> scrollableArea = MockScrollableArea::create(IntPoint(100, 100));
    RefPtrWillBeRawPtr<Scrollbar> horizontalScrollbar = Scrollbar::createForTesting(scrollableArea.get(), HorizontalScrollbar, RegularScrollbar, &theme);
    horizontalScrollbar->clearTrackNeedsRepaint();
    horizontalScrollbar->clearThumbNeedsRepaint();
    RefPtrWillBeRawPtr<Scrollbar> verticalScrollbar = Scrollbar::createForTesting(scrollableArea.get(), VerticalScrollbar, RegularScrollbar, &theme);
    verticalScrollbar->clearTrackNeedsRepaint();
    verticalScrollbar->clearThumbNeedsRepaint();
    EXPECT_CALL(*scrollableArea, horizontalScrollbar()).WillRepeatedly(Return(horizontalScrollbar.get()));
    EXPECT_CALL(*scrollableArea, verticalScrollbar()).WillRepeatedly(Return(verticalScrollbar.get()));

    // Composited scrollbars only need repainting when parts become invalid
    // (e.g. if the track changes appearance when the thumb reaches the end).
    MockGraphicsLayerClient graphicsLayerClient;
    MockGraphicsLayer layerForHorizontalScrollbar(&graphicsLayerClient);
    layerForHorizontalScrollbar.setDrawsContent(true);
    layerForHorizontalScrollbar.setSize(FloatSize(10, 10));
    MockGraphicsLayer layerForVerticalScrollbar(&graphicsLayerClient);
    layerForVerticalScrollbar.setDrawsContent(true);
    layerForVerticalScrollbar.setSize(FloatSize(10, 10));
    EXPECT_CALL(*scrollableArea, layerForHorizontalScrollbar()).WillRepeatedly(Return(&layerForHorizontalScrollbar));
    EXPECT_CALL(*scrollableArea, layerForVerticalScrollbar()).WillRepeatedly(Return(&layerForVerticalScrollbar));
    ASSERT_TRUE(scrollableArea->hasLayerForHorizontalScrollbar());
    ASSERT_TRUE(scrollableArea->hasLayerForVerticalScrollbar());
    EXPECT_CALL(theme, shouldRepaintAllPartsOnInvalidation()).WillRepeatedly(Return(false));

    // First, we'll scroll horizontally, and the theme will require repainting
    // the back button (i.e. the track).
    EXPECT_CALL(theme, invalidateOnThumbPositionChange(_, _, _)).WillOnce(Return(BackButtonStartPart));
    scrollableArea->setScrollPosition(DoublePoint(50, 0), ProgrammaticScroll);
    EXPECT_TRUE(layerForHorizontalScrollbar.hasTrackedPaintInvalidations());
    EXPECT_FALSE(layerForVerticalScrollbar.hasTrackedPaintInvalidations());
    EXPECT_TRUE(horizontalScrollbar->trackNeedsRepaint());
    EXPECT_FALSE(horizontalScrollbar->thumbNeedsRepaint());
    layerForHorizontalScrollbar.resetTrackedPaintInvalidations();
    horizontalScrollbar->clearTrackNeedsRepaint();

    // Next, we'll scroll vertically, but invalidate the thumb.
    EXPECT_CALL(theme, invalidateOnThumbPositionChange(_, _, _)).WillOnce(Return(ThumbPart));
    scrollableArea->setScrollPosition(DoublePoint(50, 50), ProgrammaticScroll);
    EXPECT_FALSE(layerForHorizontalScrollbar.hasTrackedPaintInvalidations());
    EXPECT_TRUE(layerForVerticalScrollbar.hasTrackedPaintInvalidations());
    EXPECT_FALSE(verticalScrollbar->trackNeedsRepaint());
    EXPECT_TRUE(verticalScrollbar->thumbNeedsRepaint());
    layerForVerticalScrollbar.resetTrackedPaintInvalidations();
    verticalScrollbar->clearThumbNeedsRepaint();

    // Next we'll scroll in both, but the thumb position moving requires no
    // invalidations. Nonetheless the GraphicsLayer should be invalidated,
    // because we still need to update the underlying layer (though no
    // rasterization will be required).
    EXPECT_CALL(theme, invalidateOnThumbPositionChange(_, _, _)).Times(2).WillRepeatedly(Return(NoPart));
    scrollableArea->setScrollPosition(DoublePoint(70, 70), ProgrammaticScroll);
    EXPECT_TRUE(layerForHorizontalScrollbar.hasTrackedPaintInvalidations());
    EXPECT_TRUE(layerForVerticalScrollbar.hasTrackedPaintInvalidations());
    EXPECT_FALSE(horizontalScrollbar->trackNeedsRepaint());
    EXPECT_FALSE(horizontalScrollbar->thumbNeedsRepaint());
    EXPECT_FALSE(verticalScrollbar->trackNeedsRepaint());
    EXPECT_FALSE(verticalScrollbar->thumbNeedsRepaint());

    // Forced GC in order to finalize objects depending on the mock object.
    Heap::collectAllGarbage();
}