470082ed5c5ef02a733e6d94121c049205be0d0e
[WebKit-https.git] / Source / WebCore / platform / graphics / BitmapImage.cpp
1 /*
2  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
3  * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE COMPUTER, INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "BitmapImage.h"
29
30 #include "FloatRect.h"
31 #include "ImageBuffer.h"
32 #include "ImageObserver.h"
33 #include "IntRect.h"
34 #include "MIMETypeRegistry.h"
35 #include "Timer.h"
36 #include <wtf/CurrentTime.h>
37 #include <wtf/Vector.h>
38 #include <wtf/text/WTFString.h>
39
40 #if PLATFORM(IOS)
41 #include <limits>
42 #endif
43
44 namespace WebCore {
45
46 // FIXME: We should better integrate the iOS and non-iOS code in this class. Unlike other ports, the
47 // iOS port caches the metadata for a frame without decoding the image.
48 BitmapImage::BitmapImage(ImageObserver* observer)
49     : Image(observer)
50     , m_currentFrame(0)
51     , m_frames(0)
52     , m_repetitionCount(cAnimationNone)
53     , m_repetitionCountStatus(Unknown)
54     , m_repetitionsComplete(0)
55     , m_desiredFrameStartTime(0)
56     , m_decodedSize(0)
57     , m_decodedPropertiesSize(0)
58     , m_frameCount(0)
59 #if PLATFORM(IOS)
60     // FIXME: We should expose a setting to enable/disable progressive loading remove the PLATFORM(IOS)-guard.
61     , m_progressiveLoadChunkTime(0)
62     , m_progressiveLoadChunkCount(0)
63 #endif
64     , m_isSolidColor(false)
65     , m_checkedForSolidColor(false)
66     , m_animationFinished(false)
67     , m_allDataReceived(false)
68     , m_haveSize(false)
69     , m_sizeAvailable(false)
70     , m_hasUniformFrameSize(true)
71     , m_haveFrameCount(false)
72     , m_cachedImage(0)
73 {
74 }
75
76 BitmapImage::~BitmapImage()
77 {
78     invalidatePlatformData();
79     stopAnimation();
80 }
81
82 bool BitmapImage::hasSingleSecurityOrigin() const
83 {
84     return true;
85 }
86
87 void BitmapImage::destroyDecodedData(bool destroyAll)
88 {
89     unsigned frameBytesCleared = 0;
90     const size_t clearBeforeFrame = destroyAll ? m_frames.size() : m_currentFrame;
91
92     // Because we can advance frames without always needing to decode the actual
93     // bitmap data, |m_currentFrame| may be larger than m_frames.size();
94     // make sure not to walk off the end of the container in this case.
95     for (size_t i = 0; i <  std::min(clearBeforeFrame, m_frames.size()); ++i) {
96         // The underlying frame isn't actually changing (we're just trying to
97         // save the memory for the framebuffer data), so we don't need to clear
98         // the metadata.
99         unsigned frameBytes = m_frames[i].m_frameBytes;
100         if (m_frames[i].clear(false))
101             frameBytesCleared += frameBytes;
102     }
103
104     destroyMetadataAndNotify(frameBytesCleared);
105
106     m_source.clear(destroyAll, clearBeforeFrame, data(), m_allDataReceived);
107     return;
108 }
109
110 void BitmapImage::destroyDecodedDataIfNecessary(bool destroyAll)
111 {
112     // Animated images >5MB are considered large enough that we'll only hang on
113     // to one frame at a time.
114 #if PLATFORM(IOS)
115     static const unsigned cLargeAnimationCutoff = 2097152;
116
117      // If we have decoded frames but there is no encoded data, we shouldn't destroy
118      // the decoded image since we won't be able to reconstruct it later.
119      if (!data() && m_frames.size())
120          return;
121 #else
122     static const unsigned cLargeAnimationCutoff = 5242880;
123 #endif
124
125     // If we have decoded frames but there is no encoded data, we shouldn't destroy
126     // the decoded image since we won't be able to reconstruct it later.
127     if (!data() && m_frames.size())
128         return;
129
130     unsigned allFrameBytes = 0;
131     for (size_t i = 0; i < m_frames.size(); ++i)
132         allFrameBytes += m_frames[i].m_frameBytes;
133
134     if (allFrameBytes > cLargeAnimationCutoff)
135         destroyDecodedData(destroyAll);
136 }
137
138 void BitmapImage::destroyMetadataAndNotify(unsigned frameBytesCleared)
139 {
140     m_isSolidColor = false;
141     m_checkedForSolidColor = false;
142     invalidatePlatformData();
143
144     ASSERT(m_decodedSize >= frameBytesCleared);
145     m_decodedSize -= frameBytesCleared;
146     if (frameBytesCleared > 0) {
147         frameBytesCleared += m_decodedPropertiesSize;
148         m_decodedPropertiesSize = 0;
149     }
150     if (frameBytesCleared && imageObserver())
151         imageObserver()->decodedSizeChanged(this, -safeCast<int>(frameBytesCleared));
152 }
153
154 #if PLATFORM(IOS)
155 void BitmapImage::cacheFrame(size_t index, float scaleHint)
156 #else
157 void BitmapImage::cacheFrame(size_t index)
158 #endif
159 {
160     size_t numFrames = frameCount();
161     ASSERT(m_decodedSize == 0 || numFrames > 1);
162     
163     if (m_frames.size() < numFrames)
164         m_frames.grow(numFrames);
165
166 #if PLATFORM(IOS)
167     m_frames[index].m_frame = m_source.createFrameAtIndex(index, &scaleHint);
168     m_frames[index].m_scale = scaleHint;
169 #else
170     m_frames[index].m_frame = m_source.createFrameAtIndex(index);
171 #endif
172     if (numFrames == 1 && m_frames[index].m_frame)
173         checkForSolidColor();
174
175     m_frames[index].m_orientation = m_source.orientationAtIndex(index);
176     m_frames[index].m_haveMetadata = true;
177     m_frames[index].m_isComplete = m_source.frameIsCompleteAtIndex(index);
178     if (repetitionCount(false) != cAnimationNone)
179         m_frames[index].m_duration = m_source.frameDurationAtIndex(index);
180     m_frames[index].m_hasAlpha = m_source.frameHasAlphaAtIndex(index);
181     m_frames[index].m_frameBytes = m_source.frameBytesAtIndex(index);
182
183     const IntSize frameSize(index ? m_source.frameSizeAtIndex(index) : m_size);
184     if (frameSize != m_size)
185         m_hasUniformFrameSize = false;
186     if (m_frames[index].m_frame) {
187         int deltaBytes = safeCast<int>(m_frames[index].m_frameBytes);
188         m_decodedSize += deltaBytes;
189         // The fully-decoded frame will subsume the partially decoded data used
190         // to determine image properties.
191         deltaBytes -= m_decodedPropertiesSize;
192         m_decodedPropertiesSize = 0;
193         if (imageObserver())
194             imageObserver()->decodedSizeChanged(this, deltaBytes);
195     }
196 }
197
198 #if PLATFORM(IOS)
199 void BitmapImage::cacheFrameInfo(size_t index)
200 {
201     size_t numFrames = frameCount();
202
203     if (m_frames.size() < numFrames)
204         m_frames.resize(numFrames);
205
206     ASSERT(!m_frames[index].m_haveInfo);
207
208     if (shouldAnimate())
209         m_frames[index].m_duration = m_source.frameDurationAtIndex(index);
210     m_frames[index].m_hasAlpha = m_source.frameHasAlphaAtIndex(index);
211     m_frames[index].m_haveInfo = true;
212 }
213 #endif
214
215 void BitmapImage::didDecodeProperties() const
216 {
217     if (m_decodedSize)
218         return;
219     size_t updatedSize = m_source.bytesDecodedToDetermineProperties();
220     if (m_decodedPropertiesSize == updatedSize)
221         return;
222     int deltaBytes = updatedSize - m_decodedPropertiesSize;
223 #if !ASSERT_DISABLED
224     bool overflow = updatedSize > m_decodedPropertiesSize && deltaBytes < 0;
225     bool underflow = updatedSize < m_decodedPropertiesSize && deltaBytes > 0;
226     ASSERT(!overflow && !underflow);
227 #endif
228     m_decodedPropertiesSize = updatedSize;
229     if (imageObserver())
230         imageObserver()->decodedSizeChanged(this, deltaBytes);
231 }
232
233 void BitmapImage::updateSize(ImageOrientationDescription description) const
234 {
235     if (!m_sizeAvailable || m_haveSize)
236         return;
237
238     m_size = m_source.size(description);
239     m_sizeRespectingOrientation = m_source.size(ImageOrientationDescription(RespectImageOrientation, description.imageOrientation()));
240     m_imageOrientation = static_cast<unsigned>(description.imageOrientation());
241     m_shouldRespectImageOrientation = static_cast<unsigned>(description.respectImageOrientation());
242 #if PLATFORM(IOS)
243     m_originalSize = m_source.originalSize();
244     m_originalSizeRespectingOrientation = m_source.originalSize(RespectImageOrientation);
245 #endif
246     m_haveSize = true;
247     didDecodeProperties();
248 }
249
250 IntSize BitmapImage::size() const
251 {
252     updateSize();
253     return m_size;
254 }
255
256 IntSize BitmapImage::sizeRespectingOrientation(ImageOrientationDescription description) const
257 {
258     updateSize(description);
259     return m_sizeRespectingOrientation;
260 }
261
262 #if PLATFORM(IOS)
263 IntSize BitmapImage::originalSize() const
264 {
265     updateSize();
266     return m_originalSize;
267 }
268
269 IntSize BitmapImage::originalSizeRespectingOrientation() const
270 {
271     updateSize();
272     return m_originalSizeRespectingOrientation;
273 }
274 #endif
275
276 IntSize BitmapImage::currentFrameSize() const
277 {
278     if (!m_currentFrame || m_hasUniformFrameSize)
279         return size();
280     IntSize frameSize = m_source.frameSizeAtIndex(m_currentFrame);
281     didDecodeProperties();
282     return frameSize;
283 }
284
285 bool BitmapImage::getHotSpot(IntPoint& hotSpot) const
286 {
287     bool result = m_source.getHotSpot(hotSpot);
288     didDecodeProperties();
289     return result;
290 }
291
292 bool BitmapImage::dataChanged(bool allDataReceived)
293 {
294     // Because we're modifying the current frame, clear its (now possibly
295     // inaccurate) metadata as well.
296 #if !PLATFORM(IOS)
297     // Clear all partially-decoded frames. For most image formats, there is only
298     // one frame, but at least GIF and ICO can have more. With GIFs, the frames
299     // come in order and we ask to decode them in order, waiting to request a
300     // subsequent frame until the prior one is complete. Given that we clear
301     // incomplete frames here, this means there is at most one incomplete frame
302     // (even if we use destroyDecodedData() -- since it doesn't reset the
303     // metadata), and it is after all the complete frames.
304     //
305     // With ICOs, on the other hand, we may ask for arbitrary frames at
306     // different times (e.g. because we're displaying a higher-resolution image
307     // in the content area and using a lower-resolution one for the favicon),
308     // and the frames aren't even guaranteed to appear in the file in the same
309     // order as in the directory, so an arbitrary number of the frames might be
310     // incomplete (if we ask for frames for which we've not yet reached the
311     // start of the frame data), and any or none of them might be the particular
312     // frame affected by appending new data here. Thus we have to clear all the
313     // incomplete frames to be safe.
314     unsigned frameBytesCleared = 0;
315     for (size_t i = 0; i < m_frames.size(); ++i) {
316         // NOTE: Don't call frameIsCompleteAtIndex() here, that will try to
317         // decode any uncached (i.e. never-decoded or
318         // cleared-on-a-previous-pass) frames!
319         unsigned frameBytes = m_frames[i].m_frameBytes;
320         if (m_frames[i].m_haveMetadata && !m_frames[i].m_isComplete)
321             frameBytesCleared += (m_frames[i].clear(true) ? frameBytes : 0);
322     }
323     destroyMetadataAndNotify(frameBytesCleared);
324 #else
325     int deltaBytes = 0;
326     if (!m_frames.isEmpty()) {
327         int bytes = m_frames[m_frames.size() - 1].m_frameBytes;
328         if (m_frames[m_frames.size() - 1].clear(true)) {
329             deltaBytes += bytes;
330             deltaBytes += m_decodedPropertiesSize;
331             m_decodedPropertiesSize = 0;
332         }
333     }
334     destroyMetadataAndNotify(deltaBytes);
335 #endif
336     
337     // Feed all the data we've seen so far to the image decoder.
338     m_allDataReceived = allDataReceived;
339 #if PLATFORM(IOS)
340     // FIXME: We should expose a setting to enable/disable progressive loading and make this
341     // code conditional on it. Then we can remove the PLATFORM(IOS)-guard.
342     static const double chunkLoadIntervals[] = {0, 1, 3, 6, 15};
343     double interval = chunkLoadIntervals[std::min(m_progressiveLoadChunkCount, static_cast<uint16_t>(4))];
344
345     bool needsUpdate = false;
346     if (currentTime() - m_progressiveLoadChunkTime > interval) { // The first time through, the chunk time will be 0 and the image will get an update.
347         needsUpdate = true;
348         m_progressiveLoadChunkTime = currentTime();
349         ASSERT(m_progressiveLoadChunkCount <= std::numeric_limits<uint16_t>::max());
350         ++m_progressiveLoadChunkCount;
351     }
352     if (needsUpdate || allDataReceived)
353         m_source.setData(data(), allDataReceived);
354 #else
355     m_source.setData(data(), allDataReceived);
356 #endif
357
358     m_haveFrameCount = false;
359     m_hasUniformFrameSize = true;
360     return isSizeAvailable();
361 }
362
363 String BitmapImage::filenameExtension() const
364 {
365     return m_source.filenameExtension();
366 }
367
368 size_t BitmapImage::frameCount()
369 {
370     if (!m_haveFrameCount) {
371         m_frameCount = m_source.frameCount();
372         // If decoder is not initialized yet, m_source.frameCount() returns 0.
373         if (m_frameCount) {
374             didDecodeProperties();
375             m_haveFrameCount = true;
376         }
377     }
378     return m_frameCount;
379 }
380
381 bool BitmapImage::isSizeAvailable()
382 {
383     if (m_sizeAvailable)
384         return true;
385
386     m_sizeAvailable = m_source.isSizeAvailable();
387     didDecodeProperties();
388
389     return m_sizeAvailable;
390 }
391
392 #if !PLATFORM(IOS)
393 bool BitmapImage::ensureFrameIsCached(size_t index)
394 {
395     if (index >= frameCount())
396         return false;
397
398     if (index >= m_frames.size() || !m_frames[index].m_frame)
399         cacheFrame(index);
400     return true;
401 }
402 #else
403 bool BitmapImage::ensureFrameInfoIsCached(size_t index)
404 {
405     if (index >= frameCount())
406         return false;
407
408     if (index >= m_frames.size() || !m_frames[index].m_haveInfo)
409         cacheFrameInfo(index);
410     return true;
411 }
412 #endif
413
414 PassNativeImagePtr BitmapImage::frameAtIndex(size_t index)
415 {
416 #if PLATFORM(IOS)
417     return frameAtIndex(index, 1.0f);
418 #else
419     if (!ensureFrameIsCached(index))
420         return nullptr;
421     return m_frames[index].m_frame;
422 #endif
423 }
424
425 #if PLATFORM(IOS)
426 PassNativeImagePtr BitmapImage::frameAtIndex(size_t index, float scaleHint)
427 {
428     if (index >= frameCount())
429         return nullptr;
430
431     if (index >= m_frames.size() || !m_frames[index].m_frame)
432         cacheFrame(index, scaleHint);
433     else if (std::min(1.0f, scaleHint) > m_frames[index].m_scale) {
434         // If the image is already cached, but at too small a size, re-decode a larger version.
435         int sizeChange = -m_frames[index].m_frameBytes;
436         ASSERT(static_cast<int>(m_decodedSize) + sizeChange >= 0);
437         m_frames[index].clear(true);
438         invalidatePlatformData();
439         m_decodedSize += sizeChange;
440         if (imageObserver())
441             imageObserver()->decodedSizeChanged(this, sizeChange);
442
443         cacheFrame(index, scaleHint);
444     }
445     return m_frames[index].m_frame;
446 }
447 #endif
448
449 bool BitmapImage::frameIsCompleteAtIndex(size_t index)
450 {
451 #if PLATFORM(IOS)
452     // FIXME: cacheFrameInfo does not set m_isComplete. Should it?
453     if (!ensureFrameInfoIsCached(index))
454         return false;
455 #else
456     if (!ensureFrameIsCached(index))
457         return false;
458 #endif
459     return m_frames[index].m_isComplete;
460 }
461
462 float BitmapImage::frameDurationAtIndex(size_t index)
463 {
464 #if PLATFORM(IOS)
465     if (!ensureFrameInfoIsCached(index))
466         return 0;
467 #else
468     if (!ensureFrameIsCached(index))
469         return 0;
470 #endif
471     return m_frames[index].m_duration;
472 }
473
474 PassNativeImagePtr BitmapImage::nativeImageForCurrentFrame()
475 {
476     return frameAtIndex(currentFrame());
477 }
478
479 bool BitmapImage::frameHasAlphaAtIndex(size_t index)
480 {
481 #if PLATFORM(IOS)
482     if (!ensureFrameInfoIsCached(index))
483         return true; // FIXME: Why would an invalid index return true here?
484 #else
485     if (m_frames.size() <= index)
486         return true;
487 #endif
488     if (m_frames[index].m_haveMetadata)
489         return m_frames[index].m_hasAlpha;
490
491     return m_source.frameHasAlphaAtIndex(index);
492 }
493
494 bool BitmapImage::currentFrameKnownToBeOpaque()
495 {
496     return !frameHasAlphaAtIndex(currentFrame());
497 }
498
499 ImageOrientation BitmapImage::frameOrientationAtIndex(size_t index)
500 {
501 #if PLATFORM(IOS)
502     // FIXME: cacheFrameInfo does not set m_orientation. Should it?
503     if (!ensureFrameInfoIsCached(index))
504         return DefaultImageOrientation;
505 #else
506     if (!ensureFrameIsCached(index))
507         return DefaultImageOrientation;
508 #endif
509
510     if (m_frames[index].m_haveMetadata)
511         return m_frames[index].m_orientation;
512
513     return m_source.orientationAtIndex(index);
514 }
515
516 #if !ASSERT_DISABLED
517 bool BitmapImage::notSolidColor()
518 {
519     return size().width() != 1 || size().height() != 1 || frameCount() > 1;
520 }
521 #endif
522
523 int BitmapImage::repetitionCount(bool imageKnownToBeComplete)
524 {
525     if ((m_repetitionCountStatus == Unknown) || ((m_repetitionCountStatus == Uncertain) && imageKnownToBeComplete)) {
526         // Snag the repetition count.  If |imageKnownToBeComplete| is false, the
527         // repetition count may not be accurate yet for GIFs; in this case the
528         // decoder will default to cAnimationLoopOnce, and we'll try and read
529         // the count again once the whole image is decoded.
530         m_repetitionCount = m_source.repetitionCount();
531         didDecodeProperties();
532         m_repetitionCountStatus = (imageKnownToBeComplete || m_repetitionCount == cAnimationNone) ? Certain : Uncertain;
533     }
534     return m_repetitionCount;
535 }
536
537 bool BitmapImage::shouldAnimate()
538 {
539     return (repetitionCount(false) != cAnimationNone && !m_animationFinished && imageObserver());
540 }
541
542 void BitmapImage::startAnimation(bool catchUpIfNecessary)
543 {
544     if (m_frameTimer || !shouldAnimate() || frameCount() <= 1)
545         return;
546
547     // If we aren't already animating, set now as the animation start time.
548     const double time = monotonicallyIncreasingTime();
549     if (!m_desiredFrameStartTime)
550         m_desiredFrameStartTime = time;
551
552     // Don't advance the animation to an incomplete frame.
553     size_t nextFrame = (m_currentFrame + 1) % frameCount();
554     if (!m_allDataReceived && !frameIsCompleteAtIndex(nextFrame))
555         return;
556
557     // Don't advance past the last frame if we haven't decoded the whole image
558     // yet and our repetition count is potentially unset.  The repetition count
559     // in a GIF can potentially come after all the rest of the image data, so
560     // wait on it.
561     if (!m_allDataReceived && repetitionCount(false) == cAnimationLoopOnce && m_currentFrame >= (frameCount() - 1))
562         return;
563
564     // Determine time for next frame to start.  By ignoring paint and timer lag
565     // in this calculation, we make the animation appear to run at its desired
566     // rate regardless of how fast it's being repainted.
567     const double currentDuration = frameDurationAtIndex(m_currentFrame);
568     m_desiredFrameStartTime += currentDuration;
569
570 #if !PLATFORM(IOS)
571     // When an animated image is more than five minutes out of date, the
572     // user probably doesn't care about resyncing and we could burn a lot of
573     // time looping through frames below.  Just reset the timings.
574     const double cAnimationResyncCutoff = 5 * 60;
575     if ((time - m_desiredFrameStartTime) > cAnimationResyncCutoff)
576         m_desiredFrameStartTime = time + currentDuration;
577 #else
578     // Maintaining frame-to-frame delays is more important than
579     // maintaining absolute animation timing, so reset the timings each frame.
580     m_desiredFrameStartTime = time + currentDuration;
581 #endif
582
583     // The image may load more slowly than it's supposed to animate, so that by
584     // the time we reach the end of the first repetition, we're well behind.
585     // Clamp the desired frame start time in this case, so that we don't skip
586     // frames (or whole iterations) trying to "catch up".  This is a tradeoff:
587     // It guarantees users see the whole animation the second time through and
588     // don't miss any repetitions, and is closer to what other browsers do; on
589     // the other hand, it makes animations "less accurate" for pages that try to
590     // sync an image and some other resource (e.g. audio), especially if users
591     // switch tabs (and thus stop drawing the animation, which will pause it)
592     // during that initial loop, then switch back later.
593     if (nextFrame == 0 && m_repetitionsComplete == 0 && m_desiredFrameStartTime < time)
594         m_desiredFrameStartTime = time;
595
596     if (!catchUpIfNecessary || time < m_desiredFrameStartTime) {
597         // Haven't yet reached time for next frame to start; delay until then.
598         m_frameTimer = std::make_unique<Timer<BitmapImage>>(this, &BitmapImage::advanceAnimation);
599         m_frameTimer->startOneShot(std::max(m_desiredFrameStartTime - time, 0.));
600     } else {
601         // We've already reached or passed the time for the next frame to start.
602         // See if we've also passed the time for frames after that to start, in
603         // case we need to skip some frames entirely.  Remember not to advance
604         // to an incomplete frame.
605         for (size_t frameAfterNext = (nextFrame + 1) % frameCount(); frameIsCompleteAtIndex(frameAfterNext); frameAfterNext = (nextFrame + 1) % frameCount()) {
606             // Should we skip the next frame?
607             double frameAfterNextStartTime = m_desiredFrameStartTime + frameDurationAtIndex(nextFrame);
608             if (time < frameAfterNextStartTime)
609                 break;
610
611             // Yes; skip over it without notifying our observers.
612             if (!internalAdvanceAnimation(true))
613                 return;
614             m_desiredFrameStartTime = frameAfterNextStartTime;
615             nextFrame = frameAfterNext;
616         }
617
618         // Draw the next frame immediately.  Note that m_desiredFrameStartTime
619         // may be in the past, meaning the next time through this function we'll
620         // kick off the next advancement sooner than this frame's duration would
621         // suggest.
622         if (internalAdvanceAnimation(false)) {
623             // The image region has been marked dirty, but once we return to our
624             // caller, draw() will clear it, and nothing will cause the
625             // animation to advance again.  We need to start the timer for the
626             // next frame running, or the animation can hang.  (Compare this
627             // with when advanceAnimation() is called, and the region is dirtied
628             // while draw() is not in the callstack, meaning draw() gets called
629             // to update the region and thus startAnimation() is reached again.)
630             // NOTE: For large images with slow or heavily-loaded systems,
631             // throwing away data as we go (see destroyDecodedData()) means we
632             // can spend so much time re-decoding data above that by the time we
633             // reach here we're behind again.  If we let startAnimation() run
634             // the catch-up code again, we can get long delays without painting
635             // as we race the timer, or even infinite recursion.  In this
636             // situation the best we can do is to simply change frames as fast
637             // as possible, so force startAnimation() to set a zero-delay timer
638             // and bail out if we're not caught up.
639             startAnimation(false);
640         }
641     }
642 }
643
644 void BitmapImage::stopAnimation()
645 {
646     // This timer is used to animate all occurrences of this image.  Don't invalidate
647     // the timer unless all renderers have stopped drawing.
648     m_frameTimer = nullptr;
649 }
650
651 void BitmapImage::resetAnimation()
652 {
653     stopAnimation();
654     m_currentFrame = 0;
655     m_repetitionsComplete = 0;
656     m_desiredFrameStartTime = 0;
657     m_animationFinished = false;
658     
659     // For extremely large animations, when the animation is reset, we just throw everything away.
660     destroyDecodedDataIfNecessary(true);
661 }
662
663 void BitmapImage::drawPattern(GraphicsContext* ctxt, const FloatRect& tileRect, const AffineTransform& transform,
664     const FloatPoint& phase, ColorSpace styleColorSpace, CompositeOperator op, const FloatRect& destRect, BlendMode blendMode)
665 {
666     if (tileRect.isEmpty())
667         return;
668
669     if (!ctxt->drawLuminanceMask()) {
670         Image::drawPattern(ctxt, tileRect, transform, phase, styleColorSpace, op, destRect, blendMode);
671         return;
672     }
673     if (!m_cachedImage) {
674         std::unique_ptr<ImageBuffer> buffer = ImageBuffer::create(expandedIntSize(tileRect.size()));
675         ASSERT(buffer.get());
676
677         ImageObserver* observer = imageObserver();
678         ASSERT(observer);
679
680         // Temporarily reset image observer, we don't want to receive any changeInRect() calls due to this relayout.
681         setImageObserver(0);
682
683         draw(buffer->context(), tileRect, tileRect, styleColorSpace, op, blendMode, ImageOrientationDescription());
684
685         setImageObserver(observer);
686         buffer->convertToLuminanceMask();
687
688         m_cachedImage = buffer->copyImage(DontCopyBackingStore, Unscaled);
689         m_cachedImage->setSpaceSize(spaceSize());
690
691         setImageObserver(observer);
692     }
693
694     ctxt->setDrawLuminanceMask(false);
695     m_cachedImage->drawPattern(ctxt, tileRect, transform, phase, styleColorSpace, op, destRect, blendMode);
696 }
697
698
699 void BitmapImage::advanceAnimation(Timer<BitmapImage>*)
700 {
701     internalAdvanceAnimation(false);
702     // At this point the image region has been marked dirty, and if it's
703     // onscreen, we'll soon make a call to draw(), which will call
704     // startAnimation() again to keep the animation moving.
705 }
706
707 bool BitmapImage::internalAdvanceAnimation(bool skippingFrames)
708 {
709     // Stop the animation.
710     stopAnimation();
711     
712 #if !PLATFORM(IOS)
713     // See if anyone is still paying attention to this animation.  If not, we don't
714     // advance and will remain suspended at the current frame until the animation is resumed.
715     if (!skippingFrames && imageObserver()->shouldPauseAnimation(this))
716         return false;
717 #endif
718
719     ++m_currentFrame;
720     bool advancedAnimation = true;
721     bool destroyAll = false;
722     if (m_currentFrame >= frameCount()) {
723         ++m_repetitionsComplete;
724
725         // Get the repetition count again.  If we weren't able to get a
726         // repetition count before, we should have decoded the whole image by
727         // now, so it should now be available.
728         // Note that we don't need to special-case cAnimationLoopOnce here
729         // because it is 0 (see comments on its declaration in ImageSource.h).
730         if (repetitionCount(true) != cAnimationLoopInfinite && m_repetitionsComplete > m_repetitionCount) {
731             m_animationFinished = true;
732             m_desiredFrameStartTime = 0;
733             --m_currentFrame;
734             advancedAnimation = false;
735         } else {
736             m_currentFrame = 0;
737             destroyAll = true;
738         }
739     }
740     destroyDecodedDataIfNecessary(destroyAll);
741
742     // We need to draw this frame if we advanced to it while not skipping, or if
743     // while trying to skip frames we hit the last frame and thus had to stop.
744     if (skippingFrames != advancedAnimation)
745         imageObserver()->animationAdvanced(this);
746     return advancedAnimation;
747 }
748
749 bool BitmapImage::mayFillWithSolidColor()
750 {
751     if (!m_checkedForSolidColor && frameCount() > 0) {
752         checkForSolidColor();
753         // WINCE PORT: checkForSolidColor() doesn't set m_checkedForSolidColor until
754         // it gets enough information to make final decision.
755 #if !OS(WINCE)
756         ASSERT(m_checkedForSolidColor);
757 #endif
758     }
759     return m_isSolidColor && !m_currentFrame;
760 }
761
762 Color BitmapImage::solidColor() const
763 {
764     return m_solidColor;
765 }
766     
767 bool BitmapImage::canAnimate()
768 {
769     return shouldAnimate() && frameCount() > 1;
770 }
771
772 }