Commit 56427184 authored by Andrew Osmond's avatar Andrew Osmond
Browse files

Bug 1711061 - Part 3. Add WebRenderImageProvider and implement for rasterized providers. r=tnikkel 

This provides the framework to allow ISurfaceProvider objects to
implement WebRenderImageProvider. It is straightforward for rasterized
providers (DecodedSurfaceProvider, and SimpleSurfaceProvider). Later
parts in this series will provide the necessary changes for blob
recordings and for animatedi images.

Differential Revision: https://phabricator.services.mozilla.com/D126597
parent 6a2ad86d

image/DecodedSurfaceProvider.cpp

+25 −0
Original line number Diff line number Diff line
@@ -6,11 +6,13 @@ 
#include "DecodedSurfaceProvider.h"



#include "mozilla/StaticPrefs_image.h"

#include "mozilla/layers/SharedSurfacesChild.h"

#include "nsProxyRelease.h"



#include "Decoder.h"



using namespace mozilla::gfx;

using namespace mozilla::layers;



namespace mozilla {

namespace image {
@@ -205,5 +207,28 @@ bool DecodedSurfaceProvider::ShouldPreferSyncRun() const { 
      StaticPrefs::image_mem_decode_bytes_at_a_time_AtStartup());

}



nsresult DecodedSurfaceProvider::UpdateKey(

    layers::RenderRootStateManager* aManager,

    wr::IpcResourceUpdateQueue& aResources, wr::ImageKey& aKey) {

  MOZ_ASSERT(mSurface);

  RefPtr<SourceSurface> surface = mSurface->GetSourceSurface();

  if (!surface) {

    return NS_ERROR_FAILURE;

  }



  return SharedSurfacesChild::Share(surface, aManager, aResources, aKey);

}



nsresult SimpleSurfaceProvider::UpdateKey(

    layers::RenderRootStateManager* aManager,

    wr::IpcResourceUpdateQueue& aResources, wr::ImageKey& aKey) {

  RefPtr<SourceSurface> surface = mSurface->GetSourceSurface();

  if (!surface) {

    return NS_ERROR_FAILURE;

  }



  return SharedSurfacesChild::Share(surface, aManager, aResources, aKey);

}



}  // namespace image

}  // namespace mozilla

image/DecodedSurfaceProvider.h

+9 −0
Original line number Diff line number Diff line
@@ -55,6 +55,15 @@ class DecodedSurfaceProvider final : public ISurfaceProvider, 
  // don't block layout or page load.

  TaskPriority Priority() const override { return TaskPriority::eLow; }



  //////////////////////////////////////////////////////////////////////////////

  // WebRenderImageProvider implementation.

  //////////////////////////////////////////////////////////////////////////////



 public:

  nsresult UpdateKey(layers::RenderRootStateManager* aManager,

                     wr::IpcResourceUpdateQueue& aResources,

                     wr::ImageKey& aKey) override;



 private:

  virtual ~DecodedSurfaceProvider();

image/ISurfaceProvider.h

+16 −11
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include "mozilla/NotNull.h"

#include "mozilla/TimeStamp.h"

#include "mozilla/gfx/2D.h"

#include "mozilla/image/WebRenderImageProvider.h"



#include "imgFrame.h"

#include "SurfaceCache.h"
@@ -31,7 +32,7 @@ class DrawableSurface; 
 * An interface for objects which can either store a surface or dynamically

 * generate one.

 */

class ISurfaceProvider {

class ISurfaceProvider : public WebRenderImageProvider {

 public:

  // Subclasses may or may not be XPCOM classes, so we just require that they

  // implement AddRef and Release.
@@ -45,8 +46,8 @@ class ISurfaceProvider { 
  /// entry in the surface cache.

  const SurfaceKey& GetSurfaceKey() const { return mSurfaceKey; }



  /// @return a (potentially lazily computed) drawable reference to a surface.

  virtual DrawableSurface Surface();

  /// @return a drawable reference to a surface.

  DrawableSurface Surface();



  /// @return true if DrawableRef() will return a completely decoded surface.

  virtual bool IsFinished() const = 0;
@@ -92,7 +93,8 @@ class ISurfaceProvider { 
 protected:

  ISurfaceProvider(const ImageKey aImageKey, const SurfaceKey& aSurfaceKey,

                   AvailabilityState aAvailability)

      : mImageKey(aImageKey),

      : WebRenderImageProvider(aImageKey),

        mImageKey(aImageKey),

        mSurfaceKey(aSurfaceKey),

        mAvailability(aAvailability) {

    MOZ_ASSERT(aImageKey, "Must have a valid image key");
@@ -145,10 +147,6 @@ class MOZ_STACK_CLASS DrawableSurface final { 
 public:

  DrawableSurface() : mHaveSurface(false) {}



  explicit DrawableSurface(DrawableFrameRef&& aDrawableRef)

      : mDrawableRef(std::move(aDrawableRef)),

        mHaveSurface(bool(mDrawableRef)) {}



  explicit DrawableSurface(NotNull<ISurfaceProvider*> aProvider)

      : mProvider(aProvider), mHaveSurface(true) {}
@@ -232,6 +230,10 @@ class MOZ_STACK_CLASS DrawableSurface final { 
    return mProvider->IsFullyDecoded();

  }



  void TakeProvider(WebRenderImageProvider** aOutProvider) {

    mProvider.forget(aOutProvider);

  }



  explicit operator bool() const { return mHaveSurface; }

  imgFrame* operator->() { return DrawableRef().get(); }
@@ -261,10 +263,9 @@ class MOZ_STACK_CLASS DrawableSurface final { 
};



// Surface() is implemented here so that DrawableSurface's definition is

// visible. This default implementation eagerly obtains a DrawableFrameRef for

// the first frame and is intended for static ISurfaceProviders.

// visible.

inline DrawableSurface ISurfaceProvider::Surface() {

  return DrawableSurface(DrawableRef(/* aFrame = */ 0));

  return DrawableSurface(WrapNotNull(this));

}



/**
@@ -289,6 +290,10 @@ class SimpleSurfaceProvider final : public ISurfaceProvider { 
    return size.width * size.height * mSurface->GetBytesPerPixel();

  }



  nsresult UpdateKey(layers::RenderRootStateManager* aManager,

                     wr::IpcResourceUpdateQueue& aResources,

                     wr::ImageKey& aKey) override;



 protected:

  DrawableFrameRef DrawableRef(size_t aFrame) override {

    MOZ_ASSERT(aFrame == 0,

image/Image.cpp

+13 −1
Original line number Diff line number Diff line
@@ -7,9 +7,11 @@ 


#include "imgRequest.h"

#include "Layers.h"  // for LayerManager

#include "WebRenderImageProvider.h"

#include "nsIObserverService.h"

#include "nsRefreshDriver.h"

#include "nsContentUtils.h"

#include "mozilla/Atomics.h"

#include "mozilla/gfx/Point.h"

#include "mozilla/gfx/Rect.h"

#include "mozilla/gfx/SourceSurfaceRawData.h"
@@ -23,6 +25,15 @@ 
namespace mozilla {

namespace image {



WebRenderImageProvider::WebRenderImageProvider(const ImageResource* aImage)

    : mProviderId(aImage->GetImageProviderId()) {}



/* static */ ImageProviderId WebRenderImageProvider::AllocateProviderId() {

  // Callable on all threads.

  static Atomic<ImageProviderId> sProviderId(0u);

  return ++sProviderId;

}



///////////////////////////////////////////////////////////////////////////////

// Memory Reporting

///////////////////////////////////////////////////////////////////////////////
@@ -421,7 +432,8 @@ ImageResource::ImageResource(nsIURI* aURI) 
      mAnimating(false),

      mError(false),

      mImageProducerID(layers::ImageContainer::AllocateProducerID()),

      mLastFrameID(0) {}

      mLastFrameID(0),

      mProviderId(WebRenderImageProvider::AllocateProviderId()) {}



ImageResource::~ImageResource() {

  // Ask our ProgressTracker to drop its weak reference to us.

image/Image.h

+4 −0
Original line number Diff line number Diff line
@@ -22,6 +22,7 @@ 
#include "nsStringFwd.h"

#include "ProgressTracker.h"

#include "SurfaceCache.h"

#include "WebRenderImageProvider.h"



class imgRequest;

class nsIRequest;
@@ -325,6 +326,8 @@ class ImageResource : public Image { 
  void CollectSizeOfSurfaces(nsTArray<SurfaceMemoryCounter>& aCounters,

                             MallocSizeOf aMallocSizeOf) const override;



  ImageProviderId GetImageProviderId() const { return mProviderId; }



 protected:

  explicit ImageResource(nsIURI* aURI);

  ~ImageResource();
@@ -501,6 +504,7 @@ class ImageResource : public Image { 
  AutoTArray<ImageContainerEntry, 1> mImageContainers;

  layers::ImageContainer::ProducerID mImageProducerID;

  layers::ImageContainer::FrameID mLastFrameID;

  ImageProviderId mProviderId;

};



}  // namespace image