#include <embedder_test_compositor_vulkan.h>

Inheritance diagram for flutter::testing::EmbedderTestCompositorVulkan:

Public Member Functions
	EmbedderTestCompositorVulkan (SkISize surface_size, sk_sp< GrDirectContext > context)

	~EmbedderTestCompositorVulkan () 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_vulkan.h.

Constructor & Destructor Documentation

◆ EmbedderTestCompositorVulkan()

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

Definition at line 18 of file embedder_test_compositor_vulkan.cc.

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

flutter::testing::EmbedderTestCompositor::EmbedderTestCompositor

EmbedderTestCompositor(SkISize surface_size, sk_sp< GrDirectContext > context)

Definition embedder_test_compositor.cc:16

◆ ~EmbedderTestCompositorVulkan()

flutter::testing::EmbedderTestCompositorVulkan::~EmbedderTestCompositorVulkan ( )

overridedefault

Member Function Documentation

◆ UpdateOffscrenComposition()

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

overrideprivatevirtual

Implements flutter::testing::EmbedderTestCompositor.

Definition at line 25 of file embedder_test_compositor_vulkan.cc.

                         {
  last_composition_ = nullptr;
 
  const auto image_info = SkImageInfo::MakeN32Premul(surface_size_);
 
  sk_sp<SkSurface> 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<EmbedderTestBackingStoreProducer::UserData*>(
                layer->backing_store->user_data)
                ->surface->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_vulkan.h
shell/platform/embedder/tests/embedder_test_compositor_vulkan.cc

Public Member Functions