2013-03-14  Nándor Huszka  <hnandor@inf.u-szeged.hu>

        [WK2] TiledBackingStore: invisible GIFs are animated

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

        The patch stops painting invisible animations, and restart drawing them when they are visible again. 

        How it works:

        1. before painting (in BitmapImage::draw) an animated BitmapImage asks TiledBackingStore 

           whether it is visible (TiledBackingStore::isVisible)

             - yes: paint it

             - no: do not paint it

        2. TBS remembers an invisible animated image (TiledBackingStore::savePseudoDirtyRect)

             - splits image's rect between tiles

             - every tile save the appropriate slice of image rect (Tile::savePseudoDirtyRect)

        * image is visible again because of scrolling *

        3. (in coverWithTilesIfNeeded) TBS checks previously saved invisible animated images (optimizeDirtyRects)

             - every tile checks its own rect set (Tile::optimizeDirtyRect): stored rects (that are visible now) 

               will be united with dirty rect

        * every tiles' dirty rect will be repainted *

          => previously freezed but now visible animated images will be animated again *

        Reviewed by NOBODY (OOPS!).

        No new tests (OOPS!).

        * CMakeLists.txt:

        * Target.pri:

        * WebCore.gypi:

        * platform/graphics/Tile.cpp: Added.

        (WebCore):

        (WebCore::Tile::savePseudoDirtyRect):

        (WebCore::Tile::optimizeDirtyRect):

        * platform/graphics/Tile.h:

        (Tile):

        * platform/graphics/TiledBackingStore.cpp:

        (WebCore):

        (WebCore::TiledBackingStore::TiledBackingStore):

        (WebCore::TiledBackingStore::coverWithTilesIfNeeded):

        (WebCore::TiledBackingStore::optimizeDirtyRects):

        (WebCore::TiledBackingStore::isVisible):

        (WebCore::TiledBackingStore::savePseudoDirtyRect):

        * platform/graphics/TiledBackingStore.h:

        (TiledBackingStore):

        * platform/graphics/cairo/BitmapImageCairo.cpp:

        (WebCore):

        (WebCore::BitmapImage::draw):

        * platform/graphics/texmap/coordinated/CoordinatedTile.cpp:

        (WebCore::CoordinatedTile::CoordinatedTile):

        * platform/graphics/texmap/coordinated/CoordinatedTile.h:

        (CoordinatedTile):

#if USE(TILED_BACKING_STORE)

#include "TiledBackingStore.h"

#endif

#if USE(TILED_BACKING_STORE)

// FIXME: we should access TBS through Frame

extern TiledBackingStore* tbs;

#endif

#include "FloatRect.h"

    bool isVisible(const FloatRect&);

    void optimizeDirtyRects();

    void savePseudoDirtyRect(const FloatRect&);

// FIXME: for the time being we pass TBS to BitmapImage this way,

// but it should be accessed through Frame.

TiledBackingStore* tbs;

    // FIXME

    tbs = this;

    // Animations that became visible should be painted also.

    optimizeDirtyRects();

// Optimization: examine saved pseudo-dirty rects and if it is needed complete dirty rects with them.

void TiledBackingStore::optimizeDirtyRects()

{

    IntRect visibleRect = this->visibleRect();

    TileMap::iterator end = m_tiles.end();

    for (TileMap::iterator it = m_tiles.begin(); it != end; ++it) {

        IntRect tileRect = it->value->rect();

        if (tileRect.intersects(visibleRect))

            it->value->optimizeDirtyRect(visibleRect);

    }

}

// In addition it can be used in order to avoid the painting of an invisible animation.

bool TiledBackingStore::isVisible(const FloatRect& rect)

{

    FloatRect visibleRect(m_visibleRect);

    if (visibleRect.intersects(rect))

        return true;

    // If rect is completely invisible, store it.

    savePseudoDirtyRect(rect);

    return false;

}

// This method makes sense when we call it with an invisible animation's rect.

// Pseudo-dirty rect: should only be painted before it becomes visible.

void TiledBackingStore::savePseudoDirtyRect(const FloatRect& rect)

{

    // Rect may intersect more tiles, so split it up between tiles.

    TileMap::iterator end = m_tiles.end();

    for (TileMap::iterator it = m_tiles.begin(); it != end; ++it) {

        FloatRect tileRect = it->value->rect();

        FloatRect pseudoDirtyRectSlice = intersection(tileRect, rect);

        if (!pseudoDirtyRectSlice.isEmpty())

            it->value->savePseudoDirtyRect(pseudoDirtyRectSlice);

    }

}

#include "FloatRect.h"

    void savePseudoDirtyRect(const FloatRect&);

    void optimizeDirtyRect(const IntRect&);

protected:

    // Moved from CoordinatedTile, because savePseudoDirtyRect and optimizeDirtyRect use it.

    IntRect m_dirtyRect;

private:

    // Stores rects that are not visible now, so we didn't paint them, but they may become visible later.

    Vector<FloatRect> m_pseudoDirtyRects;

/*

 Copyright (C) 2013 Nokia Corporation and/or its subsidiary(-ies)

 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,

 but WITHOUT ANY WARRANTY; without even the implied warranty of

 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 Library General Public License for more details.

 You should have received a copy of the GNU Library General Public License

 along with this library; see the file COPYING.LIB.  If not, write to

 the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 Boston, MA 02110-1301, USA.

 */

#include "config.h"

#if USE(TILED_BACKING_STORE)

#include "Tile.h"

namespace WebCore {

// Puts a rect into m_pseudoDirtyRects.

void Tile::savePseudoDirtyRect(const FloatRect& rect)

{

    // If we have already saved a rect, don't save it.

    unsigned size = m_pseudoDirtyRects.size();

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

        if (m_pseudoDirtyRects[n].contains(rect))

            return;

    }

    m_pseudoDirtyRects.append(rect);

}

void Tile::optimizeDirtyRect(const IntRect& rect)

{

    FloatRect visibleRect(rect);

    // Traverse saved pseudo dirty rects.

    unsigned lastElementNeedToKeep = 0;

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

        FloatRect pseudoDirtyRect = m_pseudoDirtyRects[lastElementNeedToKeep];

        if (pseudoDirtyRect.intersects(visibleRect)) {

            m_dirtyRect.unite(enclosingIntRect(pseudoDirtyRect));

            m_pseudoDirtyRects.remove(lastElementNeedToKeep);

        } else {

            // Skip invisible rect.

            lastElementNeedToKeep++;

        }

    }

}

}

#endif

    m_dirtyRect = m_rect;

    platform/graphics/Tile.cpp

    platform/graphics/Tile.cpp \

            'platform/graphics/Tile.cpp',