Remove ImageSource::bytesDecodedToDetermineProperties() and fallout

Source/core/platform/graphics/BitmapImage.cpp

 /*
  * Copyright (C) 2006 Samuel Weinig (sam.weinig@gmail.com)
  * Copyright (C) 2004, 2005, 2006, 2008 Apple Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
@@ skipping 31 matching lines @@
 
 BitmapImage::BitmapImage(ImageObserver* observer)
     : Image(observer)
     , m_currentFrame(0)
     , m_frames(0)
     , m_frameTimer(0)
     , m_repetitionCount(cAnimationNone)
     , m_repetitionCountStatus(Unknown)
     , m_repetitionsComplete(0)
     , m_desiredFrameStartTime(0)
-    , m_decodedSize(0)
-    , m_decodedPropertiesSize(0)
     , m_frameCount(0)
     , m_isSolidColor(false)
     , m_checkedForSolidColor(false)
     , m_animationFinished(false)
     , m_allDataReceived(false)
     , m_haveSize(false)
     , m_sizeAvailable(false)
     , m_hasUniformFrameSize(true)
     , m_haveFrameCount(false)
 {
 }
 
 BitmapImage::BitmapImage(PassRefPtr<NativeImageSkia> nativeImage, ImageObserver* observer)
     : Image(observer)
     , m_size(nativeImage->bitmap().width(), nativeImage->bitmap().height())
     , m_currentFrame(0)
     , m_frames(0)
     , m_frameTimer(0)
     , m_repetitionCount(cAnimationNone)
     , m_repetitionCountStatus(Unknown)
     , m_repetitionsComplete(0)
-    , m_decodedSize(nativeImage->decodedSize())
-    , m_decodedPropertiesSize(0)
     , m_frameCount(1)
     , m_isSolidColor(false)
     , m_checkedForSolidColor(false)
     , m_animationFinished(true)
     , m_allDataReceived(true)
     , m_haveSize(true)
     , m_sizeAvailable(true)
     , m_haveFrameCount(true)
 {
     // Since we don't have a decoder, we can't figure out the image orientation.
@@ skipping 41 matching lines @@
 
     if (allFrameBytes > cLargeAnimationCutoff)
         destroyDecodedData(false);
 }
 
 void BitmapImage::destroyMetadataAndNotify(size_t frameBytesCleared)
 {
     m_isSolidColor = false;
     m_checkedForSolidColor = false;
 
-    ASSERT(m_decodedSize >= frameBytesCleared);
-    m_decodedSize -= frameBytesCleared;
-    if (frameBytesCleared > 0) {
-        frameBytesCleared += m_decodedPropertiesSize;
-        m_decodedPropertiesSize = 0;
-    }
     if (frameBytesCleared && imageObserver())
         imageObserver()->decodedSizeChanged(this, -safeCast<int>(frameBytesCleared));
 }
 
 void BitmapImage::cacheFrame(size_t index)
 {
     size_t numFrames = frameCount();
     if (m_frames.size() < numFrames)
         m_frames.grow(numFrames);
 
     m_frames[index].m_frame = m_source.createFrameAtIndex(index);
     if (numFrames == 1 && m_frames[index].m_frame)
         checkForSolidColor();
 
     m_frames[index].m_orientation = m_source.orientationAtIndex(index);
     m_frames[index].m_haveMetadata = true;
     m_frames[index].m_isComplete = m_source.frameIsCompleteAtIndex(index);
     if (repetitionCount(false) != cAnimationNone)
         m_frames[index].m_duration = m_source.frameDurationAtIndex(index);
     m_frames[index].m_hasAlpha = m_source.frameHasAlphaAtIndex(index);
     m_frames[index].m_frameBytes = m_source.frameBytesAtIndex(index);
 
     const IntSize frameSize(index ? m_source.frameSizeAtIndex(index) : m_size);
     if (frameSize != m_size)
         m_hasUniformFrameSize = false;
     if (m_frames[index].m_frame) {
         int deltaBytes = safeCast<int>(m_frames[index].m_frameBytes);
-        m_decodedSize += deltaBytes;
         // The fully-decoded frame will subsume the partially decoded data used
         // to determine image properties.
-        deltaBytes -= m_decodedPropertiesSize;
-        m_decodedPropertiesSize = 0;
         if (imageObserver())
             imageObserver()->decodedSizeChanged(this, deltaBytes);
     }
 }
 
-void BitmapImage::didDecodeProperties() const
-{
-    if (m_decodedSize)
-        return;
-    size_t updatedSize = m_source.bytesDecodedToDetermineProperties();
-    if (m_decodedPropertiesSize == updatedSize)
-        return;
-    int deltaBytes = updatedSize - m_decodedPropertiesSize;
-#if !ASSERT_DISABLED
-    bool overflow = updatedSize > m_decodedPropertiesSize && deltaBytes < 0;
-    bool underflow = updatedSize < m_decodedPropertiesSize && deltaBytes > 0;
-    ASSERT(!overflow && !underflow);
-#endif
-    m_decodedPropertiesSize = updatedSize;
-    if (imageObserver())
-        imageObserver()->decodedSizeChanged(this, deltaBytes);
-}
-
 void BitmapImage::updateSize() const
 {
     if (!m_sizeAvailable || m_haveSize)
         return;
 
     m_size = m_source.size();
     m_sizeRespectingOrientation = m_source.size(RespectImageOrientation);
     m_haveSize = true;
-    didDecodeProperties();
 }
 
 IntSize BitmapImage::size() const
 {
     updateSize();
     return m_size;
 }
 
 IntSize BitmapImage::sizeRespectingOrientation() const
 {
     updateSize();
     return m_sizeRespectingOrientation;
 }
 
 IntSize BitmapImage::currentFrameSize() const
 {
     if (!m_currentFrame || m_hasUniformFrameSize)
         return size();
     IntSize frameSize = m_source.frameSizeAtIndex(m_currentFrame);
-    didDecodeProperties();
     return frameSize;
 }
 
 bool BitmapImage::getHotSpot(IntPoint& hotSpot) const
 {
     bool result = m_source.getHotSpot(hotSpot);
-    didDecodeProperties();
     return result;
 }
 
 bool BitmapImage::dataChanged(bool allDataReceived)
 {
     // Clear all partially-decoded frames. For most image formats, there is only
     // one frame, but at least GIF and ICO can have more. With GIFs, the frames
     // come in order and we ask to decode them in order, waiting to request a
     // subsequent frame until the prior one is complete. Given that we clear
     // incomplete frames here, this means there is at most one incomplete frame
@@ skipping 83 matching lines @@
     if (ImageObserver* observer = imageObserver())
         observer->didDraw(this);
 }
 
 size_t BitmapImage::frameCount()
 {
     if (!m_haveFrameCount) {
         m_frameCount = m_source.frameCount();
         // If decoder is not initialized yet, m_source.frameCount() returns 0.
         if (m_frameCount) {
-            didDecodeProperties();
             m_haveFrameCount = true;
         }
     }
     return m_frameCount;
 }
 
 bool BitmapImage::isSizeAvailable()
 {
     if (m_sizeAvailable)
         return true;
 
     m_sizeAvailable = m_source.isSizeAvailable();
-    didDecodeProperties();
 
     return m_sizeAvailable;
 }
 
 bool BitmapImage::ensureFrameIsCached(size_t index)
 {
     if (index >= frameCount())
         return false;
 
     if (index >= m_frames.size() || !m_frames[index].m_frame)
@@ skipping 69 matching lines @@
 
 
 int BitmapImage::repetitionCount(bool imageKnownToBeComplete)
 {
     if ((m_repetitionCountStatus == Unknown) || ((m_repetitionCountStatus == Uncertain) && imageKnownToBeComplete)) {
         // Snag the repetition count.  If |imageKnownToBeComplete| is false, the
         // repetition count may not be accurate yet for GIFs; in this case the
         // decoder will default to cAnimationLoopOnce, and we'll try and read
         // the count again once the whole image is decoded.
         m_repetitionCount = m_source.repetitionCount();
-        didDecodeProperties();
         m_repetitionCountStatus = (imageKnownToBeComplete || m_repetitionCount == cAnimationNone) ? Certain : Uncertain;
     }
     return m_repetitionCount;
 }
 
 bool BitmapImage::shouldAnimate()
 {
     return (repetitionCount(false) != cAnimationNone && !m_animationFinished && imageObserver());
 }
 
@@ skipping 106 matching lines @@
     stopAnimation();
     m_currentFrame = 0;
     m_repetitionsComplete = 0;
     m_desiredFrameStartTime = 0;
     m_animationFinished = false;
 
     // For extremely large animations, when the animation is reset, we just throw everything away.
     destroyDecodedDataIfNecessary();
 }
 
-unsigned BitmapImage::decodedSize() const
-{
-    return m_decodedSize;
-}
-
-
-
 void BitmapImage::advanceAnimation(Timer<BitmapImage>*)
 {
     internalAdvanceAnimation(false);
     // At this point the image region has been marked dirty, and if it's
     // onscreen, we'll soon make a call to draw(), which will call
     // startAnimation() again to keep the animation moving.
 }
 
 bool BitmapImage::internalAdvanceAnimation(bool skippingFrames)
 {
@@ skipping 60 matching lines @@
     }
     return m_isSolidColor && !m_currentFrame;
 }
 
 Color BitmapImage::solidColor() const
 {
     return m_solidColor;
 }
 
 }