Drop Timer::startOneShot() overload taking a double
[WebKit-https.git] / Source / WebCore / rendering / ImageQualityController.cpp
1 /*
2  * Copyright (C) 2013 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #include "config.h"
27 #include "ImageQualityController.h"
28
29 #include "Frame.h"
30 #include "GraphicsContext.h"
31 #include "Page.h"
32 #include "RenderBoxModelObject.h"
33 #include "RenderView.h"
34
35 namespace WebCore {
36
37 static const double cInterpolationCutoff = 800. * 800.;
38 static const Seconds lowQualityTimeThreshold { 500_ms };
39
40 ImageQualityController::ImageQualityController(const RenderView& renderView)
41     : m_renderView(renderView)
42     , m_timer(*this, &ImageQualityController::highQualityRepaintTimerFired)
43 {
44 }
45
46 void ImageQualityController::removeLayer(RenderBoxModelObject* object, LayerSizeMap* innerMap, const void* layer)
47 {
48     if (!innerMap)
49         return;
50     innerMap->remove(layer);
51     if (innerMap->isEmpty())
52         removeObject(object);
53 }
54
55 void ImageQualityController::set(RenderBoxModelObject* object, LayerSizeMap* innerMap, const void* layer, const LayoutSize& size)
56 {
57     if (innerMap)
58         innerMap->set(layer, size);
59     else {
60         LayerSizeMap newInnerMap;
61         newInnerMap.set(layer, size);
62         m_objectLayerSizeMap.set(object, newInnerMap);
63     }
64 }
65
66 void ImageQualityController::removeObject(RenderBoxModelObject* object)
67 {
68     m_objectLayerSizeMap.remove(object);
69     if (m_objectLayerSizeMap.isEmpty()) {
70         m_animatedResizeIsActive = false;
71         m_timer.stop();
72     }
73 }
74
75 void ImageQualityController::highQualityRepaintTimerFired()
76 {
77     if (m_renderView.renderTreeBeingDestroyed())
78         return;
79     if (!m_animatedResizeIsActive && !m_liveResizeOptimizationIsActive)
80         return;
81     m_animatedResizeIsActive = false;
82
83     // If the FrameView is in live resize, punt the timer and hold back for now.
84     if (m_renderView.frameView().inLiveResize()) {
85         restartTimer();
86         return;
87     }
88
89     for (auto it = m_objectLayerSizeMap.begin(), end = m_objectLayerSizeMap.end(); it != end; ++it)
90         it->key->repaint();
91
92     m_liveResizeOptimizationIsActive = false;
93 }
94
95 void ImageQualityController::restartTimer()
96 {
97     m_timer.startOneShot(lowQualityTimeThreshold);
98 }
99
100 std::optional<InterpolationQuality> ImageQualityController::interpolationQualityFromStyle(const RenderStyle& style)
101 {
102     switch (style.imageRendering()) {
103     case ImageRenderingOptimizeSpeed:
104         return InterpolationLow;
105     case ImageRenderingCrispEdges:
106     case ImageRenderingPixelated:
107         return InterpolationNone;
108     case ImageRenderingOptimizeQuality:
109         return InterpolationDefault; // FIXME: CSS 3 Images says that optimizeQuality should behave like 'auto', but that prevents authors from overriding this low quality rendering behavior.
110     case ImageRenderingAuto:
111         break;
112     }
113     return std::nullopt;
114 }
115
116 InterpolationQuality ImageQualityController::chooseInterpolationQuality(GraphicsContext& context, RenderBoxModelObject* object, Image& image, const void* layer, const LayoutSize& size)
117 {
118     // If the image is not a bitmap image, then none of this is relevant and we just paint at high quality.
119     if (!(image.isBitmapImage() || image.isPDFDocumentImage()) || context.paintingDisabled())
120         return InterpolationDefault;
121
122     if (std::optional<InterpolationQuality> styleInterpolation = interpolationQualityFromStyle(object->style()))
123         return styleInterpolation.value();
124
125     // Make sure to use the unzoomed image size, since if a full page zoom is in effect, the image
126     // is actually being scaled.
127     IntSize imageSize(image.width(), image.height());
128
129     // Look ourselves up in the hashtables.
130     auto i = m_objectLayerSizeMap.find(object);
131     LayerSizeMap* innerMap = i != m_objectLayerSizeMap.end() ? &i->value : 0;
132     LayoutSize oldSize;
133     bool isFirstResize = true;
134     if (innerMap) {
135         LayerSizeMap::iterator j = innerMap->find(layer);
136         if (j != innerMap->end()) {
137             isFirstResize = false;
138             oldSize = j->value;
139         }
140     }
141
142     // If the containing FrameView is being resized, paint at low quality until resizing is finished.
143     if (Frame* frame = object->document().frame()) {
144         bool frameViewIsCurrentlyInLiveResize = frame->view() && frame->view()->inLiveResize();
145         if (frameViewIsCurrentlyInLiveResize) {
146             set(object, innerMap, layer, size);
147             restartTimer();
148             m_liveResizeOptimizationIsActive = true;
149             return InterpolationLow;
150         }
151         if (m_liveResizeOptimizationIsActive)
152             return InterpolationDefault;
153     }
154
155     const AffineTransform& currentTransform = context.getCTM();
156     bool contextIsScaled = !currentTransform.isIdentityOrTranslationOrFlipped();
157     if (!contextIsScaled && size == imageSize) {
158         // There is no scale in effect. If we had a scale in effect before, we can just remove this object from the list.
159         removeLayer(object, innerMap, layer);
160         return InterpolationDefault;
161     }
162
163     // There is no need to hash scaled images that always use low quality mode when the page demands it. This is the iChat case.
164     if (m_renderView.page().inLowQualityImageInterpolationMode()) {
165         double totalPixels = static_cast<double>(image.width()) * static_cast<double>(image.height());
166         if (totalPixels > cInterpolationCutoff)
167             return InterpolationLow;
168     }
169
170     // If an animated resize is active, paint in low quality and kick the timer ahead.
171     if (m_animatedResizeIsActive) {
172         set(object, innerMap, layer, size);
173         restartTimer();
174         return InterpolationLow;
175     }
176     // If this is the first time resizing this image, or its size is the
177     // same as the last resize, draw at high res, but record the paint
178     // size and set the timer.
179     if (isFirstResize || oldSize == size) {
180         restartTimer();
181         set(object, innerMap, layer, size);
182         return InterpolationDefault;
183     }
184     // If the timer is no longer active, draw at high quality and don't
185     // set the timer.
186     if (!m_timer.isActive()) {
187         removeLayer(object, innerMap, layer);
188         return InterpolationDefault;
189     }
190     // This object has been resized to two different sizes while the timer
191     // is active, so draw at low quality, set the flag for animated resizes and
192     // the object to the list for high quality redraw.
193     set(object, innerMap, layer, size);
194     m_animatedResizeIsActive = true;
195     restartTimer();
196     return InterpolationLow;
197 }
198
199 }