WebCore/ChangeLog

        Reviewed by NOBODY (OOPS!).

        https://bugs.webkit.org/show_bug.cgi?id=23360

        When using accelerated compositing, make repaints use the correct

        repaint container. Hook up the RenderLayerCompositor in RenderView,

        and add to RenderView a method that repaints both the view

        contents, and any intersecting composited layers.

        * rendering/RenderBox.cpp:

        (WebCore::RenderBox::computeRectForRepaint):

        * rendering/RenderInline.cpp:

        (WebCore::RenderInline::clippedOverflowRectForRepaint):

        * rendering/RenderObject.cpp:

        (WebCore::RenderObject::containingBlockWidth):

        (WebCore::RenderObject::containingBlockHeight):

        (WebCore::RenderObject::containerForRepaint):

        (WebCore::RenderObject::repaintUsingContainer):

        * rendering/RenderView.cpp:

        (WebCore::RenderView::RenderView):

        (WebCore::RenderView::~RenderView):

        (WebCore::RenderView::shouldRepaint):

        (WebCore::RenderView::repaintViewRectangle):

        (WebCore::RenderView::repaintRectangleInViewAndCompositedLayers):

        (WebCore::RenderView::setMaximalOutlineSize):

        (WebCore::RenderView::setSelection):

        (WebCore::RenderView::updateWidgetPositions):

        (WebCore::RenderView::usesCompositing):

        (WebCore::RenderView::compositor):

        (WebCore::RenderView::didMoveOnscreen):

        (WebCore::RenderView::willMoveOffscreen):

        * rendering/RenderView.h:

2009-02-02  Simon Fraser  <simon.fraser@apple.com>

        Reviewed by NOBODY (OOPS!).

        https://bugs.webkit.org/show_bug.cgi?id=23358

        Hook accelerated compositing into RenderLayer.

WebCore/rendering/RenderBox.cpp

@@void RenderBox::computeRectForRepaint(RenderBox* repaintContainer, IntRect& rect

    // in the parent's coordinate space that encloses us.

    if (m_layer && m_layer->transform()) {

        fixed = false;

1572 rect = m_layer->transform()->mapRect(rect);

#if USE(ACCELERATED_COMPOSITING)

        // Ideally, repaints would never cross compositing boundaries, but there are cases

        // where they still do (e.g. for selection). When computing repaint rects across

        // compositing boundaries, we just ignore transforms applied to compositing layers.

        if (!m_layer->isComposited())

            rect = enclosingIntRect(m_layer->transform()->mapRect(FloatRect(rect)));

#else

        rect = enclosingIntRect(m_layer->transform()->mapRect(FloatRect(rect)));

#endif

        // FIXME: this clobbers topLeft adjustment done for multicol above

        topLeft = rect.location();

        topLeft.move(x(), y());

WebCore/rendering/RenderInline.cpp

@@IntRect RenderInline::clippedOverflowRectForRepaint(RenderBox* repaintContainer)

        IntRect repaintRect(x, y, r.width(), r.height());

        r = intersection(repaintRect, boxRect);

    }

561 ASSERT(repaintContainer != this);

562 cb->computeRectForRepaint(repaintContainer, r);

    // Don't allow computeRectForRepaint to go above the repaint container.

    if (repaintContainer != this)

        cb->computeRectForRepaint(repaintContainer, r);

    if (ow) {

        for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling()) {

WebCore/rendering/RenderObject.cpp

#include <stdio.h>

#include <wtf/RefCountedLeakCounter.h>

#if USE(ACCELERATED_COMPOSITING)

#include "RenderLayerCompositor.h"

#endif

#if ENABLE(WML)

#include "WMLNames.h"

#endif

@@RenderBlock* RenderObject::containingBlock() const

int RenderObject::containingBlockWidth() const

{

581 // ~~FIXME~~ ?

582 return contain~~ingBlock()~~->availableWidth();

585 RenderBlock* container = containingBlock();

586 return container ? container->availableWidth() : 0;

}

int RenderObject::containingBlockHeight() const

{

587 // ~~FIXME~~ ?

588 return contain~~ingBlock()~~->contentHeight();

591 RenderBlock* container = containingBlock();

592 return container ? container->contentHeight() : 0;

}

static bool mustRepaintFillLayers(const RenderObject* renderer, const FillLayer* layer)

@@void RenderObject::paint(PaintInfo& /*paintInfo*/, int /*tx*/, int /*ty*/)

RenderBox* RenderObject::containerForRepaint() const

{

1555 // For now, all repaints are root-relative.

#if USE(ACCELERATED_COMPOSITING)

    if (RenderView* v = view()) {

        if (v->usesCompositing()) {

            RenderLayer* compLayer = v->compositor()->enclosingCompositingLayer(enclosingLayer());

            return compLayer ? compLayer->renderer() : 0;

        }

    }

#endif

    // Do root-relative repaint.

    return 0;

}

@@void RenderObject::repaintUsingContainer(RenderBox* repaintContainer, const IntR

        RenderView* v = repaintContainer ? toRenderView(repaintContainer) : view();

        v->repaintViewRectangle(r, immediate);

    } else {

1565 // Handle container-relative repaints eventually.

#if USE(ACCELERATED_COMPOSITING)

        RenderView* v = view();

        if (v->usesCompositing()) {

            ASSERT(repaintContainer->hasLayer() && repaintContainer->layer()->isComposited());

            repaintContainer->layer()->setBackingNeedsRepaintInRect(r);

        }

#else

15661584 ASSERT_NOT_REACHED();

1585#endif

    }

}

WebCore/rendering/RenderView.cpp

#include "HitTestResult.h"

#include "RenderLayer.h"

#if USE(ACCELERATED_COMPOSITING)

#include "RenderLayerCompositor.h"

#endif

namespace WebCore {

RenderView::RenderView(Node* node, FrameView* view)

@@RenderView::RenderView(Node* node, FrameView* view)

    , m_maximalOutlineSize(0)

    , m_layoutState(0)

    , m_layoutStateDisableCount(0)

#if USE(ACCELERATED_COMPOSITING)

    , m_compositor(0)

#endif

{

    // Clear our anonymous bit, set because RenderObject assumes

    // any renderer with document as the node is anonymous.

@@RenderView::RenderView(Node* node, FrameView* view)

RenderView::~RenderView()

{

#if USE(ACCELERATED_COMPOSITING)

    delete m_compositor;

#endif

}

void RenderView::calcHeight()

@@void RenderView::paintBoxDecorations(PaintInfo& paintInfo, int, int)

    }

}

216 v~~oid~~ RenderView::repaint~~ViewRectangle~~(const IntRect& ur, b~~ool immediate)~~

226bool RenderView::shouldRepaint(const IntRect& r) const

217227{

218 if (printing() || ur.width() == 0 || ur.height() == 0)

219 return;

228 if (printing() || r.width() == 0 || r.height() == 0)

229 return false;

220230

221231 if (!m_frameView)

        return false;

    return true;

}

void RenderView::repaintViewRectangle(const IntRect& ur, bool immediate)

{

    if (!shouldRepaint(ur))

        return;

    // We always just invalidate the root view, since we could be an iframe that is clipped out

@@void RenderView::repaintViewRectangle(const IntRect& ur, bool immediate)

    }

}

void RenderView::repaintRectangleInViewAndCompositedLayers(const IntRect& ur, bool immediate)

{

    if (!shouldRepaint(ur))

        return;

    repaintViewRectangle(ur, immediate);

#if USE(ACCELERATED_COMPOSITING)

    // If we're a frame, repaintViewRectangle will have repainted via a RenderObject in the

    // parent document.

    if (document()->ownerElement())

        return;

    if (compositor()->inCompositingMode())

        compositor()->repaintCompositedLayersAbsoluteRect(ur);

#endif

}

void RenderView::computeRectForRepaint(RenderBox* repaintContainer, IntRect& rect, bool fixed)

{

    // If a container was specified, and was not 0 or the RenderView,

@@IntRect RenderView::selectionBounds(bool clipToVisibleContent) const

    return selRect;

}

#if USE(ACCELERATED_COMPOSITING)

// Compositing layer dimensions take outline size into account, so we have to recompute layer

// bounds when it changes.

// FIXME: This is ugly; it would be nice to have a better way to do this.

void RenderView::setMaximalOutlineSize(int o)

{

    if (o != m_maximalOutlineSize) {

        m_maximalOutlineSize = o;

        if (m_frameView)

            m_frameView->updateCompositingLayers(FrameView::ForcedUpdate);

    }

}

#endif

void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* end, int endPos)

{

    // Make sure both our start and end objects are defined.

@@void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* e

        if (!newInfo || oldInfo->rect() != newInfo->rect() || oldInfo->state() != newInfo->state() ||

            (m_selectionStart == obj && oldStartPos != m_selectionStartPos) ||

            (m_selectionEnd == obj && oldEndPos != m_selectionEndPos)) {

442 repaint~~View~~Rectangle(oldInfo->rect());

493 repaintRectangleInViewAndCompositedLayers(oldInfo->rect());

443494 if (newInfo) {

444 repaint~~View~~Rectangle(newInfo->rect());

495 repaintRectangleInViewAndCompositedLayers(newInfo->rect());

                newSelectedObjects.remove(obj);

                delete newInfo;

            }

@@void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* e

    SelectedObjectMap::iterator newObjectsEnd = newSelectedObjects.end();

    for (SelectedObjectMap::iterator i = newSelectedObjects.begin(); i != newObjectsEnd; ++i) {

        SelectionInfo* newInfo = i->second;

456 repaint~~View~~Rectangle(newInfo->rect());

507 repaintRectangleInViewAndCompositedLayers(newInfo->rect());

        delete newInfo;

    }

@@void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* e

        BlockSelectionInfo* newInfo = newSelectedBlocks.get(block);

        BlockSelectionInfo* oldInfo = i->second;

        if (!newInfo || oldInfo->rects() != newInfo->rects() || oldInfo->state() != newInfo->state()) {

467 repaint~~View~~Rectangle(oldInfo->rects());

518 repaintRectangleInViewAndCompositedLayers(oldInfo->rects());

468519 if (newInfo) {

469 repaint~~View~~Rectangle(newInfo->rects());

520 repaintRectangleInViewAndCompositedLayers(newInfo->rects());

                newSelectedBlocks.remove(block);

                delete newInfo;

            }

@@void RenderView::setSelection(RenderObject* start, int startPos, RenderObject* e

    SelectedBlockMap::iterator newBlocksEnd = newSelectedBlocks.end();

    for (SelectedBlockMap::iterator i = newSelectedBlocks.begin(); i != newBlocksEnd; ++i) {

        BlockSelectionInfo* newInfo = i->second;

481 repaint~~View~~Rectangle(newInfo->rects());

532 repaintRectangleInViewAndCompositedLayers(newInfo->rects());

        delete newInfo;

    }

}

@@bool RenderView::printing() const

void RenderView::updateWidgetPositions()

{

#if USE(ACCELERATED_COMPOSITING)

    if (m_compositor)

        m_compositor->updateRootLayerPosition();

#endif

    RenderObjectSet::iterator end = m_widgets.end();

    for (RenderObjectSet::iterator it = m_widgets.begin(); it != end; ++it)

        (*it)->updateWidgetPosition();

@@void RenderView::updateHitTestResult(HitTestResult& result, const IntPoint& poin

    }

}

#if USE(ACCELERATED_COMPOSITING)

bool RenderView::usesCompositing() const

{

    return m_compositor && m_compositor->inCompositingMode();

}

RenderLayerCompositor* RenderView::compositor()

{

    if (!m_compositor)

        m_compositor = new RenderLayerCompositor(this);

    return m_compositor;

}

#endif

629700void RenderView::didMoveOnscreen()

630701{

631 // FIXME: will call into RenderLayerCompositor

#if USE(ACCELERATED_COMPOSITING)

    if (m_compositor)

        m_compositor->didMoveOnscreen();

#endif

}

void RenderView::willMoveOffscreen()

{

636 // FIXME: will call into RenderLayerCompositor

#if USE(ACCELERATED_COMPOSITING)

    if (m_compositor)

        m_compositor->willMoveOffscreen();

#endif

}

} // namespace WebCore

WebCore/rendering/RenderView.h

#include "RenderBlock.h"

namespace WebCore {

    
#if USE(ACCELERATED_COMPOSITING)

class GraphicsLayer;

class RenderLayerCompositor;

#endif

class RenderView : public RenderBlock {

public:

@@public:

    virtual bool hasOverhangingFloats() { return false; }

    virtual void computeRectForRepaint(RenderBox* repaintContainer, IntRect&, bool fixed = false);

6470 virtual void repaintViewRectangle(const IntRect&, bool immediate = false);

    // Repaint the view, and all composited layers that intersect the given absolute rectangle.

    // FIXME: ideally we'd never have to do this, if all repaints are container-relative.

    virtual void repaintRectangleInViewAndCompositedLayers(const IntRect&, bool immediate = false);

    virtual void paint(PaintInfo&, int tx, int ty);

    virtual void paintBoxDecorations(PaintInfo&, int tx, int ty);

@@public:

    IntRect selectionBounds(bool clipToVisibleContent = true) const;

#if USE(ACCELERATED_COMPOSITING)

    void setMaximalOutlineSize(int o);

#else

88100 void setMaximalOutlineSize(int o) { m_maximalOutlineSize = o; }

101#endif

    int maximalOutlineSize() const { return m_maximalOutlineSize; }

    virtual IntRect viewRect() const;

@@public:

    virtual void updateHitTestResult(HitTestResult&, const IntPoint&);

#if USE(ACCELERATED_COMPOSITING)

    RenderLayerCompositor* compositor();

    bool usesCompositing() const;

#endif

    // Notifications that this view became visible in a window, or will be

    // removed from the window.

    void didMoveOnscreen();

    void willMoveOffscreen();

@@private:

    // selectionRect should never be called on a RenderView

    virtual IntRect selectionRect(bool);

179 bool shouldRepaint(const IntRect& r) const;

180

protected:

    FrameView* m_frameView;

@@private:

    bool m_forcedPageBreak;

    LayoutState* m_layoutState;

    unsigned m_layoutStateDisableCount;

#if USE(ACCELERATED_COMPOSITING)

    RenderLayerCompositor* m_compositor;

#endif

};

inline RenderView* toRenderView(RenderObject* o)