layout/svg/nsSVGImageFrame.cpp

   1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
   2 /* This Source Code Form is subject to the terms of the Mozilla Public
   3  * License, v. 2.0. If a copy of the MPL was not distributed with this
   4  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
   5
   6 // Keep in (case-insensitive) order:
   7 #include "gfxContext.h"
   8 #include "gfxPlatform.h"
   9 #include "mozilla/gfx/2D.h"
  10 #include "imgIContainer.h"
  11 #include "nsContainerFrame.h"
  12 #include "nsIImageLoadingContent.h"
  13 #include "nsLayoutUtils.h"
  14 #include "nsRenderingContext.h"
  15 #include "imgINotificationObserver.h"
  16 #include "nsSVGEffects.h"
  17 #include "nsSVGPathGeometryFrame.h"
  18 #include "mozilla/dom/SVGSVGElement.h"
  19 #include "nsSVGUtils.h"
  20 #include "SVGContentUtils.h"
  21 #include "SVGImageContext.h"
  22 #include "mozilla/dom/SVGImageElement.h"
  23 #include "nsContentUtils.h"
  24 #include "nsIReflowCallback.h"
  25
  26 using namespace mozilla;
  27 using namespace mozilla::dom;
  28 using namespace mozilla::gfx;
  29
  30 class nsSVGImageFrame;
  31
  32 class nsSVGImageListener MOZ_FINAL : public imgINotificationObserver
  33 {
  34 public:
  35   explicit nsSVGImageListener(nsSVGImageFrame *aFrame);
  36
  37   NS_DECL_ISUPPORTS
  38   NS_DECL_IMGINOTIFICATIONOBSERVER
  39
  40   void SetFrame(nsSVGImageFrame *frame) { mFrame = frame; }
  41
  42 private:
  43   ~nsSVGImageListener() {}
  44
  45   nsSVGImageFrame *mFrame;
  46 };
  47
  48 typedef nsSVGPathGeometryFrame nsSVGImageFrameBase;
  49
  50 class nsSVGImageFrame : public nsSVGImageFrameBase,
  51                         public nsIReflowCallback
  52 {
  53   friend nsIFrame*
  54   NS_NewSVGImageFrame(nsIPresShell* aPresShell, nsStyleContext* aContext);
  55
  56 protected:
  57   explicit nsSVGImageFrame(nsStyleContext* aContext) : nsSVGImageFrameBase(aContext),
  58                                                        mReflowCallbackPosted(false) {}
  59   virtual ~nsSVGImageFrame();
  60
  61 public:
  62   NS_DECL_FRAMEARENA_HELPERS
  63
  64   // nsISVGChildFrame interface:
  65   virtual nsresult PaintSVG(nsRenderingContext *aContext,
  66                             const nsIntRect *aDirtyRect,
  67                             nsIFrame* aTransformRoot) MOZ_OVERRIDE;
  68   virtual nsIFrame* GetFrameForPoint(const gfxPoint& aPoint) MOZ_OVERRIDE;
  69   virtual void ReflowSVG() MOZ_OVERRIDE;
  70
  71   // nsSVGPathGeometryFrame methods:
  72   virtual uint16_t GetHitTestFlags() MOZ_OVERRIDE;
  73
  74   // nsIFrame interface:
  75   virtual nsresult  AttributeChanged(int32_t         aNameSpaceID,
  76                                      nsIAtom*        aAttribute,
  77                                      int32_t         aModType) MOZ_OVERRIDE;
  78   virtual void Init(nsIContent*       aContent,
  79                     nsContainerFrame* aParent,
  80                     nsIFrame*         aPrevInFlow) MOZ_OVERRIDE;
  81   virtual void DestroyFrom(nsIFrame* aDestructRoot) MOZ_OVERRIDE;
  82
  83   /**
  84    * Get the "type" of the frame
  85    *
  86    * @see nsGkAtoms::svgImageFrame
  87    */
  88   virtual nsIAtom* GetType() const MOZ_OVERRIDE;
  89
  90 #ifdef DEBUG_FRAME_DUMP
  91   virtual nsresult GetFrameName(nsAString& aResult) const MOZ_OVERRIDE
  92   {
  93     return MakeFrameName(NS_LITERAL_STRING("SVGImage"), aResult);
  94   }
  95 #endif
  96
  97   // nsIReflowCallback
  98   virtual bool ReflowFinished() MOZ_OVERRIDE;
  99   virtual void ReflowCallbackCanceled() MOZ_OVERRIDE;
 100
 101 private:
 102   gfx::Matrix GetRasterImageTransform(int32_t aNativeWidth,
 103                                       int32_t aNativeHeight,
 104                                       uint32_t aFor,
 105                                       nsIFrame* aTransformRoot = nullptr);
 106   gfx::Matrix GetVectorImageTransform(uint32_t aFor,
 107                                       nsIFrame* aTransformRoot = nullptr);
 108   bool TransformContextForPainting(gfxContext* aGfxContext,
 109                                    nsIFrame* aTransformRoot);
 110
 111   nsCOMPtr<imgINotificationObserver> mListener;
 112
 113   nsCOMPtr<imgIContainer> mImageContainer;
 114
 115   bool mReflowCallbackPosted;
 116
 117   friend class nsSVGImageListener;
 118 };
 119
 120 //----------------------------------------------------------------------
 121 // Implementation
 122
 123 nsIFrame*
 124 NS_NewSVGImageFrame(nsIPresShell* aPresShell, nsStyleContext* aContext)
 125 {
 126   return new (aPresShell) nsSVGImageFrame(aContext);
 127 }
 128
 129 NS_IMPL_FRAMEARENA_HELPERS(nsSVGImageFrame)
 130
 131 nsSVGImageFrame::~nsSVGImageFrame()
 132 {
 133   // set the frame to null so we don't send messages to a dead object.
 134   if (mListener) {
 135     nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mContent);
 136     if (imageLoader) {
 137       imageLoader->RemoveObserver(mListener);
 138     }
 139     reinterpret_cast<nsSVGImageListener*>(mListener.get())->SetFrame(nullptr);
 140   }
 141   mListener = nullptr;
 142 }
 143
 144 void
 145 nsSVGImageFrame::Init(nsIContent*       aContent,
 146                       nsContainerFrame* aParent,
 147                       nsIFrame*         aPrevInFlow)
 148 {
 149   NS_ASSERTION(aContent->IsSVG(nsGkAtoms::image),
 150                "Content is not an SVG image!");
 151
 152   nsSVGImageFrameBase::Init(aContent, aParent, aPrevInFlow);
 153
 154   mListener = new nsSVGImageListener(this);
 155   nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mContent);
 156   if (!imageLoader) {
 157     NS_RUNTIMEABORT("Why is this not an image loading content?");
 158   }
 159
 160   // We should have a PresContext now, so let's notify our image loader that
 161   // we need to register any image animations with the refresh driver.
 162   imageLoader->FrameCreated(this);
 163
 164   imageLoader->AddObserver(mListener);
 165 }
 166
 167 /* virtual */ void
 168 nsSVGImageFrame::DestroyFrom(nsIFrame* aDestructRoot)
 169 {
 170   if (mReflowCallbackPosted) {
 171     PresContext()->PresShell()->CancelReflowCallback(this);
 172     mReflowCallbackPosted = false;
 173   }
 174
 175   nsCOMPtr<nsIImageLoadingContent> imageLoader =
 176     do_QueryInterface(nsFrame::mContent);
 177
 178   if (imageLoader) {
 179     imageLoader->FrameDestroyed(this);
 180   }
 181
 182   nsFrame::DestroyFrom(aDestructRoot);
 183 }
 184
 185 //----------------------------------------------------------------------
 186 // nsIFrame methods:
 187
 188 nsresult
 189 nsSVGImageFrame::AttributeChanged(int32_t         aNameSpaceID,
 190                                   nsIAtom*        aAttribute,
 191                                   int32_t         aModType)
 192 {
 193   if (aNameSpaceID == kNameSpaceID_None) {
 194     if (aAttribute == nsGkAtoms::x ||
 195         aAttribute == nsGkAtoms::y ||
 196         aAttribute == nsGkAtoms::width ||
 197         aAttribute == nsGkAtoms::height) {
 198       nsSVGEffects::InvalidateRenderingObservers(this);
 199       nsSVGUtils::ScheduleReflowSVG(this);
 200       return NS_OK;
 201     }
 202     else if (aAttribute == nsGkAtoms::preserveAspectRatio) {
 203       // We don't paint the content of the image using display lists, therefore
 204       // we have to invalidate for this children-only transform changes since
 205       // there is no layer tree to notice that the transform changed and
 206       // recomposite.
 207       InvalidateFrame();
 208       return NS_OK;
 209     }
 210   }
 211   if (aNameSpaceID == kNameSpaceID_XLink &&
 212       aAttribute == nsGkAtoms::href) {
 213
 214     // Prevent setting image.src by exiting early
 215     if (nsContentUtils::IsImageSrcSetDisabled()) {
 216       return NS_OK;
 217     }
 218     SVGImageElement *element = static_cast<SVGImageElement*>(mContent);
 219
 220     if (element->mStringAttributes[SVGImageElement::HREF].IsExplicitlySet()) {
 221       element->LoadSVGImage(true, true);
 222     } else {
 223       element->CancelImageRequests(true);
 224     }
 225   }
 226
 227   return nsSVGImageFrameBase::AttributeChanged(aNameSpaceID,
 228                                                aAttribute, aModType);
 229 }
 230
 231 gfx::Matrix
 232 nsSVGImageFrame::GetRasterImageTransform(int32_t aNativeWidth,
 233                                          int32_t aNativeHeight,
 234                                          uint32_t aFor,
 235                                          nsIFrame* aTransformRoot)
 236 {
 237   float x, y, width, height;
 238   SVGImageElement *element = static_cast<SVGImageElement*>(mContent);
 239   element->GetAnimatedLengthValues(&x, &y, &width, &height, nullptr);
 240
 241   Matrix viewBoxTM =
 242     SVGContentUtils::GetViewBoxTransform(width, height,
 243                                          0, 0, aNativeWidth, aNativeHeight,
 244                                          element->mPreserveAspectRatio);
 245
 246   return viewBoxTM *
 247          gfx::Matrix::Translation(x, y) *
 248          gfx::ToMatrix(GetCanvasTM(aFor, aTransformRoot));
 249 }
 250
 251 gfx::Matrix
 252 nsSVGImageFrame::GetVectorImageTransform(uint32_t aFor,
 253                                          nsIFrame* aTransformRoot)
 254 {
 255   float x, y, width, height;
 256   SVGImageElement *element = static_cast<SVGImageElement*>(mContent);
 257   element->GetAnimatedLengthValues(&x, &y, &width, &height, nullptr);
 258
 259   // No viewBoxTM needed here -- our height/width overrides any concept of
 260   // "native size" that the SVG image has, and it will handle viewBox and
 261   // preserveAspectRatio on its own once we give it a region to draw into.
 262
 263   return gfx::Matrix::Translation(x, y) *
 264          gfx::ToMatrix(GetCanvasTM(aFor, aTransformRoot));
 265 }
 266
 267 bool
 268 nsSVGImageFrame::TransformContextForPainting(gfxContext* aGfxContext,
 269                                              nsIFrame* aTransformRoot)
 270 {
 271   gfx::Matrix imageTransform;
 272   if (mImageContainer->GetType() == imgIContainer::TYPE_VECTOR) {
 273     imageTransform = GetVectorImageTransform(FOR_PAINTING, aTransformRoot);
 274   } else {
 275     int32_t nativeWidth, nativeHeight;
 276     if (NS_FAILED(mImageContainer->GetWidth(&nativeWidth)) ||
 277         NS_FAILED(mImageContainer->GetHeight(&nativeHeight)) ||
 278         nativeWidth == 0 || nativeHeight == 0) {
 279       return false;
 280     }
 281     imageTransform =
 282       GetRasterImageTransform(nativeWidth, nativeHeight, FOR_PAINTING,
 283                               aTransformRoot);
 284
 285     // NOTE: We need to cancel out the effects of Full-Page-Zoom, or else
 286     // it'll get applied an extra time by DrawSingleUnscaledImage.
 287     nscoord appUnitsPerDevPx = PresContext()->AppUnitsPerDevPixel();
 288     gfxFloat pageZoomFactor =
 289       nsPresContext::AppUnitsToFloatCSSPixels(appUnitsPerDevPx);
 290     imageTransform.Scale(pageZoomFactor, pageZoomFactor);
 291   }
 292
 293   if (imageTransform.IsSingular()) {
 294     return false;
 295   }
 296
 297   aGfxContext->Multiply(ThebesMatrix(imageTransform));
 298   return true;
 299 }
 300
 301 //----------------------------------------------------------------------
 302 // nsISVGChildFrame methods:
 303 nsresult
 304 nsSVGImageFrame::PaintSVG(nsRenderingContext *aContext,
 305                           const nsIntRect *aDirtyRect,
 306                           nsIFrame* aTransformRoot)
 307 {
 308   nsresult rv = NS_OK;
 309
 310   if (!StyleVisibility()->IsVisible())
 311     return NS_OK;
 312
 313   float x, y, width, height;
 314   SVGImageElement *imgElem = static_cast<SVGImageElement*>(mContent);
 315   imgElem->GetAnimatedLengthValues(&x, &y, &width, &height, nullptr);
 316   NS_ASSERTION(width > 0 && height > 0,
 317                "Should only be painting things with valid width/height");
 318
 319   if (!mImageContainer) {
 320     nsCOMPtr<imgIRequest> currentRequest;
 321     nsCOMPtr<nsIImageLoadingContent> imageLoader = do_QueryInterface(mContent);
 322     if (imageLoader)
 323       imageLoader->GetRequest(nsIImageLoadingContent::CURRENT_REQUEST,
 324                               getter_AddRefs(currentRequest));
 325
 326     if (currentRequest)
 327       currentRequest->GetImage(getter_AddRefs(mImageContainer));
 328   }
 329
 330   if (mImageContainer) {
 331     gfxContext* ctx = aContext->ThebesContext();
 332     gfxContextAutoSaveRestore autoRestorer(ctx);
 333
 334     if (StyleDisplay()->IsScrollableOverflow()) {
 335       gfxRect clipRect = nsSVGUtils::GetClipRectForFrame(this, x, y,
 336                                                          width, height);
 337       nsSVGUtils::SetClipRect(ctx, GetCanvasTM(FOR_PAINTING, aTransformRoot),
 338                               clipRect);
 339     }
 340
 341     if (!TransformContextForPainting(ctx, aTransformRoot)) {
 342       return NS_ERROR_FAILURE;
 343     }
 344
 345     // fill-opacity doesn't affect <image>, so if we're allowed to
 346     // optimize group opacity, the opacity used for compositing the
 347     // image into the current canvas is just the group opacity.
 348     float opacity = 1.0f;
 349     if (nsSVGUtils::CanOptimizeOpacity(this)) {
 350       opacity = StyleDisplay()->mOpacity;
 351     }
 352
 353     if (opacity != 1.0f || StyleDisplay()->mMixBlendMode != NS_STYLE_BLEND_NORMAL) {
 354       ctx->PushGroup(gfxContentType::COLOR_ALPHA);
 355     }
 356
 357     nscoord appUnitsPerDevPx = PresContext()->AppUnitsPerDevPixel();
 358     nsRect dirtyRect; // only used if aDirtyRect is non-null
 359     if (aDirtyRect) {
 360       NS_ASSERTION(!NS_SVGDisplayListPaintingEnabled() ||
 361                    (mState & NS_FRAME_IS_NONDISPLAY),
 362                    "Display lists handle dirty rect intersection test");
 363       dirtyRect = aDirtyRect->ToAppUnits(appUnitsPerDevPx);
 364       // Adjust dirtyRect to match our local coordinate system.
 365       nsRect rootRect =
 366         nsSVGUtils::TransformFrameRectToOuterSVG(mRect,
 367                       GetCanvasTM(FOR_PAINTING), PresContext());
 368       dirtyRect.MoveBy(-rootRect.TopLeft());
 369     }
 370
 371     // XXXbholley - I don't think huge images in SVGs are common enough to
 372     // warrant worrying about the responsiveness impact of doing synchronous
 373     // decodes. The extra code complexity of determinining when we want to
 374     // force sync probably just isn't worth it, so always pass FLAG_SYNC_DECODE
 375     uint32_t drawFlags = imgIContainer::FLAG_SYNC_DECODE;
 376
 377     if (mImageContainer->GetType() == imgIContainer::TYPE_VECTOR) {
 378       // Package up the attributes of this image element which can override the
 379       // attributes of mImageContainer's internal SVG document.
 380       SVGImageContext context(nsIntSize(width, height),
 381                               Some(imgElem->mPreserveAspectRatio.GetAnimValue()));
 382
 383       nsRect destRect(0, 0,
 384                       appUnitsPerDevPx * width,
 385                       appUnitsPerDevPx * height);
 386
 387       // Note: Can't use DrawSingleUnscaledImage for the TYPE_VECTOR case.
 388       // That method needs our image to have a fixed native width & height,
 389       // and that's not always true for TYPE_VECTOR images.
 390       nsLayoutUtils::DrawSingleImage(
 391         aContext,
 392         PresContext(),
 393         mImageContainer,
 394         nsLayoutUtils::GetGraphicsFilterForFrame(this),
 395         destRect,
 396         aDirtyRect ? dirtyRect : destRect,
 397         &context,
 398         drawFlags);
 399     } else { // mImageContainer->GetType() == TYPE_RASTER
 400       nsLayoutUtils::DrawSingleUnscaledImage(
 401         aContext,
 402         PresContext(),
 403         mImageContainer,
 404         nsLayoutUtils::GetGraphicsFilterForFrame(this),
 405         nsPoint(0, 0),
 406         aDirtyRect ? &dirtyRect : nullptr,
 407         drawFlags);
 408     }
 409
 410     if (opacity != 1.0f || StyleDisplay()->mMixBlendMode != NS_STYLE_BLEND_NORMAL) {
 411       ctx->PopGroupToSource();
 412       ctx->SetOperator(gfxContext::OPERATOR_OVER);
 413       ctx->Paint(opacity);
 414     }
 415     // gfxContextAutoSaveRestore goes out of scope & cleans up our gfxContext
 416   }
 417
 418   return rv;
 419 }
 420
 421 nsIFrame*
 422 nsSVGImageFrame::GetFrameForPoint(const gfxPoint& aPoint)
 423 {
 424   Rect rect;
 425   SVGImageElement *element = static_cast<SVGImageElement*>(mContent);
 426   element->GetAnimatedLengthValues(&rect.x, &rect.y,
 427                                    &rect.width, &rect.height, nullptr);
 428
 429   if (!rect.Contains(ToPoint(aPoint))) {
 430     return nullptr;
 431   }
 432
 433   // Special case for raster images -- we only want to accept points that fall
 434   // in the underlying image's (scaled to fit) native bounds.  That region
 435   // doesn't necessarily map to our <image> element's [x,y,width,height] if the
 436   // raster image's aspect ratio is being preserved.  We have to look up the
 437   // native image size & our viewBox transform in order to filter out points
 438   // that fall outside that area.  (This special case doesn't apply to vector
 439   // images because they don't limit their drawing to explicit "native
 440   // bounds" -- they have an infinite canvas on which to place content.)
 441   if (StyleDisplay()->IsScrollableOverflow() && mImageContainer) {
 442     if (mImageContainer->GetType() == imgIContainer::TYPE_RASTER) {
 443       int32_t nativeWidth, nativeHeight;
 444       if (NS_FAILED(mImageContainer->GetWidth(&nativeWidth)) ||
 445           NS_FAILED(mImageContainer->GetHeight(&nativeHeight)) ||
 446           nativeWidth == 0 || nativeHeight == 0) {
 447         return nullptr;
 448       }
 449       Matrix viewBoxTM =
 450         SVGContentUtils::GetViewBoxTransform(rect.width, rect.height,
 451                                              0, 0, nativeWidth, nativeHeight,
 452                                              element->mPreserveAspectRatio);
 453       if (!nsSVGUtils::HitTestRect(viewBoxTM,
 454                                    0, 0, nativeWidth, nativeHeight,
 455                                    aPoint.x - rect.x, aPoint.y - rect.y)) {
 456         return nullptr;
 457       }
 458     }
 459   }
 460
 461   return this;
 462 }
 463
 464 nsIAtom *
 465 nsSVGImageFrame::GetType() const
 466 {
 467   return nsGkAtoms::svgImageFrame;
 468 }
 469
 470 //----------------------------------------------------------------------
 471 // nsSVGPathGeometryFrame methods:
 472
 473 // Lie about our fill/stroke so that covered region and hit detection work properly
 474
 475 void
 476 nsSVGImageFrame::ReflowSVG()
 477 {
 478   NS_ASSERTION(nsSVGUtils::OuterSVGIsCallingReflowSVG(this),
 479                "This call is probably a wasteful mistake");
 480
 481   NS_ABORT_IF_FALSE(!(GetStateBits() & NS_FRAME_IS_NONDISPLAY),
 482                     "ReflowSVG mechanism not designed for this");
 483
 484   if (!nsSVGUtils::NeedsReflowSVG(this)) {
 485     return;
 486   }
 487
 488   float x, y, width, height;
 489   SVGImageElement *element = static_cast<SVGImageElement*>(mContent);
 490   element->GetAnimatedLengthValues(&x, &y, &width, &height, nullptr);
 491
 492   Rect extent(x, y, width, height);
 493
 494   if (!extent.IsEmpty()) {
 495     mRect = nsLayoutUtils::RoundGfxRectToAppRect(extent,
 496               PresContext()->AppUnitsPerCSSPixel());
 497   } else {
 498     mRect.SetEmpty();
 499   }
 500
 501   if (mState & NS_FRAME_FIRST_REFLOW) {
 502     // Make sure we have our filter property (if any) before calling
 503     // FinishAndStoreOverflow (subsequent filter changes are handled off
 504     // nsChangeHint_UpdateEffects):
 505     nsSVGEffects::UpdateEffects(this);
 506
 507     if (!mReflowCallbackPosted) {
 508       nsIPresShell* shell = PresContext()->PresShell();
 509       mReflowCallbackPosted = true;
 510       shell->PostReflowCallback(this);
 511     }
 512   }
 513
 514   nsRect overflow = nsRect(nsPoint(0,0), mRect.Size());
 515   nsOverflowAreas overflowAreas(overflow, overflow);
 516   FinishAndStoreOverflow(overflowAreas, mRect.Size());
 517
 518   mState &= ~(NS_FRAME_FIRST_REFLOW | NS_FRAME_IS_DIRTY |
 519               NS_FRAME_HAS_DIRTY_CHILDREN);
 520
 521   // Invalidate, but only if this is not our first reflow (since if it is our
 522   // first reflow then we haven't had our first paint yet).
 523   if (!(GetParent()->GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
 524     InvalidateFrame();
 525   }
 526 }
 527
 528 bool
 529 nsSVGImageFrame::ReflowFinished()
 530 {
 531   mReflowCallbackPosted = false;
 532
 533   nsLayoutUtils::UpdateImageVisibilityForFrame(this);
 534
 535   return false;
 536 }
 537
 538 void
 539 nsSVGImageFrame::ReflowCallbackCanceled()
 540 {
 541   mReflowCallbackPosted = false;
 542 }
 543
 544 uint16_t
 545 nsSVGImageFrame::GetHitTestFlags()
 546 {
 547   uint16_t flags = 0;
 548
 549   switch(StyleVisibility()->mPointerEvents) {
 550     case NS_STYLE_POINTER_EVENTS_NONE:
 551       break;
 552     case NS_STYLE_POINTER_EVENTS_VISIBLEPAINTED:
 553     case NS_STYLE_POINTER_EVENTS_AUTO:
 554       if (StyleVisibility()->IsVisible()) {
 555         /* XXX: should check pixel transparency */
 556         flags |= SVG_HIT_TEST_FILL;
 557       }
 558       break;
 559     case NS_STYLE_POINTER_EVENTS_VISIBLEFILL:
 560     case NS_STYLE_POINTER_EVENTS_VISIBLESTROKE:
 561     case NS_STYLE_POINTER_EVENTS_VISIBLE:
 562       if (StyleVisibility()->IsVisible()) {
 563         flags |= SVG_HIT_TEST_FILL;
 564       }
 565       break;
 566     case NS_STYLE_POINTER_EVENTS_PAINTED:
 567       /* XXX: should check pixel transparency */
 568       flags |= SVG_HIT_TEST_FILL;
 569       break;
 570     case NS_STYLE_POINTER_EVENTS_FILL:
 571     case NS_STYLE_POINTER_EVENTS_STROKE:
 572     case NS_STYLE_POINTER_EVENTS_ALL:
 573       flags |= SVG_HIT_TEST_FILL;
 574       break;
 575     default:
 576       NS_ERROR("not reached");
 577       break;
 578   }
 579
 580   return flags;
 581 }
 582
 583 //----------------------------------------------------------------------
 584 // nsSVGImageListener implementation
 585
 586 NS_IMPL_ISUPPORTS(nsSVGImageListener, imgINotificationObserver)
 587
 588 nsSVGImageListener::nsSVGImageListener(nsSVGImageFrame *aFrame) :  mFrame(aFrame)
 589 {
 590 }
 591
 592 NS_IMETHODIMP
 593 nsSVGImageListener::Notify(imgIRequest *aRequest, int32_t aType, const nsIntRect* aData)
 594 {
 595   if (!mFrame)
 596     return NS_ERROR_FAILURE;
 597
 598   if (aType == imgINotificationObserver::LOAD_COMPLETE) {
 599     mFrame->InvalidateFrame();
 600     nsSVGEffects::InvalidateRenderingObservers(mFrame);
 601     nsSVGUtils::ScheduleReflowSVG(mFrame);
 602   }
 603
 604   if (aType == imgINotificationObserver::FRAME_UPDATE) {
 605     // No new dimensions, so we don't need to call
 606     // nsSVGUtils::InvalidateAndScheduleBoundsUpdate.
 607     nsSVGEffects::InvalidateRenderingObservers(mFrame);
 608     mFrame->InvalidateFrame();
 609   }
 610
 611   if (aType == imgINotificationObserver::SIZE_AVAILABLE) {
 612     // Called once the resource's dimensions have been obtained.
 613     aRequest->GetImage(getter_AddRefs(mFrame->mImageContainer));
 614     mFrame->InvalidateFrame();
 615     nsSVGEffects::InvalidateRenderingObservers(mFrame);
 616     nsSVGUtils::ScheduleReflowSVG(mFrame);
 617   }
 618
 619   return NS_OK;
 620 }
 621