2013-04-17  Nándor Huszka  <hnandor@inf.u-szeged.hu>

        Reorganize animation starting

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

        The patch reorganizes animation starting.

        After it we don't need to start them explicitly,

        because FrameView will do this automatically.

        So far starting animation is done by painting.

        Now it is done by FrameView instead of image drawing.

        It is needed to know every animation, so RenderImage

        passes itself to FrameView by calling its animateLater method.

        FrameView resumes only visible animations after painting

        (in paintContents) and after scrolling (in wheelEvent)

        with resumeAnimationsIfNeeded.

        Animation stops after it hase became invisible, it is checked

        by RenderObject::willRenderImage. By calling FrameView's

        shouldRenderAnimation method we get the answer whether it is needed

        to render the animation. On the other hand FrameView

        saves it if animation isn't visible.

        So the animation can be resumed when it becomes visible again.

        Dead RenderObjects are removed from FrameView's register

        with removeSavedAnimation in RenderObject::willBeDestroyed,

        and startAnimation isn't handled by BitmapImage already.

        Reviewed by NOBODY (OOPS!).

        No new tests (OOPS!).

        * page/FrameView.cpp:

        (WebCore::FrameView::paintContents):

        (WebCore):

        (WebCore::FrameView::saveStoppedAnimation):

        (WebCore::FrameView::animateLater):

        (WebCore::FrameView::removeSavedAnimation):

        (WebCore::FrameView::resumeAnimatingImagesIfNeeded):

        (WebCore::FrameView::shouldRenderAnimation):

        (WebCore::FrameView::computeScrolledViewPort):

        (WebCore::FrameView::wheelEvent):

        * page/FrameView.h:

        (FrameView):

        * platform/graphics/BitmapImage.cpp:

        (WebCore::BitmapImage::startAnimation):

        * platform/graphics/cairo/BitmapImageCairo.cpp:

        (WebCore::BitmapImage::draw):

        * rendering/RenderImage.cpp:

        (WebCore::RenderImage::paintIntoRect):

        * rendering/RenderObject.cpp:

        (WebCore::RenderObject::willBeDestroyed):

        (WebCore::RenderObject::willRenderImage):

#include "BitmapImage.h"

#include "RenderImage.h"

    // resume animations after painting

    resumeAnimatingImagesIfNeeded(rect);

// place animation in the vector of stopped animations

void FrameView::saveStoppedAnimation(RenderObject* animation)

{

    const size_t index = m_animationsToResume.find(animation);

    ASSERT(index > -1);

    m_animationsToResume.remove(index);

    m_stoppedAnimations.append(animation);

}

// remember animation, it may be saved already

void FrameView::animateLater(RenderObject* animation)

{

    if (m_animationsToResume.contains(animation))

        return;

    if (m_stoppedAnimations.contains(animation))

        return;

    // we didn't deal with it yet

    m_stoppedAnimations.append(animation);

}

void FrameView::removeSavedAnimation(RenderObject* animation)

{

    size_t index = m_animationsToResume.find(animation);

    if (index != WTF::notFound) {

        m_animationsToResume.remove(index);

        return;

    }

    index = m_stoppedAnimations.find(animation);

    if (index != WTF::notFound)

        m_stoppedAnimations.remove(index);

}

void FrameView::resumeAnimatingImagesIfNeeded(const IntRect& area)

{

    RenderObject* stoppedAnimation;

    IntRect stoppedAnimationBoundingBox;

    bool intersectsArea;

    // search for animations that are now stopped but should be resumed

    unsigned lastElementNeedToKeep = 0;

    while (m_stoppedAnimations.size() != lastElementNeedToKeep) {

        stoppedAnimation = m_stoppedAnimations[lastElementNeedToKeep];

        stoppedAnimationBoundingBox = stoppedAnimation->absoluteBoundingBoxRect();

        intersectsArea = stoppedAnimationBoundingBox.intersects(area);

        if (intersectsArea) {

            m_stoppedAnimations.remove(lastElementNeedToKeep);

            m_animationsToResume.append(stoppedAnimation);

        } else {

            // skip actual animation

            lastElementNeedToKeep++;

        }

    }

    RenderObject* animationToResume;

    IntRect animationToResumeBoundingBox;

    unsigned size = m_animationsToResume.size();

    for (unsigned n = 0; n < size; ++n) {

        animationToResume = m_animationsToResume[n];

        animationToResumeBoundingBox = animationToResume->absoluteBoundingBoxRect();

        intersectsArea = animationToResumeBoundingBox.intersects(area);

        // start every animation that should be resumed

        if (intersectsArea) {

            CachedImage* cachedImage = toRenderImage(animationToResume)->cachedImage();

            if (!cachedImage)

                continue;

            if (!cachedImage->hasImage())

                continue;

            Image* image = cachedImage->image();

            if (!image->isBitmapImage())

                continue;

            BitmapImage* bitmapImage = static_cast<BitmapImage*>(image);

            if (!bitmapImage->canAnimate())

                continue;

            image->startAnimation();

        }

    }

}

bool FrameView::shouldRenderAnimation(RenderObject* animation)

{

    bool visible = visibleContentRect().intersects(animation->absoluteBoundingBoxRect());

    if (m_isViewPortScrolled)

        visible = m_scrolledViewPort.intersects(animation->absoluteBoundingBoxRect());

    bool animationShouldResume = m_animationsToResume.find(animation) != WTF::notFound;

    if (visible && animationShouldResume)

        return true;

    // save animation in order to deal with it later

    saveStoppedAnimation(animation);

    return false;

}

IntRect FrameView::computeScrolledViewPort(float deltaX, float deltaY)

{

    IntRect viewPort = visibleContentRect();

    int newX = viewPort.x() - deltaX;

    int newY = viewPort.y() - deltaY;

    IntRect scrolledViewPort(IntPoint(newX, newY), viewPort.size());

    return scrolledViewPort;

}

            m_isViewPortScrolled = true;

            m_scrolledViewPort = computeScrolledViewPort(deltaX, deltaY);

            const IntRect scrolledViewPort(m_scrolledViewPort.location(), m_scrolledViewPort.size());

            // it is needed to resume animations before scrolling

            resumeAnimatingImagesIfNeeded(scrolledViewPort);

            m_isViewPortScrolled = false;

    bool shouldRenderAnimation(RenderObject*);

    void animateLater(RenderObject*);

    void removeSavedAnimation(RenderObject*);

    IntRect computeScrolledViewPort(float, float);

    void resumeAnimatingImagesIfNeeded(const IntRect&);

    void saveStoppedAnimation(RenderObject*);

    Vector<RenderObject*> m_stoppedAnimations;

    Vector<RenderObject*> m_animationsToResume;

    IntRect m_scrolledViewPort;

    bool m_isViewPortScrolled;

    // register itself in FrameView, because it isn't animated yet

    view()->frameView()->animateLater(this);

    // remove dead animations from FrameView

    ASSERT(frame()->view());

    frame()->view()->removeSavedAnimation(this);

    // FrameView knows whether animation is visible

    if (!view()->frameView()->shouldRenderAnimation(this))

        return false;