The Tor Browser: image/src/ClippedImage.cpp@6474c204b198 (annotated)

image/src/ClippedImage.cpp@6474c204b198 (annotated)

image/src/ClippedImage.cpp

Wed, 31 Dec 2014 06:09:35 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Wed, 31 Dec 2014 06:09:35 +0100
changeset 0: 6474c204b198
permissions: -rw-r--r--

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

 /* -*- 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/. */
 #include "gfxDrawable.h"
 #include "gfxPlatform.h"
 #include "gfxUtils.h"
 #include "mozilla/gfx/2D.h"
 #include "mozilla/RefPtr.h"
 #include "ClippedImage.h"
 #include "Orientation.h"
 #include "SVGImageContext.h"
 using namespace mozilla;
 using namespace mozilla::gfx;
 using mozilla::layers::LayerManager;
 using mozilla::layers::ImageContainer;
 namespace mozilla {
 namespace image {
 class ClippedImageCachedSurface
 {
 public:
   ClippedImageCachedSurface(TemporaryRef<SourceSurface> aSurface,
                             const nsIntSize& aViewportSize,
                             const SVGImageContext* aSVGContext,
                             float aFrame,
                             uint32_t aFlags)
     : mSurface(aSurface)
     , mViewportSize(aViewportSize)
     , mFrame(aFrame)
     , mFlags(aFlags)
   {
     MOZ_ASSERT(mSurface, "Must have a valid surface");
     if (aSVGContext) {
       mSVGContext.construct(*aSVGContext);
     }
   }
   bool Matches(const nsIntSize& aViewportSize,
                const SVGImageContext* aSVGContext,
                float aFrame,
                uint32_t aFlags)
   {
     bool matchesSVGContext = (!aSVGContext && mSVGContext.empty()) ||
                              *aSVGContext == mSVGContext.ref();
     return mViewportSize == aViewportSize &&
            matchesSVGContext &&
            mFrame == aFrame &&
            mFlags == aFlags;
   }
   TemporaryRef<SourceSurface> Surface() {
     return mSurface;
   }
 private:
   RefPtr<SourceSurface>              mSurface;
   const nsIntSize                    mViewportSize;
   Maybe<SVGImageContext>             mSVGContext;
   const float                        mFrame;
   const uint32_t                     mFlags;
 };
 class DrawSingleTileCallback : public gfxDrawingCallback
 {
 public:
   DrawSingleTileCallback(ClippedImage* aImage,
                          const nsIntRect& aClip,
                          const nsIntSize& aViewportSize,
                          const SVGImageContext* aSVGContext,
                          uint32_t aWhichFrame,
                          uint32_t aFlags)
     : mImage(aImage)
     , mClip(aClip)
     , mViewportSize(aViewportSize)
     , mSVGContext(aSVGContext)
     , mWhichFrame(aWhichFrame)
     , mFlags(aFlags)
   {
     MOZ_ASSERT(mImage, "Must have an image to clip");
   }
   virtual bool operator()(gfxContext* aContext,
                           const gfxRect& aFillRect,
                           const GraphicsFilter& aFilter,
                           const gfxMatrix& aTransform)
   {
     // Draw the image. |gfxCallbackDrawable| always calls this function with
     // arguments that guarantee we never tile.
     mImage->DrawSingleTile(aContext, aFilter, aTransform, aFillRect, mClip,
                            mViewportSize, mSVGContext, mWhichFrame, mFlags);
     return true;
   }
 private:
   nsRefPtr<ClippedImage> mImage;
   const nsIntRect        mClip;
   const nsIntSize        mViewportSize;
   const SVGImageContext* mSVGContext;
   const uint32_t         mWhichFrame;
   const uint32_t         mFlags;
 };
 ClippedImage::ClippedImage(Image* aImage,
                            nsIntRect aClip)
   : ImageWrapper(aImage)
   , mClip(aClip)
 {
   MOZ_ASSERT(aImage != nullptr, "ClippedImage requires an existing Image");
 }
 ClippedImage::~ClippedImage()
 { }
 bool
 ClippedImage::ShouldClip()
 {
   // We need to evaluate the clipping region against the image's width and height
   // once they're available to determine if it's valid and whether we actually
   // need to do any work. We may fail if the image's width and height aren't
   // available yet, in which case we'll try again later.
   if (mShouldClip.empty()) {
     int32_t width, height;
     nsRefPtr<imgStatusTracker> innerImageStatusTracker =
       InnerImage()->GetStatusTracker();
     if (InnerImage()->HasError()) {
       // If there's a problem with the inner image we'll let it handle everything.
       mShouldClip.construct(false);
     } else if (NS_SUCCEEDED(InnerImage()->GetWidth(&width)) && width > 0 &&
                NS_SUCCEEDED(InnerImage()->GetHeight(&height)) && height > 0) {
       // Clamp the clipping region to the size of the underlying image.
       mClip = mClip.Intersect(nsIntRect(0, 0, width, height));
       // If the clipping region is the same size as the underlying image we
       // don't have to do anything.
       mShouldClip.construct(!mClip.IsEqualInterior(nsIntRect(0, 0, width, height)));
     } else if (innerImageStatusTracker &&
                innerImageStatusTracker->IsLoading()) {
       // The image just hasn't finished loading yet. We don't yet know whether
       // clipping with be needed or not for now. Just return without memoizing
       // anything.
       return false;
     } else {
       // We have a fully loaded image without a clearly defined width and
       // height. This can happen with SVG images.
       mShouldClip.construct(false);
     }
   }
   MOZ_ASSERT(!mShouldClip.empty(), "Should have computed a result");
   return mShouldClip.ref();
 }
 NS_IMPL_ISUPPORTS(ClippedImage, imgIContainer)
 nsIntRect
 ClippedImage::FrameRect(uint32_t aWhichFrame)
 {
   if (!ShouldClip()) {
     return InnerImage()->FrameRect(aWhichFrame);
   }
   return nsIntRect(0, 0, mClip.width, mClip.height);
 }
 NS_IMETHODIMP
 ClippedImage::GetWidth(int32_t* aWidth)
 {
   if (!ShouldClip()) {
     return InnerImage()->GetWidth(aWidth);
   }
   *aWidth = mClip.width;
   return NS_OK;
 }
 NS_IMETHODIMP
 ClippedImage::GetHeight(int32_t* aHeight)
 {
   if (!ShouldClip()) {
     return InnerImage()->GetHeight(aHeight);
   }
   *aHeight = mClip.height;
   return NS_OK;
 }
 NS_IMETHODIMP
 ClippedImage::GetIntrinsicSize(nsSize* aSize)
 {
   if (!ShouldClip()) {
     return InnerImage()->GetIntrinsicSize(aSize);
   }
   *aSize = nsSize(mClip.width, mClip.height);
   return NS_OK;
 }
 NS_IMETHODIMP
 ClippedImage::GetIntrinsicRatio(nsSize* aRatio)
 {
   if (!ShouldClip()) {
     return InnerImage()->GetIntrinsicRatio(aRatio);
   }
   *aRatio = nsSize(mClip.width, mClip.height);
   return NS_OK;
 }
 NS_IMETHODIMP_(TemporaryRef<SourceSurface>)
 ClippedImage::GetFrame(uint32_t aWhichFrame,
                        uint32_t aFlags)
 {
   return GetFrameInternal(mClip.Size(), nullptr, aWhichFrame, aFlags);
 }
 TemporaryRef<SourceSurface>
 ClippedImage::GetFrameInternal(const nsIntSize& aViewportSize,
                                const SVGImageContext* aSVGContext,
                                uint32_t aWhichFrame,
                                uint32_t aFlags)
 {
   if (!ShouldClip()) {
     return InnerImage()->GetFrame(aWhichFrame, aFlags);
   }
   float frameToDraw = InnerImage()->GetFrameIndex(aWhichFrame);
   if (!mCachedSurface || !mCachedSurface->Matches(aViewportSize,
                                                   aSVGContext,
                                                   frameToDraw,
                                                   aFlags)) {
     // Create a surface to draw into.
     RefPtr<DrawTarget> target = gfxPlatform::GetPlatform()->
       CreateOffscreenContentDrawTarget(IntSize(mClip.width, mClip.height),
                                        SurfaceFormat::B8G8R8A8);
     nsRefPtr<gfxContext> ctx = new gfxContext(target);
     // Create our callback.
     nsRefPtr<gfxDrawingCallback> drawTileCallback =
       new DrawSingleTileCallback(this, mClip, aViewportSize, aSVGContext, aWhichFrame, aFlags);
     nsRefPtr<gfxDrawable> drawable =
       new gfxCallbackDrawable(drawTileCallback, mClip.Size());
     // Actually draw. The callback will end up invoking DrawSingleTile.
     gfxRect imageRect(0, 0, mClip.width, mClip.height);
     gfxUtils::DrawPixelSnapped(ctx, drawable, gfxMatrix(),
                                imageRect, imageRect, imageRect, imageRect,
                                gfxImageFormat::ARGB32,
                                GraphicsFilter::FILTER_FAST);
     // Cache the resulting surface.
     mCachedSurface = new ClippedImageCachedSurface(target->Snapshot(),
                                                    aViewportSize,
                                                    aSVGContext,
                                                    frameToDraw,
                                                    aFlags);
   }
   MOZ_ASSERT(mCachedSurface, "Should have a cached surface now");
   return mCachedSurface->Surface();
 }
 NS_IMETHODIMP
 ClippedImage::GetImageContainer(LayerManager* aManager, ImageContainer** _retval)
 {
   // XXX(seth): We currently don't have a way of clipping the result of
   // GetImageContainer. We work around this by always returning null, but if it
   // ever turns out that ClippedImage is widely used on codepaths that can
   // actually benefit from GetImageContainer, it would be a good idea to fix
   // that method for performance reasons.
   if (!ShouldClip()) {
     return InnerImage()->GetImageContainer(aManager, _retval);
   }
   *_retval = nullptr;
   return NS_OK;
 }
 bool
 ClippedImage::MustCreateSurface(gfxContext* aContext,
                                 const gfxMatrix& aTransform,
                                 const gfxRect& aSourceRect,
                                 const nsIntRect& aSubimage,
                                 const uint32_t aFlags) const
 {
   gfxRect gfxImageRect(0, 0, mClip.width, mClip.height);
   nsIntRect intImageRect(0, 0, mClip.width, mClip.height);
   bool willTile = !gfxImageRect.Contains(aSourceRect) &&
                   !(aFlags & imgIContainer::FLAG_CLAMP);
   bool willResample = (aContext->CurrentMatrix().HasNonIntegerTranslation() ||
                        aTransform.HasNonIntegerTranslation()) &&
                       (willTile || !aSubimage.Contains(intImageRect));
   return willTile || willResample;
 }
 NS_IMETHODIMP
 ClippedImage::Draw(gfxContext* aContext,
                    GraphicsFilter aFilter,
                    const gfxMatrix& aUserSpaceToImageSpace,
                    const gfxRect& aFill,
                    const nsIntRect& aSubimage,
                    const nsIntSize& aViewportSize,
                    const SVGImageContext* aSVGContext,
                    uint32_t aWhichFrame,
                    uint32_t aFlags)
 {
   if (!ShouldClip()) {
     return InnerImage()->Draw(aContext, aFilter, aUserSpaceToImageSpace,
                               aFill, aSubimage, aViewportSize, aSVGContext,
                               aWhichFrame, aFlags);
   }
   // Check for tiling. If we need to tile then we need to create a
   // gfxCallbackDrawable to handle drawing for us.
   gfxRect sourceRect = aUserSpaceToImageSpace.Transform(aFill);
   if (MustCreateSurface(aContext, aUserSpaceToImageSpace, sourceRect, aSubimage, aFlags)) {
     // Create a temporary surface containing a single tile of this image.
     // GetFrame will call DrawSingleTile internally.
     RefPtr<SourceSurface> surface =
       GetFrameInternal(aViewportSize, aSVGContext, aWhichFrame, aFlags);
     NS_ENSURE_TRUE(surface, NS_ERROR_FAILURE);
     // Create a drawable from that surface.
     nsRefPtr<gfxSurfaceDrawable> drawable =
       new gfxSurfaceDrawable(surface, gfxIntSize(mClip.width, mClip.height));
     // Draw.
     gfxRect imageRect(0, 0, mClip.width, mClip.height);
     gfxRect subimage(aSubimage.x, aSubimage.y, aSubimage.width, aSubimage.height);
     gfxUtils::DrawPixelSnapped(aContext, drawable, aUserSpaceToImageSpace,
                                subimage, sourceRect, imageRect, aFill,
                                gfxImageFormat::ARGB32, aFilter);
     return NS_OK;
   }
   // Determine the appropriate subimage for the inner image.
   nsIntRect innerSubimage(aSubimage);
   innerSubimage.MoveBy(mClip.x, mClip.y);
   innerSubimage.Intersect(mClip);
   return DrawSingleTile(aContext, aFilter, aUserSpaceToImageSpace, aFill, innerSubimage,
                         aViewportSize, aSVGContext, aWhichFrame, aFlags);
 }
 gfxFloat
 ClippedImage::ClampFactor(const gfxFloat aToClamp, const int aReference) const
 {
   return aToClamp > aReference ? aReference / aToClamp
                                : 1.0;
 }
 nsresult
 ClippedImage::DrawSingleTile(gfxContext* aContext,
                              GraphicsFilter aFilter,
                              const gfxMatrix& aUserSpaceToImageSpace,
                              const gfxRect& aFill,
                              const nsIntRect& aSubimage,
                              const nsIntSize& aViewportSize,
                              const SVGImageContext* aSVGContext,
                              uint32_t aWhichFrame,
                              uint32_t aFlags)
 {
   MOZ_ASSERT(!MustCreateSurface(aContext, aUserSpaceToImageSpace,
                                 aUserSpaceToImageSpace.Transform(aFill),
                                 aSubimage - nsIntPoint(mClip.x, mClip.y), aFlags),
              "DrawSingleTile shouldn't need to create a surface");
   // Make the viewport reflect the original image's size.
   nsIntSize viewportSize(aViewportSize);
   int32_t imgWidth, imgHeight;
   if (NS_SUCCEEDED(InnerImage()->GetWidth(&imgWidth)) &&
       NS_SUCCEEDED(InnerImage()->GetHeight(&imgHeight))) {
     viewportSize = nsIntSize(imgWidth, imgHeight);
   } else {
     MOZ_ASSERT(false, "If ShouldClip() led us to draw then we should never get here");
   }
   // Add a translation to the transform to reflect the clipping region.
   gfxMatrix transform(aUserSpaceToImageSpace);
   transform.Multiply(gfxMatrix().Translate(gfxPoint(mClip.x, mClip.y)));
   // "Clamp the source rectangle" to the clipping region's width and height.
   // Really, this means modifying the transform to get the results we want.
   gfxRect sourceRect = transform.Transform(aFill);
   if (sourceRect.width > mClip.width || sourceRect.height > mClip.height) {
     gfxMatrix clampSource;
     clampSource.Translate(gfxPoint(sourceRect.x, sourceRect.y));
     clampSource.Scale(ClampFactor(sourceRect.width, mClip.width),
                       ClampFactor(sourceRect.height, mClip.height));
     clampSource.Translate(gfxPoint(-sourceRect.x, -sourceRect.y));
     transform.Multiply(clampSource);
   }
   return InnerImage()->Draw(aContext, aFilter, transform, aFill, aSubimage,
                             viewportSize, aSVGContext, aWhichFrame, aFlags);
 }
 NS_IMETHODIMP
 ClippedImage::RequestDiscard()
 {
   // We're very aggressive about discarding.
   mCachedSurface = nullptr;
   return InnerImage()->RequestDiscard();
 }
 NS_IMETHODIMP_(Orientation)
 ClippedImage::GetOrientation()
 {
   // XXX(seth): This should not actually be here; this is just to work around a
   // what appears to be a bug in MSVC's linker.
   return InnerImage()->GetOrientation();
 }
 } // namespace image
 } // namespace mozilla

The Tor Browser / annotate

image/src/ClippedImage.cpp@6474c204b198 (annotated)

image/src/ClippedImage.cpp