diff -r 000000000000 -r 6474c204b198 content/base/src/nsImageLoadingContent.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/content/base/src/nsImageLoadingContent.h	Wed Dec 31 06:09:35 2014 +0100
@@ -0,0 +1,412 @@
+/* -*- 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__