Add m-esr52 at 52.6.0

1 files changed, 667 insertions, 0 deletions

diff --git a/layout/svg/nsSVGImageFrame.cpp b/layout/svg/nsSVGImageFrame.cpp
new file mode 100644
index 000000000..c0a7f9419
--- /dev/null
+++ b/layout/svg/nsSVGImageFrame.cpp
@@ -0,0 +1,667 @@
+/* -*- 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/. */
+
+// Keep in (case-insensitive) order:
+#include "gfxContext.h"
+#include "gfxPlatform.h"
+#include "mozilla/gfx/2D.h"
+#include "imgIContainer.h"
+#include "nsContainerFrame.h"
+#include "nsIImageLoadingContent.h"
+#include "nsLayoutUtils.h"
+#include "imgINotificationObserver.h"
+#include "nsSVGEffects.h"
+#include "nsSVGPathGeometryFrame.h"
+#include "mozilla/dom/SVGSVGElement.h"
+#include "nsSVGUtils.h"
+#include "SVGContentUtils.h"
+#include "SVGImageContext.h"
+#include "mozilla/dom/SVGImageElement.h"
+#include "nsContentUtils.h"
+#include "nsIReflowCallback.h"
+#include "mozilla/Unused.h"
+
+using namespace mozilla;
+using namespace mozilla::dom;
+using namespace mozilla::gfx;
+using namespace mozilla::image;
+
+class nsSVGImageFrame;
+
+class nsSVGImageListener final : public imgINotificationObserver
+{
+public:
+  explicit nsSVGImageListener(nsSVGImageFrame *aFrame);
+
+  NS_DECL_ISUPPORTS
+  NS_DECL_IMGINOTIFICATIONOBSERVER
+
+  void SetFrame(nsSVGImageFrame *frame) { mFrame = frame; }
+
+private:
+  ~nsSVGImageListener() {}
+
+  nsSVGImageFrame *mFrame;
+};
+
+class nsSVGImageFrame : public nsSVGPathGeometryFrame
+                      , public nsIReflowCallback
+{
+  friend nsIFrame*
+  NS_NewSVGImageFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
+
+protected:
+  explicit nsSVGImageFrame(nsStyleContext* aContext)
+    : nsSVGPathGeometryFrame(aContext)
+    , mReflowCallbackPosted(false)
+  {
+    EnableVisibilityTracking();
+  }
+
+  virtual ~nsSVGImageFrame();
+
+public:
+  NS_DECL_FRAMEARENA_HELPERS
+
+  // nsISVGChildFrame interface:
+  virtual DrawResult PaintSVG(gfxContext& aContext,
+                              const gfxMatrix& aTransform,
+                              const nsIntRect* aDirtyRect = nullptr) override;
+  virtual nsIFrame* GetFrameForPoint(const gfxPoint& aPoint) override;
+  virtual void ReflowSVG() override;
+
+  // nsSVGPathGeometryFrame methods:
+  virtual uint16_t GetHitTestFlags() override;
+
+  // nsIFrame interface:
+  virtual nsresult  AttributeChanged(int32_t         aNameSpaceID,
+                                     nsIAtom*        aAttribute,
+                                     int32_t         aModType) override;
+
+  void OnVisibilityChange(Visibility aNewVisibility,
+                          Maybe<OnNonvisible> aNonvisibleAction = Nothing()) override;
+
+  virtual void Init(nsIContent*       aContent,
+                    nsContainerFrame* aParent,
+                    nsIFrame*         aPrevInFlow) override;
+  virtual void DestroyFrom(nsIFrame* aDestructRoot) override;
+
+  /**
+   * Get the "type" of the frame
+   *
+   * @see nsGkAtoms::svgImageFrame
+   */
+  virtual nsIAtom* GetType() const override;
+
+#ifdef DEBUG_FRAME_DUMP
+  virtual nsresult GetFrameName(nsAString& aResult) const override
+  {
+    return MakeFrameName(NS_LITERAL_STRING("SVGImage"), aResult);
+  }
+#endif
+
+  // nsIReflowCallback
+  virtual bool ReflowFinished() override;
+  virtual void ReflowCallbackCanceled() override;
+
+private:
+  gfx::Matrix GetRasterImageTransform(int32_t aNativeWidth,
+                                      int32_t aNativeHeight);
+  gfx::Matrix GetVectorImageTransform();
+  bool TransformContextForPainting(gfxContext* aGfxContext,
+                                   const gfxMatrix& aTransform);
+
+  nsCOMPtr<imgINotificationObserver> mListener;
+
+  nsCOMPtr<imgIContainer> mImageContainer;
+
+  bool mReflowCallbackPosted;
+
+  friend class nsSVGImageListener;
+};
+
+//----------------------------------------------------------------------
+// Implementation
+
+nsIFrame*
+NS_NewSVGImageFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
+{
+  return new (aPresShell) nsSVGImageFrame(aContext);
+}
+
+NS_IMPL_FRAMEARENA_HELPERS(nsSVGImageFrame)
+
+nsSVGImageFrame::~nsSVGImageFrame()
+{
+  // set the frame to null so we don't send messages to a dead object.
+  if (mListener) {
+    nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mContent);
+    if (imageLoader) {
+      imageLoader->RemoveObserver(mListener);
+    }
+    reinterpret_cast<nsSVGImageListener*>(mListener.get())->SetFrame(nullptr);
+  }
+  mListener = nullptr;
+}
+
+void
+nsSVGImageFrame::Init(nsIContent*       aContent,
+                      nsContainerFrame* aParent,
+                      nsIFrame*         aPrevInFlow)
+{
+  NS_ASSERTION(aContent->IsSVGElement(nsGkAtoms::image),
+               "Content is not an SVG image!");
+
+  nsSVGPathGeometryFrame::Init(aContent, aParent, aPrevInFlow);
+
+  if (GetStateBits() & NS_FRAME_IS_NONDISPLAY) {
+    // Non-display frames are likely to be patterns, masks or the like.
+    // Treat them as always visible.
+    IncApproximateVisibleCount();
+  }
+
+  mListener = new nsSVGImageListener(this);
+  nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mContent);
+  if (!imageLoader) {
+    NS_RUNTIMEABORT("Why is this not an image loading content?");
+  }
+
+  // We should have a PresContext now, so let's notify our image loader that
+  // we need to register any image animations with the refresh driver.
+  imageLoader->FrameCreated(this);
+
+  imageLoader->AddObserver(mListener);
+}
+
+/* virtual */ void
+nsSVGImageFrame::DestroyFrom(nsIFrame* aDestructRoot)
+{
+  if (GetStateBits() & NS_FRAME_IS_NONDISPLAY) {
+    DecApproximateVisibleCount();
+  }
+
+  if (mReflowCallbackPosted) {
+    PresContext()->PresShell()->CancelReflowCallback(this);
+    mReflowCallbackPosted = false;
+  }
+
+  nsCOMPtr<nsIImageLoadingContent> imageLoader =
+    do_QueryInterface(nsFrame::mContent);
+
+  if (imageLoader) {
+    imageLoader->FrameDestroyed(this);
+  }
+
+  nsFrame::DestroyFrom(aDestructRoot);
+}
+
+//----------------------------------------------------------------------
+// nsIFrame methods:
+
+nsresult
+nsSVGImageFrame::AttributeChanged(int32_t         aNameSpaceID,
+                                  nsIAtom*        aAttribute,
+                                  int32_t         aModType)
+{
+  if (aNameSpaceID == kNameSpaceID_None) {
+    if (aAttribute == nsGkAtoms::x ||
+        aAttribute == nsGkAtoms::y ||
+        aAttribute == nsGkAtoms::width ||
+        aAttribute == nsGkAtoms::height) {
+      nsLayoutUtils::PostRestyleEvent(
+        mContent->AsElement(), nsRestyleHint(0),
+        nsChangeHint_InvalidateRenderingObservers);
+      nsSVGUtils::ScheduleReflowSVG(this);
+      return NS_OK;
+    }
+    else if (aAttribute == nsGkAtoms::preserveAspectRatio) {
+      // We don't paint the content of the image using display lists, therefore
+      // we have to invalidate for this children-only transform changes since
+      // there is no layer tree to notice that the transform changed and
+      // recomposite.
+      InvalidateFrame();
+      return NS_OK;
+    }
+  }
+  if ((aNameSpaceID == kNameSpaceID_XLink ||
+       aNameSpaceID == kNameSpaceID_None) &&
+      aAttribute == nsGkAtoms::href) {
+    SVGImageElement *element = static_cast<SVGImageElement*>(mContent);
+
+    bool hrefIsSet =
+      element->mStringAttributes[SVGImageElement::HREF].IsExplicitlySet() ||
+      element->mStringAttributes[SVGImageElement::XLINK_HREF].IsExplicitlySet();
+    if (hrefIsSet) {
+      element->LoadSVGImage(true, true);
+    } else {
+      element->CancelImageRequests(true);
+    }
+  }
+
+  return nsSVGPathGeometryFrame::AttributeChanged(aNameSpaceID,
+                                                  aAttribute, aModType);
+}
+
+void
+nsSVGImageFrame::OnVisibilityChange(Visibility aNewVisibility,
+                                    Maybe<OnNonvisible> aNonvisibleAction)
+{
+  nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mContent);
+  if (!imageLoader) {
+    nsSVGPathGeometryFrame::OnVisibilityChange(aNewVisibility, aNonvisibleAction);
+    return;
+  }
+
+  imageLoader->OnVisibilityChange(aNewVisibility, aNonvisibleAction);
+
+  nsSVGPathGeometryFrame::OnVisibilityChange(aNewVisibility, aNonvisibleAction);
+}
+
+gfx::Matrix
+nsSVGImageFrame::GetRasterImageTransform(int32_t aNativeWidth,
+                                         int32_t aNativeHeight)
+{
+  float x, y, width, height;
+  SVGImageElement *element = static_cast<SVGImageElement*>(mContent);
+  element->GetAnimatedLengthValues(&x, &y, &width, &height, nullptr);
+
+  Matrix viewBoxTM =
+    SVGContentUtils::GetViewBoxTransform(width, height,
+                                         0, 0, aNativeWidth, aNativeHeight,
+                                         element->mPreserveAspectRatio);
+
+  return viewBoxTM * gfx::Matrix::Translation(x, y);
+}
+
+gfx::Matrix
+nsSVGImageFrame::GetVectorImageTransform()
+{
+  float x, y, width, height;
+  SVGImageElement *element = static_cast<SVGImageElement*>(mContent);
+  element->GetAnimatedLengthValues(&x, &y, &width, &height, nullptr);
+
+  // No viewBoxTM needed here -- our height/width overrides any concept of
+  // "native size" that the SVG image has, and it will handle viewBox and
+  // preserveAspectRatio on its own once we give it a region to draw into.
+
+  return gfx::Matrix::Translation(x, y);
+}
+
+bool
+nsSVGImageFrame::TransformContextForPainting(gfxContext* aGfxContext,
+                                             const gfxMatrix& aTransform)
+{
+  gfx::Matrix imageTransform;
+  if (mImageContainer->GetType() == imgIContainer::TYPE_VECTOR) {
+    imageTransform = GetVectorImageTransform() * ToMatrix(aTransform);
+  } else {
+    int32_t nativeWidth, nativeHeight;
+    if (NS_FAILED(mImageContainer->GetWidth(&nativeWidth)) ||
+        NS_FAILED(mImageContainer->GetHeight(&nativeHeight)) ||
+        nativeWidth == 0 || nativeHeight == 0) {
+      return false;
+    }
+    imageTransform =
+      GetRasterImageTransform(nativeWidth, nativeHeight) * ToMatrix(aTransform);
+
+    // NOTE: We need to cancel out the effects of Full-Page-Zoom, or else
+    // it'll get applied an extra time by DrawSingleUnscaledImage.
+    nscoord appUnitsPerDevPx = PresContext()->AppUnitsPerDevPixel();
+    gfxFloat pageZoomFactor =
+      nsPresContext::AppUnitsToFloatCSSPixels(appUnitsPerDevPx);
+    imageTransform.PreScale(pageZoomFactor, pageZoomFactor);
+  }
+
+  if (imageTransform.IsSingular()) {
+    return false;
+  }
+
+  aGfxContext->Multiply(ThebesMatrix(imageTransform));
+  return true;
+}
+
+//----------------------------------------------------------------------
+// nsISVGChildFrame methods:
+DrawResult
+nsSVGImageFrame::PaintSVG(gfxContext& aContext,
+                          const gfxMatrix& aTransform,
+                          const nsIntRect *aDirtyRect)
+{
+  if (!StyleVisibility()->IsVisible())
+    return DrawResult::SUCCESS;
+
+  float x, y, width, height;
+  SVGImageElement *imgElem = static_cast<SVGImageElement*>(mContent);
+  imgElem->GetAnimatedLengthValues(&x, &y, &width, &height, nullptr);
+  NS_ASSERTION(width > 0 && height > 0,
+               "Should only be painting things with valid width/height");
+
+  if (!mImageContainer) {
+    nsCOMPtr<imgIRequest> currentRequest;
+    nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mContent);
+    if (imageLoader)
+      imageLoader->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
+                              getter_AddRefs(currentRequest));
+
+    if (currentRequest)
+      currentRequest->GetImage(getter_AddRefs(mImageContainer));
+  }
+
+  DrawResult result = DrawResult::SUCCESS;
+  if (mImageContainer) {
+    gfxContextAutoSaveRestore autoRestorer(&aContext);
+
+    if (StyleDisplay()->IsScrollableOverflow()) {
+      gfxRect clipRect = nsSVGUtils::GetClipRectForFrame(this, x, y,
+                                                         width, height);
+      nsSVGUtils::SetClipRect(&aContext, aTransform, clipRect);
+    }
+
+    if (!TransformContextForPainting(&aContext, aTransform)) {
+      return DrawResult::SUCCESS;
+    }
+
+    // fill-opacity doesn't affect <image>, so if we're allowed to
+    // optimize group opacity, the opacity used for compositing the
+    // image into the current canvas is just the group opacity.
+    float opacity = 1.0f;
+    if (nsSVGUtils::CanOptimizeOpacity(this)) {
+      opacity = StyleEffects()->mOpacity;
+    }
+
+    if (opacity != 1.0f || StyleEffects()->mMixBlendMode != NS_STYLE_BLEND_NORMAL) {
+      aContext.PushGroupForBlendBack(gfxContentType::COLOR_ALPHA, opacity);
+    }
+
+    nscoord appUnitsPerDevPx = PresContext()->AppUnitsPerDevPixel();
+    nsRect dirtyRect; // only used if aDirtyRect is non-null
+    if (aDirtyRect) {
+      NS_ASSERTION(!NS_SVGDisplayListPaintingEnabled() ||
+                   (mState & NS_FRAME_IS_NONDISPLAY),
+                   "Display lists handle dirty rect intersection test");
+      dirtyRect = ToAppUnits(*aDirtyRect, appUnitsPerDevPx);
+      // Adjust dirtyRect to match our local coordinate system.
+      nsRect rootRect =
+        nsSVGUtils::TransformFrameRectToOuterSVG(mRect, aTransform,
+                                                 PresContext());
+      dirtyRect.MoveBy(-rootRect.TopLeft());
+    }
+
+    // XXXbholley - I don't think huge images in SVGs are common enough to
+    // warrant worrying about the responsiveness impact of doing synchronous
+    // decodes. The extra code complexity of determinining when we want to
+    // force sync probably just isn't worth it, so always pass FLAG_SYNC_DECODE
+    uint32_t drawFlags = imgIContainer::FLAG_SYNC_DECODE;
+
+    if (mImageContainer->GetType() == imgIContainer::TYPE_VECTOR) {
+      // Package up the attributes of this image element which can override the
+      // attributes of mImageContainer's internal SVG document.  The 'width' &
+      // 'height' values we're passing in here are in CSS units (though they
+      // come from width/height *attributes* in SVG). They influence the region
+      // of the SVG image's internal document that is visible, in combination
+      // with preserveAspectRatio and viewBox.
+      SVGImageContext context(CSSIntSize::Truncate(width, height),
+                              Some(imgElem->mPreserveAspectRatio.GetAnimValue()),
+                              1.0, true);
+
+      // For the actual draw operation to draw crisply (and at the right size),
+      // our destination rect needs to be |width|x|height|, *in dev pixels*.
+      LayoutDeviceSize devPxSize(width, height);
+      nsRect destRect(nsPoint(),
+                      LayoutDevicePixel::ToAppUnits(devPxSize,
+                                                    appUnitsPerDevPx));
+
+      // Note: Can't use DrawSingleUnscaledImage for the TYPE_VECTOR case.
+      // That method needs our image to have a fixed native width & height,
+      // and that's not always true for TYPE_VECTOR images.
+      result = nsLayoutUtils::DrawSingleImage(
+        aContext,
+        PresContext(),
+        mImageContainer,
+        nsLayoutUtils::GetSamplingFilterForFrame(this),
+        destRect,
+        aDirtyRect ? dirtyRect : destRect,
+        &context,
+        drawFlags);
+    } else { // mImageContainer->GetType() == TYPE_RASTER
+      result = nsLayoutUtils::DrawSingleUnscaledImage(
+        aContext,
+        PresContext(),
+        mImageContainer,
+        nsLayoutUtils::GetSamplingFilterForFrame(this),
+        nsPoint(0, 0),
+        aDirtyRect ? &dirtyRect : nullptr,
+        drawFlags);
+    }
+
+    if (opacity != 1.0f || StyleEffects()->mMixBlendMode != NS_STYLE_BLEND_NORMAL) {
+      aContext.PopGroupAndBlend();
+    }
+    // gfxContextAutoSaveRestore goes out of scope & cleans up our gfxContext
+  }
+
+  return result;
+}
+
+nsIFrame*
+nsSVGImageFrame::GetFrameForPoint(const gfxPoint& aPoint)
+{
+  if (!(GetStateBits() & NS_STATE_SVG_CLIPPATH_CHILD) && !GetHitTestFlags()) {
+    return nullptr;
+  }
+
+  Rect rect;
+  SVGImageElement *element = static_cast<SVGImageElement*>(mContent);
+  element->GetAnimatedLengthValues(&rect.x, &rect.y,
+                                   &rect.width, &rect.height, nullptr);
+
+  if (!rect.Contains(ToPoint(aPoint))) {
+    return nullptr;
+  }
+
+  // Special case for raster images -- we only want to accept points that fall
+  // in the underlying image's (scaled to fit) native bounds.  That region
+  // doesn't necessarily map to our <image> element's [x,y,width,height] if the
+  // raster image's aspect ratio is being preserved.  We have to look up the
+  // native image size & our viewBox transform in order to filter out points
+  // that fall outside that area.  (This special case doesn't apply to vector
+  // images because they don't limit their drawing to explicit "native
+  // bounds" -- they have an infinite canvas on which to place content.)
+  if (StyleDisplay()->IsScrollableOverflow() && mImageContainer) {
+    if (mImageContainer->GetType() == imgIContainer::TYPE_RASTER) {
+      int32_t nativeWidth, nativeHeight;
+      if (NS_FAILED(mImageContainer->GetWidth(&nativeWidth)) ||
+          NS_FAILED(mImageContainer->GetHeight(&nativeHeight)) ||
+          nativeWidth == 0 || nativeHeight == 0) {
+        return nullptr;
+      }
+      Matrix viewBoxTM =
+        SVGContentUtils::GetViewBoxTransform(rect.width, rect.height,
+                                             0, 0, nativeWidth, nativeHeight,
+                                             element->mPreserveAspectRatio);
+      if (!nsSVGUtils::HitTestRect(viewBoxTM,
+                                   0, 0, nativeWidth, nativeHeight,
+                                   aPoint.x - rect.x, aPoint.y - rect.y)) {
+        return nullptr;
+      }
+    }
+  }
+
+  return this;
+}
+
+nsIAtom *
+nsSVGImageFrame::GetType() const
+{
+  return nsGkAtoms::svgImageFrame;
+}
+
+//----------------------------------------------------------------------
+// nsSVGPathGeometryFrame methods:
+
+// Lie about our fill/stroke so that covered region and hit detection work properly
+
+void
+nsSVGImageFrame::ReflowSVG()
+{
+  NS_ASSERTION(nsSVGUtils::OuterSVGIsCallingReflowSVG(this),
+               "This call is probably a wasteful mistake");
+
+  MOZ_ASSERT(!(GetStateBits() & NS_FRAME_IS_NONDISPLAY),
+             "ReflowSVG mechanism not designed for this");
+
+  if (!nsSVGUtils::NeedsReflowSVG(this)) {
+    return;
+  }
+
+  float x, y, width, height;
+  SVGImageElement *element = static_cast<SVGImageElement*>(mContent);
+  element->GetAnimatedLengthValues(&x, &y, &width, &height, nullptr);
+
+  Rect extent(x, y, width, height);
+
+  if (!extent.IsEmpty()) {
+    mRect = nsLayoutUtils::RoundGfxRectToAppRect(extent, 
+              PresContext()->AppUnitsPerCSSPixel());
+  } else {
+    mRect.SetEmpty();
+  }
+
+  if (mState & NS_FRAME_FIRST_REFLOW) {
+    // Make sure we have our filter property (if any) before calling
+    // FinishAndStoreOverflow (subsequent filter changes are handled off
+    // nsChangeHint_UpdateEffects):
+    nsSVGEffects::UpdateEffects(this);
+
+    if (!mReflowCallbackPosted) {
+      nsIPresShell* shell = PresContext()->PresShell();
+      mReflowCallbackPosted = true;
+      shell->PostReflowCallback(this);
+    }
+  }
+
+  nsRect overflow = nsRect(nsPoint(0,0), mRect.Size());
+  nsOverflowAreas overflowAreas(overflow, overflow);
+  FinishAndStoreOverflow(overflowAreas, mRect.Size());
+
+  mState &= ~(NS_FRAME_FIRST_REFLOW | NS_FRAME_IS_DIRTY |
+              NS_FRAME_HAS_DIRTY_CHILDREN);
+
+  // Invalidate, but only if this is not our first reflow (since if it is our
+  // first reflow then we haven't had our first paint yet).
+  if (!(GetParent()->GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
+    InvalidateFrame();
+  }
+}
+
+bool
+nsSVGImageFrame::ReflowFinished()
+{
+  mReflowCallbackPosted = false;
+
+  // XXX(seth): We don't need this. The purpose of updating visibility
+  // synchronously is to ensure that animated images start animating
+  // immediately. In the short term, however,
+  // nsImageLoadingContent::OnUnlockedDraw() is enough to ensure that
+  // animations start as soon as the image is painted for the first time, and in
+  // the long term we want to update visibility information from the display
+  // list whenever we paint, so we don't actually need to do this. However, to
+  // avoid behavior changes during the transition from the old image visibility
+  // code, we'll leave it in for now.
+  UpdateVisibilitySynchronously();
+
+  return false;
+}
+
+void
+nsSVGImageFrame::ReflowCallbackCanceled()
+{
+  mReflowCallbackPosted = false;
+}
+
+uint16_t
+nsSVGImageFrame::GetHitTestFlags()
+{
+  uint16_t flags = 0;
+
+  switch (StyleUserInterface()->mPointerEvents) {
+    case NS_STYLE_POINTER_EVENTS_NONE:
+      break;
+    case NS_STYLE_POINTER_EVENTS_VISIBLEPAINTED:
+    case NS_STYLE_POINTER_EVENTS_AUTO:
+      if (StyleVisibility()->IsVisible()) {
+        /* XXX: should check pixel transparency */
+        flags |= SVG_HIT_TEST_FILL;
+      }
+      break;
+    case NS_STYLE_POINTER_EVENTS_VISIBLEFILL:
+    case NS_STYLE_POINTER_EVENTS_VISIBLESTROKE:
+    case NS_STYLE_POINTER_EVENTS_VISIBLE:
+      if (StyleVisibility()->IsVisible()) {
+        flags |= SVG_HIT_TEST_FILL;
+      }
+      break;
+    case NS_STYLE_POINTER_EVENTS_PAINTED:
+      /* XXX: should check pixel transparency */
+      flags |= SVG_HIT_TEST_FILL;
+      break;
+    case NS_STYLE_POINTER_EVENTS_FILL:
+    case NS_STYLE_POINTER_EVENTS_STROKE:
+    case NS_STYLE_POINTER_EVENTS_ALL:
+      flags |= SVG_HIT_TEST_FILL;
+      break;
+    default:
+      NS_ERROR("not reached");
+      break;
+  }
+
+  return flags;
+}
+
+//----------------------------------------------------------------------
+// nsSVGImageListener implementation
+
+NS_IMPL_ISUPPORTS(nsSVGImageListener, imgINotificationObserver)
+
+nsSVGImageListener::nsSVGImageListener(nsSVGImageFrame *aFrame) :  mFrame(aFrame)
+{
+}
+
+NS_IMETHODIMP
+nsSVGImageListener::Notify(imgIRequest *aRequest, int32_t aType, const nsIntRect* aData)
+{
+  if (!mFrame)
+    return NS_ERROR_FAILURE;
+
+  if (aType == imgINotificationObserver::LOAD_COMPLETE) {
+    mFrame->InvalidateFrame();
+    nsLayoutUtils::PostRestyleEvent(
+      mFrame->GetContent()->AsElement(), nsRestyleHint(0),
+      nsChangeHint_InvalidateRenderingObservers);
+    nsSVGUtils::ScheduleReflowSVG(mFrame);
+  }
+
+  if (aType == imgINotificationObserver::FRAME_UPDATE) {
+    // No new dimensions, so we don't need to call
+    // nsSVGUtils::InvalidateAndScheduleBoundsUpdate.
+    nsLayoutUtils::PostRestyleEvent(
+      mFrame->GetContent()->AsElement(), nsRestyleHint(0),
+      nsChangeHint_InvalidateRenderingObservers);
+    mFrame->InvalidateFrame();
+  }
+
+  if (aType == imgINotificationObserver::SIZE_AVAILABLE) {
+    // Called once the resource's dimensions have been obtained.
+    aRequest->GetImage(getter_AddRefs(mFrame->mImageContainer));
+    mFrame->InvalidateFrame();
+    nsLayoutUtils::PostRestyleEvent(
+      mFrame->GetContent()->AsElement(), nsRestyleHint(0),
+      nsChangeHint_InvalidateRenderingObservers);
+    nsSVGUtils::ScheduleReflowSVG(mFrame);
+  }
+
+  return NS_OK;
+}
+