Line data    Source code

       1             : /* This Source Code Form is subject to the terms of the Mozilla Public
       2             :  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
       3             :  * You can obtain one at http://mozilla.org/MPL/2.0/. */
       4             : 
       5             : // A class that handles style system image loads (other image loads are handled
       6             : // by the nodes in the content tree).
       7             : 
       8             : #ifndef mozilla_css_ImageLoader_h___
       9             : #define mozilla_css_ImageLoader_h___
      10             : 
      11             : #include "nsClassHashtable.h"
      12             : #include "nsHashKeys.h"
      13             : #include "nsTArray.h"
      14             : #include "imgIRequest.h"
      15             : #include "imgIOnloadBlocker.h"
      16             : #include "imgINotificationObserver.h"
      17             : #include "mozilla/Attributes.h"
      18             : 
      19             : class imgIContainer;
      20             : class nsIFrame;
      21             : class nsIDocument;
      22             : class nsPresContext;
      23             : class nsIURI;
      24             : class nsIPrincipal;
      25             : 
      26             : namespace mozilla {
      27             : namespace css {
      28             : 
      29             : struct ImageValue;
      30             : 
      31             : class ImageLoader final : public imgINotificationObserver,
      32             :                           public imgIOnloadBlocker
      33             : {
      34             : public:
      35             :   typedef mozilla::css::ImageValue Image;
      36             : 
      37          55 :   explicit ImageLoader(nsIDocument* aDocument)
      38          55 :   : mDocument(aDocument),
      39          55 :     mInClone(false)
      40             :   {
      41          55 :     MOZ_ASSERT(mDocument);
      42          55 :   }
      43             : 
      44             :   NS_DECL_ISUPPORTS
      45             :   NS_DECL_IMGIONLOADBLOCKER
      46             :   NS_DECL_IMGINOTIFICATIONOBSERVER
      47             : 
      48             :   void DropDocumentReference();
      49             : 
      50             :   void MaybeRegisterCSSImage(Image* aImage);
      51             :   void DeregisterCSSImage(Image* aImage);
      52             : 
      53             :   void AssociateRequestToFrame(imgIRequest* aRequest,
      54             :                                nsIFrame* aFrame);
      55             : 
      56             :   void DisassociateRequestFromFrame(imgIRequest* aRequest,
      57             :                                     nsIFrame* aFrame);
      58             : 
      59             :   void DropRequestsForFrame(nsIFrame* aFrame);
      60             : 
      61             :   void SetAnimationMode(uint16_t aMode);
      62             : 
      63             :   // The prescontext for this ImageLoader's document. We need it to be passed
      64             :   // in because this can be called during presentation destruction after the
      65             :   // presshell pointer on the document has been cleared.
      66             :   void ClearFrames(nsPresContext* aPresContext);
      67             : 
      68             :   void LoadImage(nsIURI* aURI, nsIPrincipal* aPrincipal, nsIURI* aReferrer,
      69             :                  Image* aCSSValue);
      70             : 
      71             :   void DestroyRequest(imgIRequest* aRequest);
      72             : 
      73             :   void FlushUseCounters();
      74             : 
      75             : private:
      76           0 :   ~ImageLoader() {}
      77             : 
      78             :   // We need to be able to look up the frames associated with a request (for
      79             :   // delivering notifications) and the requests associated with a frame (when
      80             :   // the frame goes away). Thus we maintain hashtables going both ways.  These
      81             :   // should always be in sync.
      82             : 
      83             :   typedef nsTArray<nsIFrame*> FrameSet;
      84             :   typedef nsTArray<nsCOMPtr<imgIRequest> > RequestSet;
      85             :   typedef nsTHashtable<nsPtrHashKey<Image> > ImageHashSet;
      86             :   typedef nsClassHashtable<nsISupportsHashKey,
      87             :                            FrameSet> RequestToFrameMap;
      88             :   typedef nsClassHashtable<nsPtrHashKey<nsIFrame>,
      89             :                            RequestSet> FrameToRequestMap;
      90             : 
      91             :   void AddImage(Image* aCSSImage);
      92             :   void RemoveImage(Image* aCSSImage);
      93             : 
      94             :   nsPresContext* GetPresContext();
      95             : 
      96             :   void DoRedraw(FrameSet* aFrameSet, bool aForcePaint);
      97             : 
      98             :   nsresult OnSizeAvailable(imgIRequest* aRequest, imgIContainer* aImage);
      99             :   nsresult OnFrameComplete(imgIRequest* aRequest);
     100             :   nsresult OnImageIsAnimated(imgIRequest* aRequest);
     101             :   nsresult OnFrameUpdate(imgIRequest* aRequest);
     102             : 
     103             :   // Helpers for DropRequestsForFrame / DisassociateRequestFromFrame above.
     104             :   void RemoveRequestToFrameMapping(imgIRequest* aRequest, nsIFrame* aFrame);
     105             :   void RemoveFrameToRequestMapping(imgIRequest* aRequest, nsIFrame* aFrame);
     106             : 
     107             :   // A map of imgIRequests to the nsIFrames that are using them.
     108             :   RequestToFrameMap mRequestToFrameMap;
     109             : 
     110             :   // A map of nsIFrames to the imgIRequests they use.
     111             :   FrameToRequestMap mFrameToRequestMap;
     112             : 
     113             :   // A weak pointer to our document. Nulled out by DropDocumentReference.
     114             :   nsIDocument* mDocument;
     115             : 
     116             :   // The set of all nsCSSValue::Images (whether they're associated a frame or
     117             :   // not).  We'll need this when we go away to remove any requests associated
     118             :   // with our document from those Images.
     119             :   ImageHashSet mImages;
     120             : 
     121             :   // Are we cloning?  If so, ignore any notifications we get.
     122             :   bool mInClone;
     123             : };
     124             : 
     125             : } // namespace css
     126             : } // namespace mozilla
     127             : 
     128             : #endif /* mozilla_css_ImageLoader_h___ */