flutter::testing::EmbedderConfigBuilder Class Reference

#include <embedder_config_builder.h>

Public Types
enum class	InitializationPreference { kSnapshotsInitialize , kAOTDataInitialize , kMultiAOTInitialize , kNoInitialize }

Public Member Functions
	EmbedderConfigBuilder (EmbedderTestContext &context, InitializationPreference preference=InitializationPreference::kSnapshotsInitialize)
	~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={})
void	SetOpenGLFBOCallBack ()
void	SetOpenGLPresentCallBack ()
void	SetAssetsPath ()
void	SetSnapshots ()
void	SetAOTDataElf ()
void	SetIsolateCreateCallbackHook ()
void	SetSemanticsCallbackHooks ()
void	SetLogMessageCallbackHook ()
void	SetChannelUpdateCallbackHook ()
void	SetLogTag (std::string tag)
void	SetLocalizationCallbackHooks ()
void	SetExecutableName (std::string executable_name)
void	SetDartEntrypoint (std::string entrypoint)
void	AddCommandLineArgument (std::string arg)
void	AddDartEntrypointArgument (std::string arg)
void	SetPlatformTaskRunner (const FlutterTaskRunnerDescription *runner)
void	SetRenderTaskRunner (const FlutterTaskRunnerDescription *runner)
void	SetPlatformMessageCallback (const std::function< void(const FlutterPlatformMessage *)> &callback)
void	SetCompositor (bool avoid_backing_store_cache=false, bool use_present_layers_callback=false)
FlutterCompositor &	GetCompositor ()
FlutterRendererConfig &	GetRendererConfig ()
void	SetRenderTargetType (EmbedderTestBackingStoreProducer::RenderTargetType type, FlutterSoftwarePixelFormat software_pixfmt=kFlutterSoftwarePixelFormatNative32)
UniqueEngine	LaunchEngine () const
UniqueEngine	InitializeEngine () const
void	SetupVsyncCallback ()

Detailed Description

Definition at line 30 of file embedder_config_builder.h.

Member Enumeration Documentation

InitializationPreference

enum class flutter::testing::EmbedderConfigBuilder::InitializationPreference

strong

Enumerator
kSnapshotsInitialize
kAOTDataInitialize
kMultiAOTInitialize
kNoInitialize

Definition at line 32 of file embedder_config_builder.h.

                                      {
    kSnapshotsInitialize,
    kAOTDataInitialize,
    kMultiAOTInitialize,
    kNoInitialize,
  };

Constructor & Destructor Documentation

EmbedderConfigBuilder()

flutter::testing::EmbedderConfigBuilder::EmbedderConfigBuilder ( EmbedderTestContext &  context, InitializationPreference  preference = InitializationPreference::kSnapshotsInitialize  )

explicit

Definition at line 32 of file embedder_config_builder.cc.

    : context_(context) {
  project_args_.struct_size = sizeof(project_args_);
  project_args_.shutdown_dart_vm_when_done = true;
  project_args_.platform_message_callback =
      [](const FlutterPlatformMessage* message, void* context) {
        reinterpret_cast<EmbedderTestContext*>(context)
            ->PlatformMessageCallback(message);
      };
 
  custom_task_runners_.struct_size = sizeof(FlutterCustomTaskRunners);
 
#ifdef SHELL_ENABLE_GL
  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();
  };
#endif
 
#ifdef SHELL_ENABLE_METAL
  InitializeMetalRendererConfig();
#endif
 
#ifdef SHELL_ENABLE_VULKAN
  InitializeVulkanRendererConfig();
#endif
 
  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");
 
  if (preference != InitializationPreference::kNoInitialize) {
    SetAssetsPath();
    SetIsolateCreateCallbackHook();
    SetSemanticsCallbackHooks();
    SetLogMessageCallbackHook();
    SetLocalizationCallbackHooks();
    SetChannelUpdateCallbackHook();
    AddCommandLineArgument("--disable-vm-service");
 
    if (preference == InitializationPreference::kSnapshotsInitialize ||
        preference == InitializationPreference::kMultiAOTInitialize) {
      SetSnapshots();
    }
    if (preference == InitializationPreference::kAOTDataInitialize ||
        preference == InitializationPreference::kMultiAOTInitialize) {
      SetAOTDataElf();
    }
  }
}

~EmbedderConfigBuilder()

flutter::testing::EmbedderConfigBuilder::~EmbedderConfigBuilder ( )

default

Member Function Documentation

AddCommandLineArgument()

void flutter::testing::EmbedderConfigBuilder::AddCommandLineArgument

(

std::string

arg

)

Definition at line 307 of file embedder_config_builder.cc.

                                                                {
  if (arg.empty()) {
    return;
  }
 
  command_line_arguments_.emplace_back(std::move(arg));
}

AddDartEntrypointArgument()

void flutter::testing::EmbedderConfigBuilder::AddDartEntrypointArgument

(

std::string

arg

)

Definition at line 315 of file embedder_config_builder.cc.

                                                                   {
  if (arg.empty()) {
    return;
  }
 
  dart_entrypoint_arguments_.emplace_back(std::move(arg));
}

GetCompositor()

FlutterCompositor & flutter::testing::EmbedderConfigBuilder::GetCompositor

(

)

Definition at line 402 of file embedder_config_builder.cc.

                                                        {
  return compositor_;
}

GetProjectArgs()

FlutterProjectArgs & flutter::testing::EmbedderConfigBuilder::GetProjectArgs

(

)

Definition at line 134 of file embedder_config_builder.cc.

                                                          {
  return project_args_;
}

GetRendererConfig()

FlutterRendererConfig & flutter::testing::EmbedderConfigBuilder::GetRendererConfig

(

)

Definition at line 339 of file embedder_config_builder.cc.

                                                                {
  return renderer_config_;
}

InitializeEngine()

UniqueEngine flutter::testing::EmbedderConfigBuilder::InitializeEngine

(

)

const

Definition at line 421 of file embedder_config_builder.cc.

                                                           {
  return SetupEngine(false);
}

LaunchEngine()

UniqueEngine flutter::testing::EmbedderConfigBuilder::LaunchEngine

(

)

const

Definition at line 417 of file embedder_config_builder.cc.

                                                       {
  return SetupEngine(true);
}

SetAOTDataElf()

void flutter::testing::EmbedderConfigBuilder::SetAOTDataElf

(

)

Definition at line 251 of file embedder_config_builder.cc.

                                          {
  project_args_.aot_data = context_.GetAOTData();
}

SetAssetsPath()

void flutter::testing::EmbedderConfigBuilder::SetAssetsPath

(

)

Definition at line 225 of file embedder_config_builder.cc.

                                          {
  project_args_.assets_path = context_.GetAssetsPath().c_str();
}

SetChannelUpdateCallbackHook()

void flutter::testing::EmbedderConfigBuilder::SetChannelUpdateCallbackHook

(

)

Definition at line 276 of file embedder_config_builder.cc.

                                                         {
  project_args_.channel_update_callback =
      context_.GetChannelUpdateCallbackHook();
}

SetCompositor()

void flutter::testing::EmbedderConfigBuilder::SetCompositor	(	bool	avoid_backing_store_cache = false,
		bool	use_present_layers_callback = false
	)

Definition at line 358 of file embedder_config_builder.cc.

                                                                            {
  context_.SetupCompositor();
  auto& compositor = context_.GetCompositor();
  compositor_.struct_size = sizeof(compositor_);
  compositor_.user_data = &compositor;
  compositor_.create_backing_store_callback =
      [](const FlutterBackingStoreConfig* config,  //
         FlutterBackingStore* backing_store_out,   //
         void* user_data                           //
      ) {
        return reinterpret_cast<EmbedderTestCompositor*>(user_data)
            ->CreateBackingStore(config, backing_store_out);
      };
  compositor_.collect_backing_store_callback =
      [](const FlutterBackingStore* backing_store,  //
         void* user_data                            //
      ) {
        return reinterpret_cast<EmbedderTestCompositor*>(user_data)
            ->CollectBackingStore(backing_store);
      };
  if (use_present_layers_callback) {
    compositor_.present_layers_callback = [](const FlutterLayer** layers,
                                             size_t layers_count,
                                             void* user_data) {
      auto compositor = reinterpret_cast<EmbedderTestCompositor*>(user_data);
 
      // The present layers callback is incompatible with multiple views;
      // it can only be used to render the implicit view.
      return compositor->Present(kFlutterImplicitViewId, layers, layers_count);
    };
  } else {
    compositor_.present_view_callback = [](const FlutterPresentViewInfo* info) {
      auto compositor =
          reinterpret_cast<EmbedderTestCompositor*>(info->user_data);
 
      return compositor->Present(info->view_id, info->layers,
                                 info->layers_count);
    };
  }
  compositor_.avoid_backing_store_cache = avoid_backing_store_cache;
  project_args_.compositor = &compositor_;
}

SetDartEntrypoint()

void flutter::testing::EmbedderConfigBuilder::SetDartEntrypoint

(

std::string

entrypoint

)

Definition at line 298 of file embedder_config_builder.cc.

                                                                  {
  if (entrypoint.empty()) {
    return;
  }
 
  dart_entrypoint_ = std::move(entrypoint);
  project_args_.custom_dart_entrypoint = dart_entrypoint_.c_str();
}

SetExecutableName()

void flutter::testing::EmbedderConfigBuilder::SetExecutableName

(

std::string

executable_name

)

Definition at line 291 of file embedder_config_builder.cc.

                                                                       {
  if (executable_name.empty()) {
    return;
  }
  command_line_arguments_[0] = std::move(executable_name);
}

SetIsolateCreateCallbackHook()

void flutter::testing::EmbedderConfigBuilder::SetIsolateCreateCallbackHook

(

)

Definition at line 255 of file embedder_config_builder.cc.

                                                         {
  project_args_.root_isolate_create_callback =
      EmbedderTestContext::GetIsolateCreateCallbackHook();
}

SetLocalizationCallbackHooks()

void flutter::testing::EmbedderConfigBuilder::SetLocalizationCallbackHooks

(

)

Definition at line 286 of file embedder_config_builder.cc.

                                                         {
  project_args_.compute_platform_resolved_locale_callback =
      EmbedderTestContext::GetComputePlatformResolvedLocaleCallbackHook();
}

SetLogMessageCallbackHook()

void flutter::testing::EmbedderConfigBuilder::SetLogMessageCallbackHook

(

)

Definition at line 271 of file embedder_config_builder.cc.

                                                      {
  project_args_.log_message_callback =
      EmbedderTestContext::GetLogMessageCallbackHook();
}

SetLogTag()

void flutter::testing::EmbedderConfigBuilder::SetLogTag

(

std::string

tag

)

Definition at line 281 of file embedder_config_builder.cc.

                                                   {
  log_tag_ = std::move(tag);
  project_args_.log_tag = log_tag_.c_str();
}

SetMetalRendererConfig()

void flutter::testing::EmbedderConfigBuilder::SetMetalRendererConfig

(

SkISize

surface_size

)

Definition at line 201 of file embedder_config_builder.cc.

                                                                       {
#ifdef SHELL_ENABLE_METAL
  renderer_config_.type = FlutterRendererType::kMetal;
  renderer_config_.metal = metal_renderer_config_;
  context_.SetupSurface(surface_size);
#endif
}

SetOpenGLFBOCallBack()

void flutter::testing::EmbedderConfigBuilder::SetOpenGLFBOCallBack

(

)

Definition at line 144 of file embedder_config_builder.cc.

                                                 {
#ifdef SHELL_ENABLE_GL
  // 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);
  };
#endif
}

SetOpenGLPresentCallBack()

void flutter::testing::EmbedderConfigBuilder::SetOpenGLPresentCallBack

(

)

Definition at line 161 of file embedder_config_builder.cc.

                                                     {
#ifdef SHELL_ENABLE_GL
  // 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,
        });
  };
#endif
}

SetOpenGLRendererConfig()

void flutter::testing::EmbedderConfigBuilder::SetOpenGLRendererConfig

(

SkISize

surface_size

)

Definition at line 193 of file embedder_config_builder.cc.

                                                                        {
#ifdef SHELL_ENABLE_GL
  renderer_config_.type = FlutterRendererType::kOpenGL;
  renderer_config_.open_gl = opengl_renderer_config_;
  context_.SetupSurface(surface_size);
#endif
}

SetPlatformMessageCallback()

void flutter::testing::EmbedderConfigBuilder::SetPlatformMessageCallback

(

const std::function< void(const FlutterPlatformMessage *)> &

callback

)

Definition at line 353 of file embedder_config_builder.cc.

                                                                      {
  context_.SetPlatformMessageCallback(callback);
}

SetPlatformTaskRunner()

void flutter::testing::EmbedderConfigBuilder::SetPlatformTaskRunner

(

const FlutterTaskRunnerDescription *

runner

)

Definition at line 323 of file embedder_config_builder.cc.

                                                {
  if (runner == nullptr) {
    return;
  }
  custom_task_runners_.platform_task_runner = runner;
  project_args_.custom_task_runners = &custom_task_runners_;
}

SetRendererConfig()

void flutter::testing::EmbedderConfigBuilder::SetRendererConfig	(	EmbedderTestContextType	type,
		SkISize	surface_size
	)

Definition at line 175 of file embedder_config_builder.cc.

                                                                    {
  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;
  }
}

SetRenderTargetType()

void flutter::testing::EmbedderConfigBuilder::SetRenderTargetType	(	EmbedderTestBackingStoreProducer::RenderTargetType	type,
		FlutterSoftwarePixelFormat	software_pixfmt = kFlutterSoftwarePixelFormatNative32
	)

Definition at line 406 of file embedder_config_builder.cc.

                                                {
  auto& compositor = context_.GetCompositor();
  // TODO(wrightgeorge): figure out a better way of plumbing through the
  // GrDirectContext
  compositor.SetBackingStoreProducer(
      std::make_unique<EmbedderTestBackingStoreProducer>(
          compositor.GetGrContext(), type, software_pixfmt));
}

SetRenderTaskRunner()

void flutter::testing::EmbedderConfigBuilder::SetRenderTaskRunner

(

const FlutterTaskRunnerDescription *

runner

)

Definition at line 343 of file embedder_config_builder.cc.

                                                {
  if (runner == nullptr) {
    return;
  }
 
  custom_task_runners_.render_task_runner = runner;
  project_args_.custom_task_runners = &custom_task_runners_;
}

SetSemanticsCallbackHooks()

void flutter::testing::EmbedderConfigBuilder::SetSemanticsCallbackHooks

(

)

Definition at line 260 of file embedder_config_builder.cc.

                                                      {
  project_args_.update_semantics_callback2 =
      context_.GetUpdateSemanticsCallback2Hook();
  project_args_.update_semantics_callback =
      context_.GetUpdateSemanticsCallbackHook();
  project_args_.update_semantics_node_callback =
      context_.GetUpdateSemanticsNodeCallbackHook();
  project_args_.update_semantics_custom_action_callback =
      context_.GetUpdateSemanticsCustomActionCallbackHook();
}

SetSnapshots()

void flutter::testing::EmbedderConfigBuilder::SetSnapshots

(

)

Definition at line 229 of file embedder_config_builder.cc.

                                         {
  if (auto mapping = context_.GetVMSnapshotData()) {
    project_args_.vm_snapshot_data = mapping->GetMapping();
    project_args_.vm_snapshot_data_size = mapping->GetSize();
  }
 
  if (auto mapping = context_.GetVMSnapshotInstructions()) {
    project_args_.vm_snapshot_instructions = mapping->GetMapping();
    project_args_.vm_snapshot_instructions_size = mapping->GetSize();
  }
 
  if (auto mapping = context_.GetIsolateSnapshotData()) {
    project_args_.isolate_snapshot_data = mapping->GetMapping();
    project_args_.isolate_snapshot_data_size = mapping->GetSize();
  }
 
  if (auto mapping = context_.GetIsolateSnapshotInstructions()) {
    project_args_.isolate_snapshot_instructions = mapping->GetMapping();
    project_args_.isolate_snapshot_instructions_size = mapping->GetSize();
  }
}

SetSoftwareRendererConfig()

void flutter::testing::EmbedderConfigBuilder::SetSoftwareRendererConfig

(

SkISize

surface_size = SkISize::Make(1, 1)

)

Definition at line 138 of file embedder_config_builder.cc.

                                                                          {
  renderer_config_.type = FlutterRendererType::kSoftware;
  renderer_config_.software = software_renderer_config_;
  context_.SetupSurface(surface_size);
}

SetupVsyncCallback()

void flutter::testing::EmbedderConfigBuilder::SetupVsyncCallback

(

)

Definition at line 332 of file embedder_config_builder.cc.

                                               {
  project_args_.vsync_callback = [](void* user_data, intptr_t baton) {
    auto context = reinterpret_cast<EmbedderTestContext*>(user_data);
    context->RunVsyncCallback(baton);
  };
}

SetVulkanRendererConfig()

void flutter::testing::EmbedderConfigBuilder::SetVulkanRendererConfig	(	SkISize	surface_size,
		std::optional< FlutterVulkanInstanceProcAddressCallback >	instance_proc_address_callback = {}
	)

Definition at line 209 of file embedder_config_builder.cc.

                                        {
#ifdef SHELL_ENABLE_VULKAN
  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);
#endif
}

---

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

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