The Tor Browser / file revision

 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */

 // vim: ft=cpp tw=78 sw=2 et ts=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/. */

 /*

  * A base class which implements nsIImageLoadingContent and can be

  * subclassed by various content nodes that want to provide image

  * loading functionality (eg <img>, <object>, etc).

  */

 #ifndef nsImageLoadingContent_h__

 #define nsImageLoadingContent_h__

 #include "imgINotificationObserver.h"

 #include "imgIOnloadBlocker.h"

 #include "mozilla/CORSMode.h"

 #include "mozilla/EventStates.h"

 #include "nsCOMPtr.h"

 #include "nsIImageLoadingContent.h"

 #include "nsIRequest.h"

 #include "mozilla/ErrorResult.h"

 #include "nsAutoPtr.h"

 class nsIURI;

 class nsIDocument;

 class imgILoader;

 class nsIIOService;

 class nsPresContext;

 class nsIContent;

 class imgRequestProxy;

 #ifdef LoadImage

 // Undefine LoadImage to prevent naming conflict with Windows.

 #undef LoadImage

 #endif

 class nsImageLoadingContent : public nsIImageLoadingContent,

                               public imgIOnloadBlocker

 {

   /* METHODS */

 public:

   nsImageLoadingContent();

   virtual ~nsImageLoadingContent();

   NS_DECL_IMGINOTIFICATIONOBSERVER

   NS_DECL_NSIIMAGELOADINGCONTENT

   NS_DECL_IMGIONLOADBLOCKER

   // Web IDL binding methods.

   // Note that the XPCOM SetLoadingEnabled, AddObserver, RemoveObserver,

   // ForceImageState methods are OK for Web IDL bindings to use as well,

   // since none of them throw when called via the Web IDL bindings.

   bool LoadingEnabled() const { return mLoadingEnabled; }

   int16_t ImageBlockingStatus() const

   {

     return mImageBlockingStatus;

   }

   already_AddRefed<imgIRequest>

     GetRequest(int32_t aRequestType, mozilla::ErrorResult& aError);

   int32_t

     GetRequestType(imgIRequest* aRequest, mozilla::ErrorResult& aError);

   already_AddRefed<nsIURI> GetCurrentURI(mozilla::ErrorResult& aError);

   already_AddRefed<nsIStreamListener>

     LoadImageWithChannel(nsIChannel* aChannel, mozilla::ErrorResult& aError);

   void ForceReload(mozilla::ErrorResult& aError);

 protected:

   /**

    * LoadImage is called by subclasses when the appropriate

    * attributes (eg 'src' for <img> tags) change.  The string passed

    * in is the new uri string; this consolidates the code for getting

    * the charset, constructing URI objects, and any other incidentals

    * into this superclass.   

    *

    * @param aNewURI the URI spec to be loaded (may be a relative URI)

    * @param aForce If true, make sure to load the URI.  If false, only

    *        load if the URI is different from the currently loaded URI.

    * @param aNotify If true, nsIDocumentObserver state change notifications

    *                will be sent as needed.

    */

   nsresult LoadImage(const nsAString& aNewURI, bool aForce,

                      bool aNotify);

   /**

    * ImageState is called by subclasses that are computing their content state.

    * The return value will have the NS_EVENT_STATE_BROKEN,

    * NS_EVENT_STATE_USERDISABLED, and NS_EVENT_STATE_SUPPRESSED bits set as

    * needed.  Note that this state assumes that this node is "trying" to be an

    * image (so for example complete lack of attempt to load an image will lead

    * to NS_EVENT_STATE_BROKEN being set).  Subclasses that are not "trying" to

    * be an image (eg an HTML <input> of type other than "image") should just

    * not call this method when computing their intrinsic state.

    */

   mozilla::EventStates ImageState() const;

   /**

    * LoadImage is called by subclasses when the appropriate

    * attributes (eg 'src' for <img> tags) change. If callers have an

    * URI object already available, they should use this method.

    *

    * @param aNewURI the URI to be loaded

    * @param aForce If true, make sure to load the URI.  If false, only

    *        load if the URI is different from the currently loaded URI.

    * @param aNotify If true, nsIDocumentObserver state change notifications

    *                will be sent as needed.

    * @param aDocument Optional parameter giving the document this node is in.

    *        This is purely a performance optimization.

    * @param aLoadFlags Optional parameter specifying load flags to use for

    *        the image load

    */

   nsresult LoadImage(nsIURI* aNewURI, bool aForce, bool aNotify,

                      nsIDocument* aDocument = nullptr,

                      nsLoadFlags aLoadFlags = nsIRequest::LOAD_NORMAL);

   /**

    * helpers to get the document for this content (from the nodeinfo

    * and such).  Not named GetOwnerDoc/GetCurrentDoc to prevent ambiguous

    * method names in subclasses

    *

    * @return the document we belong to

    */

   nsIDocument* GetOurOwnerDoc();

   nsIDocument* GetOurCurrentDoc();

   /**

    * Helper function to get the frame associated with this content. Not named

    * GetPrimaryFrame to prevent ambiguous method names in subclasses.

    *

    * @return The frame which we belong to, or nullptr if it doesn't exist.

    */

   nsIFrame* GetOurPrimaryFrame();

   /**

    * Helper function to get the PresContext associated with this content's

    * frame. Not named GetPresContext to prevent ambiguous method names in

    * subclasses.

    *

    * @return The nsPresContext associated with our frame, or nullptr if either

    *         the frame doesn't exist, or the frame's prescontext doesn't exist.

    */

   nsPresContext* GetFramePresContext();

   /**

    * CancelImageRequests is called by subclasses when they want to

    * cancel all image requests (for example when the subclass is

    * somehow not an image anymore).

    */

   void CancelImageRequests(bool aNotify);

   /**

    * UseAsPrimaryRequest is called by subclasses when they have an existing

    * imgRequestProxy that they want this nsImageLoadingContent to use.  This may

    * effectively be called instead of LoadImage or LoadImageWithChannel.

    * If aNotify is true, this method will notify on state changes.

    */

   nsresult UseAsPrimaryRequest(imgRequestProxy* aRequest, bool aNotify);

   /**

    * Derived classes of nsImageLoadingContent MUST call

    * DestroyImageLoadingContent from their destructor, or earlier.  It

    * does things that cannot be done in ~nsImageLoadingContent because

    * they rely on being able to QueryInterface to other derived classes,

    * which cannot happen once the derived class destructor has started

    * calling the base class destructors.

    */

   void DestroyImageLoadingContent();

   void ClearBrokenState() { mBroken = false; }

   // Sets blocking state only if the desired state is different from the

   // current one. See the comment for mBlockingOnload for more information.

   void SetBlockingOnload(bool aBlocking);

   /**

    * Returns the CORS mode that will be used for all future image loads. The

    * default implementation returns CORS_NONE unconditionally.

    */

   virtual mozilla::CORSMode GetCORSMode();

   // Subclasses are *required* to call BindToTree/UnbindFromTree.

   void BindToTree(nsIDocument* aDocument, nsIContent* aParent,

                   nsIContent* aBindingParent, bool aCompileEventHandlers);

   void UnbindFromTree(bool aDeep, bool aNullParent);

   nsresult OnStopRequest(imgIRequest* aRequest, nsresult aStatus);

   void OnUnlockedDraw();

   nsresult OnImageIsAnimated(imgIRequest *aRequest);

 private:

   /**

    * Struct used to manage the image observers.

    */

   struct ImageObserver {

     ImageObserver(imgINotificationObserver* aObserver);

     ~ImageObserver();

     nsCOMPtr<imgINotificationObserver> mObserver;

     ImageObserver* mNext;

   };

   /**

    * Struct to report state changes

    */

   struct AutoStateChanger {

     AutoStateChanger(nsImageLoadingContent* aImageContent,

                      bool aNotify) :

       mImageContent(aImageContent),

       mNotify(aNotify)

     {

       mImageContent->mStateChangerDepth++;

     }

     ~AutoStateChanger()

     {

       mImageContent->mStateChangerDepth--;

       mImageContent->UpdateImageState(mNotify);

     }

     nsImageLoadingContent* mImageContent;

     bool mNotify;

   };

   friend struct AutoStateChanger;

   /**

    * UpdateImageState recomputes the current state of this image loading

    * content and updates what ImageState() returns accordingly.  It will also

    * fire a ContentStatesChanged() notification as needed if aNotify is true.

    */

   void UpdateImageState(bool aNotify);

   /**

    * Method to fire an event once we know what's going on with the image load.

    *

    * @param aEventType "load" or "error" depending on how things went

    */

   nsresult FireEvent(const nsAString& aEventType);

 protected:

   /**

    * Method to create an nsIURI object from the given string (will

    * handle getting the right charset, base, etc).  You MUST pass in a

    * non-null document to this function.

    *

    * @param aSpec the string spec (from an HTML attribute, eg)

    * @param aDocument the document we belong to

    * @return the URI we want to be loading

    */

   nsresult StringToURI(const nsAString& aSpec, nsIDocument* aDocument,

                        nsIURI** aURI);

   void CreateStaticImageClone(nsImageLoadingContent* aDest) const;

   /**

    * Prepare and returns a reference to the "next request". If there's already

    * a _usable_ current request (one with SIZE_AVAILABLE), this request is

    * "pending" until it becomes usable. Otherwise, this becomes the current

    * request.

    */

    nsRefPtr<imgRequestProxy>& PrepareNextRequest();

   /**

    * Called when we would normally call PrepareNextRequest(), but the request was

    * blocked.

    */

   void SetBlockedRequest(nsIURI* aURI, int16_t aContentDecision);

   /**

    * Returns a COMPtr reference to the current/pending image requests, cleaning

    * up and canceling anything that was there before. Note that if you just want

    * to get rid of one of the requests, you should call

    * Clear*Request(NS_BINDING_ABORTED) instead, since it passes a more appropriate

    * aReason than Prepare*Request() does (NS_ERROR_IMAGE_SRC_CHANGED).

    */

   nsRefPtr<imgRequestProxy>& PrepareCurrentRequest();

   nsRefPtr<imgRequestProxy>& PreparePendingRequest();

   /**

    * Switch our pending request to be our current request.

    * mPendingRequest must be non-null!

    */

   void MakePendingRequestCurrent();

   /**

    * Cancels and nulls-out the "current" and "pending" requests if they exist.

    */

   void ClearCurrentRequest(nsresult aReason, uint32_t aFlags);

   void ClearPendingRequest(nsresult aReason, uint32_t aFlags);

   /**

    * Retrieve a pointer to the 'registered with the refresh driver' flag for

    * which a particular image request corresponds.

    *

    * @returns A pointer to the boolean flag for a given image request, or

    *          |nullptr| if the request is not either |mPendingRequest| or

    *          |mCurrentRequest|.

    */

   bool* GetRegisteredFlagForRequest(imgIRequest* aRequest);

   /**

    * Reset animation of the current request if |mNewRequestsWillNeedAnimationReset|

    * was true when the request was prepared.

    */

   void ResetAnimationIfNeeded();

   /**

    * Static helper method to tell us if we have the size of a request. The

    * image may be null.

    */

   static bool HaveSize(imgIRequest *aImage);

   /**

    * Adds/Removes a given imgIRequest from our document's tracker.

    *

    * No-op if aImage is null.

    *

    * REQUEST_DISCARD passed to UntrackImage means we request the discard of the

    * decoded data of the image.

    */

   void TrackImage(imgIRequest* aImage);

   enum {

     REQUEST_DISCARD = 0x1

   };

   void UntrackImage(imgIRequest* aImage, uint32_t aFlags = 0);

   /* MEMBERS */

   nsRefPtr<imgRequestProxy> mCurrentRequest;

   nsRefPtr<imgRequestProxy> mPendingRequest;

   uint32_t mCurrentRequestFlags;

   uint32_t mPendingRequestFlags;

   enum {

     // Set if the request needs ResetAnimation called on it.

     REQUEST_NEEDS_ANIMATION_RESET = 0x00000001U,

     // Set if the request is blocking onload.

     REQUEST_BLOCKS_ONLOAD = 0x00000002U,

     // Set if the request is currently tracked with the document.

     REQUEST_IS_TRACKED = 0x00000004U

   };

   // If the image was blocked or if there was an error loading, it's nice to

   // still keep track of what the URI was despite not having an imgIRequest.

   // We only maintain this in those situations (in the common case, this is

   // always null).

   nsCOMPtr<nsIURI>      mCurrentURI;

 private:

   /**

    * Typically we will have only one observer (our frame in the screen

    * prescontext), so we want to only make space for one and to

    * heap-allocate anything past that (saves memory and malloc churn

    * in the common case).  The storage is a linked list, we just

    * happen to actually hold the first observer instead of a pointer

    * to it.

    */

   ImageObserver mObserverList;

   /**

    * When mIsImageStateForced is true, this holds the ImageState that we'll

    * return in ImageState().

    */

   mozilla::EventStates mForcedImageState;

   int16_t mImageBlockingStatus;

   bool mLoadingEnabled : 1;

   /**

    * When true, we return mForcedImageState from ImageState().

    */

   bool mIsImageStateForced : 1;

   /**

    * The state we had the last time we checked whether we needed to notify the

    * document of a state change.  These are maintained by UpdateImageState.

    */

   bool mLoading : 1;

   bool mBroken : 1;

   bool mUserDisabled : 1;

   bool mSuppressed : 1;

   bool mFireEventsOnDecode : 1;

 protected:

   /**

    * A hack to get animations to reset, see bug 594771. On requests

    * that originate from setting .src, we mark them for needing their animation

    * reset when they are ready. mNewRequestsWillNeedAnimationReset is set to

    * true while preparing such requests (as a hack around needing to change an

    * interface), and the other two booleans store which of the current

    * and pending requests are of the sort that need their animation restarted.

    */

   bool mNewRequestsWillNeedAnimationReset : 1;

 private:

   /* The number of nested AutoStateChangers currently tracking our state. */

   uint8_t mStateChangerDepth;

   // Flags to indicate whether each of the current and pending requests are

   // registered with the refresh driver.

   bool mCurrentRequestRegistered;

   bool mPendingRequestRegistered;

   // True when FrameCreate has been called but FrameDestroy has not.

   bool mFrameCreateCalled;

   uint32_t mVisibleCount;

 };

 #endif // nsImageLoadingContent_h__