Changeset 215952 in webkit


Ignore:
Timestamp:
Apr 28, 2017 3:37:56 PM (7 years ago)
Author:
commit-queue@webkit.org
Message:

Unify how BitmapImage handles the availability of a decoded for large and animated images
https://bugs.webkit.org/show_bug.cgi?id=171410

Patch by Said Abou-Hallawa <sabouhallawa@apple.com> on 2017-04-28
Reviewed by Simon Fraser.

Rename some functions which are related to animation frame availability.
Make BitmapImage call ImageObserver::imageFrameAvailable() whenever a
frame is available regardless it is for an animated or for a large image.

  • html/HTMLMediaElement.cpp:

(WebCore::HTMLMediaElement::isVisibleInViewport):

  • html/MediaElementSession.cpp:

(WebCore::MediaElementSession::autoplayPermitted):
(WebCore::isMainContentForPurposesOfAutoplay):

  • loader/cache/CachedImage.cpp:

(WebCore::CachedImage::CachedImageObserver::imageFrameAvailable):
(WebCore::CachedImage::imageFrameAvailable):
(WebCore::CachedImage::usesImageContainerSize): Deleted.
(WebCore::CachedImage::imageHasRelativeWidth): Deleted.
(WebCore::CachedImage::imageHasRelativeHeight): Deleted.
(WebCore::CachedImage::CachedImageObserver::animationAdvanced): Deleted.
(WebCore::CachedImage::animationAdvanced): Deleted.

  • loader/cache/CachedImage.h:
  • loader/cache/CachedImageClient.h:

(WebCore::CachedImageClient::imageFrameAvailable):
(WebCore::CachedImageClient::newImageAnimationFrameAvailable): Deleted.

  • platform/graphics/BitmapImage.cpp:

(WebCore::BitmapImage::internalAdvanceAnimation):
(WebCore::BitmapImage::imageFrameAvailableAtIndex):
(WebCore::BitmapImage::newFrameNativeImageAvailableAtIndex): Deleted.

  • platform/graphics/BitmapImage.h:
  • platform/graphics/Image.h:

(WebCore::Image::imageFrameAvailableAtIndex):
(WebCore::Image::newFrameNativeImageAvailableAtIndex): Deleted.

  • platform/graphics/ImageFrameCache.cpp:

(WebCore::ImageFrameCache::cacheAsyncFrameNativeImageAtIndex):

  • platform/graphics/ImageObserver.h:
  • platform/graphics/ImageTypes.h:
  • rendering/RenderElement.cpp:

(WebCore::RenderElement::RenderElement):
(WebCore::RenderElement::shouldRepaintInVisibleRect):
(WebCore::RenderElement::imageFrameAvailable):
(WebCore::RenderElement::repaintForPausedImageAnimationsIfNeeded):
(WebCore::shouldRepaintForImageAnimation): Deleted.
(WebCore::RenderElement::newImageAnimationFrameAvailable): Deleted.

  • rendering/RenderElement.h:
  • rendering/RenderView.cpp:

(WebCore::RenderView::updateVisibleViewportRect):

  • svg/graphics/SVGImageClients.h:
Location:
trunk/Source/WebCore
Files:
16 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r215951 r215952  
     12017-04-28  Said Abou-Hallawa  <sabouhallawa@apple.com>
     2
     3        Unify how BitmapImage handles the availability of a decoded for large and animated images
     4        https://bugs.webkit.org/show_bug.cgi?id=171410
     5
     6        Reviewed by Simon Fraser.
     7
     8        Rename some functions which are related to animation frame availability.
     9        Make BitmapImage call ImageObserver::imageFrameAvailable() whenever a
     10        frame is available regardless it is for an animated or for a large image.
     11
     12        * html/HTMLMediaElement.cpp:
     13        (WebCore::HTMLMediaElement::isVisibleInViewport):
     14        * html/MediaElementSession.cpp:
     15        (WebCore::MediaElementSession::autoplayPermitted):
     16        (WebCore::isMainContentForPurposesOfAutoplay):
     17        * loader/cache/CachedImage.cpp:
     18        (WebCore::CachedImage::CachedImageObserver::imageFrameAvailable):
     19        (WebCore::CachedImage::imageFrameAvailable):
     20        (WebCore::CachedImage::usesImageContainerSize): Deleted.
     21        (WebCore::CachedImage::imageHasRelativeWidth): Deleted.
     22        (WebCore::CachedImage::imageHasRelativeHeight): Deleted.
     23        (WebCore::CachedImage::CachedImageObserver::animationAdvanced): Deleted.
     24        (WebCore::CachedImage::animationAdvanced): Deleted.
     25        * loader/cache/CachedImage.h:
     26        * loader/cache/CachedImageClient.h:
     27        (WebCore::CachedImageClient::imageFrameAvailable):
     28        (WebCore::CachedImageClient::newImageAnimationFrameAvailable): Deleted.
     29        * platform/graphics/BitmapImage.cpp:
     30        (WebCore::BitmapImage::internalAdvanceAnimation):
     31        (WebCore::BitmapImage::imageFrameAvailableAtIndex):
     32        (WebCore::BitmapImage::newFrameNativeImageAvailableAtIndex): Deleted.
     33        * platform/graphics/BitmapImage.h:
     34        * platform/graphics/Image.h:
     35        (WebCore::Image::imageFrameAvailableAtIndex):
     36        (WebCore::Image::newFrameNativeImageAvailableAtIndex): Deleted.
     37        * platform/graphics/ImageFrameCache.cpp:
     38        (WebCore::ImageFrameCache::cacheAsyncFrameNativeImageAtIndex):
     39        * platform/graphics/ImageObserver.h:
     40        * platform/graphics/ImageTypes.h:
     41        * rendering/RenderElement.cpp:
     42        (WebCore::RenderElement::RenderElement):
     43        (WebCore::RenderElement::shouldRepaintInVisibleRect):
     44        (WebCore::RenderElement::imageFrameAvailable):
     45        (WebCore::RenderElement::repaintForPausedImageAnimationsIfNeeded):
     46        (WebCore::shouldRepaintForImageAnimation): Deleted.
     47        (WebCore::RenderElement::newImageAnimationFrameAvailable): Deleted.
     48        * rendering/RenderElement.h:
     49        * rendering/RenderView.cpp:
     50        (WebCore::RenderView::updateVisibleViewportRect):
     51        * svg/graphics/SVGImageClients.h:
     52
    1532017-04-28  Jeremy Jones  <jeremyj@apple.com>
    254
  • trunk/Source/WebCore/html/HTMLMediaElement.cpp

    r215948 r215952  
    74187418{
    74197419    auto renderer = this->renderer();
    7420     return renderer && renderer->visibleInViewportState() == RenderElement::VisibleInViewport;
     7420    return renderer && renderer->visibleInViewportState() == VisibleInViewportState::Yes;
    74217421}
    74227422
  • trunk/Source/WebCore/html/MediaElementSession.cpp

    r215617 r215952  
    210210    if (renderer->view().frameView().isOffscreen())
    211211        return false;
    212     if (renderer->visibleInViewportState() != RenderElement::VisibleInViewport)
     212    if (renderer->visibleInViewportState() != VisibleInViewportState::Yes)
    213213        return false;
    214214    return true;
     
    663663    if (renderer->style().visibility() != VISIBLE)
    664664        return false;
    665     if (renderer->visibleInViewportState() != RenderElement::VisibleInViewport && !element.isPlaying())
     665    if (renderer->visibleInViewportState() != VisibleInViewportState::Yes && !element.isPlaying())
    666666        return false;
    667667
  • trunk/Source/WebCore/loader/cache/CachedImage.cpp

    r215900 r215952  
    240240}
    241241
    242 bool CachedImage::usesImageContainerSize() const
    243 {
    244     if (m_image)
    245         return m_image->usesContainerSize();
    246 
    247     return false;
    248 }
    249 
    250 bool CachedImage::imageHasRelativeWidth() const
    251 {
    252     if (m_image)
    253         return m_image->hasRelativeWidth();
    254 
    255     return false;
    256 }
    257 
    258 bool CachedImage::imageHasRelativeHeight() const
    259 {
    260     if (m_image)
    261         return m_image->hasRelativeHeight();
    262 
    263     return false;
    264 }
    265 
    266242LayoutSize CachedImage::imageSizeForRenderer(const RenderElement* renderer, float multiplier, SizeType sizeType)
    267243{
     
    367343}
    368344
    369 void CachedImage::CachedImageObserver::animationAdvanced(const Image* image)
     345void CachedImage::CachedImageObserver::imageFrameAvailable(const Image* image, ImageAnimatingState animatingState, const IntRect* changeRect)
    370346{
    371347    for (auto cachedImage : m_cachedImages)
    372         cachedImage->animationAdvanced(image);
     348        cachedImage->imageFrameAvailable(image, animatingState, changeRect);
    373349}
    374350
     
    522498}
    523499
    524 void CachedImage::animationAdvanced(const Image* image)
     500void CachedImage::imageFrameAvailable(const Image* image, ImageAnimatingState animatingState, const IntRect* changeRect)
    525501{
    526502    if (!image || image != m_image)
    527503        return;
    528504
    529     bool shouldPauseAnimation = true;
    530 
    531505    CachedResourceClientWalker<CachedImageClient> clientWalker(m_clients);
     506    VisibleInViewportState visibleState = VisibleInViewportState::No;
     507
    532508    while (CachedImageClient* client = clientWalker.next()) {
    533         bool canPause = false;
    534         client->newImageAnimationFrameAvailable(*this, canPause);
    535         if (!canPause)
    536             shouldPauseAnimation = false;
    537     }
    538 
    539     if (shouldPauseAnimation)
     509        if (client->imageFrameAvailable(*this, animatingState, changeRect) == VisibleInViewportState::Yes)
     510            visibleState = VisibleInViewportState::Yes;
     511    }
     512
     513    if (visibleState == VisibleInViewportState::No && animatingState == ImageAnimatingState::Yes)
    540514        m_image->stopAnimation();
    541515}
  • trunk/Source/WebCore/loader/cache/CachedImage.h

    r215900 r215952  
    6565
    6666    void setContainerSizeForRenderer(const CachedImageClient*, const LayoutSize&, float);
    67     bool usesImageContainerSize() const;
    68     bool imageHasRelativeWidth() const;
    69     bool imageHasRelativeHeight() const;
     67    bool usesImageContainerSize() const { return m_image && m_image->usesContainerSize(); }
     68    bool imageHasRelativeWidth() const { return m_image && m_image->hasRelativeWidth(); }
     69    bool imageHasRelativeHeight() const { return m_image && m_image->hasRelativeHeight(); }
    7070
    7171    void addDataBuffer(SharedBuffer&) override;
     
    132132        void didDraw(const Image*) final;
    133133
    134         void animationAdvanced(const Image*) final;
     134        void imageFrameAvailable(const Image*, ImageAnimatingState, const IntRect* changeRect = nullptr) final;
    135135        void changedInRect(const Image*, const IntRect*) final;
    136136
     
    140140    void decodedSizeChanged(const Image*, long long delta);
    141141    void didDraw(const Image*);
    142     void animationAdvanced(const Image*);
     142    void imageFrameAvailable(const Image*, ImageAnimatingState, const IntRect* changeRect = nullptr);
    143143    void changedInRect(const Image*, const IntRect*);
    144144
  • trunk/Source/WebCore/loader/cache/CachedImageClient.h

    r215700 r215952  
    2424
    2525#include "CachedResourceClient.h"
     26#include "ImageTypes.h"
    2627
    2728namespace WebCore {
     
    2930class CachedImage;
    3031class IntRect;
     32
     33enum class VisibleInViewportState { Unknown, Yes, No };
    3134
    3235class CachedImageClient : public CachedResourceClient {
     
    4144
    4245    // Called when GIF animation progresses.
    43     virtual void newImageAnimationFrameAvailable(CachedImage& image, bool& canPause) { imageChanged(&image); canPause = true; }
     46    virtual VisibleInViewportState imageFrameAvailable(CachedImage& image, ImageAnimatingState, const IntRect* changeRect) { imageChanged(&image, changeRect); return VisibleInViewportState::No; }
    4447
    4548    virtual void didRemoveCachedImageClient(CachedImage&) { }
  • trunk/Source/WebCore/platform/graphics/BitmapImage.cpp

    r215900 r215952  
    412412
    413413    if (imageObserver())
    414         imageObserver()->animationAdvanced(this);
     414        imageObserver()->imageFrameAvailable(this, ImageAnimatingState::Yes);
    415415
    416416    LOG(Images, "BitmapImage::%s - %p - url: %s [m_currentFrame = %ld]", __FUNCTION__, this, sourceURL().string().utf8().data(), m_currentFrame);
     
    443443}
    444444
    445 void BitmapImage::newFrameNativeImageAvailableAtIndex(size_t index)
     445void BitmapImage::imageFrameAvailableAtIndex(size_t index)
    446446{
    447447    UNUSED_PARAM(index);
     
    458458    } else {
    459459        ASSERT(index == m_currentFrame && !m_currentFrame);
    460         imageObserver()->changedInRect(this, nullptr);
     460        imageObserver()->imageFrameAvailable(this, ImageAnimatingState::No);
    461461       
    462462        if (m_source.isAsyncDecodingQueueIdle())
  • trunk/Source/WebCore/platform/graphics/BitmapImage.h

    r215900 r215952  
    175175    void stopAnimation() override;
    176176    void resetAnimation() override;
    177     void newFrameNativeImageAvailableAtIndex(size_t) override;
     177    void imageFrameAvailableAtIndex(size_t) override;
    178178
    179179    // Handle platform-specific data
  • trunk/Source/WebCore/platform/graphics/Image.h

    r215710 r215952  
    134134    virtual void stopAnimation() {}
    135135    virtual void resetAnimation() {}
    136     virtual void newFrameNativeImageAvailableAtIndex(size_t) { }
     136    virtual void imageFrameAvailableAtIndex(size_t) { }
    137137    virtual bool isAnimating() const { return false; }
    138138   
  • trunk/Source/WebCore/platform/graphics/ImageFrameCache.cpp

    r215710 r215952  
    256256    // Notify the image with the readiness of the new frame NativeImage.
    257257    if (m_image)
    258         m_image->newFrameNativeImageAvailableAtIndex(index);
     258        m_image->imageFrameAvailableAtIndex(index);
    259259}
    260260
  • trunk/Source/WebCore/platform/graphics/ImageObserver.h

    r215900 r215952  
    2727#define ImageObserver_h
    2828
     29#include "ImageTypes.h"
     30
    2931namespace WebCore {
    3032
     
    4446    virtual void didDraw(const Image*) = 0;
    4547
    46     virtual void animationAdvanced(const Image*) = 0;
     48    virtual void imageFrameAvailable(const Image*, ImageAnimatingState, const IntRect* changeRect = nullptr) = 0;
    4749    virtual void changedInRect(const Image*, const IntRect* changeRect = nullptr) = 0;
    4850};
  • trunk/Source/WebCore/platform/graphics/ImageTypes.h

    r215211 r215952  
    6464    Ignored
    6565};
    66    
     66
     67enum class ImageAnimatingState { Yes, No };
     68
    6769enum class EncodedDataStatus {
    6870    Error,
  • trunk/Source/WebCore/rendering/RenderElement.cpp

    r215700 r215952  
    116116    , m_renderBlockFlowLineLayoutPath(RenderBlockFlow::UndeterminedPath)
    117117    , m_isRegisteredForVisibleInViewportCallback(false)
    118     , m_visibleInViewportState(VisibilityUnknown)
     118    , m_visibleInViewportState(static_cast<unsigned>(VisibleInViewportState::Unknown))
    119119    , m_firstChild(nullptr)
    120120    , m_lastChild(nullptr)
     
    14341434}
    14351435
    1436 static bool shouldRepaintForImageAnimation(const RenderElement& renderer, const IntRect& visibleRect)
    1437 {
    1438     const Document& document = renderer.document();
    1439     if (document.activeDOMObjectsAreSuspended())
     1436bool RenderElement::shouldRepaintInVisibleRect(const IntRect& visibleRect) const
     1437{
     1438    if (document().activeDOMObjectsAreSuspended())
    14401439        return false;
    1441     if (renderer.style().visibility() != VISIBLE)
     1440    if (style().visibility() != VISIBLE)
    14421441        return false;
    1443     if (renderer.view().frameView().isOffscreen())
     1442    if (view().frameView().isOffscreen())
    14441443        return false;
    14451444
     
    14481447    // be propagated to the root. At this point, we unfortunately don't have access to the image anymore so we
    14491448    // can no longer check if it is a background image.
    1450     bool backgroundIsPaintedByRoot = renderer.isDocumentElementRenderer();
    1451     if (renderer.isBody()) {
    1452         auto& rootRenderer = *renderer.parent(); // If <body> has a renderer then <html> does too.
     1449    bool backgroundIsPaintedByRoot = isDocumentElementRenderer();
     1450    if (isBody()) {
     1451        auto& rootRenderer = *parent(); // If <body> has a renderer then <html> does too.
    14531452        ASSERT(rootRenderer.isDocumentElementRenderer());
    14541453        ASSERT(is<HTMLHtmlElement>(rootRenderer.element()));
     
    14571456
    14581457    }
    1459     LayoutRect backgroundPaintingRect = backgroundIsPaintedByRoot ? renderer.view().backgroundRect() : renderer.absoluteClippedOverflowRect();
     1458
     1459    LayoutRect backgroundPaintingRect = backgroundIsPaintedByRoot ? view().backgroundRect() : absoluteClippedOverflowRect();
    14601460    if (!visibleRect.intersects(enclosingIntRect(backgroundPaintingRect)))
    14611461        return false;
     
    14841484void RenderElement::setVisibleInViewportState(VisibleInViewportState state)
    14851485{
    1486     if (state == m_visibleInViewportState)
    1487         return;
    1488     m_visibleInViewportState = state;
     1486    if (state == visibleInViewportState())
     1487        return;
     1488    m_visibleInViewportState = static_cast<unsigned>(state);
    14891489    visibleInViewportStateChanged();
    14901490}
     
    14951495}
    14961496
    1497 void RenderElement::newImageAnimationFrameAvailable(CachedImage& image, bool& canPause)
     1497VisibleInViewportState RenderElement::imageFrameAvailable(CachedImage& image, ImageAnimatingState animatingState, const IntRect* changeRect)
    14981498{
    14991499    auto& frameView = view().frameView();
    15001500    auto visibleRect = frameView.windowToContents(frameView.windowClipRect());
    1501     if (!shouldRepaintForImageAnimation(*this, visibleRect)) {
     1501    bool shouldRepaint = shouldRepaintInVisibleRect(visibleRect);
     1502
     1503    if (!shouldRepaint && animatingState == ImageAnimatingState::Yes)
    15021504        view().addRendererWithPausedImageAnimations(*this, image);
    1503         canPause = true;
    1504         return;
    1505     }
    1506     imageChanged(&image);
     1505
     1506    // Static images should repaint even if they are outside the viewport rectangle
     1507    // because they should be inside the TileCoverageRect.
     1508    if (shouldRepaint || animatingState == ImageAnimatingState::No)
     1509        imageChanged(&image, changeRect);
     1510
     1511    return shouldRepaint ? VisibleInViewportState::Yes : VisibleInViewportState::No;
    15071512}
    15081513
     
    15161521{
    15171522    ASSERT(m_hasPausedImageAnimations);
    1518     if (!shouldRepaintForImageAnimation(*this, visibleRect))
     1523    if (!shouldRepaintInVisibleRect(visibleRect))
    15191524        return false;
    15201525
  • trunk/Source/WebCore/rendering/RenderElement.h

    r215700 r215952  
    139139    bool borderImageIsLoadedAndCanBeRendered() const;
    140140    bool mayCauseRepaintInsideViewport(const IntRect* visibleRect = nullptr) const;
     141    bool shouldRepaintInVisibleRect(const IntRect& visibleRect) const;
    141142
    142143    // Returns true if this renderer requires a new stacking context.
     
    188189    void unregisterForVisibleInViewportCallback();
    189190
    190     enum VisibleInViewportState {
    191         VisibilityUnknown,
    192         VisibleInViewport,
    193         NotVisibleInViewport,
    194     };
    195191    VisibleInViewportState visibleInViewportState() const { return static_cast<VisibleInViewportState>(m_visibleInViewportState); }
    196192    void setVisibleInViewportState(VisibleInViewportState);
     
    319315    void invalidateCachedFirstLineStyle();
    320316
    321     void newImageAnimationFrameAvailable(CachedImage&, bool& canPause) final;
     317    VisibleInViewportState imageFrameAvailable(CachedImage&, ImageAnimatingState, const IntRect* changeRect) final;
    322318    void didRemoveCachedImageClient(CachedImage&) final;
    323319
  • trunk/Source/WebCore/rendering/RenderView.cpp

    r215160 r215952  
    13911391
    13921392    for (auto* renderer : m_visibleInViewportRenderers) {
    1393         auto state = visibleRect.intersects(enclosingIntRect(renderer->absoluteClippedOverflowRect())) ? RenderElement::VisibleInViewport : RenderElement::NotVisibleInViewport;
     1393        auto state = visibleRect.intersects(enclosingIntRect(renderer->absoluteClippedOverflowRect())) ? VisibleInViewportState::Yes : VisibleInViewportState::No;
    13941394        renderer->setVisibleInViewportState(state);
    13951395    }
  • trunk/Source/WebCore/svg/graphics/SVGImageClients.h

    r214503 r215952  
    5353    void invalidateContentsAndRootView(const IntRect& r) final
    5454    {
    55         // If m_image->m_page is null, we're being destructed, don't fire changedInRect() in that case.
     55        // If m_image->m_page is null, we're being destroyed.
    5656        if (!m_image || !m_image->m_page)
    5757            return;
     
    6161            return;
    6262
    63         if (m_image->isAnimating())
    64             imageObserver->animationAdvanced(m_image);
    65         else
    66             imageObserver->changedInRect(m_image, &r);
     63        imageObserver->imageFrameAvailable(m_image, m_image->isAnimating() ? ImageAnimatingState::Yes : ImageAnimatingState::No, &r);
    6764    }
    6865   
Note: See TracChangeset for help on using the changeset viewer.