The Tor Browser: image/src/RasterImage.h@b8a032363ba2 (annotated)

image/src/RasterImage.h@b8a032363ba2 (annotated)

image/src/RasterImage.h

Thu, 22 Jan 2015 13:21:57 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 22 Jan 2015 13:21:57 +0100
branch: TOR_BUG_9701
changeset 15: b8a032363ba2
permissions: -rw-r--r--

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-
  *
  * This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 /** @file
  * This file declares the RasterImage class, which
  * handles static and animated rasterized images.
  *
  * @author  Stuart Parmenter <pavlov@netscape.com>
  * @author  Chris Saari <saari@netscape.com>
  * @author  Arron Mogge <paper@animecity.nu>
  * @author  Andrew Smith <asmith15@learn.senecac.on.ca>
  */
 #ifndef mozilla_imagelib_RasterImage_h_
 #define mozilla_imagelib_RasterImage_h_
 #include "Image.h"
 #include "FrameBlender.h"
 #include "nsCOMPtr.h"
 #include "imgIContainer.h"
 #include "nsIProperties.h"
 #include "nsTArray.h"
 #include "imgFrame.h"
 #include "nsThreadUtils.h"
 #include "DecodeStrategy.h"
 #include "DiscardTracker.h"
 #include "Orientation.h"
 #include "nsIObserver.h"
 #include "mozilla/MemoryReporting.h"
 #include "mozilla/Mutex.h"
 #include "mozilla/ReentrantMonitor.h"
 #include "mozilla/TimeStamp.h"
 #include "mozilla/StaticPtr.h"
 #include "mozilla/WeakPtr.h"
 #ifdef DEBUG
   #include "imgIContainerDebug.h"
 #endif
 class nsIInputStream;
 class nsIThreadPool;
 class nsIRequest;
 #define NS_RASTERIMAGE_CID \
 { /* 376ff2c1-9bf6-418a-b143-3340c00112f7 */         \
 x376ff2c1,                                     \
 x9bf6,                                         \
 x418a,                                         \
     {0xb1, 0x43, 0x33, 0x40, 0xc0, 0x01, 0x12, 0xf7} \
 }
 /**
  * Handles static and animated image containers.
  *
  *
  * @par A Quick Walk Through
  * The decoder initializes this class and calls AppendFrame() to add a frame.
  * Once RasterImage detects more than one frame, it starts the animation
  * with StartAnimation(). Note that the invalidation events for RasterImage are
  * generated automatically using nsRefreshDriver.
  *
  * @par
  * StartAnimation() initializes the animation helper object and sets the time
  * the first frame was displayed to the current clock time.
  *
  * @par
  * When the refresh driver corresponding to the imgIContainer that this image is
  * a part of notifies the RasterImage that it's time to invalidate,
  * RequestRefresh() is called with a given TimeStamp to advance to. As long as
  * the timeout of the given frame (the frame's "delay") plus the time that frame
  * was first displayed is less than or equal to the TimeStamp given,
  * RequestRefresh() calls AdvanceFrame().
  *
  * @par
  * AdvanceFrame() is responsible for advancing a single frame of the animation.
  * It can return true, meaning that the frame advanced, or false, meaning that
  * the frame failed to advance (usually because the next frame hasn't been
  * decoded yet). It is also responsible for performing the final animation stop
  * procedure if the final frame of a non-looping animation is reached.
  *
  * @par
  * Each frame can have a different method of removing itself. These are
  * listed as imgIContainer::cDispose... constants.  Notify() calls
  * DoComposite() to handle any special frame destruction.
  *
  * @par
  * The basic path through DoComposite() is:
  * 1) Calculate Area that needs updating, which is at least the area of
  *    aNextFrame.
  * 2) Dispose of previous frame.
  * 3) Draw new image onto compositingFrame.
  * See comments in DoComposite() for more information and optimizations.
  *
  * @par
  * The rest of the RasterImage specific functions are used by DoComposite to
  * destroy the old frame and build the new one.
  *
  * @note
  * <li> "Mask", "Alpha", and "Alpha Level" are interchangeable phrases in
  * respects to RasterImage.
  *
  * @par
  * <li> GIFs never have more than a 1 bit alpha.
  * <li> APNGs may have a full alpha channel.
  *
  * @par
  * <li> Background color specified in GIF is ignored by web browsers.
  *
  * @par
  * <li> If Frame 3 wants to dispose by restoring previous, what it wants is to
  * restore the composition up to and including Frame 2, as well as Frame 2s
  * disposal.  So, in the middle of DoComposite when composing Frame 3, right
  * after destroying Frame 2's area, we copy compositingFrame to
  * prevCompositingFrame.  When DoComposite gets called to do Frame 4, we
  * copy prevCompositingFrame back, and then draw Frame 4 on top.
  *
  * @par
  * The mAnim structure has members only needed for animated images, so
  * it's not allocated until the second frame is added.
  */
 class ScaleRequest;
 namespace mozilla {
 namespace layers {
 class LayerManager;
 class ImageContainer;
 class Image;
 }
 namespace image {
 class Decoder;
 class FrameAnimator;
 class RasterImage : public ImageResource
                   , public nsIProperties
                   , public SupportsWeakPtr<RasterImage>
 #ifdef DEBUG
                   , public imgIContainerDebug
 #endif
 {
 public:
   MOZ_DECLARE_REFCOUNTED_TYPENAME(RasterImage)
   NS_DECL_THREADSAFE_ISUPPORTS
   NS_DECL_NSIPROPERTIES
   NS_DECL_IMGICONTAINER
 #ifdef DEBUG
   NS_DECL_IMGICONTAINERDEBUG
 #endif
   // (no public constructor - use ImageFactory)
   virtual ~RasterImage();
   virtual nsresult StartAnimation();
   virtual nsresult StopAnimation();
   // Methods inherited from Image
   nsresult Init(const char* aMimeType,
                 uint32_t aFlags);
   virtual nsIntRect FrameRect(uint32_t aWhichFrame) MOZ_OVERRIDE;
   // Raster-specific methods
   static NS_METHOD WriteToRasterImage(nsIInputStream* aIn, void* aClosure,
                                       const char* aFromRawSegment,
                                       uint32_t aToOffset, uint32_t aCount,
                                       uint32_t* aWriteCount);
   /* The index of the current frame that would be drawn if the image was to be
    * drawn now. */
   uint32_t GetCurrentFrameIndex();
   /* The total number of frames in this image. */
   uint32_t GetNumFrames() const;
   virtual size_t HeapSizeOfSourceWithComputedFallback(mozilla::MallocSizeOf aMallocSizeOf) const;
   virtual size_t HeapSizeOfDecodedWithComputedFallback(mozilla::MallocSizeOf aMallocSizeOf) const;
   virtual size_t NonHeapSizeOfDecoded() const;
   virtual size_t OutOfProcessSizeOfDecoded() const;
   /* Triggers discarding. */
   void Discard(bool force = false);
   void ForceDiscard() { Discard(/* force = */ true); }
   /* Callbacks for decoders */
   nsresult SetFrameAsNonPremult(uint32_t aFrameNum, bool aIsNonPremult);
   /** Sets the size and inherent orientation of the container. This should only
    * be called by the decoder. This function may be called multiple times, but
    * will throw an error if subsequent calls do not match the first.
    */
   nsresult SetSize(int32_t aWidth, int32_t aHeight, Orientation aOrientation);
   /**
    * Ensures that a given frame number exists with the given parameters, and
    * returns pointers to the data storage for that frame.
    * It is not possible to create sparse frame arrays; you can only append
    * frames to the current frame array.
    */
   nsresult EnsureFrame(uint32_t aFramenum, int32_t aX, int32_t aY,
                        int32_t aWidth, int32_t aHeight,
                        gfxImageFormat aFormat,
                        uint8_t aPaletteDepth,
                        uint8_t** imageData,
                        uint32_t* imageLength,
                        uint32_t** paletteData,
                        uint32_t* paletteLength,
                        imgFrame** aFrame);
   /**
    * A shorthand for EnsureFrame, above, with aPaletteDepth = 0 and paletteData
    * and paletteLength set to null.
    */
   nsresult EnsureFrame(uint32_t aFramenum, int32_t aX, int32_t aY,
                        int32_t aWidth, int32_t aHeight,
                        gfxImageFormat aFormat,
                        uint8_t** imageData,
                        uint32_t* imageLength,
                        imgFrame** aFrame);
   /* notification that the entire image has been decoded */
   nsresult DecodingComplete();
   /**
    * Number of times to loop the image.
    * @note -1 means forever.
    */
   void     SetLoopCount(int32_t aLoopCount);
   /* Add compressed source data to the imgContainer.
    *
    * The decoder will use this data, either immediately or at draw time, to
    * decode the image.
    *
    * XXX This method's only caller (WriteToContainer) ignores the return
    * value. Should this just return void?
    */
   nsresult AddSourceData(const char *aBuffer, uint32_t aCount);
   virtual nsresult OnImageDataAvailable(nsIRequest* aRequest,
                                         nsISupports* aContext,
                                         nsIInputStream* aInStr,
                                         uint64_t aSourceOffset,
                                         uint32_t aCount) MOZ_OVERRIDE;
   virtual nsresult OnImageDataComplete(nsIRequest* aRequest,
                                        nsISupports* aContext,
                                        nsresult aStatus,
                                        bool aLastPart) MOZ_OVERRIDE;
   virtual nsresult OnNewSourceData() MOZ_OVERRIDE;
   static already_AddRefed<nsIEventTarget> GetEventTarget() {
     return DecodePool::Singleton()->GetEventTarget();
   }
   /**
    * A hint of the number of bytes of source data that the image contains. If
    * called early on, this can help reduce copying and reallocations by
    * appropriately preallocating the source data buffer.
    *
    * We take this approach rather than having the source data management code do
    * something more complicated (like chunklisting) because HTTP is by far the
    * dominant source of images, and the Content-Length header is quite reliable.
    * Thus, pre-allocation simplifies code and reduces the total number of
    * allocations.
    */
   nsresult SetSourceSizeHint(uint32_t sizeHint);
   /* Provide a hint for the requested resolution of the resulting image. */
   void SetRequestedResolution(const nsIntSize requestedResolution) {
     mRequestedResolution = requestedResolution;
   }
   nsIntSize GetRequestedResolution() {
     return mRequestedResolution;
   }
   /* Provide a hint for the requested dimension of the resulting image. */
   void SetRequestedSampleSize(int requestedSampleSize) {
     mRequestedSampleSize = requestedSampleSize;
   }
   int GetRequestedSampleSize() {
     return mRequestedSampleSize;
   }
  nsCString GetURIString() {
     nsCString spec;
     if (GetURI()) {
       GetURI()->GetSpec(spec);
     }
     return spec;
   }
   // Called from module startup. Sets up RasterImage to be used.
   static void Initialize();
   enum ScaleStatus
   {
     SCALE_INVALID,
     SCALE_PENDING,
     SCALE_DONE
   };
   // Call this with a new ScaleRequest to mark this RasterImage's scale result
   // as waiting for the results of this request. You call to ScalingDone before
   // request is destroyed!
   void ScalingStart(ScaleRequest* request);
   // Call this with a finished ScaleRequest to set this RasterImage's scale
   // result. Give it a ScaleStatus of SCALE_DONE if everything succeeded, and
   // SCALE_INVALID otherwise.
   void ScalingDone(ScaleRequest* request, ScaleStatus status);
   // Decoder shutdown
   enum eShutdownIntent {
     eShutdownIntent_Done        = 0,
     eShutdownIntent_NotNeeded   = 1,
     eShutdownIntent_Error       = 2,
     eShutdownIntent_AllCount    = 3
   };
   // Decode strategy
 private:
   already_AddRefed<imgStatusTracker> CurrentStatusTracker()
   {
     mDecodingMonitor.AssertCurrentThreadIn();
     nsRefPtr<imgStatusTracker> statusTracker;
     statusTracker = mDecodeRequest ? mDecodeRequest->mStatusTracker
                                    : mStatusTracker;
     MOZ_ASSERT(statusTracker);
     return statusTracker.forget();
   }
   nsresult OnImageDataCompleteCore(nsIRequest* aRequest, nsISupports*, nsresult aStatus);
   /**
    * Each RasterImage has a pointer to one or zero heap-allocated
    * DecodeRequests.
    */
   struct DecodeRequest
   {
     DecodeRequest(RasterImage* aImage)
       : mImage(aImage)
       , mBytesToDecode(0)
       , mRequestStatus(REQUEST_INACTIVE)
       , mChunkCount(0)
       , mAllocatedNewFrame(false)
     {
       MOZ_ASSERT(aImage, "aImage cannot be null");
       MOZ_ASSERT(aImage->mStatusTracker,
                  "aImage should have an imgStatusTracker");
       mStatusTracker = aImage->mStatusTracker->CloneForRecording();
     }
     NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DecodeRequest)
     // The status tracker that is associated with a given decode request, to
     // ensure their lifetimes are linked.
     nsRefPtr<imgStatusTracker> mStatusTracker;
     RasterImage* mImage;
     uint32_t mBytesToDecode;
     enum DecodeRequestStatus
     {
       REQUEST_INACTIVE,
       REQUEST_PENDING,
       REQUEST_ACTIVE,
       REQUEST_WORK_DONE,
       REQUEST_STOPPED
     } mRequestStatus;
     /* Keeps track of how much time we've burned decoding this particular decode
      * request. */
     TimeDuration mDecodeTime;
     /* The number of chunks it took to decode this image. */
     int32_t mChunkCount;
     /* True if a new frame has been allocated, but DecodeSomeData hasn't yet
      * been called to flush data to it */
     bool mAllocatedNewFrame;
   };
   /*
    * DecodePool is a singleton class we use when decoding large images.
    *
    * When we wish to decode an image larger than
    * image.mem.max_bytes_for_sync_decode, we call DecodePool::RequestDecode()
    * for the image.  This adds the image to a queue of pending requests and posts
    * the DecodePool singleton to the event queue, if it's not already pending
    * there.
    *
    * When the DecodePool is run from the event queue, it decodes the image (and
    * all others it's managing) in chunks, periodically yielding control back to
    * the event loop.
    */
   class DecodePool : public nsIObserver
   {
   public:
     NS_DECL_THREADSAFE_ISUPPORTS
     NS_DECL_NSIOBSERVER
     static DecodePool* Singleton();
     /**
      * Ask the DecodePool to asynchronously decode this image.
      */
     void RequestDecode(RasterImage* aImg);
     /**
      * Decode aImg for a short amount of time, and post the remainder to the
      * queue.
      */
     void DecodeABitOf(RasterImage* aImg, DecodeStrategy aStrategy);
     /**
      * Ask the DecodePool to stop decoding this image.  Internally, we also
      * call this function when we finish decoding an image.
      *
      * Since the DecodePool keeps raw pointers to RasterImages, make sure you
      * call this before a RasterImage is destroyed!
      */
     static void StopDecoding(RasterImage* aImg);
     /**
      * Synchronously decode the beginning of the image until we run out of
      * bytes or we get the image's size.  Note that this done on a best-effort
      * basis; if the size is burried too deep in the image, we'll give up.
      *
      * @return NS_ERROR if an error is encountered, and NS_OK otherwise.  (Note
      *         that we return NS_OK even when the size was not found.)
      */
     nsresult DecodeUntilSizeAvailable(RasterImage* aImg);
     /**
      * Returns an event target interface to the thread pool; primarily for
      * OnDataAvailable delivery off main thread.
      *
      * @return An nsIEventTarget interface to mThreadPool.
      */
     already_AddRefed<nsIEventTarget> GetEventTarget();
     virtual ~DecodePool();
   private: /* statics */
     static StaticRefPtr<DecodePool> sSingleton;
   private: /* methods */
     DecodePool();
     enum DecodeType {
       DECODE_TYPE_UNTIL_TIME,
       DECODE_TYPE_UNTIL_SIZE,
       DECODE_TYPE_UNTIL_DONE_BYTES
     };
     /* Decode some chunks of the given image.  If aDecodeType is UNTIL_SIZE,
      * decode until we have the image's size, then stop. If bytesToDecode is
      * non-0, at most bytesToDecode bytes will be decoded. if aDecodeType is
      * UNTIL_DONE_BYTES, decode until all bytesToDecode bytes are decoded.
      */
     nsresult DecodeSomeOfImage(RasterImage* aImg,
                                DecodeStrategy aStrategy,
                                DecodeType aDecodeType = DECODE_TYPE_UNTIL_TIME,
                                uint32_t bytesToDecode = 0);
     /* A decode job dispatched to a thread pool by DecodePool.
      */
     class DecodeJob : public nsRunnable
     {
     public:
       DecodeJob(DecodeRequest* aRequest, RasterImage* aImg)
         : mRequest(aRequest)
         , mImage(aImg)
       {}
       NS_IMETHOD Run();
     protected:
       virtual ~DecodeJob();
     private:
       nsRefPtr<DecodeRequest> mRequest;
       nsRefPtr<RasterImage> mImage;
     };
   private: /* members */
     // mThreadPoolMutex protects mThreadPool. For all RasterImages R,
     // R::mDecodingMonitor must be acquired before mThreadPoolMutex
     // if both are acquired; the other order may cause deadlock.
     mozilla::Mutex            mThreadPoolMutex;
     nsCOMPtr<nsIThreadPool>   mThreadPool;
   };
   class DecodeDoneWorker : public nsRunnable
   {
   public:
     /**
      * Called by the DecodePool with an image when it's done some significant
      * portion of decoding that needs to be notified about.
      *
      * Ensures the decode state accumulated by the decoding process gets
      * applied to the image.
      */
     static void NotifyFinishedSomeDecoding(RasterImage* image, DecodeRequest* request);
     NS_IMETHOD Run();
   private: /* methods */
     DecodeDoneWorker(RasterImage* image, DecodeRequest* request);
   private: /* members */
     nsRefPtr<RasterImage> mImage;
     nsRefPtr<DecodeRequest> mRequest;
   };
   class FrameNeededWorker : public nsRunnable
   {
   public:
     /**
      * Called by the DecodeJob with an image when it's been told by the
      * decoder that it needs a new frame to be allocated on the main thread.
      *
      * Dispatches an event to do so, which will further dispatch a
      * DecodeRequest event to continue decoding.
      */
     static void GetNewFrame(RasterImage* image);
     NS_IMETHOD Run();
   private: /* methods */
     FrameNeededWorker(RasterImage* image);
   private: /* members */
     nsRefPtr<RasterImage> mImage;
   };
   nsresult FinishedSomeDecoding(eShutdownIntent intent = eShutdownIntent_Done,
                                 DecodeRequest* request = nullptr);
   bool DrawWithPreDownscaleIfNeeded(imgFrame *aFrame,
                                     gfxContext *aContext,
                                     GraphicsFilter aFilter,
                                     const gfxMatrix &aUserSpaceToImageSpace,
                                     const gfxRect &aFill,
                                     const nsIntRect &aSubimage,
                                     uint32_t aFlags);
   nsresult CopyFrame(uint32_t aWhichFrame,
                      uint32_t aFlags,
                      gfxImageSurface **_retval);
   /**
    * Deletes and nulls out the frame in mFrames[framenum].
    *
    * Does not change the size of mFrames.
    *
    * @param framenum The index of the frame to be deleted.
    *                 Must lie in [0, mFrames.Length() )
    */
   void DeleteImgFrame(uint32_t framenum);
   imgFrame* GetImgFrameNoDecode(uint32_t framenum);
   imgFrame* GetImgFrame(uint32_t framenum);
   imgFrame* GetDrawableImgFrame(uint32_t framenum);
   imgFrame* GetCurrentImgFrame();
   uint32_t GetCurrentImgFrameIndex() const;
   size_t SizeOfDecodedWithComputedFallbackIfHeap(gfxMemoryLocation aLocation,
                                                  mozilla::MallocSizeOf aMallocSizeOf) const;
   void EnsureAnimExists();
   nsresult InternalAddFrameHelper(uint32_t framenum, imgFrame *frame,
                                   uint8_t **imageData, uint32_t *imageLength,
                                   uint32_t **paletteData, uint32_t *paletteLength,
                                   imgFrame** aRetFrame);
   nsresult InternalAddFrame(uint32_t framenum, int32_t aX, int32_t aY, int32_t aWidth, int32_t aHeight,
                             gfxImageFormat aFormat, uint8_t aPaletteDepth,
                             uint8_t **imageData, uint32_t *imageLength,
                             uint32_t **paletteData, uint32_t *paletteLength,
                             imgFrame** aRetFrame);
   nsresult DoImageDataComplete();
   bool ApplyDecodeFlags(uint32_t aNewFlags, uint32_t aWhichFrame);
   already_AddRefed<layers::Image> GetCurrentImage();
   void UpdateImageContainer();
   void SetInUpdateImageContainer(bool aInUpdate) { mInUpdateImageContainer = aInUpdate; }
   bool IsInUpdateImageContainer() { return mInUpdateImageContainer; }
   enum RequestDecodeType {
       ASYNCHRONOUS,
       SYNCHRONOUS_NOTIFY,
       SYNCHRONOUS_NOTIFY_AND_SOME_DECODE
   };
   NS_IMETHOD RequestDecodeCore(RequestDecodeType aDecodeType);
   // We would like to just check if we have a zero lock count, but we can't do
   // that for animated images because in EnsureAnimExists we lock the image and
   // never unlock so that animated images always have their lock count >= 1. In
   // that case we use our animation consumers count as a proxy for lock count.
   bool IsUnlocked() { return (mLockCount == 0 || (mAnim && mAnimationConsumers == 0)); }
 private: // data
   nsIntSize                  mSize;
   Orientation                mOrientation;
   // Whether our frames were decoded using any special flags.
   // Some flags (e.g. unpremultiplied data) may not be compatible
   // with the browser's needs for displaying the image to the user.
   // As such, we may need to redecode if we're being asked for
   // a frame with different flags.  0 indicates default flags.
   //
   // Valid flag bits are imgIContainer::FLAG_DECODE_NO_PREMULTIPLY_ALPHA
   // and imgIContainer::FLAG_DECODE_NO_COLORSPACE_CONVERSION.
   uint32_t                   mFrameDecodeFlags;
   //! All the frames of the image
   FrameBlender              mFrameBlender;
   // The last frame we decoded for multipart images.
   imgFrame*                  mMultipartDecodedFrame;
   nsCOMPtr<nsIProperties>    mProperties;
   // IMPORTANT: if you use mAnim in a method, call EnsureImageIsDecoded() first to ensure
   // that the frames actually exist (they may have been discarded to save memory, or
   // we maybe decoding on draw).
   FrameAnimator* mAnim;
   // Discard members
   uint32_t                   mLockCount;
   DiscardTracker::Node       mDiscardTrackerNode;
   // Source data members
   nsCString                  mSourceDataMimeType;
   friend class DiscardTracker;
   // How many times we've decoded this image.
   // This is currently only used for statistics
   int32_t                        mDecodeCount;
   // If the image contains multiple resolutions, a hint as to which one should be used
   nsIntSize                  mRequestedResolution;
   // A hint for image decoder that directly scale the image to smaller buffer
   int                        mRequestedSampleSize;
   // Cached value for GetImageContainer.
   nsRefPtr<mozilla::layers::ImageContainer> mImageContainer;
   // If not cached in mImageContainer, this might have our image container
   WeakPtr<mozilla::layers::ImageContainer> mImageContainerCache;
 #ifdef DEBUG
   uint32_t                       mFramesNotified;
 #endif
   // Below are the pieces of data that can be accessed on more than one thread
   // at once, and hence need to be locked by mDecodingMonitor.
   // BEGIN LOCKED MEMBER VARIABLES
   mozilla::ReentrantMonitor  mDecodingMonitor;
   FallibleTArray<char>       mSourceData;
   // Decoder and friends
   nsRefPtr<Decoder>          mDecoder;
   nsRefPtr<DecodeRequest>    mDecodeRequest;
   uint32_t                   mBytesDecoded;
   bool                       mInDecoder;
   // END LOCKED MEMBER VARIABLES
   // Notification state. Used to avoid recursive notifications.
   ImageStatusDiff            mStatusDiff;
   bool                       mNotifying:1;
   // Boolean flags (clustered together to conserve space):
   bool                       mHasSize:1;       // Has SetSize() been called?
   bool                       mDecodeOnDraw:1;  // Decoding on draw?
   bool                       mMultipart:1;     // Multipart?
   bool                       mDiscardable:1;   // Is container discardable?
   bool                       mHasSourceData:1; // Do we have source data?
   // Do we have the frames in decoded form?
   bool                       mDecoded:1;
   bool                       mHasBeenDecoded:1;
   // Whether the animation can stop, due to running out
   // of frames, or no more owning request
   bool                       mAnimationFinished:1;
   // Whether we're calling Decoder::Finish() from ShutdownDecoder.
   bool                       mFinishing:1;
   bool                       mInUpdateImageContainer:1;
   // Whether, once we are done doing a size decode, we should immediately kick
   // off a full decode.
   bool                       mWantFullDecode:1;
   // Set when a decode worker detects an error off-main-thread. Once the error
   // is handled on the main thread, mError is set, but mPendingError is used to
   // stop decode work immediately.
   bool                       mPendingError:1;
   // Decoding
   nsresult RequestDecodeIfNeeded(nsresult aStatus,
                                  eShutdownIntent aIntent,
                                  bool aDone,
                                  bool aWasSize);
   nsresult WantDecodedFrames();
   nsresult SyncDecode();
   nsresult InitDecoder(bool aDoSizeDecode);
   nsresult WriteToDecoder(const char *aBuffer, uint32_t aCount, DecodeStrategy aStrategy);
   nsresult DecodeSomeData(uint32_t aMaxBytes, DecodeStrategy aStrategy);
   bool     IsDecodeFinished();
   TimeStamp mDrawStartTime;
   inline bool CanQualityScale(const gfxSize& scale);
   inline bool CanScale(GraphicsFilter aFilter, gfxSize aScale, uint32_t aFlags);
   struct ScaleResult
   {
     ScaleResult()
      : status(SCALE_INVALID)
     {}
     gfxSize scale;
     nsAutoPtr<imgFrame> frame;
     ScaleStatus status;
   };
   ScaleResult mScaleResult;
   // We hold on to a bare pointer to a ScaleRequest while it's outstanding so
   // we can mark it as stopped if necessary. The ScaleWorker/DrawWorker duo
   // will inform us when to let go of this pointer.
   ScaleRequest* mScaleRequest;
   // Initializes imgStatusTracker and resets it on RasterImage destruction.
   nsAutoPtr<imgStatusTrackerInit> mStatusTrackerInit;
   nsresult ShutdownDecoder(eShutdownIntent aIntent);
   // Error handling.
   void DoError();
   class HandleErrorWorker : public nsRunnable
   {
   public:
     /**
      * Called from decoder threads when DoError() is called, since errors can't
      * be handled safely off-main-thread. Dispatches an event which reinvokes
      * DoError on the main thread if there isn't one already pending.
      */
     static void DispatchIfNeeded(RasterImage* aImage);
     NS_IMETHOD Run();
   private:
     HandleErrorWorker(RasterImage* aImage);
     nsRefPtr<RasterImage> mImage;
   };
   // Helpers
   bool CanDiscard();
   bool CanForciblyDiscard();
   bool CanForciblyDiscardAndRedecode();
   bool DiscardingActive();
   bool StoringSourceData() const;
 protected:
   RasterImage(imgStatusTracker* aStatusTracker = nullptr,
               ImageURL* aURI = nullptr);
   bool ShouldAnimate();
   friend class ImageFactory;
 };
 inline NS_IMETHODIMP RasterImage::GetAnimationMode(uint16_t *aAnimationMode) {
   return GetAnimationModeInternal(aAnimationMode);
 }
 // Asynchronous Decode Requestor
 //
 // We use this class when someone calls requestDecode() from within a decode
 // notification. Since requestDecode() involves modifying the decoder's state
 // (for example, possibly shutting down a header-only decode and starting a
 // full decode), we don't want to do this from inside a decoder.
 class imgDecodeRequestor : public nsRunnable
 {
   public:
     imgDecodeRequestor(RasterImage &aContainer) {
       mContainer = aContainer.asWeakPtr();
     }
     NS_IMETHOD Run() {
       if (mContainer)
         mContainer->StartDecoding();
       return NS_OK;
     }
   private:
     WeakPtr<RasterImage> mContainer;
 };
 } // namespace image
 } // namespace mozilla
 #endif /* mozilla_imagelib_RasterImage_h_ */

The Tor Browser / annotate

image/src/RasterImage.h@b8a032363ba2 (annotated)

image/src/RasterImage.h