firka/flutter
firka/flutter
4
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Move renderer config to EmbedderTestContext (flutter/engine#56699)

Browse Source 
Moves all backend-specific renderer configuration out of `EmbedderConfigBuilder` and into the backend-specific subclasses of `EmbedderTestContext`. `EmbedderTestContext` is already backend-specific and as of recent patches, also houses compositor configuration, making it the natural home of this code.

As a result, we no longer need backend-specific methods such as `SetSoftwareRendererConfig`, `SetMetalRendererConfig`, `SetOpenGLRendererConfig`, `SetVulkanRendererConfig`. Nor do we need manual backend initialisation in `EmbedderConfigBuilder`. Nor does that initialisation any longer require relying on internal backend-specific code within `EmbedderTestContext`, since we now do that initialisation in the `EmbedderTestContext` constructor.

Since the bulk of the work previously done by this method now occurs in the `EmbedderTestContext` constructor, the only work remaining in these methods is surface creation. Further, since this is all now implemented in backend-specific `EmbedderTestContext` subclasses, they have all been renamed to a single method: `SetSurface`.

Previously, all of these methods took a surface_size parameter, with two exceptions:
* `SetVulkanRendererConfig` also took an optional `FlutterVulkanInstanceProcAddressCallback` parameter. This has been extracted to a separate method `SetVulkanInstanceProcAddressCallback` on `EmbedderTestContextVulkan`.
* `SetSoftwareRendererConfig` defaulted the parameter to a size of (1, 1). For consistency, this is no longer defaulted, and all call sites have been updated, consistent with other backends.

Lastly, one nice benefit is that because the render config is initialised in the `EmbedderTestContext` constructor, there's no longer a requirement to call `Set*RendererConfig` prior modifying any specific properties on the config, nor is it problematic to call the (replacement) `SetSurface` method after modifying the config. Where the renderer config was being customised in embedder unit tests, I've pushed that customisation up to the top of the test where the rest of the test context is configured.

This eliminates nearly all remaining `#ifdef SHELL_ENABLE_$BACKEND` blocks in the EmbedderTest infrastructure.

Issue: https://github.com/flutter/flutter/issues/158998

[C++, Objective-C, Java style guides]: https://github.com/flutter/engine/blob/main/CONTRIBUTING.md#style
This commit is contained in:
Chris Bracken 2024-11-19 08:33:22 -08:00 committed by GitHub
parent 235cf5e17f
commit 4e8108b3d2
21 changed files with 685 additions and 907 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
engine/src/flutter/shell/platform/embedder/BUILD.gn
View File

@ -315,7 +315,6 @@ if (enable_unittests) {
if (test_enable_gl) {
sources += [
"tests/embedder_config_builder_gl.cc",
"tests/embedder_test_backingstore_producer_gl.cc",
"tests/embedder_test_backingstore_producer_gl.h",
"tests/embedder_test_compositor_gl.cc",
@ -333,7 +332,6 @@ if (enable_unittests) {
if (test_enable_metal) {
sources += [
"tests/embedder_config_builder_metal.mm",
"tests/embedder_test_backingstore_producer_metal.h",
"tests/embedder_test_backingstore_producer_metal.mm",
"tests/embedder_test_compositor_metal.h",
@ -348,7 +346,6 @@ if (enable_unittests) {
if (test_enable_vulkan) {
sources += [
"tests/embedder_config_builder_vulkan.cc",
"tests/embedder_test_backingstore_producer_vulkan.cc",
"tests/embedder_test_backingstore_producer_vulkan.h",
"tests/embedder_test_compositor_vulkan.cc",

16
engine/src/flutter/shell/platform/embedder/tests/embedder_a11y_unittests.cc
View File

@ -35,7 +35,7 @@ TEST_F(EmbedderTest, CannotProvideMultipleSemanticsCallbacks) {
{
EmbedderConfigBuilder builder(
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.GetProjectArgs().update_semantics_callback =
[](const FlutterSemanticsUpdate* update, void* user_data) {};
builder.GetProjectArgs().update_semantics_callback2 =
@ -48,7 +48,7 @@ TEST_F(EmbedderTest, CannotProvideMultipleSemanticsCallbacks) {
{
EmbedderConfigBuilder builder(
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.GetProjectArgs().update_semantics_callback2 =
[](const FlutterSemanticsUpdate2* update, void* user_data) {};
builder.GetProjectArgs().update_semantics_node_callback =
@ -63,7 +63,7 @@ TEST_F(EmbedderTest, CannotProvideMultipleSemanticsCallbacks) {
{
EmbedderConfigBuilder builder(
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.GetProjectArgs().update_semantics_callback =
[](const FlutterSemanticsUpdate* update, void* user_data) {};
builder.GetProjectArgs().update_semantics_node_callback =
@ -78,7 +78,7 @@ TEST_F(EmbedderTest, CannotProvideMultipleSemanticsCallbacks) {
{
EmbedderConfigBuilder builder(
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.GetProjectArgs().update_semantics_callback2 =
[](const FlutterSemanticsUpdate2* update, void* user_data) {};
builder.GetProjectArgs().update_semantics_callback =
@ -171,7 +171,7 @@ TEST_F(EmbedderA11yTest, A11yTreeIsConsistentUsingV3Callbacks) {
});
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("a11y_main");
auto engine = builder.LaunchEngine();
@ -375,7 +375,7 @@ TEST_F(EmbedderA11yTest, A11yStringAttributes) {
});
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("a11y_string_attributes");
auto engine = builder.LaunchEngine();
@ -468,7 +468,7 @@ TEST_F(EmbedderA11yTest, A11yTreeIsConsistentUsingV2Callbacks) {
});
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("a11y_main");
auto engine = builder.LaunchEngine();
@ -662,7 +662,7 @@ TEST_F(EmbedderA11yTest, A11yTreeIsConsistentUsingV1Callbacks) {
});
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("a11y_main");
auto engine = builder.LaunchEngine();

110
engine/src/flutter/shell/platform/embedder/tests/embedder_config_builder.cc
View File

@ -8,7 +8,6 @@
#include "flutter/runtime/dart_vm.h"
#include "flutter/shell/platform/embedder/embedder.h"
#include "tests/embedder_test_context.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/skia/include/core/SkImage.h"
namespace flutter::testing {
@ -27,28 +26,6 @@ EmbedderConfigBuilder::EmbedderConfigBuilder(
custom_task_runners_.struct_size = sizeof(FlutterCustomTaskRunners);
InitializeGLRendererConfig();
InitializeMetalRendererConfig();
InitializeVulkanRendererConfig();
software_renderer_config_.struct_size = sizeof(FlutterSoftwareRendererConfig);
software_renderer_config_.surface_present_callback =
[](void* context, const void* allocation, size_t row_bytes,
size_t height) {
auto image_info =
SkImageInfo::MakeN32Premul(SkISize::Make(row_bytes / 4, height));
SkBitmap bitmap;
if (!bitmap.installPixels(image_info, const_cast<void*>(allocation),
row_bytes)) {
FML_LOG(ERROR) << "Could not copy pixels for the software "
"composition from the engine.";
return false;
}
bitmap.setImmutable();
return reinterpret_cast<EmbedderTestContextSoftware*>(context)->Present(
SkImages::RasterFromBitmap(bitmap));
};
// The first argument is always the executable name. Don't make tests have to
// do this manually.
AddCommandLineArgument("embedder_unittest");
@ -79,30 +56,6 @@ FlutterProjectArgs& EmbedderConfigBuilder::GetProjectArgs() {
return project_args_;
}
void EmbedderConfigBuilder::SetSoftwareRendererConfig(SkISize surface_size) {
renderer_config_.type = FlutterRendererType::kSoftware;
renderer_config_.software = software_renderer_config_;
context_.SetupSurface(surface_size);
}
void EmbedderConfigBuilder::SetRendererConfig(EmbedderTestContextType type,
SkISize surface_size) {
switch (type) {
case EmbedderTestContextType::kOpenGLContext:
SetOpenGLRendererConfig(surface_size);
break;
case EmbedderTestContextType::kMetalContext:
SetMetalRendererConfig(surface_size);
break;
case EmbedderTestContextType::kVulkanContext:
SetVulkanRendererConfig(surface_size);
break;
case EmbedderTestContextType::kSoftwareContext:
SetSoftwareRendererConfig(surface_size);
break;
}
}
void EmbedderConfigBuilder::SetAssetsPath() {
project_args_.assets_path = context_.GetAssetsPath().c_str();
}
@ -217,10 +170,6 @@ void EmbedderConfigBuilder::SetupVsyncCallback() {
};
}
FlutterRendererConfig& EmbedderConfigBuilder::GetRendererConfig() {
return renderer_config_;
}
void EmbedderConfigBuilder::SetRenderTaskRunner(
const FlutterTaskRunnerDescription* runner) {
if (runner == nullptr) {
@ -336,11 +285,12 @@ UniqueEngine EmbedderConfigBuilder::SetupEngine(bool run) const {
project_args.dart_entrypoint_argc = 0;
}
auto result =
run ? FlutterEngineRun(FLUTTER_ENGINE_VERSION, &renderer_config_,
&project_args, &context_, &engine)
: FlutterEngineInitialize(FLUTTER_ENGINE_VERSION, &renderer_config_,
&project_args, &context_, &engine);
auto result = run ? FlutterEngineRun(FLUTTER_ENGINE_VERSION,
&context_.GetRendererConfig(),
&project_args, &context_, &engine)
: FlutterEngineInitialize(
FLUTTER_ENGINE_VERSION, &context_.GetRendererConfig(),
&project_args, &context_, &engine);
if (result != kSuccess) {
return {};
@ -349,52 +299,4 @@ UniqueEngine EmbedderConfigBuilder::SetupEngine(bool run) const {
return UniqueEngine{engine};
}
#ifndef SHELL_ENABLE_GL
// OpenGL fallback implementations.
// See: flutter/shell/platform/embedder/tests/embedder_config_builder_gl.cc.
void EmbedderConfigBuilder::InitializeGLRendererConfig() {
// no-op.
}
void EmbedderConfigBuilder::SetOpenGLFBOCallBack() {
FML_LOG(FATAL) << "OpenGL is not enabled in this build.";
}
void EmbedderConfigBuilder::SetOpenGLPresentCallBack() {
FML_LOG(FATAL) << "OpenGL is not enabled in this build.";
}
void EmbedderConfigBuilder::SetOpenGLRendererConfig(SkISize surface_size) {
FML_LOG(FATAL) << "OpenGL is not enabled in this build.";
}
#endif
#ifndef SHELL_ENABLE_METAL
// Metal fallback implementations.
// See: flutter/shell/platform/embedder/tests/embedder_config_builder_metal.mm.
void EmbedderConfigBuilder::InitializeMetalRendererConfig() {
// no-op.
}
void EmbedderConfigBuilder::SetMetalRendererConfig(SkISize surface_size) {
FML_LOG(FATAL) << "Metal is not enabled in this build.";
}
#endif
#ifndef SHELL_ENABLE_VULKAN
// Vulkan fallback implementations.
// See: flutter/shell/platform/embedder/tests/embedder_config_builder_vulkan.cc.
void EmbedderConfigBuilder::InitializeVulkanRendererConfig() {
// no-op.
}
void EmbedderConfigBuilder::SetVulkanRendererConfig(
SkISize surface_size,
std::optional<FlutterVulkanInstanceProcAddressCallback>
instance_proc_address_callback) {
FML_LOG(FATAL) << "Vulkan is not enabled in this build.";
}
#endif
} // namespace flutter::testing

42
engine/src/flutter/shell/platform/embedder/tests/embedder_config_builder.h
View File

@ -44,31 +44,6 @@ class EmbedderConfigBuilder {
FlutterProjectArgs& GetProjectArgs();
void SetRendererConfig(EmbedderTestContextType type, SkISize surface_size);
void SetSoftwareRendererConfig(SkISize surface_size = SkISize::Make(1, 1));
void SetOpenGLRendererConfig(SkISize surface_size);
void SetMetalRendererConfig(SkISize surface_size);
void SetVulkanRendererConfig(
SkISize surface_size,
std::optional<FlutterVulkanInstanceProcAddressCallback>
instance_proc_address_callback = {});
// Used to explicitly set an `open_gl.fbo_callback`. Using this method will
// cause your test to fail since the ctor for this class sets
// `open_gl.fbo_callback_with_frame_info`. This method exists as a utility to
// explicitly test this behavior.
void SetOpenGLFBOCallBack();
// Used to explicitly set an `open_gl.present`. Using this method will cause
// your test to fail since the ctor for this class sets
// `open_gl.present_with_info`. This method exists as a utility to explicitly
// test this behavior.
void SetOpenGLPresentCallBack();
void SetAssetsPath();
void SetSnapshots();
@ -109,7 +84,7 @@ class EmbedderConfigBuilder {
FlutterCompositor& GetCompositor();
FlutterRendererConfig& GetRendererConfig();
void SetSurface(SkISize surface_size) { context_.SetSurface(surface_size); }
void SetRenderTargetType(
EmbedderTestBackingStoreProducer::RenderTargetType type,
@ -125,23 +100,8 @@ class EmbedderConfigBuilder {
void SetupVsyncCallback();
private:
void InitializeGLRendererConfig();
void InitializeVulkanRendererConfig();
void InitializeMetalRendererConfig();
EmbedderTestContext& context_;
FlutterProjectArgs project_args_ = {};
FlutterRendererConfig renderer_config_ = {};
FlutterSoftwareRendererConfig software_renderer_config_ = {};
#ifdef SHELL_ENABLE_GL
FlutterOpenGLRendererConfig opengl_renderer_config_ = {};
#endif
#ifdef SHELL_ENABLE_METAL
FlutterMetalRendererConfig metal_renderer_config_ = {};
#endif
#ifdef SHELL_ENABLE_VULKAN
FlutterVulkanRendererConfig vulkan_renderer_config_ = {};
#endif
std::string dart_entrypoint_;
FlutterCustomTaskRunners custom_task_runners_ = {};
FlutterCompositor compositor_ = {};

81
engine/src/flutter/shell/platform/embedder/tests/embedder_config_builder_gl.cc
View File

@ -1,81 +0,0 @@
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "flutter/shell/platform/embedder/tests/embedder_config_builder.h"
#include "flutter/shell/platform/embedder/tests/embedder_test_compositor_gl.h"
#include "flutter/shell/platform/embedder/tests/embedder_test_context_gl.h"
namespace flutter::testing {
void EmbedderConfigBuilder::InitializeGLRendererConfig() {
opengl_renderer_config_.struct_size = sizeof(FlutterOpenGLRendererConfig);
opengl_renderer_config_.make_current = [](void* context) -> bool {
return reinterpret_cast<EmbedderTestContextGL*>(context)->GLMakeCurrent();
};
opengl_renderer_config_.clear_current = [](void* context) -> bool {
return reinterpret_cast<EmbedderTestContextGL*>(context)->GLClearCurrent();
};
opengl_renderer_config_.present_with_info =
[](void* context, const FlutterPresentInfo* present_info) -> bool {
return reinterpret_cast<EmbedderTestContextGL*>(context)->GLPresent(
*present_info);
};
opengl_renderer_config_.fbo_with_frame_info_callback =
[](void* context, const FlutterFrameInfo* frame_info) -> uint32_t {
return reinterpret_cast<EmbedderTestContextGL*>(context)->GLGetFramebuffer(
*frame_info);
};
opengl_renderer_config_.populate_existing_damage = nullptr;
opengl_renderer_config_.make_resource_current = [](void* context) -> bool {
return reinterpret_cast<EmbedderTestContextGL*>(context)
->GLMakeResourceCurrent();
};
opengl_renderer_config_.gl_proc_resolver = [](void* context,
const char* name) -> void* {
return reinterpret_cast<EmbedderTestContextGL*>(context)->GLGetProcAddress(
name);
};
opengl_renderer_config_.fbo_reset_after_present = true;
opengl_renderer_config_.surface_transformation =
[](void* context) -> FlutterTransformation {
return reinterpret_cast<EmbedderTestContext*>(context)
->GetRootSurfaceTransformation();
};
}
void EmbedderConfigBuilder::SetOpenGLFBOCallBack() {
// SetOpenGLRendererConfig must be called before this.
FML_CHECK(renderer_config_.type == FlutterRendererType::kOpenGL);
renderer_config_.open_gl.fbo_callback = [](void* context) -> uint32_t {
FlutterFrameInfo frame_info = {};
// fbo_callback doesn't use the frame size information, only
// fbo_callback_with_frame_info does.
frame_info.struct_size = sizeof(FlutterFrameInfo);
frame_info.size.width = 0;
frame_info.size.height = 0;
return reinterpret_cast<EmbedderTestContextGL*>(context)->GLGetFramebuffer(
frame_info);
};
}
void EmbedderConfigBuilder::SetOpenGLPresentCallBack() {
// SetOpenGLRendererConfig must be called before this.
FML_CHECK(renderer_config_.type == FlutterRendererType::kOpenGL);
renderer_config_.open_gl.present = [](void* context) -> bool {
// passing a placeholder fbo_id.
return reinterpret_cast<EmbedderTestContextGL*>(context)->GLPresent(
FlutterPresentInfo{
.fbo_id = 0,
});
};
}
void EmbedderConfigBuilder::SetOpenGLRendererConfig(SkISize surface_size) {
renderer_config_.type = FlutterRendererType::kOpenGL;
renderer_config_.open_gl = opengl_renderer_config_;
context_.SetupSurface(surface_size);
}
} // namespace flutter::testing

47
engine/src/flutter/shell/platform/embedder/tests/embedder_config_builder_metal.mm
View File

@ -1,47 +0,0 @@
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "flutter/shell/platform/embedder/tests/embedder_config_builder.h"
#include "flutter/shell/platform/embedder/tests/embedder_test_context_metal.h"
namespace flutter::testing {
void EmbedderConfigBuilder::InitializeMetalRendererConfig() {
if (context_.GetContextType() != EmbedderTestContextType::kMetalContext) {
return;
}
metal_renderer_config_.struct_size = sizeof(metal_renderer_config_);
EmbedderTestContextMetal& metal_context = reinterpret_cast<EmbedderTestContextMetal&>(context_);
metal_renderer_config_.device = metal_context.GetTestMetalContext()->GetMetalDevice();
metal_renderer_config_.present_command_queue =
metal_context.GetTestMetalContext()->GetMetalCommandQueue();
metal_renderer_config_.get_next_drawable_callback = [](void* user_data,
const FlutterFrameInfo* frame_info) {
return reinterpret_cast<EmbedderTestContextMetal*>(user_data)->GetNextDrawable(frame_info);
};
metal_renderer_config_.present_drawable_callback =
[](void* user_data, const FlutterMetalTexture* texture) -> bool {
EmbedderTestContextMetal* metal_context =
reinterpret_cast<EmbedderTestContextMetal*>(user_data);
return metal_context->Present(texture->texture_id);
};
metal_renderer_config_.external_texture_frame_callback =
[](void* user_data, int64_t texture_id, size_t width, size_t height,
FlutterMetalExternalTexture* texture_out) -> bool {
EmbedderTestContextMetal* metal_context =
reinterpret_cast<EmbedderTestContextMetal*>(user_data);
return metal_context->PopulateExternalTexture(texture_id, width, height, texture_out);
};
}
void EmbedderConfigBuilder::SetMetalRendererConfig(SkISize surface_size) {
renderer_config_.type = FlutterRendererType::kMetal;
renderer_config_.metal = metal_renderer_config_;
context_.SetupSurface(surface_size);
}
} // namespace flutter::testing

73
engine/src/flutter/shell/platform/embedder/tests/embedder_config_builder_vulkan.cc
View File

@ -1,73 +0,0 @@
// Copyright 2013 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "flutter/shell/platform/embedder/tests/embedder_config_builder.h"
#include "flutter/shell/platform/embedder/tests/embedder_test_context_vulkan.h"
#include "flutter/vulkan/vulkan_device.h" // nogncheck
#include "vulkan/vulkan_core.h" // nogncheck
namespace flutter::testing {
void EmbedderConfigBuilder::InitializeVulkanRendererConfig() {
if (context_.GetContextType() != EmbedderTestContextType::kVulkanContext) {
return;
}
vulkan_renderer_config_.struct_size = sizeof(FlutterVulkanRendererConfig);
vulkan_renderer_config_.version =
static_cast<EmbedderTestContextVulkan&>(context_)
.vulkan_context_->application_->GetAPIVersion();
vulkan_renderer_config_.instance =
static_cast<EmbedderTestContextVulkan&>(context_)
.vulkan_context_->application_->GetInstance();
vulkan_renderer_config_.physical_device =
static_cast<EmbedderTestContextVulkan&>(context_)
.vulkan_context_->device_->GetPhysicalDeviceHandle();
vulkan_renderer_config_.device =
static_cast<EmbedderTestContextVulkan&>(context_)
.vulkan_context_->device_->GetHandle();
vulkan_renderer_config_.queue_family_index =
static_cast<EmbedderTestContextVulkan&>(context_)
.vulkan_context_->device_->GetGraphicsQueueIndex();
vulkan_renderer_config_.queue =
static_cast<EmbedderTestContextVulkan&>(context_)
.vulkan_context_->device_->GetQueueHandle();
vulkan_renderer_config_.get_instance_proc_address_callback =
EmbedderTestContextVulkan::InstanceProcAddr;
vulkan_renderer_config_.get_next_image_callback =
[](void* context,
const FlutterFrameInfo* frame_info) -> FlutterVulkanImage {
VkImage image =
reinterpret_cast<EmbedderTestContextVulkan*>(context)->GetNextImage(
{static_cast<int>(frame_info->size.width),
static_cast<int>(frame_info->size.height)});
return {
.struct_size = sizeof(FlutterVulkanImage),
.image = reinterpret_cast<uint64_t>(image),
.format = VK_FORMAT_R8G8B8A8_UNORM,
};
};
vulkan_renderer_config_.present_image_callback =
[](void* context, const FlutterVulkanImage* image) -> bool {
return reinterpret_cast<EmbedderTestContextVulkan*>(context)->PresentImage(
reinterpret_cast<VkImage>(image->image));
};
}
void EmbedderConfigBuilder::SetVulkanRendererConfig(
SkISize surface_size,
std::optional<FlutterVulkanInstanceProcAddressCallback>
instance_proc_address_callback) {
renderer_config_.type = FlutterRendererType::kVulkan;
FlutterVulkanRendererConfig vulkan_renderer_config = vulkan_renderer_config_;
if (instance_proc_address_callback.has_value()) {
vulkan_renderer_config.get_instance_proc_address_callback =
instance_proc_address_callback.value();
}
renderer_config_.vulkan = vulkan_renderer_config;
context_.SetupSurface(surface_size);
}
} // namespace flutter::testing

709
engine/src/flutter/shell/platform/embedder/tests/embedder_gl_unittests.cc
View File

File diff suppressed because it is too large Load Diff

21
engine/src/flutter/shell/platform/embedder/tests/embedder_metal_unittests.mm
View File

@ -39,9 +39,8 @@ TEST_F(EmbedderTest, CanRenderGradientWithMetal) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kMetalContext);
EmbedderConfigBuilder builder(context);
builder.SetDartEntrypoint("render_gradient");
builder.SetMetalRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
auto rendered_scene = context.GetNextSceneImage();
@ -108,7 +107,7 @@ TEST_F(EmbedderTest, ExternalTextureMetal) {
EmbedderConfigBuilder builder(context);
builder.SetDartEntrypoint("render_texture");
builder.SetMetalRendererConfig(texture_size);
builder.SetSurface(texture_size);
auto engine = builder.LaunchEngine();
ASSERT_TRUE(engine.is_valid());
@ -132,7 +131,7 @@ TEST_F(EmbedderTest, MetalCompositorMustBeAbleToRenderPlatformViews) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kMetalContext);
EmbedderConfigBuilder builder(context);
builder.SetMetalRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
builder.SetCompositor();
builder.SetDartEntrypoint("can_composite_platform_views");
@ -245,7 +244,7 @@ TEST_F(EmbedderTest, CanRenderSceneWithoutCustomCompositorMetal) {
EmbedderConfigBuilder builder(context);
builder.SetDartEntrypoint("can_render_scene_without_custom_compositor");
builder.SetMetalRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
auto rendered_scene = context.GetNextSceneImage();
@ -267,7 +266,7 @@ TEST_F(EmbedderTest, TextureDestructionCallbackCalledWithoutCustomCompositorMeta
EmbedderTestContextMetal& context = reinterpret_cast<EmbedderTestContextMetal&>(
GetEmbedderContext(EmbedderTestContextType::kMetalContext));
EmbedderConfigBuilder builder(context);
builder.SetMetalRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
builder.SetDartEntrypoint("texture_destruction_callback_called_without_custom_compositor");
struct CollectContext {
@ -317,7 +316,7 @@ TEST_F(EmbedderTest, CompositorMustBeAbleToRenderKnownSceneMetal) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kMetalContext);
EmbedderConfigBuilder builder(context);
builder.SetMetalRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
builder.SetCompositor();
builder.SetDartEntrypoint("can_composite_platform_views_with_known_scene");
@ -513,7 +512,7 @@ TEST_F(EmbedderTest, CompositorMustBeAbleToRenderKnownSceneMetal) {
TEST_F(EmbedderTest, CreateInvalidBackingstoreMetalTexture) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kMetalContext);
EmbedderConfigBuilder builder(context);
builder.SetMetalRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
builder.SetCompositor();
builder.SetRenderTargetType(EmbedderTestBackingStoreProducer::RenderTargetType::kMetalTexture);
builder.SetDartEntrypoint("invalid_backingstore");
@ -621,7 +620,7 @@ TEST_F(EmbedderTest, CanRenderWithImpellerMetal) {
builder.AddCommandLineArgument("--enable-impeller");
builder.SetDartEntrypoint("render_impeller_test");
builder.SetMetalRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
auto rendered_scene = context.GetNextSceneImage();
@ -646,7 +645,7 @@ TEST_F(EmbedderTest, CanRenderTextWithImpellerMetal) {
builder.AddCommandLineArgument("--enable-impeller");
builder.SetDartEntrypoint("render_impeller_text_test");
builder.SetMetalRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
auto rendered_scene = context.GetNextSceneImage();
@ -671,7 +670,7 @@ TEST_F(EmbedderTest, CanRenderTextWithImpellerAndCompositorMetal) {
builder.AddCommandLineArgument("--enable-impeller");
builder.SetDartEntrypoint("render_impeller_text_test");
builder.SetMetalRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
builder.SetCompositor();
builder.SetRenderTargetType(EmbedderTestBackingStoreProducer::RenderTargetType::kMetalTexture);

4
engine/src/flutter/shell/platform/embedder/tests/embedder_test_context.cc
View File

@ -96,6 +96,10 @@ void EmbedderTestContext::SetRootSurfaceTransformation(SkMatrix matrix) {
root_surface_transformation_ = matrix;
}
FlutterRendererConfig& EmbedderTestContext::GetRendererConfig() {
return renderer_config_;
}
void EmbedderTestContext::AddIsolateCreateCallback(
const fml::closure& closure) {
if (closure) {

9
engine/src/flutter/shell/platform/embedder/tests/embedder_test_context.h
View File

@ -72,9 +72,7 @@ class EmbedderTestContext {
void SetRootSurfaceTransformation(SkMatrix matrix);
void SetRenderTargetType(
EmbedderTestBackingStoreProducer::RenderTargetType type,
FlutterSoftwarePixelFormat software_pixfmt);
FlutterRendererConfig& GetRendererConfig();
void AddIsolateCreateCallback(const fml::closure& closure);
@ -129,6 +127,7 @@ class EmbedderTestContext {
UniqueAOTData aot_data_;
std::vector<fml::closure> isolate_create_callbacks_;
std::shared_ptr<TestDartNativeResolver> native_resolver_;
FlutterRendererConfig renderer_config_ = {};
SemanticsUpdateCallback2 update_semantics_callback2_;
SemanticsUpdateCallback update_semantics_callback_;
SemanticsNodeCallback update_semantics_node_callback_;
@ -163,6 +162,8 @@ class EmbedderTestContext {
void SetupAOTDataIfNecessary();
virtual void SetSurface(SkISize surface_size) = 0;
virtual void SetupCompositor() = 0;
void FireIsolateCreateCallbacks();
@ -178,8 +179,6 @@ class EmbedderTestContext {
void SetNextSceneCallback(const NextSceneCallback& next_scene_callback);
virtual void SetupSurface(SkISize surface_size) = 0;
FML_DISALLOW_COPY_AND_ASSIGN(EmbedderTestContext);
};

82
engine/src/flutter/shell/platform/embedder/tests/embedder_test_context_gl.cc
View File

@ -4,6 +4,7 @@
#include "flutter/shell/platform/embedder/tests/embedder_test_context_gl.h"
#include <memory>
#include <utility>
#include "flutter/fml/make_copyable.h"
@ -11,26 +12,85 @@
#include "flutter/runtime/dart_vm.h"
#include "flutter/shell/platform/embedder/tests/embedder_assertions.h"
#include "flutter/shell/platform/embedder/tests/embedder_test_compositor_gl.h"
#include "flutter/testing/test_gl_surface.h"
#include "flutter/testing/testing.h"
#include "tests/embedder_test.h"
#include "third_party/dart/runtime/bin/elf_loader.h"
#include "third_party/skia/include/core/SkSurface.h"
namespace flutter {
namespace testing {
namespace flutter::testing {
EmbedderTestContextGL::EmbedderTestContextGL(std::string assets_path)
: EmbedderTestContext(std::move(assets_path)),
egl_context_(std::make_shared<TestEGLContext>()) {}
egl_context_(std::make_shared<TestEGLContext>()) {
renderer_config_.type = FlutterRendererType::kOpenGL;
renderer_config_.open_gl = {
.struct_size = sizeof(FlutterOpenGLRendererConfig),
.make_current = [](void* context) -> bool {
return reinterpret_cast<EmbedderTestContextGL*>(context)
->GLMakeCurrent();
},
.clear_current = [](void* context) -> bool {
return reinterpret_cast<EmbedderTestContextGL*>(context)
->GLClearCurrent();
},
.make_resource_current = [](void* context) -> bool {
return reinterpret_cast<EmbedderTestContextGL*>(context)
->GLMakeResourceCurrent();
},
.fbo_reset_after_present = true,
.surface_transformation = [](void* context) -> FlutterTransformation {
return reinterpret_cast<EmbedderTestContextGL*>(context)
->GetRootSurfaceTransformation();
},
.gl_proc_resolver = [](void* context, const char* name) -> void* {
return reinterpret_cast<EmbedderTestContextGL*>(context)
->GLGetProcAddress(name);
},
.fbo_with_frame_info_callback =
[](void* context, const FlutterFrameInfo* frame_info) -> uint32_t {
return reinterpret_cast<EmbedderTestContextGL*>(context)
->GLGetFramebuffer(*frame_info);
},
.present_with_info = [](void* context,
const FlutterPresentInfo* present_info) -> bool {
return reinterpret_cast<EmbedderTestContextGL*>(context)->GLPresent(
*present_info);
},
.populate_existing_damage = nullptr,
};
}
EmbedderTestContextGL::~EmbedderTestContextGL() {
SetGLGetFBOCallback(nullptr);
}
void EmbedderTestContextGL::SetupSurface(SkISize surface_size) {
FML_CHECK(!gl_surface_);
gl_surface_ = std::make_unique<TestGLSurface>(egl_context_, surface_size);
void EmbedderTestContextGL::SetOpenGLFBOCallBack() {
// SetOpenGLRendererConfig must be called before this.
FML_CHECK(renderer_config_.type == FlutterRendererType::kOpenGL);
renderer_config_.open_gl.fbo_callback = [](void* context) -> uint32_t {
FlutterFrameInfo frame_info = {};
// fbo_callback doesn't use the frame size information, only
// fbo_callback_with_frame_info does.
frame_info.struct_size = sizeof(FlutterFrameInfo);
frame_info.size.width = 0;
frame_info.size.height = 0;
return reinterpret_cast<EmbedderTestContextGL*>(context)->GLGetFramebuffer(
frame_info);
};
}
void EmbedderTestContextGL::SetOpenGLPresentCallBack() {
// SetOpenGLRendererConfig must be called before this.
FML_CHECK(renderer_config_.type == FlutterRendererType::kOpenGL);
renderer_config_.open_gl.present = [](void* context) -> bool {
// passing a placeholder fbo_id.
return reinterpret_cast<EmbedderTestContextGL*>(context)->GLPresent(
FlutterPresentInfo{
.fbo_id = 0,
});
};
}
bool EmbedderTestContextGL::GLMakeCurrent() {
@ -136,6 +196,11 @@ uint32_t EmbedderTestContextGL::GetWindowFBOId() const {
return gl_surface_->GetWindowFBOId();
}
void EmbedderTestContextGL::SetSurface(SkISize surface_size) {
FML_CHECK(!gl_surface_);
gl_surface_ = std::make_unique<TestGLSurface>(egl_context_, surface_size);
}
void EmbedderTestContextGL::SetupCompositor() {
FML_CHECK(!compositor_) << "Already set up a compositor in this context.";
FML_CHECK(gl_surface_)
@ -145,5 +210,4 @@ void EmbedderTestContextGL::SetupCompositor() {
GLClearCurrent();
}
} // namespace testing
} // namespace flutter
} // namespace flutter::testing

26
engine/src/flutter/shell/platform/embedder/tests/embedder_test_context_gl.h
View File

@ -30,6 +30,18 @@ class EmbedderTestContextGL : public EmbedderTestContext {
// |EmbedderTestContext|
EmbedderTestContextType GetContextType() const override;
// Used to explicitly set an `open_gl.fbo_callback`. Using this method will
// cause your test to fail since the ctor for this class sets
// `open_gl.fbo_callback_with_frame_info`. This method exists as a utility to
// explicitly test this behavior.
void SetOpenGLFBOCallBack();
// Used to explicitly set an `open_gl.present`. Using this method will cause
// your test to fail since the ctor for this class sets
// `open_gl.present_with_info`. This method exists as a utility to explicitly
// test this behavior.
void SetOpenGLPresentCallBack();
//----------------------------------------------------------------------------
/// @brief Sets a callback that will be invoked (on the raster task
/// runner) when the engine asks the embedder for a new FBO ID at
@ -66,14 +78,12 @@ class EmbedderTestContextGL : public EmbedderTestContext {
void* GLGetProcAddress(const char* name);
protected:
virtual void SetupCompositor() override;
void SetupCompositorUsingGLSurfaces();
private:
// This allows the builder to access the hooks.
friend class EmbedderConfigBuilder;
// |EmbedderTestContext|
void SetSurface(SkISize surface_size) override;
// |EmbedderTestContext|
void SetupCompositor() override;
std::shared_ptr<TestEGLContext> egl_context_;
std::unique_ptr<TestGLSurface> gl_surface_;
@ -83,8 +93,6 @@ class EmbedderTestContextGL : public EmbedderTestContext {
GLPresentCallback gl_present_callback_;
GLPopulateExistingDamageCallback gl_populate_existing_damage_callback_;
void SetupSurface(SkISize surface_size) override;
bool GLMakeCurrent();
bool GLClearCurrent();

12
engine/src/flutter/shell/platform/embedder/tests/embedder_test_context_metal.h
View File

@ -35,9 +35,6 @@ class EmbedderTestContextMetal : public EmbedderTestContext {
// |EmbedderTestContext|
size_t GetSurfacePresentCount() const override;
// |EmbedderTestContext|
void SetupCompositor() override;
void SetExternalTextureCallback(
TestExternalTextureCallback external_texture_frame_callback);
@ -61,8 +58,11 @@ class EmbedderTestContextMetal : public EmbedderTestContext {
FlutterMetalTexture GetNextDrawable(const FlutterFrameInfo* frame_info);
private:
// This allows the builder to access the hooks.
friend class EmbedderConfigBuilder;
// |EmbedderTestContext|
void SetSurface(SkISize surface_size) override;
// |EmbedderTestContext|
void SetupCompositor() override;
TestExternalTextureCallback external_texture_frame_callback_ = nullptr;
SkISize surface_size_ = SkISize::MakeEmpty();
@ -72,8 +72,6 @@ class EmbedderTestContextMetal : public EmbedderTestContext {
PresentCallback present_callback_ = nullptr;
NextDrawableCallback next_drawable_callback_ = nullptr;
void SetupSurface(SkISize surface_size) override;
FML_DISALLOW_COPY_AND_ASSIGN(EmbedderTestContextMetal);
};

56
engine/src/flutter/shell/platform/embedder/tests/embedder_test_context_metal.mm
View File

@ -11,35 +11,41 @@
#include "flutter/fml/logging.h"
#include "flutter/shell/platform/embedder/tests/embedder_test_compositor_metal.h"
namespace flutter {
namespace testing {
namespace flutter::testing {
EmbedderTestContextMetal::EmbedderTestContextMetal(std::string assets_path)
: EmbedderTestContext(std::move(assets_path)) {
metal_context_ = std::make_unique<TestMetalContext>();
renderer_config_.type = FlutterRendererType::kMetal;
renderer_config_.metal = {
.struct_size = sizeof(FlutterMetalRendererConfig),
.device = metal_context_->GetMetalDevice(),
.present_command_queue = metal_context_->GetMetalCommandQueue(),
.get_next_drawable_callback =
[](void* user_data, const FlutterFrameInfo* frame_info) {
return reinterpret_cast<EmbedderTestContextMetal*>(user_data)->GetNextDrawable(
frame_info);
},
.present_drawable_callback = [](void* user_data, const FlutterMetalTexture* texture) -> bool {
return reinterpret_cast<EmbedderTestContextMetal*>(user_data)->Present(texture->texture_id);
},
.external_texture_frame_callback = [](void* user_data, int64_t texture_id, size_t width,
size_t height,
FlutterMetalExternalTexture* texture_out) -> bool {
return reinterpret_cast<EmbedderTestContextMetal*>(user_data)->PopulateExternalTexture(
texture_id, width, height, texture_out);
},
};
}
EmbedderTestContextMetal::~EmbedderTestContextMetal() {}
void EmbedderTestContextMetal::SetupSurface(SkISize surface_size) {
FML_CHECK(surface_size_.isEmpty());
surface_size_ = surface_size;
metal_surface_ = TestMetalSurface::Create(*metal_context_, surface_size_);
}
size_t EmbedderTestContextMetal::GetSurfacePresentCount() const {
return present_count_;
}
EmbedderTestContextType EmbedderTestContextMetal::GetContextType() const {
return EmbedderTestContextType::kMetalContext;
}
void EmbedderTestContextMetal::SetupCompositor() {
FML_CHECK(!compositor_) << "Already set up a compositor in this context.";
FML_CHECK(metal_surface_) << "Set up the Metal surface before setting up a compositor.";
compositor_ =
std::make_unique<EmbedderTestCompositorMetal>(surface_size_, metal_surface_->GetGrContext());
size_t EmbedderTestContextMetal::GetSurfacePresentCount() const {
return present_count_;
}
TestMetalContext* EmbedderTestContextMetal::GetTestMetalContext() {
@ -98,5 +104,17 @@ FlutterMetalTexture EmbedderTestContextMetal::GetNextDrawable(const FlutterFrame
return texture;
}
} // namespace testing
} // namespace flutter
void EmbedderTestContextMetal::SetSurface(SkISize surface_size) {
FML_CHECK(surface_size_.isEmpty());
surface_size_ = surface_size;
metal_surface_ = TestMetalSurface::Create(*metal_context_, surface_size_);
}
void EmbedderTestContextMetal::SetupCompositor() {
FML_CHECK(!compositor_) << "Already set up a compositor in this context.";
FML_CHECK(metal_surface_) << "Set up the Metal surface before setting up a compositor.";
compositor_ =
std::make_unique<EmbedderTestCompositorMetal>(surface_size_, metal_surface_->GetGrContext());
}
} // namespace flutter::testing

54
engine/src/flutter/shell/platform/embedder/tests/embedder_test_context_software.cc
View File

@ -13,34 +13,43 @@
#include "flutter/shell/platform/embedder/tests/embedder_test_compositor_software.h"
#include "flutter/testing/testing.h"
#include "third_party/dart/runtime/bin/elf_loader.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "third_party/skia/include/core/SkSurface.h"
namespace flutter {
namespace testing {
namespace flutter::testing {
EmbedderTestContextSoftware::EmbedderTestContextSoftware(
std::string assets_path)
: EmbedderTestContext(std::move(assets_path)) {}
: EmbedderTestContext(std::move(assets_path)) {
renderer_config_.type = FlutterRendererType::kSoftware;
renderer_config_.software = {
.struct_size = sizeof(FlutterSoftwareRendererConfig),
.surface_present_callback =
[](void* context, const void* allocation, size_t row_bytes,
size_t height) {
auto image_info = SkImageInfo::MakeN32Premul(
SkISize::Make(row_bytes / 4, height));
SkBitmap bitmap;
if (!bitmap.installPixels(image_info, const_cast<void*>(allocation),
row_bytes)) {
FML_LOG(ERROR) << "Could not copy pixels for the software "
"composition from the engine.";
return false;
}
bitmap.setImmutable();
return reinterpret_cast<EmbedderTestContextSoftware*>(context)
->Present(SkImages::RasterFromBitmap(bitmap));
},
};
}
EmbedderTestContextSoftware::~EmbedderTestContextSoftware() = default;
bool EmbedderTestContextSoftware::Present(const sk_sp<SkImage>& image) {
software_surface_present_count_++;
FireRootSurfacePresentCallbackIfPresent([image] { return image; });
return true;
}
size_t EmbedderTestContextSoftware::GetSurfacePresentCount() const {
return software_surface_present_count_;
}
EmbedderTestContextType EmbedderTestContextSoftware::GetContextType() const {
return EmbedderTestContextType::kSoftwareContext;
}
void EmbedderTestContextSoftware::SetupSurface(SkISize surface_size) {
void EmbedderTestContextSoftware::SetSurface(SkISize surface_size) {
surface_size_ = surface_size;
}
@ -49,5 +58,14 @@ void EmbedderTestContextSoftware::SetupCompositor() {
compositor_ = std::make_unique<EmbedderTestCompositorSoftware>(surface_size_);
}
} // namespace testing
} // namespace flutter
size_t EmbedderTestContextSoftware::GetSurfacePresentCount() const {
return software_surface_present_count_;
}
bool EmbedderTestContextSoftware::Present(const sk_sp<SkImage>& image) {
software_surface_present_count_++;
FireRootSurfacePresentCallbackIfPresent([image] { return image; });
return true;
}
} // namespace flutter::testing

15
engine/src/flutter/shell/platform/embedder/tests/embedder_test_context_software.h
View File

@ -18,21 +18,24 @@ class EmbedderTestContextSoftware : public EmbedderTestContext {
~EmbedderTestContextSoftware() override;
size_t GetSurfacePresentCount() const override;
// |EmbedderTestContext|
EmbedderTestContextType GetContextType() const override;
// |EmbedderTestContext|
size_t GetSurfacePresentCount() const override;
bool Present(const sk_sp<SkImage>& image);
protected:
virtual void SetupCompositor() override;
private:
// |EmbedderTestContext|
void SetSurface(SkISize surface_size) override;
// |EmbedderTestContext|
void SetupCompositor() override;
sk_sp<SkSurface> surface_;
SkISize surface_size_;
size_t software_surface_present_count_ = 0;
void SetupSurface(SkISize surface_size) override;
FML_DISALLOW_COPY_AND_ASSIGN(EmbedderTestContextSoftware);
};

73
engine/src/flutter/shell/platform/embedder/tests/embedder_test_context_vulkan.cc
View File

@ -15,20 +15,52 @@
#include "flutter/vulkan/vulkan_device.h"
#include "third_party/skia/include/core/SkSurface.h"
namespace flutter {
namespace testing {
namespace flutter::testing {
EmbedderTestContextVulkan::EmbedderTestContextVulkan(std::string assets_path)
: EmbedderTestContext(std::move(assets_path)), surface_() {
vulkan_context_ = fml::MakeRefCounted<TestVulkanContext>();
renderer_config_.type = FlutterRendererType::kVulkan;
renderer_config_.vulkan = {
.struct_size = sizeof(FlutterVulkanRendererConfig),
.version = vulkan_context_->application_->GetAPIVersion(),
.instance = vulkan_context_->application_->GetInstance(),
.physical_device = vulkan_context_->device_->GetPhysicalDeviceHandle(),
.device = vulkan_context_->device_->GetHandle(),
.queue_family_index = vulkan_context_->device_->GetGraphicsQueueIndex(),
.queue = vulkan_context_->device_->GetQueueHandle(),
.get_instance_proc_address_callback =
EmbedderTestContextVulkan::InstanceProcAddr,
.get_next_image_callback =
[](void* context,
const FlutterFrameInfo* frame_info) -> FlutterVulkanImage {
VkImage image =
reinterpret_cast<EmbedderTestContextVulkan*>(context)->GetNextImage(
{static_cast<int>(frame_info->size.width),
static_cast<int>(frame_info->size.height)});
return {
.struct_size = sizeof(FlutterVulkanImage),
.image = reinterpret_cast<uint64_t>(image),
.format = VK_FORMAT_R8G8B8A8_UNORM,
};
},
.present_image_callback = [](void* context,
const FlutterVulkanImage* image) -> bool {
return reinterpret_cast<EmbedderTestContextVulkan*>(context)
->PresentImage(reinterpret_cast<VkImage>(image->image));
},
};
}
EmbedderTestContextVulkan::~EmbedderTestContextVulkan() {}
void EmbedderTestContextVulkan::SetupSurface(SkISize surface_size) {
FML_CHECK(surface_size_.isEmpty());
surface_size_ = surface_size;
surface_ = TestVulkanSurface::Create(*vulkan_context_, surface_size_);
EmbedderTestContextType EmbedderTestContextVulkan::GetContextType() const {
return EmbedderTestContextType::kVulkanContext;
}
void EmbedderTestContextVulkan::SetVulkanInstanceProcAddressCallback(
FlutterVulkanInstanceProcAddressCallback callback) {
renderer_config_.vulkan.get_instance_proc_address_callback = callback;
}
size_t EmbedderTestContextVulkan::GetSurfacePresentCount() const {
@ -46,18 +78,6 @@ bool EmbedderTestContextVulkan::PresentImage(VkImage image) {
return true;
}
EmbedderTestContextType EmbedderTestContextVulkan::GetContextType() const {
return EmbedderTestContextType::kVulkanContext;
}
void EmbedderTestContextVulkan::SetupCompositor() {
FML_CHECK(!compositor_) << "Already set up a compositor in this context.";
FML_CHECK(surface_)
<< "Set up the Vulkan surface before setting up a compositor.";
compositor_ = std::make_unique<EmbedderTestCompositorVulkan>(
surface_size_, vulkan_context_->GetGrDirectContext());
}
void* EmbedderTestContextVulkan::InstanceProcAddr(
void* user_data,
FlutterVulkanInstanceHandle instance,
@ -68,5 +88,18 @@ void* EmbedderTestContextVulkan::InstanceProcAddr(
return reinterpret_cast<void*>(proc_addr);
}
} // namespace testing
} // namespace flutter
void EmbedderTestContextVulkan::SetSurface(SkISize surface_size) {
FML_CHECK(surface_size_.isEmpty());
surface_size_ = surface_size;
surface_ = TestVulkanSurface::Create(*vulkan_context_, surface_size_);
}
void EmbedderTestContextVulkan::SetupCompositor() {
FML_CHECK(!compositor_) << "Already set up a compositor in this context.";
FML_CHECK(surface_)
<< "Set up the Vulkan surface before setting up a compositor.";
compositor_ = std::make_unique<EmbedderTestCompositorVulkan>(
surface_size_, vulkan_context_->GetGrDirectContext());
}
} // namespace flutter::testing

16
engine/src/flutter/shell/platform/embedder/tests/embedder_test_context_vulkan.h
View File

@ -26,18 +26,24 @@ class EmbedderTestContextVulkan : public EmbedderTestContext {
// |EmbedderTestContext|
size_t GetSurfacePresentCount() const override;
// |EmbedderTestContext|
void SetupCompositor() override;
VkImage GetNextImage(const SkISize& size);
bool PresentImage(VkImage image);
void SetVulkanInstanceProcAddressCallback(
FlutterVulkanInstanceProcAddressCallback callback);
static void* InstanceProcAddr(void* user_data,
FlutterVulkanInstanceHandle instance,
const char* name);
private:
// |EmbedderTestContext|
void SetSurface(SkISize surface_size) override;
// |EmbedderTestContext|
void SetupCompositor() override;
// The TestVulkanContext destructor must be called _after_ the compositor is
// freed.
fml::RefPtr<TestVulkanContext> vulkan_context_ = nullptr;
@ -47,10 +53,6 @@ class EmbedderTestContextVulkan : public EmbedderTestContext {
SkISize surface_size_ = SkISize::MakeEmpty();
size_t present_count_ = 0;
void SetupSurface(SkISize surface_size) override;
friend class EmbedderConfigBuilder;
FML_DISALLOW_COPY_AND_ASSIGN(EmbedderTestContextVulkan);
};

132
engine/src/flutter/shell/platform/embedder/tests/embedder_unittests.cc
View File

@ -69,7 +69,7 @@ TEST_F(EmbedderTest, CanLaunchAndShutdownWithValidProjectArgs) {
fml::AutoResetWaitableEvent latch;
context.AddIsolateCreateCallback([&latch]() { latch.Signal(); });
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
auto engine = builder.LaunchEngine();
ASSERT_TRUE(engine.is_valid());
// Wait for the root isolate to launch.
@ -81,7 +81,7 @@ TEST_F(EmbedderTest, CanLaunchAndShutdownWithValidProjectArgs) {
TEST_F(EmbedderTest, DISABLED_CanLaunchAndShutdownMultipleTimes) {
EmbedderConfigBuilder builder(
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
for (size_t i = 0; i < 3; ++i) {
auto engine = builder.LaunchEngine();
ASSERT_TRUE(engine.is_valid());
@ -97,7 +97,7 @@ TEST_F(EmbedderTest, CanInvokeCustomEntrypoint) {
};
context.AddNativeCallback("SayHiFromCustomEntrypoint", entrypoint);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("customEntrypoint");
auto engine = builder.LaunchEngine();
latch.Wait();
@ -136,7 +136,7 @@ TEST_F(EmbedderTest, CanInvokeCustomEntrypointMacro) {
}));
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("customEntrypoint1");
auto engine = builder.LaunchEngine();
latch1.Wait();
@ -148,7 +148,7 @@ TEST_F(EmbedderTest, CanInvokeCustomEntrypointMacro) {
TEST_F(EmbedderTest, CanTerminateCleanly) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("terminateExitCodeHandler");
auto engine = builder.LaunchEngine();
ASSERT_TRUE(engine.is_valid());
@ -169,7 +169,7 @@ TEST_F(EmbedderTest, ExecutableNameNotNull) {
}));
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("executableNameNotNull");
builder.SetExecutableName("/path/to/binary");
auto engine = builder.LaunchEngine();
@ -192,7 +192,7 @@ TEST_F(EmbedderTest, ImplicitViewNotNull) {
}));
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("implicitViewNotNull");
auto engine = builder.LaunchEngine();
latch.Wait();
@ -239,7 +239,7 @@ TEST_F(EmbedderTest, CanSpecifyCustomPlatformTaskRunner) {
EmbedderConfigBuilder builder(context);
const auto task_runner_description =
test_task_runner.GetFlutterTaskRunnerDescription();
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetPlatformTaskRunner(&task_runner_description);
builder.SetDartEntrypoint("invokePlatformTaskRunner");
std::scoped_lock lock(engine_mutex);
@ -283,7 +283,7 @@ TEST(EmbedderTestNoFixture, CanGetCurrentTimeInNanoseconds) {
TEST_F(EmbedderTest, CanReloadSystemFonts) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
auto engine = builder.LaunchEngine();
ASSERT_TRUE(engine.is_valid());
@ -301,7 +301,7 @@ TEST_F(EmbedderTest, IsolateServiceIdSent) {
thread.GetTaskRunner()->PostTask([&]() {
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("main");
builder.SetPlatformMessageCallback(
[&](const FlutterPlatformMessage* message) {
@ -337,7 +337,7 @@ TEST_F(EmbedderTest, IsolateServiceIdSent) {
TEST_F(EmbedderTest, CanCreateAndCollectCallbacks) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("platform_messages_response");
context.AddNativeCallback(
"SignalNativeTest",
@ -376,7 +376,7 @@ TEST_F(EmbedderTest, PlatformMessagesCanReceiveResponse) {
auto& context =
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("platform_messages_response");
fml::AutoResetWaitableEvent ready;
@ -432,7 +432,7 @@ TEST_F(EmbedderTest, PlatformMessagesCanReceiveResponse) {
TEST_F(EmbedderTest, PlatformMessagesCanBeSentWithoutResponseHandles) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("platform_messages_no_response");
const std::string message_data = "Hello but don't call me back.";
@ -477,7 +477,7 @@ TEST_F(EmbedderTest, PlatformMessagesCanBeSentWithoutResponseHandles) {
TEST_F(EmbedderTest, NullPlatformMessagesCanBeSent) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("null_platform_messages");
fml::AutoResetWaitableEvent ready, message;
@ -519,7 +519,7 @@ TEST_F(EmbedderTest, NullPlatformMessagesCanBeSent) {
TEST_F(EmbedderTest, InvalidPlatformMessages) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
auto engine = builder.LaunchEngine();
ASSERT_TRUE(engine.is_valid());
@ -544,7 +544,7 @@ TEST_F(EmbedderTest, CanSetCustomLogMessageCallback) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetDartEntrypoint("custom_logger");
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
context.SetLogMessageCallback(
[&callback_latch](const char* tag, const char* message) {
EXPECT_EQ(std::string(tag), "flutter");
@ -563,7 +563,7 @@ TEST_F(EmbedderTest, CanSetCustomLogTag) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetDartEntrypoint("custom_logger");
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetLogTag("butterfly");
context.SetLogMessageCallback(
[&callback_latch](const char* tag, const char* message) {
@ -583,7 +583,7 @@ TEST_F(EmbedderTest, CanSetCustomLogTag) {
TEST_F(EmbedderTest, VMShutsDownWhenNoEnginesInProcess) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
const auto launch_count = DartVM::GetVMLaunchCount();
{
@ -602,7 +602,7 @@ TEST_F(EmbedderTest, VMShutsDownWhenNoEnginesInProcess) {
TEST_F(EmbedderTest, DartEntrypointArgs) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.AddDartEntrypointArgument("foo");
builder.AddDartEntrypointArgument("bar");
builder.SetDartEntrypoint("dart_entrypoint_args");
@ -636,7 +636,7 @@ TEST_F(EmbedderTest, VMAndIsolateSnapshotSizesAreRedundantInAOTMode) {
}
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
// The fixture sets this up correctly. Intentionally mess up the args.
builder.GetProjectArgs().vm_snapshot_data_size = 0;
@ -652,7 +652,7 @@ TEST_F(EmbedderTest, CanRenderImplicitView) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
builder.SetCompositor();
builder.SetDartEntrypoint("render_implicit_view");
builder.SetRenderTargetType(
@ -684,7 +684,7 @@ TEST_F(EmbedderTest, CanRenderImplicitViewUsingPresentLayersCallback) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
builder.SetCompositor(/* avoid_backing_store_cache = */ false,
/* use_present_layers_callback = */ true);
builder.SetDartEntrypoint("render_implicit_view");
@ -729,7 +729,7 @@ TEST_F(EmbedderTest,
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
builder.SetCompositor();
builder.SetDartEntrypoint("can_composite_platform_views_with_known_scene");
@ -948,7 +948,7 @@ TEST_F(EmbedderTest, NoLayerCreatedForTransparentOverlayOnTopOfPlatformLayer) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
builder.SetCompositor();
builder.SetDartEntrypoint("can_composite_platform_views_transparent_overlay");
@ -1085,7 +1085,7 @@ TEST_F(EmbedderTest, NoLayerCreatedForNoOverlayOnTopOfPlatformLayer) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
builder.SetCompositor();
builder.SetDartEntrypoint("can_composite_platform_views_no_overlay");
@ -1220,7 +1220,7 @@ TEST_F(EmbedderTest, NoLayerCreatedForNoOverlayOnTopOfPlatformLayer) {
TEST_F(EmbedderTest, CanCreateInitializedEngine) {
EmbedderConfigBuilder builder(
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
auto engine = builder.InitializeEngine();
ASSERT_TRUE(engine.is_valid());
engine.reset();
@ -1232,7 +1232,7 @@ TEST_F(EmbedderTest, CanCreateInitializedEngine) {
TEST_F(EmbedderTest, CanRunInitializedEngine) {
EmbedderConfigBuilder builder(
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
auto engine = builder.InitializeEngine();
ASSERT_TRUE(engine.is_valid());
ASSERT_EQ(FlutterEngineRunInitialized(engine.get()), kSuccess);
@ -1247,7 +1247,7 @@ TEST_F(EmbedderTest, CanRunInitializedEngine) {
TEST_F(EmbedderTest, CanDeinitializeAnEngine) {
EmbedderConfigBuilder builder(
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext));
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
auto engine = builder.InitializeEngine();
ASSERT_TRUE(engine.is_valid());
ASSERT_EQ(FlutterEngineRunInitialized(engine.get()), kSuccess);
@ -1278,7 +1278,7 @@ TEST_F(EmbedderTest, CanDeinitializeAnEngine) {
TEST_F(EmbedderTest, CanAddView) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("window_metrics_event_all_view_ids");
fml::AutoResetWaitableEvent ready_latch, message_latch;
@ -1326,7 +1326,7 @@ TEST_F(EmbedderTest, CanAddView) {
TEST_F(EmbedderTest, AddViewSchedulesFrame) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("add_view_schedules_frame");
fml::AutoResetWaitableEvent latch;
context.AddNativeCallback(
@ -1371,7 +1371,7 @@ TEST_F(EmbedderTest, AddViewSchedulesFrame) {
TEST_F(EmbedderTest, CanRemoveView) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("window_metrics_event_all_view_ids");
fml::AutoResetWaitableEvent ready_latch, message_latch;
@ -1432,7 +1432,7 @@ TEST_F(EmbedderTest, CanRemoveView) {
TEST_F(EmbedderTest, CannotRemoveImplicitView) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
auto engine = builder.LaunchEngine();
ASSERT_TRUE(engine.is_valid());
@ -1452,7 +1452,7 @@ TEST_F(EmbedderTest, CannotRemoveImplicitView) {
TEST_F(EmbedderTest, CannotAddDuplicateViews) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("window_metrics_event_all_view_ids");
fml::AutoResetWaitableEvent ready_latch, message_latch;
@ -1524,7 +1524,7 @@ TEST_F(EmbedderTest, CannotAddDuplicateViews) {
TEST_F(EmbedderTest, CanReuseViewIds) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("window_metrics_event_all_view_ids");
fml::AutoResetWaitableEvent ready_latch, message_latch;
@ -1589,7 +1589,7 @@ TEST_F(EmbedderTest, CanReuseViewIds) {
TEST_F(EmbedderTest, CannotRemoveUnknownView) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
auto engine = builder.LaunchEngine();
ASSERT_TRUE(engine.is_valid());
@ -1615,7 +1615,7 @@ TEST_F(EmbedderTest, CannotRemoveUnknownView) {
TEST_F(EmbedderTest, ViewOperationsOrdered) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("window_metrics_event_all_view_ids");
fml::AutoResetWaitableEvent ready_latch;
@ -1762,7 +1762,7 @@ TEST_F(EmbedderTest, ViewOperationsOrdered) {
TEST_F(EmbedderTest, CanRenderMultipleViews) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetCompositor();
builder.SetDartEntrypoint("render_all_views");
@ -1843,7 +1843,7 @@ TEST_F(EmbedderTest, BackingStoresCorrespondToTheirViews) {
EmbedderConfigBuilder builder(context);
builder.SetDartEntrypoint("render_all_views");
builder.SetSoftwareRendererConfig(SkISize::Make(800, 600));
builder.SetSurface(SkISize::Make(800, 600));
builder.SetCompositor();
EmbedderTestBackingStoreProducerSoftware producer(
@ -1995,7 +1995,7 @@ TEST_F(EmbedderTest, BackingStoresCorrespondToTheirViews) {
TEST_F(EmbedderTest, CanUpdateLocales) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("can_receive_locale_updates");
fml::AutoResetWaitableEvent latch;
context.AddNativeCallback(
@ -2056,7 +2056,7 @@ TEST_F(EmbedderTest, LocalizationCallbacksCalled) {
fml::AutoResetWaitableEvent latch;
context.AddIsolateCreateCallback([&latch]() { latch.Signal(); });
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
auto engine = builder.LaunchEngine();
ASSERT_TRUE(engine.is_valid());
// Wait for the root isolate to launch.
@ -2087,7 +2087,7 @@ TEST_F(EmbedderTest, VerifyB143464703WithSoftwareBackend) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig(SkISize::Make(1024, 600));
builder.SetSurface(SkISize::Make(1024, 600));
builder.SetCompositor();
builder.SetDartEntrypoint("verify_b143464703");
@ -2211,7 +2211,7 @@ TEST_F(EmbedderTest, CanSendLowMemoryNotification) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
auto engine = builder.LaunchEngine();
@ -2241,7 +2241,7 @@ TEST_F(EmbedderTest, CanPostTaskToAllNativeThreads) {
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
engine = builder.LaunchEngine();
@ -2385,7 +2385,7 @@ TEST_F(EmbedderTest, MustNotRunWithMultipleAOTSources) {
context,
EmbedderConfigBuilder::InitializationPreference::kMultiAOTInitialize);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
auto engine = builder.LaunchEngine();
ASSERT_FALSE(engine.is_valid());
@ -2430,7 +2430,7 @@ TEST_F(EmbedderTest, CanLaunchAndShutdownWithAValidElfSource) {
context,
EmbedderConfigBuilder::InitializationPreference::kAOTDataInitialize);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
auto engine = builder.LaunchEngine();
ASSERT_TRUE(engine.is_valid());
@ -2466,7 +2466,7 @@ TEST_F(EmbedderTest, CanSuccessfullyPopulateSpecificJITSnapshotCallbacks) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
// Construct the location of valid JIT snapshots.
const std::string src_path = GetSourcePath();
@ -2522,7 +2522,7 @@ TEST_F(EmbedderTest, JITSnapshotCallbacksFailWithInvalidLocation) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
// Explicitly define the locations of the invalid JIT snapshots
builder.GetProjectArgs().vm_snapshot_data =
@ -2559,7 +2559,7 @@ TEST_F(EmbedderTest, CanLaunchEngineWithSpecifiedJITSnapshots) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
// Construct the location of valid JIT snapshots.
const std::string src_path = GetSourcePath();
@ -2599,7 +2599,7 @@ TEST_F(EmbedderTest, CanLaunchEngineWithSomeSpecifiedJITSnapshots) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
// Construct the location of valid JIT snapshots.
const std::string src_path = GetSourcePath();
@ -2632,7 +2632,7 @@ TEST_F(EmbedderTest, CanLaunchEngineWithInvalidJITSnapshots) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
// Explicitly define the locations of the JIT snapshots
builder.GetProjectArgs().isolate_snapshot_data =
@ -2658,7 +2658,7 @@ TEST_F(EmbedderTest, CanLaunchEngineWithUnspecifiedJITSnapshots) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
ASSERT_EQ(builder.GetProjectArgs().vm_snapshot_data, nullptr);
ASSERT_EQ(builder.GetProjectArgs().vm_snapshot_instructions, nullptr);
@ -2672,7 +2672,7 @@ TEST_F(EmbedderTest, CanLaunchEngineWithUnspecifiedJITSnapshots) {
TEST_F(EmbedderTest, InvalidFlutterWindowMetricsEvent) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
auto engine = builder.LaunchEngine();
ASSERT_TRUE(engine.is_valid());
@ -2724,7 +2724,7 @@ static void expectSoftwareRenderingOutputMatches(
fml::AutoResetWaitableEvent latch;
bool matches = false;
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetCompositor();
builder.SetDartEntrypoint(std::move(entrypoint));
builder.SetRenderTargetType(
@ -2943,7 +2943,7 @@ TEST_F(EmbedderTest, KeyDataIsCorrectlySerialized) {
auto& context =
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("key_data_echo");
builder.SetPlatformMessageCallback(
[&](const FlutterPlatformMessage* message) {
@ -3065,7 +3065,7 @@ TEST_F(EmbedderTest, KeyDataAreBuffered) {
auto& context =
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("key_data_late_echo");
builder.SetPlatformMessageCallback(
[&](const FlutterPlatformMessage* message) {
@ -3166,7 +3166,7 @@ TEST_F(EmbedderTest, KeyDataResponseIsCorrectlyInvoked) {
auto& context =
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("key_data_echo");
context.AddNativeCallback(
"SignalNativeTest",
@ -3241,7 +3241,7 @@ TEST_F(EmbedderTest, BackToBackKeyEventResponsesCorrectlyInvoked) {
GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("key_data_echo");
context.AddNativeCallback(
"SignalNativeTest",
@ -3340,7 +3340,7 @@ TEST_F(EmbedderTest, VsyncCallbackPostedIntoFuture) {
}));
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetupVsyncCallback();
builder.SetDartEntrypoint("empty_scene");
engine = builder.LaunchEngine();
@ -3371,7 +3371,7 @@ TEST_F(EmbedderTest, VsyncCallbackPostedIntoFuture) {
TEST_F(EmbedderTest, CanScheduleFrame) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("can_schedule_frame");
fml::AutoResetWaitableEvent latch;
context.AddNativeCallback(
@ -3399,7 +3399,7 @@ TEST_F(EmbedderTest, CanScheduleFrame) {
TEST_F(EmbedderTest, CanSetNextFrameCallback) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("draw_solid_red");
auto engine = builder.LaunchEngine();
@ -3486,7 +3486,7 @@ TEST_F(EmbedderTest, EmbedderThreadHostUseCustomThreadConfig) {
TEST_F(EmbedderTest, CanSendPointer) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("pointer_data_packet");
fml::AutoResetWaitableEvent ready_latch, count_latch, message_latch;
@ -3537,7 +3537,7 @@ TEST_F(EmbedderTest, CanSendPointer) {
TEST_F(EmbedderTest, CanSendPointerEventWithViewId) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("pointer_data_packet_view_id");
fml::AutoResetWaitableEvent ready_latch, add_view_latch, message_latch;
@ -3599,7 +3599,7 @@ TEST_F(EmbedderTest, CanSendPointerEventWithViewId) {
TEST_F(EmbedderTest, WindowMetricsEventDefaultsToImplicitView) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("window_metrics_event_view_id");
fml::AutoResetWaitableEvent ready_latch, message_latch;
@ -3640,7 +3640,7 @@ TEST_F(EmbedderTest, WindowMetricsEventDefaultsToImplicitView) {
TEST_F(EmbedderTest, IgnoresWindowMetricsEventForUnknownView) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kSoftwareContext);
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("window_metrics_event_view_id");
fml::AutoResetWaitableEvent ready_latch, message_latch;
@ -3710,7 +3710,7 @@ TEST_F(EmbedderTest, RegisterChannelListener) {
});
EmbedderConfigBuilder builder(context);
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetDartEntrypoint("channel_listener_response");
auto engine = builder.LaunchEngine();
@ -3769,7 +3769,7 @@ TEST_F(EmbedderTest, PlatformThreadIsolatesWithCustomPlatformTaskRunner) {
EmbedderConfigBuilder builder(context);
const auto task_runner_description =
test_task_runner.GetFlutterTaskRunnerDescription();
builder.SetSoftwareRendererConfig();
builder.SetSurface(SkISize::Make(1, 1));
builder.SetPlatformTaskRunner(&task_runner_description);
builder.SetDartEntrypoint("invokePlatformThreadIsolate");
builder.AddCommandLineArgument("--enable-platform-isolates");

11
engine/src/flutter/shell/platform/embedder/tests/embedder_vk_unittests.cc
View File

@ -96,12 +96,12 @@ static_assert(
} // namespace
TEST_F(EmbedderTest, CanSwapOutVulkanCalls) {
auto& context = GetEmbedderContext(EmbedderTestContextType::kVulkanContext);
fml::AutoResetWaitableEvent latch;
auto& context = static_cast<EmbedderTestContextVulkan&>(
GetEmbedderContext(EmbedderTestContextType::kVulkanContext));
context.AddIsolateCreateCallback([&latch]() { latch.Signal(); });
EmbedderConfigBuilder builder(context);
builder.SetVulkanRendererConfig(
SkISize::Make(1024, 1024),
context.SetVulkanInstanceProcAddressCallback(
[](void* user_data, FlutterVulkanInstanceHandle instance,
const char* name) -> void* {
if (StrcmpFixed(name, "vkGetInstanceProcAddr") == 0) {
@ -114,6 +114,9 @@ TEST_F(EmbedderTest, CanSwapOutVulkanCalls) {
return EmbedderTestContextVulkan::InstanceProcAddr(user_data, instance,
name);
});
EmbedderConfigBuilder builder(context);
builder.SetSurface(SkISize::Make(1024, 1024));
auto engine = builder.LaunchEngine();
ASSERT_TRUE(engine.is_valid());
// Wait for the root isolate to launch.