flutter::testing::EmbedderTestCompositorGL Class Reference

#include <embedder_test_compositor_gl.h>

Inheritance diagram for flutter::testing::EmbedderTestCompositorGL:

Public Member Functions
	EmbedderTestCompositorGL (SkISize surface_size, sk_sp< GrDirectContext > context)
	~EmbedderTestCompositorGL () override
Public Member Functions inherited from flutter::testing::EmbedderTestCompositor
	EmbedderTestCompositor (SkISize surface_size, sk_sp< GrDirectContext > context)
virtual	~EmbedderTestCompositor ()
void	SetBackingStoreProducer (std::unique_ptr< EmbedderTestBackingStoreProducer > backingstore_producer)
bool	CreateBackingStore (const FlutterBackingStoreConfig *config, FlutterBackingStore *backing_store_out)
bool	CollectBackingStore (const FlutterBackingStore *backing_store)
bool	Present (FlutterViewId view_id, const FlutterLayer **layers, size_t layers_count)
void	SetPlatformViewRendererCallback (const PlatformViewRendererCallback &callback)
void	SetNextPresentCallback (const PresentCallback &next_present_callback)
	Allows tests to install a callback to notify them when the entire render tree has been finalized so they can run their assertions.
void	SetPresentCallback (const PresentCallback &present_callback, bool one_shot)
void	SetNextSceneCallback (const NextSceneCallback &next_scene_callback)
sk_sp< SkImage >	GetLastComposition ()
size_t	GetPendingBackingStoresCount () const
size_t	GetBackingStoresCreatedCount () const
size_t	GetBackingStoresCollectedCount () const
void	AddOnCreateRenderTargetCallback (const fml::closure &callback)
void	AddOnCollectRenderTargetCallback (const fml::closure &callback)
void	AddOnPresentCallback (const fml::closure &callback)
sk_sp< GrDirectContext >	GetGrContext ()

Private Member Functions
bool	UpdateOffscrenComposition (const FlutterLayer **layers, size_t layers_count) override

Additional Inherited Members
Public Types inherited from flutter::testing::EmbedderTestCompositor
using	PlatformViewRendererCallback = std::function< sk_sp< SkImage >(const FlutterLayer &layer, GrDirectContext *context)>
using	PresentCallback = std::function< void(FlutterViewId view_id, const FlutterLayer **layers, size_t layers_count)>
using	NextSceneCallback = std::function< void(sk_sp< SkImage > image)>
Protected Member Functions inherited from flutter::testing::EmbedderTestCompositor
	FML_DISALLOW_COPY_AND_ASSIGN (EmbedderTestCompositor)
Protected Attributes inherited from flutter::testing::EmbedderTestCompositor
std::unique_ptr< EmbedderTestBackingStoreProducer >	backingstore_producer_
const SkISize	surface_size_
sk_sp< GrDirectContext >	context_
PlatformViewRendererCallback	platform_view_renderer_callback_
bool	present_callback_is_one_shot_ = false
PresentCallback	present_callback_
NextSceneCallback	next_scene_callback_
sk_sp< SkImage >	last_composition_
size_t	backing_stores_created_ = 0
size_t	backing_stores_collected_ = 0
std::vector< fml::closure >	on_create_render_target_callbacks_
std::vector< fml::closure >	on_collect_render_target_callbacks_
std::vector< fml::closure >	on_present_callbacks_

Detailed Description

Definition at line 15 of file embedder_test_compositor_gl.h.

Constructor & Destructor Documentation

EmbedderTestCompositorGL()

flutter::testing::EmbedderTestCompositorGL::EmbedderTestCompositorGL	(	SkISize	surface_size,
		sk_sp< GrDirectContext >	context
	)

Definition at line 17 of file embedder_test_compositor_gl.cc.

    : EmbedderTestCompositor(surface_size, std::move(context)) {}

~EmbedderTestCompositorGL()

flutter::testing::EmbedderTestCompositorGL::~EmbedderTestCompositorGL ( )

overridedefault

Member Function Documentation

UpdateOffscrenComposition()

bool flutter::testing::EmbedderTestCompositorGL::UpdateOffscrenComposition ( const FlutterLayer **  layers, size_t  layers_count  )

overrideprivatevirtual

Implements flutter::testing::EmbedderTestCompositor.

Definition at line 24 of file embedder_test_compositor_gl.cc.

                         {
  last_composition_ = nullptr;
 
  const auto image_info = SkImageInfo::MakeN32Premul(surface_size_);
 
  auto surface =
      SkSurfaces::RenderTarget(context_.get(),            // context
                               skgpu::Budgeted::kNo,      // budgeted
                               image_info,                // image info
                               1,                         // sample count
                               kTopLeft_GrSurfaceOrigin,  // surface origin
                               nullptr,                   // surface properties
                               false                      // create mipmaps
      );
 
  if (!surface) {
    FML_LOG(ERROR) << "Could not update the off-screen composition.";
    return false;
  }
 
  auto canvas = surface->getCanvas();
 
  // This has to be transparent because we are going to be compositing this
  // sub-hierarchy onto the on-screen surface.
  canvas->clear(SK_ColorTRANSPARENT);
 
  for (size_t i = 0; i < layers_count; ++i) {
    const auto* layer = layers[i];
 
    sk_sp<SkImage> platform_rendered_contents;
 
    sk_sp<SkImage> layer_image;
    SkIPoint canvas_offset = SkIPoint::Make(0, 0);
 
    switch (layer->type) {
      case kFlutterLayerContentTypeBackingStore:
        layer_image =
            reinterpret_cast<SkSurface*>(layer->backing_store->user_data)
                ->makeImageSnapshot();
 
        break;
      case kFlutterLayerContentTypePlatformView:
        layer_image =
            platform_view_renderer_callback_
                ? platform_view_renderer_callback_(*layer, context_.get())
                : nullptr;
        canvas_offset = SkIPoint::Make(layer->offset.x, layer->offset.y);
        break;
    };
 
    // If the layer is not a platform view but the engine did not specify an
    // image for the backing store, it is an error.
    if (!layer_image && layer->type != kFlutterLayerContentTypePlatformView) {
      FML_LOG(ERROR) << "Could not snapshot layer in test compositor: "
                     << *layer;
      return false;
    }
 
    // The test could have just specified no contents to be rendered in place of
    // a platform view. This is not an error.
    if (layer_image) {
      // The image rendered by Flutter already has the correct offset and
      // transformation applied. The layers offset is meant for the platform.
      canvas->drawImage(layer_image.get(), canvas_offset.x(),
                        canvas_offset.y());
    }
  }
 
  last_composition_ = surface->makeImageSnapshot();
 
  if (!last_composition_) {
    FML_LOG(ERROR) << "Could not update the contents of the sub-composition.";
    return false;
  }
 
  if (next_scene_callback_) {
    auto last_composition_snapshot = last_composition_->makeRasterImage();
    FML_CHECK(last_composition_snapshot);
    auto callback = next_scene_callback_;
    next_scene_callback_ = nullptr;
    callback(std::move(last_composition_snapshot));
  }
 
  return true;
}

---

The documentation for this class was generated from the following files:

• shell/platform/embedder/tests/embedder_test_compositor_gl.h
• shell/platform/embedder/tests/embedder_test_compositor_gl.cc