Async image decoding for large images should be disabled after the first time a tile...
authorcommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 25 Jul 2017 18:53:08 +0000 (18:53 +0000)
committercommit-queue@webkit.org <commit-queue@webkit.org@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 25 Jul 2017 18:53:08 +0000 (18:53 +0000)
https://bugs.webkit.org/show_bug.cgi?id=174451
<rdar://problem/31246421>

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

Source/WebCore:

Flashing because of DOM mutation can be fixed by disabling the asynchronous
image decoding after the first time a tile was painted.

We can detect this by consulting the tile repaintCount. If it is zero, then
it is safe to use asynchronous image decoded. If the tile repaintCount is
greater than zero, we are not sure if the renderer rectangle has an image
drawn in it already or not. In this case we have to use the synchronous
image decoding to avoid causing a flash.

Tests: fast/images/async-image-background-change.html
       fast/images/async-image-src-change.html
       http/tests/multipart/multipart-async-image.html

* html/shadow/MediaControlElements.cpp:
(WebCore::MediaControlTextTrackContainerElement::createTextTrackRepresentationImage):
* page/FrameView.cpp:
(WebCore::FrameView::willPaintContents):
(WebCore::FrameView::paintContentsForSnapshot):
* page/PageOverlayController.cpp:
(WebCore::PageOverlayController::paintContents):
* page/PageOverlayController.h:
* page/linux/ResourceUsageOverlayLinux.cpp:
* page/mac/ServicesOverlayController.h:
* page/mac/ServicesOverlayController.mm:
(WebCore::ServicesOverlayController::Highlight::paintContents):
* platform/graphics/BitmapImage.cpp:
(WebCore::BitmapImage::draw):
* platform/graphics/BitmapImage.h:
* platform/graphics/GraphicsLayer.cpp:
(WebCore::GraphicsLayer::paintGraphicsLayerContents):
* platform/graphics/GraphicsLayer.h:
* platform/graphics/GraphicsLayerClient.h:
(WebCore::GraphicsLayerClient::paintContents):
* platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp:
(WebCore::LayerClient::platformCALayerPaintContents):
* platform/graphics/ca/GraphicsLayerCA.cpp:
(WebCore::GraphicsLayerCA::platformCALayerPaintContents):
* platform/graphics/ca/GraphicsLayerCA.h:
* platform/graphics/ca/PlatformCALayer.h:
* platform/graphics/ca/PlatformCALayerClient.h:
(WebCore::PlatformCALayerClient::platformCALayerRepaintCount):
* platform/graphics/ca/TileCoverageMap.cpp:
(WebCore::TileCoverageMap::platformCALayerPaintContents):
* platform/graphics/ca/TileCoverageMap.h:
* platform/graphics/ca/TileGrid.cpp:
(WebCore::TileGrid::platformCALayerPaintContents):
(WebCore::TileGrid::platformCALayerRepaintCount):
* platform/graphics/ca/TileGrid.h:
* platform/graphics/ca/cocoa/PlatformCALayerCocoa.mm:
(PlatformCALayer::drawLayerContents):
* platform/graphics/ca/win/PlatformCALayerWin.cpp:
(PlatformCALayer::drawLayerContents):
* platform/graphics/ca/win/PlatformCALayerWinInternal.cpp:
(PlatformCALayerWinInternal::displayCallback):
* platform/graphics/ca/win/WebTiledBackingLayerWin.cpp:
(WebTiledBackingLayerWin::displayCallback):
* platform/graphics/mac/WebLayer.mm:
(-[WebLayer drawInContext:]):
(-[WebSimpleLayer drawInContext:]):
* rendering/PaintPhase.h:
* rendering/RenderBoxModelObject.cpp:
(WebCore::RenderBoxModelObject::decodingModeForImageDraw):
* rendering/RenderElement.h:
* rendering/RenderLayer.cpp:
(WebCore::RenderLayer::paintLayerContents):
(WebCore::RenderLayer::paintForegroundForFragments):
* rendering/RenderLayerBacking.cpp:
(WebCore::RenderLayerBacking::paintContents):
* rendering/RenderLayerBacking.h:
* rendering/RenderLayerCompositor.cpp:
(WebCore::RenderLayerCompositor::paintContents):
* rendering/RenderLayerCompositor.h:
* rendering/RenderWidget.cpp:
(WebCore::RenderWidget::paintContents):
* testing/Internals.cpp:
(WebCore::imageFromImageElement):
(WebCore::bitmapImageFromImageElement):
(WebCore::Internals::imageFrameIndex):
(WebCore::Internals::setImageFrameDecodingDuration):
(WebCore::Internals::resetImageAnimation):
(WebCore::Internals::isImageAnimating):
(WebCore::Internals::setClearDecoderAfterAsyncFrameRequestForTesting):
(WebCore::Internals::imageDecodeCount):
(WebCore::Internals::setLargeImageAsyncDecodingEnabledForTesting):
* testing/Internals.h:
* testing/Internals.idl:

Source/WebKit:

* Shared/mac/RemoteLayerBackingStore.mm:
(WebKit::RemoteLayerBackingStore::drawInContext):
* WebProcess/InjectedBundle/DOM/InjectedBundleNodeHandle.cpp:
(WebKit::imageForRect):
* WebProcess/InjectedBundle/DOM/InjectedBundleRangeHandle.cpp:
(WebKit::InjectedBundleRangeHandle::renderedImage):
* WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.cpp:
(WebKit::CompositingCoordinator::paintContents):
* WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.h:

Source/WebKitLegacy/mac:

* WebView/WebFrame.mm:
(-[WebFrame _paintBehaviorForDestinationContext:]):
(-[WebFrame _drawRect:contentsOnly:]):
* WebView/WebHTMLView.mm:
(imageFromRect):

Source/WebKitLegacy/win:

* FullscreenVideoController.cpp:
(FullscreenVideoController::LayerClient::platformCALayerPaintContents):
* WebCoreSupport/AcceleratedCompositingContext.cpp:
(AcceleratedCompositingContext::paintContents):
* WebCoreSupport/AcceleratedCompositingContext.h:

LayoutTests:

To test async image decoding for large images, we have to create the <img>
element dynamically so we can listen to the load and webkitImageFrameReady
events and know reliably when to end the test. But with this patch the async
image decoding for large images will be disabled after the first paint.
That means async image decoding for large images will be disabled always
unless we force the async image decoding till the image is painted for the
first time. We use Internals::setLargeImageAsyncDecodingEnabledForTesting()
to force the async image decoding. So painting an image in this case will
require multiple paints; in all of them the async image decoding will be
enabled. But this is okay because it resembles the case where the <img> is
created from a static <img> tag in the HTML file.

For new tests, where we want to make sure that mutating the DOM will not
cause a flash, async image decoding will be forced till the image is drawn
for the first time. After that the async image decoding is enabled but not
forced.

Disable new tests for WK1 because the async image decoding is always enabled
because tiling does not necessarily exist in WK1 . But eventually the async
image decoding for large images will be always disabled for WK1.

* fast/images/async-image-background-change-expected.html: Added.
* fast/images/async-image-background-change.html: Added.
* fast/images/async-image-background-image-repeated.html:
* fast/images/async-image-background-image.html:
* fast/images/async-image-body-background-image.html:
* fast/images/async-image-multiple-clients-repaint.html:
* fast/images/async-image-src-change-expected.html: Added.
* fast/images/async-image-src-change.html: Added.
* fast/images/resources/green-400x400.png: Added.
* fast/images/resources/red-100x100.png: Added.
* fast/images/resources/red-400x400.png: Added.
* fast/images/sprite-sheet-image-draw.html:
* http/tests/multipart/multipart-async-image-expected.txt: Added.
* http/tests/multipart/multipart-async-image.html: Added.
* platform/ios-wk1/TestExpectations:
* platform/mac-wk1/TestExpectations:

git-svn-id: https://svn.webkit.org/repository/webkit/trunk@219876 268f45cc-cd09-0410-ab3c-d52691b4dbfc

69 files changed:
LayoutTests/ChangeLog
LayoutTests/fast/images/async-image-background-change-expected.html [new file with mode: 0644]
LayoutTests/fast/images/async-image-background-change.html [new file with mode: 0644]
LayoutTests/fast/images/async-image-background-image-repeated.html
LayoutTests/fast/images/async-image-background-image.html
LayoutTests/fast/images/async-image-body-background-image.html
LayoutTests/fast/images/async-image-multiple-clients-repaint.html
LayoutTests/fast/images/async-image-src-change-expected.html [new file with mode: 0644]
LayoutTests/fast/images/async-image-src-change.html [new file with mode: 0644]
LayoutTests/fast/images/resources/green-400x400.png [new file with mode: 0644]
LayoutTests/fast/images/resources/red-100x100.png [new file with mode: 0644]
LayoutTests/fast/images/resources/red-400x400.png [new file with mode: 0644]
LayoutTests/fast/images/sprite-sheet-image-draw.html
LayoutTests/http/tests/multipart/multipart-async-image-expected.txt [new file with mode: 0644]
LayoutTests/http/tests/multipart/multipart-async-image.html [new file with mode: 0644]
LayoutTests/platform/ios-wk1/TestExpectations
LayoutTests/platform/mac-wk1/TestExpectations
Source/WebCore/ChangeLog
Source/WebCore/html/shadow/MediaControlElements.cpp
Source/WebCore/page/FrameView.cpp
Source/WebCore/page/PageOverlayController.cpp
Source/WebCore/page/PageOverlayController.h
Source/WebCore/page/linux/ResourceUsageOverlayLinux.cpp
Source/WebCore/page/mac/ServicesOverlayController.h
Source/WebCore/page/mac/ServicesOverlayController.mm
Source/WebCore/platform/graphics/BitmapImage.cpp
Source/WebCore/platform/graphics/BitmapImage.h
Source/WebCore/platform/graphics/GraphicsLayer.cpp
Source/WebCore/platform/graphics/GraphicsLayer.h
Source/WebCore/platform/graphics/GraphicsLayerClient.h
Source/WebCore/platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp
Source/WebCore/platform/graphics/ca/GraphicsLayerCA.cpp
Source/WebCore/platform/graphics/ca/GraphicsLayerCA.h
Source/WebCore/platform/graphics/ca/PlatformCALayer.h
Source/WebCore/platform/graphics/ca/PlatformCALayerClient.h
Source/WebCore/platform/graphics/ca/TileCoverageMap.cpp
Source/WebCore/platform/graphics/ca/TileCoverageMap.h
Source/WebCore/platform/graphics/ca/TileGrid.cpp
Source/WebCore/platform/graphics/ca/TileGrid.h
Source/WebCore/platform/graphics/ca/cocoa/PlatformCALayerCocoa.mm
Source/WebCore/platform/graphics/ca/win/PlatformCALayerWin.cpp
Source/WebCore/platform/graphics/ca/win/PlatformCALayerWinInternal.cpp
Source/WebCore/platform/graphics/ca/win/WebTiledBackingLayerWin.cpp
Source/WebCore/platform/graphics/mac/WebLayer.mm
Source/WebCore/rendering/PaintPhase.h
Source/WebCore/rendering/RenderBoxModelObject.cpp
Source/WebCore/rendering/RenderElement.h
Source/WebCore/rendering/RenderLayer.cpp
Source/WebCore/rendering/RenderLayerBacking.cpp
Source/WebCore/rendering/RenderLayerBacking.h
Source/WebCore/rendering/RenderLayerCompositor.cpp
Source/WebCore/rendering/RenderLayerCompositor.h
Source/WebCore/rendering/RenderWidget.cpp
Source/WebCore/testing/Internals.cpp
Source/WebCore/testing/Internals.h
Source/WebCore/testing/Internals.idl
Source/WebKit/ChangeLog
Source/WebKit/Shared/mac/RemoteLayerBackingStore.mm
Source/WebKit/WebProcess/InjectedBundle/DOM/InjectedBundleNodeHandle.cpp
Source/WebKit/WebProcess/InjectedBundle/DOM/InjectedBundleRangeHandle.cpp
Source/WebKit/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.cpp
Source/WebKit/WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.h
Source/WebKitLegacy/mac/ChangeLog
Source/WebKitLegacy/mac/WebView/WebFrame.mm
Source/WebKitLegacy/mac/WebView/WebHTMLView.mm
Source/WebKitLegacy/win/ChangeLog
Source/WebKitLegacy/win/FullscreenVideoController.cpp
Source/WebKitLegacy/win/WebCoreSupport/AcceleratedCompositingContext.cpp
Source/WebKitLegacy/win/WebCoreSupport/AcceleratedCompositingContext.h

index cf5364c..e4ccabb 100644 (file)
@@ -1,3 +1,49 @@
+2017-07-25  Said Abou-Hallawa  <sabouhallawa@apple.com>
+
+        Async image decoding for large images should be disabled after the first time a tile is painted
+        https://bugs.webkit.org/show_bug.cgi?id=174451
+        <rdar://problem/31246421>
+
+        Reviewed by Simon Fraser.
+
+        To test async image decoding for large images, we have to create the <img>
+        element dynamically so we can listen to the load and webkitImageFrameReady
+        events and know reliably when to end the test. But with this patch the async
+        image decoding for large images will be disabled after the first paint. 
+        That means async image decoding for large images will be disabled always
+        unless we force the async image decoding till the image is painted for the
+        first time. We use Internals::setLargeImageAsyncDecodingEnabledForTesting()
+        to force the async image decoding. So painting an image in this case will
+        require multiple paints; in all of them the async image decoding will be
+        enabled. But this is okay because it resembles the case where the <img> is
+        created from a static <img> tag in the HTML file.
+
+        For new tests, where we want to make sure that mutating the DOM will not
+        cause a flash, async image decoding will be forced till the image is drawn
+        for the first time. After that the async image decoding is enabled but not
+        forced.
+
+        Disable new tests for WK1 because the async image decoding is always enabled
+        because tiling does not necessarily exist in WK1 . But eventually the async
+        image decoding for large images will be always disabled for WK1.
+
+        * fast/images/async-image-background-change-expected.html: Added.
+        * fast/images/async-image-background-change.html: Added.
+        * fast/images/async-image-background-image-repeated.html:
+        * fast/images/async-image-background-image.html:
+        * fast/images/async-image-body-background-image.html:
+        * fast/images/async-image-multiple-clients-repaint.html:
+        * fast/images/async-image-src-change-expected.html: Added.
+        * fast/images/async-image-src-change.html: Added.
+        * fast/images/resources/green-400x400.png: Added.
+        * fast/images/resources/red-100x100.png: Added.
+        * fast/images/resources/red-400x400.png: Added.
+        * fast/images/sprite-sheet-image-draw.html:
+        * http/tests/multipart/multipart-async-image-expected.txt: Added.
+        * http/tests/multipart/multipart-async-image.html: Added.
+        * platform/ios-wk1/TestExpectations:
+        * platform/mac-wk1/TestExpectations:
+
 2017-07-25  Charlie Turner  <cturner@igalia.com>
 
         [GTK] Unreviewed test gardening
diff --git a/LayoutTests/fast/images/async-image-background-change-expected.html b/LayoutTests/fast/images/async-image-background-change-expected.html
new file mode 100644 (file)
index 0000000..c6b06f0
--- /dev/null
@@ -0,0 +1,10 @@
+<style>
+    div {
+        width: 400px;
+        height: 400px;
+        background-color: green;
+    }
+</style>
+<body>
+    <div></div>
+</body>
diff --git a/LayoutTests/fast/images/async-image-background-change.html b/LayoutTests/fast/images/async-image-background-change.html
new file mode 100644 (file)
index 0000000..fe33b1a
--- /dev/null
@@ -0,0 +1,71 @@
+<!DOCTYPE html>
+<html>
+<style>
+    div {
+        width: 400px;
+        height: 400px;
+    }
+ </style>
+ <body>
+    <div></div>
+    <script>
+        function loadImageAndSetBackground(element, image, src, forceAsyncImageDrawing) {
+            return new Promise((resolve) => {
+                image.onload = (() => {
+                    if (window.internals && window.testRunner && forceAsyncImageDrawing) {
+                        // Force async image decoding for this image.
+                        internals.setLargeImageAsyncDecodingEnabledForTesting(image, true);
+
+                        // Change the background of the element.
+                        element.style.backgroundImage = 'url(' + image.src + ')';
+
+                        // Force layout and display so the image gets drawn.
+                        document.body.offsetHeight;
+                        if (window.testRunner)
+                            testRunner.display();
+
+                        image.addEventListener("webkitImageFrameReady", function() {
+                            internals.setLargeImageAsyncDecodingEnabledForTesting(image, false);
+                            setTimeout(function() {
+                                // Force redraw to get the red image drawn.
+                                testRunner.display();
+                                resolve();
+                            }, 0);
+                        }, false);
+                    } else {
+                        // Change the background of the element.
+                        element.style.backgroundImage = 'url(' + image.src + ')';
+                        resolve();
+                    }
+                });
+                image.src = src;
+            });
+        }
+        (function() {
+            if (window.internals && window.testRunner) {
+                internals.clearMemoryCache();
+                internals.settings.setWebkitImageReadyEventEnabled(true);
+                internals.settings.setLargeImageAsyncDecodingEnabled(true);
+                testRunner.waitUntilDone();
+            }
+            var image = new Image;
+            document.body.appendChild(image);
+            var element = document.querySelector("div");
+
+            // Load a large (400x400) red image to force sync image decoding and drawing.
+            loadImageAndSetBackground(element, image, "resources/red-400x400.png", true).then(() => {
+                // Replace the large red image with a large (400x400) green image.
+                // Sync image decoding and drawing have to be forced in this case.
+                return loadImageAndSetBackground(element, image, "resources/green-400x400.png", false);
+            }).then(() => {
+                image.remove();
+                // A single paint is needed to draw the large (400x400) green image.
+                if (window.testRunner)
+                    testRunner.notifyDone();
+            });
+        })();
+    </script>
+ </body>
+ </html>
\ No newline at end of file
index 6f069c5..2822f79 100644 (file)
 
             var image = new Image();
             image.onload = function() {
-                var elements = document.getElementsByClassName("image-background");
+                 // Force async image decoding for this image.
+                if (window.internals)
+                    internals.setLargeImageAsyncDecodingEnabledForTesting(image, true);
+
                 // Change the background of the elements.
+                var elements = document.getElementsByClassName("image-background");
                 if (window.internals && window.testRunner) {
                     var promises = [];
                     for (var index = 0; index < elements.length; ++index)
index 1246b30..db4877a 100644 (file)
 
             var image = new Image();
             image.onload = function() {
+                // Force async image decoding for this image.
+                if (window.internals)
+                    internals.setLargeImageAsyncDecodingEnabledForTesting(image, true);
+
+                // Change the background of the element.                 
                 var element = document.getElementsByClassName("image-background")[0];
-                // Change the background of the element.
                 element.style.backgroundImage = 'url(' + image.src + ')';
  
                 if (window.internals && window.testRunner) {
index ee821e3..aacdd14 100644 (file)
 
             var image = new Image();
             image.onload = function() {
+                // Force async image decoding for this image.
+                if (window.internals)
+                    internals.setLargeImageAsyncDecodingEnabledForTesting(image, true);
+
                 var iframeDocument = document.querySelector('iframe').contentWindow.document;
 
                 if (window.internals && window.testRunner) {
index 3a8f4a6..816d5b0 100644 (file)
 
             var image = new Image();
             image.onload = function() {
+                // Force async image decoding for this image.
+                if (window.internals)
+                    internals.setLargeImageAsyncDecodingEnabledForTesting(image, true);
+
                 if (window.internals && window.testRunner) {
                     setElementImageBackground(document.querySelector(".small-box"), image).then(() => {
                         // Call the next setElementImageBackground() asynchronously, using setTimeout(, 0),
diff --git a/LayoutTests/fast/images/async-image-src-change-expected.html b/LayoutTests/fast/images/async-image-src-change-expected.html
new file mode 100644 (file)
index 0000000..c6b06f0
--- /dev/null
@@ -0,0 +1,10 @@
+<style>
+    div {
+        width: 400px;
+        height: 400px;
+        background-color: green;
+    }
+</style>
+<body>
+    <div></div>
+</body>
diff --git a/LayoutTests/fast/images/async-image-src-change.html b/LayoutTests/fast/images/async-image-src-change.html
new file mode 100644 (file)
index 0000000..ff0e0fd
--- /dev/null
@@ -0,0 +1,57 @@
+<!DOCTYPE html>
+<html>
+<body>
+    <script>
+        function loadImageAndDraw(image, src, forceAsyncImageDrawing) {
+            return new Promise((resolve) => {
+                image.onload = (() => {
+                    if (window.internals && window.testRunner && forceAsyncImageDrawing) {
+                        // Force async image decoding for this image.
+                        internals.setLargeImageAsyncDecodingEnabledForTesting(image, true);
+
+                        // Force layout and display so the image gets drawn.
+                        document.body.offsetHeight;
+                        if (window.testRunner)
+                            testRunner.display();
+
+                        image.addEventListener("webkitImageFrameReady", function() {
+                            internals.setLargeImageAsyncDecodingEnabledForTesting(image, false);
+                            setTimeout(function() {
+                                // Force redraw to get the red image drawn.
+                                testRunner.display();
+                                resolve();
+                            }, 0);
+                        }, false);
+                    } else {
+                        resolve();                        
+                    }
+                });
+                image.src = src;
+            });
+        }
+        (function() {
+            if (window.internals && window.testRunner) {
+                internals.clearMemoryCache();
+                internals.settings.setWebkitImageReadyEventEnabled(true);
+                internals.settings.setLargeImageAsyncDecodingEnabled(true);
+                testRunner.waitUntilDone();
+            }
+            var image = new Image;
+            document.body.appendChild(image);
+            // Load a large (400x400) red image to force sync image decoding and drawing.
+            loadImageAndDraw(image, "resources/red-400x400.png", true).then(() => {
+                // Replace the large red image with a large (400x400) green image.
+                // Sync image decoding and drawing have to be forced in this case.
+                return loadImageAndDraw(image, "resources/green-400x400.png", false);
+            }).then(() => {
+                // A single paint is needed to draw the large (400x400) green image.
+                if (window.testRunner)
+                    testRunner.notifyDone();
+            });
+        })();
+    </script>
+ </body>
+ </html>
diff --git a/LayoutTests/fast/images/resources/green-400x400.png b/LayoutTests/fast/images/resources/green-400x400.png
new file mode 100644 (file)
index 0000000..5284982
Binary files /dev/null and b/LayoutTests/fast/images/resources/green-400x400.png differ
diff --git a/LayoutTests/fast/images/resources/red-100x100.png b/LayoutTests/fast/images/resources/red-100x100.png
new file mode 100644 (file)
index 0000000..91efea0
Binary files /dev/null and b/LayoutTests/fast/images/resources/red-100x100.png differ
diff --git a/LayoutTests/fast/images/resources/red-400x400.png b/LayoutTests/fast/images/resources/red-400x400.png
new file mode 100644 (file)
index 0000000..bf8772c
Binary files /dev/null and b/LayoutTests/fast/images/resources/red-400x400.png differ
index bda44fa..859a6e3 100644 (file)
 
             var image = new Image();
             image.onload = function() {
-                var element = document.getElementsByClassName("image-background")[0];
+                // Force async image decoding for this image.
+                if (window.internals)
+                    internals.setLargeImageAsyncDecodingEnabledForTesting(image, true);
+
                 // Change the background of the element.
+                var element = document.getElementsByClassName("image-background")[0];
                 element.style.backgroundImage = 'url(' + image.src + ')';
  
                 if (window.internals && window.testRunner) {
diff --git a/LayoutTests/http/tests/multipart/multipart-async-image-expected.txt b/LayoutTests/http/tests/multipart/multipart-async-image-expected.txt
new file mode 100644 (file)
index 0000000..fa0e021
--- /dev/null
@@ -0,0 +1,10 @@
+Make sure no async decoding is done for multipart images
+
+On success, you will see a series of "PASS" messages, followed by "TEST COMPLETE".
+
+
+PASS The second frame of the multipart image was drawn without async image decoding.
+PASS successfullyParsed is true
+
+TEST COMPLETE
+
diff --git a/LayoutTests/http/tests/multipart/multipart-async-image.html b/LayoutTests/http/tests/multipart/multipart-async-image.html
new file mode 100644 (file)
index 0000000..c43d81a
--- /dev/null
@@ -0,0 +1,70 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <script src="../resources/js-test-pre.js"></script>
+</head>
+<body>
+    <script>
+        function multipartUrl() {
+            var relativePath = "../../../../fast/images/resources/";
+            return "resources/multipart.php"
+                    + "?interval=0.1"
+                    + "&img1=" + relativePath + "red-100x100.png"
+                    + "&img2=" + relativePath + "green-400x400.png"
+                    + "&img3=" + relativePath + "green-400x400.png";
+        }
+
+        var intervalID = null;
+        function finishTest() {
+            if (intervalID !== null)
+                clearInterval(intervalID);
+            finishJSTest();
+        }
+
+        (function() {
+            description("Make sure no async decoding is done for multipart images");
+            jsTestIsAsync = true;
+            if (window.internals && window.testRunner) {
+                internals.clearMemoryCache();
+                internals.settings.setWebkitImageReadyEventEnabled(true);
+                internals.settings.setLargeImageAsyncDecodingEnabled(true);
+            }
+            var image = new Image;
+            document.body.appendChild(image);
+            image.addEventListener("webkitImageFrameReady", function() {
+                // The first image is small (100x100) red image which does not
+                // require async image decoding. But drawing it should prevent
+                // any subsequent async image decoding for large images.
+                testFailed("Async image decoding was mistakenly requested.");
+                finishTest();
+            }, false);
+            image.onload = function() {
+                var count = 0;
+                intervalID = setInterval(function() {
+                    // Force layout and display.
+                    document.body.offsetHeight;
+                    testRunner.display();
+                    ++count;
+
+                    if (image.offsetWidth == 400 && count == 100) {
+                        testPassed("The second frame of the multipart image was drawn without async image decoding.");
+                        finishTest();
+                    }
+
+                    if (count > 200) {
+                        testFailed("Timeout: the second frame of the multipart image was not loaded.");
+                        finishTest();
+                    }
+                }, 10);
+            }
+            image.src = multipartUrl(); 
+        })();
+    </script>
+    <script src="../resources/js-test-post.js"></script>
+</body>
+</html>
index e891500..2e9d881 100644 (file)
@@ -1107,6 +1107,11 @@ http/tests/navigation/metaredirect-goback.html
 # Disk cache is WK2 only
 http/tests/cache/disk-cache
 
+# Async image decoding is WK2 only
+fast/images/async-image-background-change.html
+fast/images/async-image-src-change.html
+http/tests/multipart/multipart-async-image.html
+
 # Flaky as of 06/08/2015
 animations/animation-direction-reverse-hardware-opacity.html [ Failure Pass ]
 animations/animation-direction-reverse-hardware.html [ Failure Pass ]
index 26c3f4e..2b41564 100644 (file)
@@ -156,6 +156,11 @@ http/tests/cache/disk-cache
 http/tests/inspector/network/resource-response-source-disk-cache.html
 http/tests/inspector/network/resource-sizes-disk-cache.html
 
+# Async image decoding is WK2 only
+fast/images/async-image-background-change.html
+fast/images/async-image-src-change.html
+http/tests/multipart/multipart-async-image.html
+
 [ Yosemite+ ] fast/ruby/ruby-expansion-cjk-2.html [ ImageOnlyFailure ]
 
 # ShouldOpenExternalURLs not yet supported in WK1
index f98d6b4..bfadf01 100644 (file)
@@ -1,3 +1,98 @@
+2017-07-25  Said Abou-Hallawa  <sabouhallawa@apple.com>
+
+        Async image decoding for large images should be disabled after the first time a tile is painted
+        https://bugs.webkit.org/show_bug.cgi?id=174451
+        <rdar://problem/31246421>
+
+        Reviewed by Simon Fraser.
+
+        Flashing because of DOM mutation can be fixed by disabling the asynchronous
+        image decoding after the first time a tile was painted.
+
+        We can detect this by consulting the tile repaintCount. If it is zero, then
+        it is safe to use asynchronous image decoded. If the tile repaintCount is
+        greater than zero, we are not sure if the renderer rectangle has an image
+        drawn in it already or not. In this case we have to use the synchronous
+        image decoding to avoid causing a flash.
+
+        Tests: fast/images/async-image-background-change.html
+               fast/images/async-image-src-change.html
+               http/tests/multipart/multipart-async-image.html
+
+        * html/shadow/MediaControlElements.cpp:
+        (WebCore::MediaControlTextTrackContainerElement::createTextTrackRepresentationImage):
+        * page/FrameView.cpp:
+        (WebCore::FrameView::willPaintContents):
+        (WebCore::FrameView::paintContentsForSnapshot):
+        * page/PageOverlayController.cpp:
+        (WebCore::PageOverlayController::paintContents):
+        * page/PageOverlayController.h:
+        * page/linux/ResourceUsageOverlayLinux.cpp:
+        * page/mac/ServicesOverlayController.h:
+        * page/mac/ServicesOverlayController.mm:
+        (WebCore::ServicesOverlayController::Highlight::paintContents):
+        * platform/graphics/BitmapImage.cpp:
+        (WebCore::BitmapImage::draw):
+        * platform/graphics/BitmapImage.h:
+        * platform/graphics/GraphicsLayer.cpp:
+        (WebCore::GraphicsLayer::paintGraphicsLayerContents):
+        * platform/graphics/GraphicsLayer.h:
+        * platform/graphics/GraphicsLayerClient.h:
+        (WebCore::GraphicsLayerClient::paintContents):
+        * platform/graphics/avfoundation/cf/MediaPlayerPrivateAVFoundationCF.cpp:
+        (WebCore::LayerClient::platformCALayerPaintContents):
+        * platform/graphics/ca/GraphicsLayerCA.cpp:
+        (WebCore::GraphicsLayerCA::platformCALayerPaintContents):
+        * platform/graphics/ca/GraphicsLayerCA.h:
+        * platform/graphics/ca/PlatformCALayer.h:
+        * platform/graphics/ca/PlatformCALayerClient.h:
+        (WebCore::PlatformCALayerClient::platformCALayerRepaintCount):
+        * platform/graphics/ca/TileCoverageMap.cpp:
+        (WebCore::TileCoverageMap::platformCALayerPaintContents):
+        * platform/graphics/ca/TileCoverageMap.h:
+        * platform/graphics/ca/TileGrid.cpp:
+        (WebCore::TileGrid::platformCALayerPaintContents):
+        (WebCore::TileGrid::platformCALayerRepaintCount):
+        * platform/graphics/ca/TileGrid.h:
+        * platform/graphics/ca/cocoa/PlatformCALayerCocoa.mm:
+        (PlatformCALayer::drawLayerContents):
+        * platform/graphics/ca/win/PlatformCALayerWin.cpp:
+        (PlatformCALayer::drawLayerContents):
+        * platform/graphics/ca/win/PlatformCALayerWinInternal.cpp:
+        (PlatformCALayerWinInternal::displayCallback):
+        * platform/graphics/ca/win/WebTiledBackingLayerWin.cpp:
+        (WebTiledBackingLayerWin::displayCallback):
+        * platform/graphics/mac/WebLayer.mm:
+        (-[WebLayer drawInContext:]):
+        (-[WebSimpleLayer drawInContext:]):
+        * rendering/PaintPhase.h:
+        * rendering/RenderBoxModelObject.cpp:
+        (WebCore::RenderBoxModelObject::decodingModeForImageDraw):
+        * rendering/RenderElement.h:
+        * rendering/RenderLayer.cpp:
+        (WebCore::RenderLayer::paintLayerContents):
+        (WebCore::RenderLayer::paintForegroundForFragments):
+        * rendering/RenderLayerBacking.cpp:
+        (WebCore::RenderLayerBacking::paintContents):
+        * rendering/RenderLayerBacking.h:
+        * rendering/RenderLayerCompositor.cpp:
+        (WebCore::RenderLayerCompositor::paintContents):
+        * rendering/RenderLayerCompositor.h:
+        * rendering/RenderWidget.cpp:
+        (WebCore::RenderWidget::paintContents):
+        * testing/Internals.cpp:
+        (WebCore::imageFromImageElement):
+        (WebCore::bitmapImageFromImageElement):
+        (WebCore::Internals::imageFrameIndex):
+        (WebCore::Internals::setImageFrameDecodingDuration):
+        (WebCore::Internals::resetImageAnimation):
+        (WebCore::Internals::isImageAnimating):
+        (WebCore::Internals::setClearDecoderAfterAsyncFrameRequestForTesting):
+        (WebCore::Internals::imageDecodeCount):
+        (WebCore::Internals::setLargeImageAsyncDecodingEnabledForTesting):
+        * testing/Internals.h:
+        * testing/Internals.idl:
+
 2017-07-23  Sam Weinig  <sam@webkit.org>
 
         [WebIDL] Add support for generating timer bindings
index 1df277a..543f61f 100644 (file)
@@ -1409,7 +1409,7 @@ RefPtr<Image> MediaControlTextTrackContainerElement::createTextTrackRepresentati
     if (!buffer)
         return nullptr;
 
-    layer->paint(buffer->context(), paintingRect, LayoutSize(), PaintBehaviorFlattenCompositingLayers, nullptr, RenderLayer::PaintLayerPaintingCompositingAllPhases);
+    layer->paint(buffer->context(), paintingRect, LayoutSize(), PaintBehaviorFlattenCompositingLayers | PaintBehaviorSnapshotting, nullptr, RenderLayer::PaintLayerPaintingCompositingAllPhases);
 
     return ImageBuffer::sinkIntoImage(WTFMove(buffer));
 }
index 61d140a..7b5dc6c 100644 (file)
@@ -4405,13 +4405,16 @@ void FrameView::willPaintContents(GraphicsContext& context, const IntRect&, Pain
     if (FrameView* parentView = parentFrameView()) {
         if (parentView->paintBehavior() & PaintBehaviorFlattenCompositingLayers)
             m_paintBehavior |= PaintBehaviorFlattenCompositingLayers;
-            
-        if (parentView->paintBehavior() & PaintBehaviorAllowAsyncImageDecoding)
-            m_paintBehavior |= PaintBehaviorAllowAsyncImageDecoding;
+        
+        if (parentView->paintBehavior() & PaintBehaviorSnapshotting)
+            m_paintBehavior |= PaintBehaviorSnapshotting;
+        
+        if (parentView->paintBehavior() & PaintBehaviorTileFirstPaint)
+            m_paintBehavior |= PaintBehaviorTileFirstPaint;
     }
 
     if (document->printing())
-        m_paintBehavior = (m_paintBehavior & ~PaintBehaviorAllowAsyncImageDecoding) | PaintBehaviorFlattenCompositingLayers;
+        m_paintBehavior |= (PaintBehaviorFlattenCompositingLayers | PaintBehaviorSnapshotting);
 
     paintingState.isFlatteningPaintOfRootFrame = (m_paintBehavior & PaintBehaviorFlattenCompositingLayers) && !frame().ownerElement();
     if (paintingState.isFlatteningPaintOfRootFrame)
@@ -4531,7 +4534,7 @@ void FrameView::paintContentsForSnapshot(GraphicsContext& context, const IntRect
 
     // Cache paint behavior and set a new behavior appropriate for snapshots.
     PaintBehavior oldBehavior = paintBehavior();
-    setPaintBehavior((oldBehavior & ~PaintBehaviorAllowAsyncImageDecoding) | PaintBehaviorFlattenCompositingLayers);
+    setPaintBehavior(oldBehavior | (PaintBehaviorFlattenCompositingLayers | PaintBehaviorSnapshotting));
 
     // If the snapshot should exclude selection, then we'll clear the current selection
     // in the render tree only. This will allow us to restore the selection from the DOM
index 4241a4b..2ca7ef0 100644 (file)
@@ -360,7 +360,7 @@ Vector<String> PageOverlayController::copyAccessibilityAttributesNames(bool para
     return { };
 }
 
-void PageOverlayController::paintContents(const WebCore::GraphicsLayer* graphicsLayer, WebCore::GraphicsContext& graphicsContext, WebCore::GraphicsLayerPaintingPhase, const WebCore::FloatRect& clipRect, GraphicsLayerPaintFlags)
+void PageOverlayController::paintContents(const WebCore::GraphicsLayer* graphicsLayer, WebCore::GraphicsContext& graphicsContext, WebCore::GraphicsLayerPaintingPhase, const WebCore::FloatRect& clipRect, GraphicsLayerPaintBehavior)
 {
     for (auto& overlayAndGraphicsLayer : m_overlayGraphicsLayers) {
         if (overlayAndGraphicsLayer.value.get() != graphicsLayer)
index b96451a..a329459 100644 (file)
@@ -88,7 +88,7 @@ private:
 
     // GraphicsLayerClient
     void notifyFlushRequired(const GraphicsLayer*) override;
-    void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect& clipRect, GraphicsLayerPaintFlags) override;
+    void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect& clipRect, GraphicsLayerPaintBehavior) override;
     float deviceScaleFactor() const override;
     bool shouldSkipLayerInDump(const GraphicsLayer*, LayerTreeAsTextBehavior) const override;
     void tiledBackingUsageChanged(const GraphicsLayer*, bool) override;
index ffc4942..97f30b2 100644 (file)
@@ -85,7 +85,7 @@ public:
     }
 
 private:
-    void paintContents(const GraphicsLayer*, GraphicsContext& context, GraphicsLayerPaintingPhase, const FloatRect& clip, GraphicsLayerPaintFlags) override
+    void paintContents(const GraphicsLayer*, GraphicsContext& context, GraphicsLayerPaintingPhase, const FloatRect& clip, GraphicsLayerPaintBehavior) override
     {
         GraphicsContextStateSaver stateSaver(context);
         context.fillRect(clip, Color(0.0f, 0.0f, 0.0f, 0.8f));
index d3aab9f..0fd4abf 100644 (file)
@@ -82,7 +82,7 @@ private:
 
         // GraphicsLayerClient
         void notifyFlushRequired(const GraphicsLayer*) override;
-        void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect& inClip, GraphicsLayerPaintFlags) override;
+        void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect& inClip, GraphicsLayerPaintBehavior) override;
         float deviceScaleFactor() const override;
 
         void didFinishFadeOutAnimation();
index 6005291..60f76ea 100644 (file)
@@ -129,7 +129,7 @@ void ServicesOverlayController::Highlight::notifyFlushRequired(const GraphicsLay
     page->chrome().client().scheduleCompositingLayerFlush();
 }
 
-void ServicesOverlayController::Highlight::paintContents(const GraphicsLayer*, GraphicsContext& graphicsContext, GraphicsLayerPaintingPhase, const FloatRect&, GraphicsLayerPaintFlags)
+void ServicesOverlayController::Highlight::paintContents(const GraphicsLayer*, GraphicsContext& graphicsContext, GraphicsLayerPaintingPhase, const FloatRect&, GraphicsLayerPaintBehavior)
 {
     if (!DataDetectorsLibrary())
         return;
index bc16b40..e49a6c3 100644 (file)
@@ -193,7 +193,7 @@ ImageDrawResult BitmapImage::draw(GraphicsContext& context, const FloatRect& des
     LOG(Images, "BitmapImage::%s - %p - url: %s [subsamplingLevel = %d scaleFactorForDrawing = (%.4f, %.4f)]", __FUNCTION__, this, sourceURL().string().utf8().data(), static_cast<int>(m_currentSubsamplingLevel), scaleFactorForDrawing.width(), scaleFactorForDrawing.height());
 
     NativeImagePtr image;
-    if (decodingMode == DecodingMode::Asynchronous && !canAnimate()) {
+    if (decodingMode == DecodingMode::Asynchronous) {
         ASSERT(!canAnimate());
         ASSERT(!m_currentFrame || m_animationFinished);
 
@@ -218,7 +218,7 @@ ImageDrawResult BitmapImage::draw(GraphicsContext& context, const FloatRect& des
         }
 
         image = frameImageAtIndex(m_currentFrame);
-        LOG(Images, "BitmapImage::%s - %p - url: %s [a decoded image frame is available for drawing]", __FUNCTION__, this, sourceURL().string().utf8().data());
+        LOG(Images, "BitmapImage::%s - %p - url: %s [a decoded frame will be used for asynchronous drawing]", __FUNCTION__, this, sourceURL().string().utf8().data());
     } else {
         StartAnimationStatus status = internalStartAnimation();
         ASSERT_IMPLIES(status == StartAnimationStatus::DecodingActive, (!m_currentFrame && !m_repetitionsComplete) || frameHasFullSizeNativeImageAtIndex(m_currentFrame, m_currentSubsamplingLevel));
@@ -227,17 +227,30 @@ ImageDrawResult BitmapImage::draw(GraphicsContext& context, const FloatRect& des
             fillWithSolidColor(context, destRect, Color(Color::yellow).colorWithAlpha(0.5), op);
             return result;
         }
-
-        if (frameIsBeingDecodedAndIsCompatibleWithOptionsAtIndex(m_currentFrame, DecodingMode::Asynchronous)) {
+        
+        // If the decodingMode changes from asynchronous to synchronous and new data is received,
+        // the current incomplete decoded frame has to be destroyed.
+        if (m_currentFrameDecodingStatus == DecodingStatus::Invalid)
+            m_source.destroyIncompleteDecodedData();
+        
+        bool frameIsCompatible = frameHasDecodedNativeImageCompatibleWithOptionsAtIndex(m_currentFrame, m_currentSubsamplingLevel, DecodingOptions(sizeForDrawing));
+        bool frameIsBeingDecoded = frameIsBeingDecodedAndIsCompatibleWithOptionsAtIndex(m_currentFrame, DecodingMode::Asynchronous);
+        
+        if (frameIsCompatible) {
+            image = frameImageAtIndex(m_currentFrame);
+            LOG(Images, "BitmapImage::%s - %p - url: %s [a decoded frame will reused for synchronous drawing]", __FUNCTION__, this, sourceURL().string().utf8().data());
+        } else if (frameIsBeingDecoded) {
             // FIXME: instead of showing the yellow rectangle and returning we need to wait for this frame to finish decoding.
             if (m_showDebugBackground) {
                 fillWithSolidColor(context, destRect, Color(Color::yellow).colorWithAlpha(0.5), op);
                 LOG(Images, "BitmapImage::%s - %p - url: %s [waiting for async decoding to finish]", __FUNCTION__, this, sourceURL().string().utf8().data());
             }
             return ImageDrawResult::DidRequestDecoding;
+        } else {
+            image = frameImageAtIndexCacheIfNeeded(m_currentFrame, m_currentSubsamplingLevel, &context);
+            LOG(Images, "BitmapImage::%s - %p - url: %s [an image frame will be decoded synchronously]", __FUNCTION__, this, sourceURL().string().utf8().data());
         }
-
-        image = frameImageAtIndexCacheIfNeeded(m_currentFrame, m_currentSubsamplingLevel, &context);
+        
         if (!image) // If it's too early we won't have an image yet.
             return ImageDrawResult::DidNothing;
 
index df9bb78..0a20c6d 100644 (file)
@@ -107,6 +107,8 @@ public:
     bool canUseAsyncDecodingForLargeImages() const;
     bool shouldUseAsyncDecodingForAnimatedImages() const;
     void setClearDecoderAfterAsyncFrameRequestForTesting(bool value) { m_clearDecoderAfterAsyncFrameRequestForTesting = value; }
+    void setLargeImageAsyncDecodingEnabledForTesting(bool enabled) { m_largeImageAsyncDecodingEnabledForTesting = enabled; }
+    bool isLargeImageAsyncDecodingEnabledForTesting() const { return m_largeImageAsyncDecodingEnabledForTesting; }
 
     WEBCORE_EXPORT unsigned decodeCountForTesting() const;
 
@@ -224,6 +226,7 @@ private:
     bool m_showDebugBackground { false };
 
     bool m_clearDecoderAfterAsyncFrameRequestForTesting { false };
+    bool m_largeImageAsyncDecodingEnabledForTesting { false };
 
 #if !LOG_DISABLED
     size_t m_lateFrameCount { 0 };
index d12193b..28c34b6 100644 (file)
@@ -418,7 +418,7 @@ void GraphicsLayer::setBackgroundColor(const Color& color)
     m_backgroundColor = color;
 }
 
-void GraphicsLayer::paintGraphicsLayerContents(GraphicsContext& context, const FloatRect& clip, GraphicsLayerPaintFlags flags)
+void GraphicsLayer::paintGraphicsLayerContents(GraphicsContext& context, const FloatRect& clip, GraphicsLayerPaintBehavior layerPaintBehavior)
 {
     FloatSize offset = offsetFromRenderer();
     context.translate(-offset);
@@ -426,7 +426,7 @@ void GraphicsLayer::paintGraphicsLayerContents(GraphicsContext& context, const F
     FloatRect clipRect(clip);
     clipRect.move(offset);
 
-    m_client.paintContents(this, context, m_paintingPhase, clipRect, flags);
+    m_client.paintContents(this, context, m_paintingPhase, clipRect, layerPaintBehavior);
 }
 
 String GraphicsLayer::animationNameForTransition(AnimatedPropertyID property)
index 3d1459c..d234bb2 100644 (file)
@@ -466,7 +466,7 @@ public:
     virtual bool usesContentsLayer() const { return false; }
 
     // Callback from the underlying graphics system to draw layer contents.
-    void paintGraphicsLayerContents(GraphicsContext&, const FloatRect& clip, GraphicsLayerPaintFlags = GraphicsLayerPaintFlags::AllowAsyncImageDecoding);
+    void paintGraphicsLayerContents(GraphicsContext&, const FloatRect& clip, GraphicsLayerPaintBehavior = GraphicsLayerPaintNormal);
 
     // For hosting this GraphicsLayer in a native layer hierarchy.
     virtual PlatformLayer* platformLayer() const { return 0; }
index 38f629e..9f2ce11 100644 (file)
@@ -75,7 +75,12 @@ enum LayerTreeAsTextBehaviorFlags {
 };
 typedef unsigned LayerTreeAsTextBehavior;
 
-enum class GraphicsLayerPaintFlags { None, AllowAsyncImageDecoding };
+enum GraphicsLayerPaintFlags {
+    GraphicsLayerPaintNormal                    = 0,
+    GraphicsLayerPaintSnapshotting              = 1 << 0,
+    GraphicsLayerPaintFirstTilePaint            = 1 << 1,
+};
+typedef unsigned GraphicsLayerPaintBehavior;
     
 class GraphicsLayerClient {
 public:
@@ -94,7 +99,7 @@ public:
     // Notification that this layer requires a flush before the next display refresh.
     virtual void notifyFlushBeforeDisplayRefresh(const GraphicsLayer*) { }
 
-    virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect& /* inClip */, GraphicsLayerPaintFlags) { }
+    virtual void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect& /* inClip */, GraphicsLayerPaintBehavior) { }
     virtual void didCommitChangesForLayer(const GraphicsLayer*) const { }
 
     // Provides current transform (taking transform-origin and animations into account). Input matrix has been
index f8ef4d5..9035244 100644 (file)
@@ -220,7 +220,7 @@ private:
 
     virtual void platformCALayerAnimationStarted(CFTimeInterval beginTime) { }
     virtual GraphicsLayer::CompositingCoordinatesOrientation platformCALayerContentsOrientation() const { return GraphicsLayer::CompositingCoordinatesBottomUp; }
-    virtual void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const FloatRect&, GraphicsLayerPaintFlags) { }
+    virtual void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const FloatRect&, GraphicsLayerPaintBehavior) { }
     virtual bool platformCALayerShowDebugBorders() const { return false; }
     virtual bool platformCALayerShowRepaintCounter(PlatformCALayer*) const { return false; }
     virtual int platformCALayerIncrementRepaintCount(PlatformCALayer*) { return 0; }
index 6d9df5b..37d3b01 100644 (file)
@@ -1579,7 +1579,7 @@ bool GraphicsLayerCA::platformCALayerShowRepaintCounter(PlatformCALayer* platfor
     return isShowingRepaintCounter();
 }
 
-void GraphicsLayerCA::platformCALayerPaintContents(PlatformCALayer*, GraphicsContext& context, const FloatRect& clip, GraphicsLayerPaintFlags flags)
+void GraphicsLayerCA::platformCALayerPaintContents(PlatformCALayer*, GraphicsContext& context, const FloatRect& clip, GraphicsLayerPaintBehavior layerPaintBehavior)
 {
     m_hasEverPainted = true;
     if (m_displayList) {
@@ -1595,7 +1595,7 @@ void GraphicsLayerCA::platformCALayerPaintContents(PlatformCALayer*, GraphicsCon
     }
 
     TraceScope tracingScope(PaintLayerStart, PaintLayerEnd);
-    paintGraphicsLayerContents(context, clip, flags);
+    paintGraphicsLayerContents(context, clip, layerPaintBehavior);
 }
 
 void GraphicsLayerCA::platformCALayerSetNeedsToRevalidateTiles()
index a3cdca5..f7fbd23 100644 (file)
@@ -188,9 +188,10 @@ private:
     WEBCORE_EXPORT void platformCALayerAnimationStarted(const String& animationKey, CFTimeInterval beginTime) override;
     WEBCORE_EXPORT void platformCALayerAnimationEnded(const String& animationKey) override;
     CompositingCoordinatesOrientation platformCALayerContentsOrientation() const override { return contentsOrientation(); }
-    WEBCORE_EXPORT void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const FloatRect& clip, GraphicsLayerPaintFlags) override;
+    WEBCORE_EXPORT void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const FloatRect& clip, GraphicsLayerPaintBehavior) override;
     bool platformCALayerShowDebugBorders() const override { return isShowingDebugBorder(); }
     WEBCORE_EXPORT bool platformCALayerShowRepaintCounter(PlatformCALayer*) const override;
+    int platformCALayerRepaintCount(PlatformCALayer*) const override { return repaintCount(); }
     int platformCALayerIncrementRepaintCount(PlatformCALayer*) override { return incrementRepaintCount(); }
 
     bool platformCALayerContentsOpaque() const override { return contentsOpaque(); }
index 88a29a0..9361cf7 100644 (file)
@@ -276,7 +276,7 @@ public:
         
     // Functions allows us to share implementation across WebTiledLayer and WebLayer
     static RepaintRectList collectRectsToPaint(CGContextRef, PlatformCALayer*);
-    static void drawLayerContents(CGContextRef, PlatformCALayer*, RepaintRectList& dirtyRects, GraphicsLayerPaintFlags);
+    static void drawLayerContents(CGContextRef, PlatformCALayer*, RepaintRectList& dirtyRects, GraphicsLayerPaintBehavior);
     static void drawRepaintIndicator(CGContextRef, PlatformCALayer*, int repaintCount, CGColorRef customBackgroundColor);
     static CGRect frameForLayer(const PlatformLayer*);
 
index a36f345..fd332f0 100644 (file)
@@ -43,9 +43,10 @@ public:
     virtual void platformCALayerAnimationStarted(const String& /*animationKey*/, CFTimeInterval) { }
     virtual void platformCALayerAnimationEnded(const String& /*animationKey*/) { }
     virtual GraphicsLayer::CompositingCoordinatesOrientation platformCALayerContentsOrientation() const { return GraphicsLayer::CompositingCoordinatesTopDown; }
-    virtual void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const FloatRect& inClip, GraphicsLayerPaintFlags) = 0;
+    virtual void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const FloatRect& inClip, GraphicsLayerPaintBehavior) = 0;
     virtual bool platformCALayerShowDebugBorders() const { return false; }
     virtual bool platformCALayerShowRepaintCounter(PlatformCALayer*) const { return false; }
+    virtual int platformCALayerRepaintCount(PlatformCALayer*) const { return 0; }
     virtual int platformCALayerIncrementRepaintCount(PlatformCALayer*) { return 0; }
     
     virtual bool platformCALayerContentsOpaque() const = 0;
index d62c7f5..f54fc99 100644 (file)
@@ -152,7 +152,7 @@ void TileCoverageMap::update()
     m_visibleViewportIndicatorLayer.get().setBorderColor(visibleRectIndicatorColor);
 }
 
-void TileCoverageMap::platformCALayerPaintContents(PlatformCALayer* platformCALayer, GraphicsContext& context, const FloatRect&, GraphicsLayerPaintFlags)
+void TileCoverageMap::platformCALayerPaintContents(PlatformCALayer* platformCALayer, GraphicsContext& context, const FloatRect&, GraphicsLayerPaintBehavior)
 {
     ASSERT_UNUSED(platformCALayer, platformCALayer == m_layer.ptr());
     m_controller.tileGrid().drawTileMapContents(context.platformContext(), m_layer.get().bounds());
index ab43a56..360b231 100644 (file)
@@ -61,7 +61,7 @@ private:
     GraphicsLayer::CompositingCoordinatesOrientation platformCALayerContentsOrientation() const override { return GraphicsLayer::CompositingCoordinatesTopDown; }
     bool platformCALayerContentsOpaque() const override { return true; }
     bool platformCALayerDrawsContent() const override { return true; }
-    void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const FloatRect&, GraphicsLayerPaintFlags) override;
+    void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const FloatRect&, GraphicsLayerPaintBehavior) override;
     float platformCALayerDeviceScaleFactor() const override;
 
     void updateTimerFired();
index 07fa960..cb16873 100644 (file)
@@ -712,13 +712,16 @@ void TileGrid::drawTileMapContents(CGContextRef context, CGRect layerBounds) con
     }
 }
 
-void TileGrid::platformCALayerPaintContents(PlatformCALayer* platformCALayer, GraphicsContext& context, const FloatRect&, GraphicsLayerPaintFlags flags)
+void TileGrid::platformCALayerPaintContents(PlatformCALayer* platformCALayer, GraphicsContext& context, const FloatRect&, GraphicsLayerPaintBehavior layerPaintBehavior)
 {
 #if PLATFORM(IOS)
     if (pthread_main_np())
         WebThreadLock();
 #endif
 
+    if (!platformCALayerRepaintCount(platformCALayer))
+        layerPaintBehavior |= GraphicsLayerPaintFirstTilePaint;
+
     {
         GraphicsContextStateSaver stateSaver(context);
 
@@ -727,7 +730,7 @@ void TileGrid::platformCALayerPaintContents(PlatformCALayer* platformCALayer, Gr
         context.scale(m_scale);
 
         PlatformCALayer::RepaintRectList dirtyRects = PlatformCALayer::collectRectsToPaint(context.platformContext(), platformCALayer);
-        PlatformCALayer::drawLayerContents(context.platformContext(), &m_controller.rootLayer(), dirtyRects, flags);
+        PlatformCALayer::drawLayerContents(context.platformContext(), &m_controller.rootLayer(), dirtyRects, layerPaintBehavior);
     }
 
     int repaintCount = platformCALayerIncrementRepaintCount(platformCALayer);
@@ -768,6 +771,12 @@ bool TileGrid::platformCALayerContentsOpaque() const
     return m_controller.tilesAreOpaque();
 }
 
+int TileGrid::platformCALayerRepaintCount(PlatformCALayer* platformCALayer) const
+{
+    const auto it = m_tileRepaintCounts.find(platformCALayer);
+    return it != m_tileRepaintCounts.end() ? it->value : 0;
+}
+
 int TileGrid::platformCALayerIncrementRepaintCount(PlatformCALayer* platformCALayer)
 {
     int repaintCount = 0;
index 8ca5c04..9835d2f 100644 (file)
@@ -143,9 +143,10 @@ private:
     void removeTiles(Vector<TileGrid::TileIndex>& toRemove);
 
     // PlatformCALayerClient
-    void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const FloatRect&, GraphicsLayerPaintFlags) override;
+    void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const FloatRect&, GraphicsLayerPaintBehavior) override;
     bool platformCALayerShowDebugBorders() const override;
     bool platformCALayerShowRepaintCounter(PlatformCALayer*) const override;
+    int platformCALayerRepaintCount(PlatformCALayer*) const override;
     int platformCALayerIncrementRepaintCount(PlatformCALayer*) override;
     bool platformCALayerContentsOpaque() const override;
     bool platformCALayerDrawsContent() const override { return true; }
index 8d9c598..5c9b42e 100644 (file)
@@ -1119,12 +1119,15 @@ PlatformCALayer::RepaintRectList PlatformCALayer::collectRectsToPaint(CGContextR
     return dirtyRects;
 }
 
-void PlatformCALayer::drawLayerContents(CGContextRef context, WebCore::PlatformCALayer* platformCALayer, RepaintRectList& dirtyRects, GraphicsLayerPaintFlags flags)
+void PlatformCALayer::drawLayerContents(CGContextRef context, WebCore::PlatformCALayer* platformCALayer, RepaintRectList& dirtyRects, GraphicsLayerPaintBehavior layerPaintBehavior)
 {
     WebCore::PlatformCALayerClient* layerContents = platformCALayer->owner();
     if (!layerContents)
         return;
-    
+
+    if (!layerContents->platformCALayerRepaintCount(platformCALayer))
+        layerPaintBehavior |= GraphicsLayerPaintFirstTilePaint;
+
 #if PLATFORM(IOS)
     WKSetCurrentGraphicsContext(context);
 #endif
@@ -1166,7 +1169,7 @@ void PlatformCALayer::drawLayerContents(CGContextRef context, WebCore::PlatformC
             GraphicsContextStateSaver stateSaver(graphicsContext);
             graphicsContext.clip(rect);
             
-            layerContents->platformCALayerPaintContents(platformCALayer, graphicsContext, rect, flags);
+            layerContents->platformCALayerPaintContents(platformCALayer, graphicsContext, rect, layerPaintBehavior);
         }
         
 #if PLATFORM(IOS)
index 83c3f1c..d107b14 100644 (file)
@@ -109,7 +109,7 @@ PlatformCALayer::RepaintRectList PlatformCALayer::collectRectsToPaint(CGContextR
     return dirtyRects;
 }
 
-void PlatformCALayer::drawLayerContents(CGContextRef context, WebCore::PlatformCALayer* platformCALayer, RepaintRectList&, GraphicsLayerPaintFlags)
+void PlatformCALayer::drawLayerContents(CGContextRef context, WebCore::PlatformCALayer* platformCALayer, RepaintRectList&, GraphicsLayerPaintBehavior)
 {
     intern(platformCALayer)->displayCallback(platformCALayer->platformLayer(), context);
 }
index f408a95..36795c1 100644 (file)
@@ -104,7 +104,7 @@ void PlatformCALayerWinInternal::displayCallback(CACFLayerRef caLayer, CGContext
     // smaller than the layer bounds (e.g. tiled layers)
     CGRect clipBounds = CGContextGetClipBoundingBox(context);
     IntRect clip(enclosingIntRect(clipBounds));
-    client->platformCALayerPaintContents(owner(), graphicsContext, clip, GraphicsLayerPaintFlags::None);
+    client->platformCALayerPaintContents(owner(), graphicsContext, clip, GraphicsLayerPaintNormal);
 
     if (client->platformCALayerShowRepaintCounter(owner())
         && !repaintCountersAreDrawnByGridController(layerType)) {
index d4ee57b..46b573b 100644 (file)
@@ -95,7 +95,7 @@ void WebTiledBackingLayerWin::displayCallback(CACFLayerRef caLayer, CGContextRef
     // smaller than the layer bounds (e.g. tiled layers)
     CGRect clipBounds = CGContextGetClipBoundingBox(context);
     IntRect clip(enclosingIntRect(clipBounds));
-    client->platformCALayerPaintContents(owner(), graphicsContext, clip, GraphicsLayerPaintFlags::None);
+    client->platformCALayerPaintContents(owner(), graphicsContext, clip, GraphicsLayerPaintNormal);
 
     if (client->platformCALayerShowRepaintCounter(owner())) {
         int drawCount = client->platformCALayerIncrementRepaintCount(owner());
index 8b9d177..3fc76c9 100644 (file)
@@ -57,7 +57,7 @@ using namespace WebCore;
     PlatformCALayer* layer = PlatformCALayer::platformCALayer(self);
     if (layer) {
         PlatformCALayer::RepaintRectList rectsToPaint = PlatformCALayer::collectRectsToPaint(context, layer);
-        PlatformCALayer::drawLayerContents(context, layer, rectsToPaint, self.isRenderingInContext ? GraphicsLayerPaintFlags::None : GraphicsLayerPaintFlags::AllowAsyncImageDecoding);
+        PlatformCALayer::drawLayerContents(context, layer, rectsToPaint, self.isRenderingInContext ? GraphicsLayerPaintSnapshotting : GraphicsLayerPaintNormal);
     }
 }
 
@@ -137,7 +137,7 @@ using namespace WebCore;
         graphicsContext.setIsAcceleratedContext(layer->acceleratesDrawing());
 
         FloatRect clipBounds = CGContextGetClipBoundingBox(context);
-        layer->owner()->platformCALayerPaintContents(layer, graphicsContext, clipBounds, self.isRenderingInContext ? GraphicsLayerPaintFlags::None : GraphicsLayerPaintFlags::AllowAsyncImageDecoding);
+        layer->owner()->platformCALayerPaintContents(layer, graphicsContext, clipBounds, self.isRenderingInContext ? GraphicsLayerPaintSnapshotting : GraphicsLayerPaintNormal);
     }
 }
 
index 256b4a5..37dc98c 100644 (file)
@@ -64,7 +64,8 @@ enum PaintBehaviorFlags {
     PaintBehaviorSelectionAndBackgroundsOnly = 1 << 7,
     PaintBehaviorExcludeSelection            = 1 << 8,
     PaintBehaviorFlattenCompositingLayers    = 1 << 9, // Paint doesn't stop at compositing layer boundaries.
-    PaintBehaviorAllowAsyncImageDecoding     = 1 << 10,
+    PaintBehaviorSnapshotting                = 1 << 10,
+    PaintBehaviorTileFirstPaint              = 1 << 11,
 };
 
 typedef unsigned PaintBehavior;
index e39640b..3da4638 100644 (file)
@@ -324,11 +324,20 @@ DecodingMode RenderBoxModelObject::decodingModeForImageDraw(const Image& image,
     if (IOSApplication::isIBooksStorytime())
         return DecodingMode::Synchronous;
 #endif
+    if (bitmapImage.isLargeImageAsyncDecodingEnabledForTesting())
+        return DecodingMode::Asynchronous;
+    if (document().isImageDocument())
+        return DecodingMode::Synchronous;
+    if (paintInfo.paintBehavior & PaintBehaviorSnapshotting)
+        return DecodingMode::Synchronous;
     if (!settings().largeImageAsyncDecodingEnabled())
         return DecodingMode::Synchronous;
     if (!bitmapImage.canUseAsyncDecodingForLargeImages())
         return DecodingMode::Synchronous;
-    if (paintInfo.paintBehavior & PaintBehaviorAllowAsyncImageDecoding)
+    if (paintInfo.paintBehavior & PaintBehaviorTileFirstPaint)
+        return DecodingMode::Asynchronous;
+    // FIXME: isVisibleInViewport() is not cheap. Find a way to make this condition faster.
+    if (!isVisibleInViewport())
         return DecodingMode::Asynchronous;
     return DecodingMode::Synchronous;
 }
index 2eb2afc..4f8226b 100644 (file)
@@ -287,6 +287,7 @@ protected:
     void adjustFlowThreadStateOnContainingBlockChangeIfNeeded();
     
     bool noLongerAffectsParentBlock() const { return s_noLongerAffectsParentBlock; }
+    bool isVisibleInViewport() const;
 
 private:
     RenderElement(ContainerNode&, RenderStyle&&, BaseTypeFlags);
@@ -316,7 +317,6 @@ private:
     std::unique_ptr<RenderStyle> computeFirstLineStyle() const;
     void invalidateCachedFirstLineStyle();
 
-    bool isVisibleInViewport() const;
     bool canDestroyDecodedData() final { return !isVisibleInViewport(); }
     VisibleInViewportState imageFrameAvailable(CachedImage&, ImageAnimatingState, const IntRect* changeRect) final;
     void didRemoveCachedImageClient(CachedImage&) final;
index e7a7ec9..d8f3793 100644 (file)
@@ -4383,9 +4383,12 @@ void RenderLayer::paintLayerContents(GraphicsContext& context, const LayerPainti
 
         if (paintingInfo.paintBehavior & PaintBehaviorFlattenCompositingLayers)
             paintBehavior |= PaintBehaviorFlattenCompositingLayers;
-            
-        if (paintingInfo.paintBehavior & PaintBehaviorAllowAsyncImageDecoding)
-            paintBehavior |= PaintBehaviorAllowAsyncImageDecoding;
+        
+        if (paintingInfo.paintBehavior & PaintBehaviorSnapshotting)
+            paintBehavior |= PaintBehaviorSnapshotting;
+        
+        if (paintingInfo.paintBehavior & PaintBehaviorTileFirstPaint)
+            paintBehavior |= PaintBehaviorTileFirstPaint;
 
         if (paintingInfo.paintBehavior & PaintBehaviorExcludeSelection)
             paintBehavior |= PaintBehaviorExcludeSelection;
@@ -4465,9 +4468,12 @@ void RenderLayer::paintLayerContents(GraphicsContext& context, const LayerPainti
         PaintBehavior paintBehavior = PaintBehaviorNormal;
         if (paintingInfo.paintBehavior & PaintBehaviorFlattenCompositingLayers)
             paintBehavior |= PaintBehaviorFlattenCompositingLayers;
-
-        if (paintingInfo.paintBehavior & PaintBehaviorAllowAsyncImageDecoding)
-            paintBehavior |= PaintBehaviorAllowAsyncImageDecoding;
+        
+        if (paintingInfo.paintBehavior & PaintBehaviorSnapshotting)
+            paintBehavior |= PaintBehaviorSnapshotting;
+        
+        if (paintingInfo.paintBehavior & PaintBehaviorTileFirstPaint)
+            paintBehavior |= PaintBehaviorTileFirstPaint;
 
         if (shouldPaintMask(paintingInfo.paintBehavior, localPaintFlags)) {
             // Paint the mask for the fragments.
@@ -4797,9 +4803,12 @@ void RenderLayer::paintForegroundForFragments(const LayerFragments& layerFragmen
 
     if (localPaintingInfo.paintBehavior & PaintBehaviorExcludeSelection)
         localPaintBehavior |= PaintBehaviorExcludeSelection;
-
-    if (localPaintingInfo.paintBehavior & PaintBehaviorAllowAsyncImageDecoding)
-        localPaintBehavior |= PaintBehaviorAllowAsyncImageDecoding;
+    
+    if (localPaintingInfo.paintBehavior & PaintBehaviorSnapshotting)
+        localPaintBehavior |= PaintBehaviorSnapshotting;
+    
+    if (localPaintingInfo.paintBehavior & PaintBehaviorTileFirstPaint)
+        localPaintBehavior |= PaintBehaviorTileFirstPaint;
 
     // Optimize clipping for the single fragment case.
     bool shouldClip = localPaintingInfo.clipToDirtyRect && layerFragments.size() == 1 && layerFragments[0].shouldPaintContent && !layerFragments[0].foregroundRect.isEmpty();
index 6b8fa76..a66704c 100644 (file)
@@ -2569,7 +2569,7 @@ void RenderLayerBacking::paintIntoLayer(const GraphicsLayer* graphicsLayer, Grap
 }
 
 // Up-call from compositing layer drawing callback.
-void RenderLayerBacking::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase paintingPhase, const FloatRect& clip, GraphicsLayerPaintFlags flags)
+void RenderLayerBacking::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase paintingPhase, const FloatRect& clip, GraphicsLayerPaintBehavior layerPaintBehavior)
 {
 #ifndef NDEBUG
     renderer().page().setIsPainting(true);
@@ -2580,6 +2580,9 @@ void RenderLayerBacking::paintContents(const GraphicsLayer* graphicsLayer, Graph
     adjustedClipRect.move(m_subpixelOffsetFromRenderer);
     IntRect dirtyRect = enclosingIntRect(adjustedClipRect);
 
+    if (!graphicsLayer->repaintCount())
+        layerPaintBehavior |= GraphicsLayerPaintFirstTilePaint;
+
     if (graphicsLayer == m_graphicsLayer.get()
         || graphicsLayer == m_foregroundLayer.get()
         || graphicsLayer == m_backgroundLayer.get()
@@ -2593,8 +2596,11 @@ void RenderLayerBacking::paintContents(const GraphicsLayer* graphicsLayer, Graph
 
         // We have to use the same root as for hit testing, because both methods can compute and cache clipRects.
         PaintBehavior behavior = PaintBehaviorNormal;
-        if (flags == GraphicsLayerPaintFlags::AllowAsyncImageDecoding)
-            behavior |= PaintBehaviorAllowAsyncImageDecoding;
+        if (layerPaintBehavior == GraphicsLayerPaintSnapshotting)
+            behavior |= PaintBehaviorSnapshotting;
+        
+        if (layerPaintBehavior == GraphicsLayerPaintFirstTilePaint)
+            behavior |= PaintBehaviorTileFirstPaint;
 
         paintIntoLayer(graphicsLayer, context, dirtyRect, behavior, paintingPhase);
 
index 9338ae3..b3a8ba1 100644 (file)
@@ -197,7 +197,7 @@ public:
     void notifyFlushRequired(const GraphicsLayer*) override;
     void notifyFlushBeforeDisplayRefresh(const GraphicsLayer*) override;
 
-    void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect& clip, GraphicsLayerPaintFlags) override;
+    void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect& clip, GraphicsLayerPaintBehavior) override;
 
     float deviceScaleFactor() const override;
     float contentsScaleMultiplierForNewTiles(const GraphicsLayer*) const override;
index 6cf143c..2ff6b6c 100644 (file)
@@ -2895,7 +2895,7 @@ void paintScrollbar(Scrollbar* scrollbar, GraphicsContext& context, const IntRec
     context.restore();
 }
 
-void RenderLayerCompositor::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase, const FloatRect& clip, GraphicsLayerPaintFlags)
+void RenderLayerCompositor::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& context, GraphicsLayerPaintingPhase, const FloatRect& clip, GraphicsLayerPaintBehavior)
 {
     IntRect pixelSnappedRectForIntegralPositionedItems = snappedIntRect(LayoutRect(clip));
     if (graphicsLayer == layerForHorizontalScrollbar())
index 9841bab..dce0434 100644 (file)
@@ -337,7 +337,7 @@ private:
 
     // GraphicsLayerClient implementation
     void notifyFlushRequired(const GraphicsLayer*) override;
-    void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect&, GraphicsLayerPaintFlags) override;
+    void paintContents(const GraphicsLayer*, GraphicsContext&, GraphicsLayerPaintingPhase, const FloatRect&, GraphicsLayerPaintBehavior) override;
     void customPositionForVisibleRectComputation(const GraphicsLayer*, FloatPoint&) const override;
     bool isTrackingRepaints() const override;
     
index ab61f06..8c1e7d4 100644 (file)
@@ -230,10 +230,10 @@ void RenderWidget::paintContents(PaintInfo& paintInfo, const LayoutPoint& paintO
     LayoutRect paintRect = paintInfo.rect;
 
     PaintBehavior oldBehavior = PaintBehaviorNormal;
-    if (is<FrameView>(*m_widget) && (paintInfo.paintBehavior & PaintBehaviorAllowAsyncImageDecoding)) {
+    if (is<FrameView>(*m_widget) && (paintInfo.paintBehavior & PaintBehaviorTileFirstPaint)) {
         FrameView& frameView = downcast<FrameView>(*m_widget);
         oldBehavior = frameView.paintBehavior();
-        frameView.setPaintBehavior(oldBehavior | PaintBehaviorAllowAsyncImageDecoding);
+        frameView.setPaintBehavior(oldBehavior | PaintBehaviorTileFirstPaint);
     }
 
     IntPoint widgetLocation = m_widget->frameRect().location();
@@ -257,7 +257,7 @@ void RenderWidget::paintContents(PaintInfo& paintInfo, const LayoutPoint& paintO
             ASSERT(!paintInfo.overlapTestRequests->contains(this) || (paintInfo.overlapTestRequests->get(this) == m_widget->frameRect()));
             paintInfo.overlapTestRequests->set(this, m_widget->frameRect());
         }
-        if (paintInfo.paintBehavior & PaintBehaviorAllowAsyncImageDecoding)
+        if (paintInfo.paintBehavior & PaintBehaviorTileFirstPaint)
             frameView.setPaintBehavior(oldBehavior);
     }
 }
index 9496b29..3679134 100644 (file)
@@ -737,79 +737,58 @@ unsigned Internals::memoryCacheSize() const
     return MemoryCache::singleton().size();
 }
 
-unsigned Internals::imageFrameIndex(HTMLImageElement& element)
+static Image* imageFromImageElement(HTMLImageElement& element)
 {
     auto* cachedImage = element.cachedImage();
-    if (!cachedImage)
-        return 0;
-
-    auto* image = cachedImage->image();
-    return is<BitmapImage>(image) ? downcast<BitmapImage>(*image).currentFrame() : 0;
+    return cachedImage ? cachedImage->image() : nullptr;
 }
 
-void Internals::setImageFrameDecodingDuration(HTMLImageElement& element, float duration)
+static BitmapImage* bitmapImageFromImageElement(HTMLImageElement& element)
 {
-    auto* cachedImage = element.cachedImage();
-    if (!cachedImage)
-        return;
+    auto* image = imageFromImageElement(element);
+    return image && is<BitmapImage>(image) ? &downcast<BitmapImage>(*image) : nullptr;
+}
 
-    auto* image = cachedImage->image();
-    if (!is<BitmapImage>(image))
-        return;
+unsigned Internals::imageFrameIndex(HTMLImageElement& element)
+{
+    auto* bitmapImage = bitmapImageFromImageElement(element);
+    return bitmapImage ? bitmapImage->currentFrame() : 0;
+}
 
-    downcast<BitmapImage>(*image).setFrameDecodingDurationForTesting(Seconds { duration });
+void Internals::setImageFrameDecodingDuration(HTMLImageElement& element, float duration)
+{
+    if (auto* bitmapImage = bitmapImageFromImageElement(element))
+        bitmapImage->setFrameDecodingDurationForTesting(Seconds { duration });
 }
 
 void Internals::resetImageAnimation(HTMLImageElement& element)
 {
-    auto* cachedImage = element.cachedImage();
-    if (!cachedImage)
-        return;
-
-    auto* image = cachedImage->image();
-    if (!is<BitmapImage>(image))
-        return;
-
-    image->resetAnimation();
+    if (auto* image = imageFromImageElement(element))
+        image->resetAnimation();
 }
 
 bool Internals::isImageAnimating(HTMLImageElement& element)
 {
-    auto* cachedImage = element.cachedImage();
-    if (!cachedImage)
-        return false;
-
-    auto* image = cachedImage->image();
-    if (!image)
-        return false;
-
-    return image->isAnimating() || image->animationPending();
+    auto* image = imageFromImageElement(element);
+    return image && (image->isAnimating() || image->animationPending());
 }
 
-void Internals::setClearDecoderAfterAsyncFrameRequestForTesting(HTMLImageElement& element, bool value)
+void Internals::setClearDecoderAfterAsyncFrameRequestForTesting(HTMLImageElement& element, bool enabled)
 {
-    auto* cachedImage = element.cachedImage();
-    if (!cachedImage)
-        return;
-
-    auto* image = cachedImage->image();
-    if (!is<BitmapImage>(image))
-        return;
-
-    downcast<BitmapImage>(*image).setClearDecoderAfterAsyncFrameRequestForTesting(value);
+    if (auto* bitmapImage = bitmapImageFromImageElement(element))
+        bitmapImage->setClearDecoderAfterAsyncFrameRequestForTesting(enabled);
 }
 
 unsigned Internals::imageDecodeCount(HTMLImageElement& element)
 {
-    auto* cachedImage = element.cachedImage();
-    if (!cachedImage)
-        return 0;
-
-    auto* image = cachedImage->image();
-    if (!is<BitmapImage>(image))
-        return 0;
+    auto* bitmapImage = bitmapImageFromImageElement(element);
+    return bitmapImage ? bitmapImage->decodeCountForTesting() : 0;
+}
 
-    return downcast<BitmapImage>(*image).decodeCountForTesting();
+void Internals::setLargeImageAsyncDecodingEnabledForTesting(HTMLImageElement& element, bool enabled)
+{
+    if (auto* bitmapImage = bitmapImageFromImageElement(element))
+        bitmapImage->setLargeImageAsyncDecodingEnabledForTesting(enabled);
 }
 
 void Internals::setGridMaxTracksLimit(unsigned maxTrackLimit)
index e68aad6..ec2f22b 100644 (file)
@@ -122,8 +122,9 @@ public:
     void setImageFrameDecodingDuration(HTMLImageElement&, float duration);
     void resetImageAnimation(HTMLImageElement&);
     bool isImageAnimating(HTMLImageElement&);
-    void setClearDecoderAfterAsyncFrameRequestForTesting(HTMLImageElement&, bool);
+    void setClearDecoderAfterAsyncFrameRequestForTesting(HTMLImageElement&, bool enabled);
     unsigned imageDecodeCount(HTMLImageElement&);
+    void setLargeImageAsyncDecodingEnabledForTesting(HTMLImageElement&, bool enabled);
 
     void setGridMaxTracksLimit(unsigned);
 
index ad6f5bc..89d14d7 100644 (file)
@@ -249,8 +249,9 @@ enum EventThrottlingBehavior {
     void setImageFrameDecodingDuration(HTMLImageElement element, unrestricted float duration);
     void resetImageAnimation(HTMLImageElement element);
     boolean isImageAnimating(HTMLImageElement element);
-    void setClearDecoderAfterAsyncFrameRequestForTesting(HTMLImageElement element, boolean value);
+    void setClearDecoderAfterAsyncFrameRequestForTesting(HTMLImageElement element, boolean enabled);
     unsigned long imageDecodeCount(HTMLImageElement element);
+    void setLargeImageAsyncDecodingEnabledForTesting(HTMLImageElement element, boolean enabled);
 
     void setGridMaxTracksLimit(unsigned long maxTracksLimit);
 
index 6f4a078..b81aab0 100644 (file)
@@ -1,3 +1,21 @@
+2017-07-25  Said Abou-Hallawa  <sabouhallawa@apple.com>
+
+        Async image decoding for large images should be disabled after the first time a tile is painted
+        https://bugs.webkit.org/show_bug.cgi?id=174451
+        <rdar://problem/31246421>
+
+        Reviewed by Simon Fraser.
+
+        * Shared/mac/RemoteLayerBackingStore.mm:
+        (WebKit::RemoteLayerBackingStore::drawInContext):
+        * WebProcess/InjectedBundle/DOM/InjectedBundleNodeHandle.cpp:
+        (WebKit::imageForRect):
+        * WebProcess/InjectedBundle/DOM/InjectedBundleRangeHandle.cpp:
+        (WebKit::InjectedBundleRangeHandle::renderedImage):
+        * WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.cpp:
+        (WebKit::CompositingCoordinator::paintContents):
+        * WebProcess/WebPage/CoordinatedGraphics/CompositingCoordinator.h:
+
 2017-07-25  Brian Burg  <bburg@apple.com>
 
         Web Automation: add support for uploading files
index 18f59f1..69a6b55 100644 (file)
@@ -336,7 +336,7 @@ void RemoteLayerBackingStore::drawInContext(GraphicsContext& context, CGImageRef
 
     context.scale(m_scale);
     
-    auto flags = m_layer->context() && m_layer->context()->nextFlushIsForImmediatePaint() ? WebCore::GraphicsLayerPaintFlags::None : WebCore::GraphicsLayerPaintFlags::AllowAsyncImageDecoding;
+    auto flags = m_layer->context() && m_layer->context()->nextFlushIsForImmediatePaint() ? WebCore::GraphicsLayerPaintSnapshotting : WebCore::GraphicsLayerPaintNormal;
     
     // FIXME: This should be moved to PlatformCALayerRemote for better layering.
     switch (m_layer->layerType()) {
index e2bd59d..ca49b0c 100644 (file)
@@ -169,7 +169,7 @@ static RefPtr<WebImage> imageForRect(FrameView* frameView, const IntRect& painti
     if (options & SnapshotOptionsExcludeSelectionHighlighting)
         shouldPaintSelection = FrameView::ExcludeSelection;
 
-    PaintBehavior paintBehavior = (frameView->paintBehavior() & ~PaintBehaviorAllowAsyncImageDecoding) | PaintBehaviorFlattenCompositingLayers;
+    PaintBehavior paintBehavior = frameView->paintBehavior() | (PaintBehaviorFlattenCompositingLayers | PaintBehaviorSnapshotting);
     if (options & SnapshotOptionsForceBlackText)
         paintBehavior |= PaintBehaviorForceBlackText;
     if (options & SnapshotOptionsForceWhiteText)
index e601d70..d1fbc25 100644 (file)
@@ -143,7 +143,7 @@ RefPtr<WebImage> InjectedBundleRangeHandle::renderedImage(SnapshotOptions option
     graphicsContext->translate(-paintRect.x(), -paintRect.y());
 
     PaintBehavior oldPaintBehavior = frameView->paintBehavior();
-    PaintBehavior paintBehavior = (oldPaintBehavior & ~PaintBehaviorAllowAsyncImageDecoding) | PaintBehaviorSelectionOnly | PaintBehaviorFlattenCompositingLayers;
+    PaintBehavior paintBehavior = oldPaintBehavior | PaintBehaviorSelectionOnly | PaintBehaviorFlattenCompositingLayers | PaintBehaviorSnapshotting;
     if (options & SnapshotOptionsForceBlackText)
         paintBehavior |= PaintBehaviorForceBlackText;
     if (options & SnapshotOptionsForceWhiteText)
index d467fbc..1ce73fc 100644 (file)
@@ -266,7 +266,7 @@ void CompositingCoordinator::notifyFlushRequired(const GraphicsLayer*)
         m_client.notifyFlushRequired();
 }
 
-void CompositingCoordinator::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& graphicsContext, GraphicsLayerPaintingPhase, const FloatRect& clipRect, GraphicsLayerPaintFlags)
+void CompositingCoordinator::paintContents(const GraphicsLayer* graphicsLayer, GraphicsContext& graphicsContext, GraphicsLayerPaintingPhase, const FloatRect& clipRect, GraphicsLayerPaintBehavior)
 {
     m_client.paintLayerContents(graphicsLayer, graphicsContext, enclosingIntRect(clipRect));
 }
index e5aa6cb..fb27563 100644 (file)
@@ -101,7 +101,7 @@ private:
     // GraphicsLayerClient
     void notifyAnimationStarted(const WebCore::GraphicsLayer*, const String&, double time) override;
     void notifyFlushRequired(const WebCore::GraphicsLayer*) override;
-    void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::FloatRect& clipRect, WebCore::GraphicsLayerPaintFlags) override;
+    void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::FloatRect& clipRect, WebCore::GraphicsLayerPaintBehavior) override;
     float deviceScaleFactor() const override;
     float pageScaleFactor() const override;
 
index 7d44d9c..e589808 100644 (file)
@@ -1,3 +1,17 @@
+2017-07-25  Said Abou-Hallawa  <sabouhallawa@apple.com>
+
+        Async image decoding for large images should be disabled after the first time a tile is painted
+        https://bugs.webkit.org/show_bug.cgi?id=174451
+        <rdar://problem/31246421>
+
+        Reviewed by Simon Fraser.
+
+        * WebView/WebFrame.mm:
+        (-[WebFrame _paintBehaviorForDestinationContext:]):
+        (-[WebFrame _drawRect:contentsOnly:]):
+        * WebView/WebHTMLView.mm:
+        (imageFromRect):
+
 2017-07-23  Darin Adler  <darin@apple.com>
 
         More NeverDestroyed and related cleanup
index 7cae06e..f0f8e62 100644 (file)
@@ -595,23 +595,23 @@ static inline WebDataSource *dataSource(DocumentLoader* loader)
     // -currentContextDrawingToScreen returns YES for bitmap contexts.
     BOOL isPrinting = ![NSGraphicsContext currentContextDrawingToScreen];
     if (isPrinting)
-        return PaintBehaviorFlattenCompositingLayers;
+        return PaintBehaviorFlattenCompositingLayers | PaintBehaviorSnapshotting;
 #endif
 
     if (!WKCGContextIsBitmapContext(context))
-        return PaintBehaviorAllowAsyncImageDecoding;
+        return PaintBehaviorNormal;
 
     // If we're drawing into a bitmap, we might be snapshotting, or drawing into a layer-backed view.
     if (WebHTMLView *htmlDocumentView = [self _webHTMLDocumentView]) {
 #if PLATFORM(IOS)
         if ([[htmlDocumentView window] isInSnapshottingPaint])
-            return 0;
+            return PaintBehaviorSnapshotting;
 #endif
         if ([htmlDocumentView _web_isDrawingIntoLayer])
-            return PaintBehaviorAllowAsyncImageDecoding;
+            return PaintBehaviorNormal;
     }
     
-    return PaintBehaviorFlattenCompositingLayers;
+    return PaintBehaviorFlattenCompositingLayers | PaintBehaviorSnapshotting;
 }
 
 - (void)_drawRect:(NSRect)rect contentsOnly:(BOOL)contentsOnly
@@ -644,9 +644,12 @@ static inline WebDataSource *dataSource(DocumentLoader* loader)
         if (FrameView* parentView = parentFrame ? parentFrame->view() : nullptr) {
             if (parentView->paintBehavior() & PaintBehaviorFlattenCompositingLayers)
                 paintBehavior |= PaintBehaviorFlattenCompositingLayers;
-                
-            if (parentView->paintBehavior() & PaintBehaviorAllowAsyncImageDecoding)
-                paintBehavior |= PaintBehaviorAllowAsyncImageDecoding;
+            
+            if (parentView->paintBehavior() & PaintBehaviorSnapshotting)
+                paintBehavior |= PaintBehaviorSnapshotting;
+            
+            if (parentView->paintBehavior() & PaintBehaviorTileFirstPaint)
+                paintBehavior |= PaintBehaviorTileFirstPaint;
         }
     } else
         paintBehavior |= [self _paintBehaviorForDestinationContext:ctx];
index acb8f52..f94733b 100644 (file)
@@ -7313,7 +7313,7 @@ static CGImageRef imageFromRect(Frame* frame, CGRect rect)
     WebHTMLView *view = (WebHTMLView *)documentView;
     
     PaintBehavior oldPaintBehavior = frame->view()->paintBehavior();
-    frame->view()->setPaintBehavior((oldPaintBehavior & ~PaintBehaviorAllowAsyncImageDecoding) | PaintBehaviorFlattenCompositingLayers);
+    frame->view()->setPaintBehavior(oldPaintBehavior | PaintBehaviorFlattenCompositingLayers | PaintBehaviorSnapshotting);
 
     BEGIN_BLOCK_OBJC_EXCEPTIONS;
     
index 50f58ce..2105998 100644 (file)
@@ -1,3 +1,17 @@
+2017-07-25  Said Abou-Hallawa  <sabouhallawa@apple.com>
+
+        Async image decoding for large images should be disabled after the first time a tile is painted
+        https://bugs.webkit.org/show_bug.cgi?id=174451
+        <rdar://problem/31246421>
+
+        Reviewed by Simon Fraser.
+
+        * FullscreenVideoController.cpp:
+        (FullscreenVideoController::LayerClient::platformCALayerPaintContents):
+        * WebCoreSupport/AcceleratedCompositingContext.cpp:
+        (AcceleratedCompositingContext::paintContents):
+        * WebCoreSupport/AcceleratedCompositingContext.h:
+
 2017-07-23  Darin Adler  <darin@apple.com>
 
         More NeverDestroyed and related cleanup
index 9e60c4f..e539cb1 100644 (file)
@@ -187,7 +187,7 @@ private:
 
     virtual void platformCALayerAnimationStarted(CFTimeInterval beginTime) { }
     virtual GraphicsLayer::CompositingCoordinatesOrientation platformCALayerContentsOrientation() const { return GraphicsLayer::CompositingCoordinatesBottomUp; }
-    virtual void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const FloatRect&, GraphicsLayerPaintFlags) { }
+    virtual void platformCALayerPaintContents(PlatformCALayer*, GraphicsContext&, const FloatRect&, GraphicsLayerPaintBehavior) { }
     virtual bool platformCALayerShowDebugBorders() const { return false; }
     virtual bool platformCALayerShowRepaintCounter(PlatformCALayer*) const { return false; }
     virtual int platformCALayerIncrementRepaintCount(PlatformCALayer*) { return 0; }
index cfaa7a7..7a0c485 100644 (file)
@@ -403,7 +403,7 @@ void AcceleratedCompositingContext::layerFlushTimerFired()
         scheduleLayerFlush();
 }
 
-void AcceleratedCompositingContext::paintContents(const GraphicsLayer*, GraphicsContext& context, GraphicsLayerPaintingPhase, const FloatRect& rectToPaint, GraphicsLayerPaintFlags)
+void AcceleratedCompositingContext::paintContents(const GraphicsLayer*, GraphicsContext& context, GraphicsLayerPaintingPhase, const FloatRect& rectToPaint, GraphicsLayerPaintBehavior)
 {
     context.save();
     context.clip(rectToPaint);
index e3235c3..f7f3842 100644 (file)
@@ -52,7 +52,7 @@ public:
     bool enabled();
 
     // GraphicsLayerClient
-    void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::FloatRect& rectToPaint, WebCore::GraphicsLayerPaintFlags) override;
+    void paintContents(const WebCore::GraphicsLayer*, WebCore::GraphicsContext&, WebCore::GraphicsLayerPaintingPhase, const WebCore::FloatRect& rectToPaint, WebCore::GraphicsLayerPaintBehavior) override;
     float deviceScaleFactor() const override;
 
     void initialize();