Remove image decoder down sampling

Source/core/platform/image-decoders/ImageDecoder.h

 /*
  * Copyright (C) 2006 Apple Computer, Inc.  All rights reserved.
- * Copyright (C) 2008-2009 Torch Mobile, Inc.
  * Copyright (C) Research In Motion Limited 2009-2010. All rights reserved.
- * Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies)
  *
  * 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
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
@@ skipping 182 matching lines @@
                                      // buffer except for GIF frames whose
                                      // original rect was smaller than the
                                      // overall image size.
         FrameStatus m_status;
         unsigned m_duration;
         FrameDisposalMethod m_disposalMethod;
         bool m_premultiplyAlpha;
     };
 
     // ImageDecoder is a base for all format-specific decoders
-    // (e.g. JPEGImageDecoder).  This base manages the ImageFrame cache.
-    //
-    // ENABLE(IMAGE_DECODER_DOWN_SAMPLING) allows image decoders to downsample
-    // at decode time.  Image decoders will downsample any images larger than
-    // |m_maxNumPixels|.  FIXME: Not yet supported by all decoders.
+    // (e.g. JPEGImageDecoder). This base manages the ImageFrame cache.
     class ImageDecoder {
         WTF_MAKE_NONCOPYABLE(ImageDecoder); WTF_MAKE_FAST_ALLOCATED;
     public:
         ImageDecoder(ImageSource::AlphaOption alphaOption, ImageSource::GammaAndColorProfileOption gammaAndColorProfileOption)
-            : m_scaled(false)
-            , m_premultiplyAlpha(alphaOption == ImageSource::AlphaPremultiplied)
+            : m_premultiplyAlpha(alphaOption == ImageSource::AlphaPremultiplied)
             , m_ignoreGammaAndColorProfile(gammaAndColorProfileOption == ImageSource::GammaAndColorProfileIgnored)
             , m_sizeAvailable(false)
-            , m_maxNumPixels(-1)
             , m_isAllDataReceived(false)
             , m_failed(false) { }
 
         virtual ~ImageDecoder() { }
 
         // Returns a caller-owned decoder of the appropriate type.  Returns 0 if
         // we can't sniff a supported type from the provided data (possibly
         // because there isn't enough data yet).
         static PassOwnPtr<ImageDecoder> create(const SharedBuffer& data, ImageSource::AlphaOption, ImageSource::GammaAndColorProfileOption);
 
@@ skipping 12 matching lines @@
         // Lazily-decodes enough of the image to get the size (if possible).
         // FIXME: Right now that has to be done by each subclass; factor the
         // decode call out and use it here.
         virtual bool isSizeAvailable()
         {
             return !m_failed && m_sizeAvailable;
         }
 
         virtual IntSize size() const { return m_size; }
 
-        IntSize scaledSize() const
-        {
-            return m_scaled ? IntSize(m_scaledColumns.size(), m_scaledRows.size()) : size();
-        }
-
         // This will only differ from size() for ICO (where each frame is a
         // different icon) or other formats where different frames are different
         // sizes.  This does NOT differ from size() for GIF, since decoding GIFs
         // composites any smaller frames against previous frames to create full-
         // size frames.
         virtual IntSize frameSizeAtIndex(size_t) const
         {
             return size();
         }
 
@@ skipping 100 matching lines @@
             return false;
         }
 
         bool failed() const { return m_failed; }
 
         // Clears decoded pixel data from before the provided frame unless that
         // data may be needed to decode future frames (e.g. due to GIF frame
         // compositing).
         virtual void clearFrameBufferCache(size_t) { }
 
-#if ENABLE(IMAGE_DECODER_DOWN_SAMPLING)
-        void setMaxNumPixels(int m) { m_maxNumPixels = m; }
-#endif
-
         // If the image has a cursor hot-spot, stores it in the argument
         // and returns true. Otherwise returns false.
         virtual bool hotSpot(IntPoint&) const { return false; }
 
         virtual void reportMemoryUsage(MemoryObjectInfo*) const;
 
         virtual void setMemoryAllocator(SkBitmap::Allocator* allocator)
         {
             // FIXME: this doesn't work for images with multiple frames.
             if (m_frameBufferCache.isEmpty())
                 m_frameBufferCache.resize(1);
             m_frameBufferCache[0].setMemoryAllocator(allocator);
         }
 
     protected:
-        void prepareScaleDataIfNecessary();
-        int upperBoundScaledX(int origX, int searchStart = 0);
-        int lowerBoundScaledX(int origX, int searchStart = 0);
-        int upperBoundScaledY(int origY, int searchStart = 0);
-        int lowerBoundScaledY(int origY, int searchStart = 0);
-        int scaledY(int origY, int searchStart = 0);
-
         RefPtr<SharedBuffer> m_data; // The encoded data.
         Vector<ImageFrame, 1> m_frameBufferCache;
-        bool m_scaled;
-        Vector<int> m_scaledColumns;
-        Vector<int> m_scaledRows;
         bool m_premultiplyAlpha;
         bool m_ignoreGammaAndColorProfile;
         ImageOrientation m_orientation;
 
     private:
         // Some code paths compute the size of the image as "width * height * 4"
         // and return it as a (signed) int.  Avoid overflow.
         static bool isOverSize(unsigned width, unsigned height)
         {
             unsigned long long total_size = static_cast<unsigned long long>(width)
                                           * static_cast<unsigned long long>(height);
             return total_size > ((1 << 29) - 1);
         }
 
         IntSize m_size;
         bool m_sizeAvailable;
-        int m_maxNumPixels;
         bool m_isAllDataReceived;
         bool m_failed;
     };
 
 } // namespace WebCore
 
 #endif