shell/platform/linux/testing/mock_engine.cc - mirrors/engine - Git at Google

 // 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.

 // This file is a historical legacy, predating the proc table API. It has been
 // updated to continue to work with the proc table, but new tests should not
 // rely on replacements set up here, but instead use test-local replacements
 // for any functions relevant to that test.
 //
 // Over time existing tests should be migrated and this file should be removed.

 #include <cstring>
 #include <unordered_map>
 #include <utility>

 #include "flutter/shell/platform/embedder/embedder.h"
 #include "flutter/shell/platform/linux/fl_method_codec_private.h"
 #include "flutter/shell/platform/linux/public/flutter_linux/fl_json_message_codec.h"
 #include "flutter/shell/platform/linux/public/flutter_linux/fl_method_response.h"
 #include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_method_codec.h"
 #include "gtest/gtest.h"

 const int32_t kFlutterSemanticsNodeIdBatchEnd = -1;
 const int32_t kFlutterSemanticsCustomActionIdBatchEnd = -1;

 struct _FlutterEngineTexture {
   bool has_new_frame;
 };

 struct _FlutterEngine {
   bool running = false;
   FlutterPlatformMessageCallback platform_message_callback;
   FlutterTaskRunnerPostTaskCallback platform_post_task_callback;
   void* user_data;
   std::unordered_map<int64_t, _FlutterEngineTexture> textures;

   _FlutterEngine(FlutterPlatformMessageCallback platform_message_callback,
                  FlutterTaskRunnerPostTaskCallback platform_post_task_callback,
                  void* user_data)
       : platform_message_callback(platform_message_callback),
         platform_post_task_callback(platform_post_task_callback),
         user_data(user_data) {}
 };

 struct _FlutterPlatformMessageResponseHandle {
   FlutterDataCallback data_callback;
   void* user_data;
   std::string channel;
   bool released;

   // Constructor for a response handle generated by the engine.
   explicit _FlutterPlatformMessageResponseHandle(std::string channel)
       : data_callback(nullptr),
         user_data(nullptr),
         channel(std::move(channel)),
         released(false) {}

   // Constructor for a response handle generated by the shell.
   _FlutterPlatformMessageResponseHandle(FlutterDataCallback data_callback,
                                         void* user_data)
       : data_callback(data_callback), user_data(user_data), released(false) {}
 };

 struct _FlutterTaskRunner {
   uint64_t task;
   std::string channel;
   const FlutterPlatformMessageResponseHandle* response_handle;
   uint8_t* message;
   size_t message_size;

   _FlutterTaskRunner(
       uint64_t task,
       const std::string& channel,
       const FlutterPlatformMessageResponseHandle* response_handle,
       const uint8_t* message,
       size_t message_size)
       : task(task),
         channel(channel),
         response_handle(response_handle),
         message_size(message_size) {
     if (message_size > 0) {
       this->message = static_cast<uint8_t*>(malloc(message_size));
       memcpy(this->message, message, message_size);
     } else {
       this->message = nullptr;
     }
   }
   ~_FlutterTaskRunner() {
     if (response_handle != nullptr) {
       EXPECT_TRUE(response_handle->released);
       delete response_handle;
     }
     free(message);
   }
 };

 namespace {

 FlutterEngineResult FlutterEngineCreateAOTData(
     const FlutterEngineAOTDataSource* source,
     FlutterEngineAOTData* data_out) {
   *data_out = nullptr;
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineCollectAOTData(FlutterEngineAOTData data) {
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineInitialize(size_t version,
                                             const FlutterRendererConfig* config,
                                             const FlutterProjectArgs* args,
                                             void* user_data,
                                             FLUTTER_API_SYMBOL(FlutterEngine) *
                                                 engine_out) {
   EXPECT_NE(config, nullptr);

   EXPECT_NE(args, nullptr);
   EXPECT_NE(args->platform_message_callback, nullptr);
   EXPECT_NE(args->custom_task_runners, nullptr);
   EXPECT_NE(args->custom_task_runners->platform_task_runner, nullptr);
   EXPECT_NE(args->custom_task_runners->platform_task_runner->post_task_callback,
             nullptr);

   EXPECT_NE(user_data, nullptr);

   EXPECT_EQ(config->type, kOpenGL);

   *engine_out = new _FlutterEngine(
       args->platform_message_callback,
       args->custom_task_runners->platform_task_runner->post_task_callback,
       user_data);
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineRunInitialized(
     FLUTTER_API_SYMBOL(FlutterEngine) engine) {
   engine->running = true;
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineRun(size_t version,
                                      const FlutterRendererConfig* config,
                                      const FlutterProjectArgs* args,
                                      void* user_data,
                                      FLUTTER_API_SYMBOL(FlutterEngine) *
                                          engine_out) {
   EXPECT_NE(config, nullptr);
   EXPECT_NE(args, nullptr);
   EXPECT_NE(user_data, nullptr);
   EXPECT_NE(engine_out, nullptr);

   FlutterEngineResult result =
       FlutterEngineInitialize(version, config, args, user_data, engine_out);
   if (result != kSuccess) {
     return result;
   }
   return FlutterEngineRunInitialized(*engine_out);
 }

 FlutterEngineResult FlutterEngineShutdown(FLUTTER_API_SYMBOL(FlutterEngine)
                                               engine) {
   delete engine;
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineDeinitialize(FLUTTER_API_SYMBOL(FlutterEngine)
                                                   engine) {
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineSendWindowMetricsEvent(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     const FlutterWindowMetricsEvent* event) {
   EXPECT_TRUE(engine->running);
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineSendPointerEvent(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     const FlutterPointerEvent* events,
     size_t events_count) {
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineSendKeyEvent(FLUTTER_API_SYMBOL(FlutterEngine)
                                                   engine,
                                               const FlutterKeyEvent* event,
                                               FlutterKeyEventCallback callback,
                                               void* user_data) {
   return kSuccess;
 }

 FLUTTER_EXPORT
 FlutterEngineResult FlutterEngineSendPlatformMessage(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     const FlutterPlatformMessage* message) {
   EXPECT_TRUE(engine->running);

   return kSuccess;
 }

 FlutterEngineResult FlutterPlatformMessageCreateResponseHandle(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     FlutterDataCallback data_callback,
     void* user_data,
     FlutterPlatformMessageResponseHandle** response_out) {
   EXPECT_TRUE(engine->running);
   EXPECT_NE(data_callback, nullptr);
   EXPECT_NE(user_data, nullptr);

   _FlutterPlatformMessageResponseHandle* handle =
       new _FlutterPlatformMessageResponseHandle(data_callback, user_data);

   *response_out = handle;
   return kSuccess;
 }

 FlutterEngineResult FlutterPlatformMessageReleaseResponseHandle(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     FlutterPlatformMessageResponseHandle* response) {
   EXPECT_NE(engine, nullptr);
   EXPECT_NE(response, nullptr);

   EXPECT_TRUE(engine->running);

   EXPECT_FALSE(response->released);
   response->released = true;

   return kSuccess;
 }

 FlutterEngineResult FlutterEngineSendPlatformMessageResponse(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     const FlutterPlatformMessageResponseHandle* handle,
     const uint8_t* data,
     size_t data_length) {
   EXPECT_NE(engine, nullptr);
   EXPECT_NE(handle, nullptr);

   EXPECT_TRUE(engine->running);

   EXPECT_FALSE(handle->released);

   delete handle;

   return kSuccess;
 }

 FlutterEngineResult FlutterEngineRunTask(FLUTTER_API_SYMBOL(FlutterEngine)
                                              engine,
                                          const FlutterTask* task) {
   EXPECT_NE(engine, nullptr);
   EXPECT_NE(task, nullptr);
   EXPECT_NE(task->runner, nullptr);

   FlutterTaskRunner runner = task->runner;
   EXPECT_NE(runner, nullptr);
   const FlutterPlatformMessageResponseHandle* response_handle =
       runner->response_handle;
   if (response_handle != nullptr) {
     EXPECT_NE(response_handle->data_callback, nullptr);
     response_handle->data_callback(runner->message, runner->message_size,
                                    response_handle->user_data);
   } else {
     _FlutterPlatformMessageResponseHandle* handle =
         new _FlutterPlatformMessageResponseHandle(runner->channel);

     FlutterPlatformMessage message;
     message.struct_size = sizeof(FlutterPlatformMessage);
     message.channel = runner->channel.c_str();
     message.message = runner->message;
     message.message_size = runner->message_size;
     message.response_handle = handle;
     engine->platform_message_callback(&message, engine->user_data);
   }

   delete runner;

   return kSuccess;
 }

 bool FlutterEngineRunsAOTCompiledDartCode() {
   return false;
 }

 FlutterEngineResult FlutterEngineUpdateLocales(FLUTTER_API_SYMBOL(FlutterEngine)
                                                    engine,
                                                const FlutterLocale** locales,
                                                size_t locales_count) {
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineUpdateSemanticsEnabled(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     bool enabled) {
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineUpdateAccessibilityFeatures(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     FlutterAccessibilityFeature features) {
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineDispatchSemanticsAction(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     uint64_t id,
     FlutterSemanticsAction action,
     const uint8_t* data,
     size_t data_length) {
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineRegisterExternalTexture(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     int64_t texture_identifier) {
   _FlutterEngineTexture texture;
   texture.has_new_frame = false;
   engine->textures[texture_identifier] = texture;
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineMarkExternalTextureFrameAvailable(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     int64_t texture_identifier) {
   auto val = engine->textures.find(texture_identifier);
   if (val == std::end(engine->textures)) {
     return kInvalidArguments;
   }
   val->second.has_new_frame = true;
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineUnregisterExternalTexture(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     int64_t texture_identifier) {
   auto val = engine->textures.find(texture_identifier);
   if (val == std::end(engine->textures)) {
     return kInvalidArguments;
   }
   engine->textures.erase(texture_identifier);
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineNotifyDisplayUpdate(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     FlutterEngineDisplaysUpdateType update_type,
     const FlutterEngineDisplay* displays,
     size_t display_count) {
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineAddView(FLUTTER_API_SYMBOL(FlutterEngine)
                                              engine,
                                          const FlutterAddViewInfo* info) {
   return kSuccess;
 }

 FlutterEngineResult FlutterEngineRemoveView(FLUTTER_API_SYMBOL(FlutterEngine)
                                                 engine,
                                             const FlutterRemoveViewInfo* info) {
   return kSuccess;
 }

 }  // namespace

 FlutterEngineResult FlutterEngineGetProcAddresses(
     FlutterEngineProcTable* table) {
   if (!table) {
     return kInvalidArguments;
   }

   FlutterEngineProcTable empty_table = {};
   *table = empty_table;

   table->CreateAOTData = &FlutterEngineCreateAOTData;
   table->CollectAOTData = &FlutterEngineCollectAOTData;
   table->Run = &FlutterEngineRun;
   table->Shutdown = &FlutterEngineShutdown;
   table->Initialize = &FlutterEngineInitialize;
   table->Deinitialize = &FlutterEngineDeinitialize;
   table->RunInitialized = &FlutterEngineRunInitialized;
   table->SendWindowMetricsEvent = &FlutterEngineSendWindowMetricsEvent;
   table->SendPointerEvent = &FlutterEngineSendPointerEvent;
   table->SendKeyEvent = &FlutterEngineSendKeyEvent;
   table->SendPlatformMessage = &FlutterEngineSendPlatformMessage;
   table->PlatformMessageCreateResponseHandle =
       &FlutterPlatformMessageCreateResponseHandle;
   table->PlatformMessageReleaseResponseHandle =
       &FlutterPlatformMessageReleaseResponseHandle;
   table->SendPlatformMessageResponse =
       &FlutterEngineSendPlatformMessageResponse;
   table->RunTask = &FlutterEngineRunTask;
   table->UpdateLocales = &FlutterEngineUpdateLocales;
   table->UpdateSemanticsEnabled = &FlutterEngineUpdateSemanticsEnabled;
   table->DispatchSemanticsAction = &FlutterEngineDispatchSemanticsAction;
   table->RunsAOTCompiledDartCode = &FlutterEngineRunsAOTCompiledDartCode;
   table->RegisterExternalTexture = &FlutterEngineRegisterExternalTexture;
   table->MarkExternalTextureFrameAvailable =
       &FlutterEngineMarkExternalTextureFrameAvailable;
   table->UnregisterExternalTexture = &FlutterEngineUnregisterExternalTexture;
   table->UpdateAccessibilityFeatures =
       &FlutterEngineUpdateAccessibilityFeatures;
   table->NotifyDisplayUpdate = &FlutterEngineNotifyDisplayUpdate;
   table->AddView = &FlutterEngineAddView;
   table->RemoveView = &FlutterEngineRemoveView;
   return kSuccess;
 }
	// 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.

	// This file is a historical legacy, predating the proc table API. It has been
	// updated to continue to work with the proc table, but new tests should not
	// rely on replacements set up here, but instead use test-local replacements
	// for any functions relevant to that test.
	//
	// Over time existing tests should be migrated and this file should be removed.

	#include <cstring>
	#include <unordered_map>
	#include <utility>

	#include "flutter/shell/platform/embedder/embedder.h"
	#include "flutter/shell/platform/linux/fl_method_codec_private.h"
	#include "flutter/shell/platform/linux/public/flutter_linux/fl_json_message_codec.h"
	#include "flutter/shell/platform/linux/public/flutter_linux/fl_method_response.h"
	#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_method_codec.h"
	#include "gtest/gtest.h"

	const int32_t kFlutterSemanticsNodeIdBatchEnd = -1;
	const int32_t kFlutterSemanticsCustomActionIdBatchEnd = -1;

	struct _FlutterEngineTexture {
	bool has_new_frame;
	};

	struct _FlutterEngine {
	bool running = false;
	FlutterPlatformMessageCallback platform_message_callback;
	FlutterTaskRunnerPostTaskCallback platform_post_task_callback;
	void* user_data;
	std::unordered_map<int64_t, _FlutterEngineTexture> textures;

	_FlutterEngine(FlutterPlatformMessageCallback platform_message_callback,
	FlutterTaskRunnerPostTaskCallback platform_post_task_callback,
	void* user_data)
	: platform_message_callback(platform_message_callback),
	platform_post_task_callback(platform_post_task_callback),
	user_data(user_data) {}
	};

	struct _FlutterPlatformMessageResponseHandle {
	FlutterDataCallback data_callback;
	void* user_data;
	std::string channel;
	bool released;

	// Constructor for a response handle generated by the engine.
	explicit _FlutterPlatformMessageResponseHandle(std::string channel)
	: data_callback(nullptr),
	user_data(nullptr),
	channel(std::move(channel)),
	released(false) {}

	// Constructor for a response handle generated by the shell.
	_FlutterPlatformMessageResponseHandle(FlutterDataCallback data_callback,
	void* user_data)
	: data_callback(data_callback), user_data(user_data), released(false) {}
	};

	struct _FlutterTaskRunner {
	uint64_t task;
	std::string channel;
	const FlutterPlatformMessageResponseHandle* response_handle;
	uint8_t* message;
	size_t message_size;

	_FlutterTaskRunner(
	uint64_t task,
	const std::string& channel,
	const FlutterPlatformMessageResponseHandle* response_handle,
	const uint8_t* message,
	size_t message_size)
	: task(task),
	channel(channel),
	response_handle(response_handle),
	message_size(message_size) {
	if (message_size > 0) {
	this->message = static_cast<uint8_t*>(malloc(message_size));
	memcpy(this->message, message, message_size);
	} else {
	this->message = nullptr;
	}
	}
	~_FlutterTaskRunner() {
	if (response_handle != nullptr) {
	EXPECT_TRUE(response_handle->released);
	delete response_handle;
	}
	free(message);
	}
	};

	namespace {

	FlutterEngineResult FlutterEngineCreateAOTData(
	const FlutterEngineAOTDataSource* source,
	FlutterEngineAOTData* data_out) {
	*data_out = nullptr;
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineCollectAOTData(FlutterEngineAOTData data) {
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineInitialize(size_t version,
	const FlutterRendererConfig* config,
	const FlutterProjectArgs* args,
	void* user_data,
	FLUTTER_API_SYMBOL(FlutterEngine) *
	engine_out) {
	EXPECT_NE(config, nullptr);

	EXPECT_NE(args, nullptr);
	EXPECT_NE(args->platform_message_callback, nullptr);
	EXPECT_NE(args->custom_task_runners, nullptr);
	EXPECT_NE(args->custom_task_runners->platform_task_runner, nullptr);
	EXPECT_NE(args->custom_task_runners->platform_task_runner->post_task_callback,
	nullptr);

	EXPECT_NE(user_data, nullptr);

	EXPECT_EQ(config->type, kOpenGL);

	*engine_out = new _FlutterEngine(
	args->platform_message_callback,
	args->custom_task_runners->platform_task_runner->post_task_callback,
	user_data);
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineRunInitialized(
	FLUTTER_API_SYMBOL(FlutterEngine) engine) {
	engine->running = true;
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineRun(size_t version,
	const FlutterRendererConfig* config,
	const FlutterProjectArgs* args,
	void* user_data,
	FLUTTER_API_SYMBOL(FlutterEngine) *
	engine_out) {
	EXPECT_NE(config, nullptr);
	EXPECT_NE(args, nullptr);
	EXPECT_NE(user_data, nullptr);
	EXPECT_NE(engine_out, nullptr);

	FlutterEngineResult result =
	FlutterEngineInitialize(version, config, args, user_data, engine_out);
	if (result != kSuccess) {
	return result;
	}
	return FlutterEngineRunInitialized(*engine_out);
	}

	FlutterEngineResult FlutterEngineShutdown(FLUTTER_API_SYMBOL(FlutterEngine)
	engine) {
	delete engine;
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineDeinitialize(FLUTTER_API_SYMBOL(FlutterEngine)
	engine) {
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineSendWindowMetricsEvent(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	const FlutterWindowMetricsEvent* event) {
	EXPECT_TRUE(engine->running);
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineSendPointerEvent(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	const FlutterPointerEvent* events,
	size_t events_count) {
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineSendKeyEvent(FLUTTER_API_SYMBOL(FlutterEngine)
	engine,
	const FlutterKeyEvent* event,
	FlutterKeyEventCallback callback,
	void* user_data) {
	return kSuccess;
	}

	FLUTTER_EXPORT
	FlutterEngineResult FlutterEngineSendPlatformMessage(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	const FlutterPlatformMessage* message) {
	EXPECT_TRUE(engine->running);

	return kSuccess;
	}

	FlutterEngineResult FlutterPlatformMessageCreateResponseHandle(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	FlutterDataCallback data_callback,
	void* user_data,
	FlutterPlatformMessageResponseHandle** response_out) {
	EXPECT_TRUE(engine->running);
	EXPECT_NE(data_callback, nullptr);
	EXPECT_NE(user_data, nullptr);

	_FlutterPlatformMessageResponseHandle* handle =
	new _FlutterPlatformMessageResponseHandle(data_callback, user_data);

	*response_out = handle;
	return kSuccess;
	}

	FlutterEngineResult FlutterPlatformMessageReleaseResponseHandle(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	FlutterPlatformMessageResponseHandle* response) {
	EXPECT_NE(engine, nullptr);
	EXPECT_NE(response, nullptr);

	EXPECT_TRUE(engine->running);

	EXPECT_FALSE(response->released);
	response->released = true;

	return kSuccess;
	}

	FlutterEngineResult FlutterEngineSendPlatformMessageResponse(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	const FlutterPlatformMessageResponseHandle* handle,
	const uint8_t* data,
	size_t data_length) {
	EXPECT_NE(engine, nullptr);
	EXPECT_NE(handle, nullptr);

	EXPECT_TRUE(engine->running);

	EXPECT_FALSE(handle->released);

	delete handle;

	return kSuccess;
	}

	FlutterEngineResult FlutterEngineRunTask(FLUTTER_API_SYMBOL(FlutterEngine)
	engine,
	const FlutterTask* task) {
	EXPECT_NE(engine, nullptr);
	EXPECT_NE(task, nullptr);
	EXPECT_NE(task->runner, nullptr);

	FlutterTaskRunner runner = task->runner;
	EXPECT_NE(runner, nullptr);
	const FlutterPlatformMessageResponseHandle* response_handle =
	runner->response_handle;
	if (response_handle != nullptr) {
	EXPECT_NE(response_handle->data_callback, nullptr);
	response_handle->data_callback(runner->message, runner->message_size,
	response_handle->user_data);
	} else {
	_FlutterPlatformMessageResponseHandle* handle =
	new _FlutterPlatformMessageResponseHandle(runner->channel);

	FlutterPlatformMessage message;
	message.struct_size = sizeof(FlutterPlatformMessage);
	message.channel = runner->channel.c_str();
	message.message = runner->message;
	message.message_size = runner->message_size;
	message.response_handle = handle;
	engine->platform_message_callback(&message, engine->user_data);
	}

	delete runner;

	return kSuccess;
	}

	bool FlutterEngineRunsAOTCompiledDartCode() {
	return false;
	}

	FlutterEngineResult FlutterEngineUpdateLocales(FLUTTER_API_SYMBOL(FlutterEngine)
	engine,
	const FlutterLocale** locales,
	size_t locales_count) {
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineUpdateSemanticsEnabled(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	bool enabled) {
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineUpdateAccessibilityFeatures(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	FlutterAccessibilityFeature features) {
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineDispatchSemanticsAction(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	uint64_t id,
	FlutterSemanticsAction action,
	const uint8_t* data,
	size_t data_length) {
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineRegisterExternalTexture(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	int64_t texture_identifier) {
	_FlutterEngineTexture texture;
	texture.has_new_frame = false;
	engine->textures[texture_identifier] = texture;
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineMarkExternalTextureFrameAvailable(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	int64_t texture_identifier) {
	auto val = engine->textures.find(texture_identifier);
	if (val == std::end(engine->textures)) {
	return kInvalidArguments;
	}
	val->second.has_new_frame = true;
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineUnregisterExternalTexture(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	int64_t texture_identifier) {
	auto val = engine->textures.find(texture_identifier);
	if (val == std::end(engine->textures)) {
	return kInvalidArguments;
	}
	engine->textures.erase(texture_identifier);
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineNotifyDisplayUpdate(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	FlutterEngineDisplaysUpdateType update_type,
	const FlutterEngineDisplay* displays,
	size_t display_count) {
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineAddView(FLUTTER_API_SYMBOL(FlutterEngine)
	engine,
	const FlutterAddViewInfo* info) {
	return kSuccess;
	}

	FlutterEngineResult FlutterEngineRemoveView(FLUTTER_API_SYMBOL(FlutterEngine)
	engine,
	const FlutterRemoveViewInfo* info) {
	return kSuccess;
	}

	} // namespace

	FlutterEngineResult FlutterEngineGetProcAddresses(
	FlutterEngineProcTable* table) {
	if (!table) {
	return kInvalidArguments;
	}

	FlutterEngineProcTable empty_table = {};
	*table = empty_table;

	table->CreateAOTData = &FlutterEngineCreateAOTData;
	table->CollectAOTData = &FlutterEngineCollectAOTData;
	table->Run = &FlutterEngineRun;
	table->Shutdown = &FlutterEngineShutdown;
	table->Initialize = &FlutterEngineInitialize;
	table->Deinitialize = &FlutterEngineDeinitialize;
	table->RunInitialized = &FlutterEngineRunInitialized;
	table->SendWindowMetricsEvent = &FlutterEngineSendWindowMetricsEvent;
	table->SendPointerEvent = &FlutterEngineSendPointerEvent;
	table->SendKeyEvent = &FlutterEngineSendKeyEvent;
	table->SendPlatformMessage = &FlutterEngineSendPlatformMessage;
	table->PlatformMessageCreateResponseHandle =
	&FlutterPlatformMessageCreateResponseHandle;
	table->PlatformMessageReleaseResponseHandle =
	&FlutterPlatformMessageReleaseResponseHandle;
	table->SendPlatformMessageResponse =
	&FlutterEngineSendPlatformMessageResponse;
	table->RunTask = &FlutterEngineRunTask;
	table->UpdateLocales = &FlutterEngineUpdateLocales;
	table->UpdateSemanticsEnabled = &FlutterEngineUpdateSemanticsEnabled;
	table->DispatchSemanticsAction = &FlutterEngineDispatchSemanticsAction;
	table->RunsAOTCompiledDartCode = &FlutterEngineRunsAOTCompiledDartCode;
	table->RegisterExternalTexture = &FlutterEngineRegisterExternalTexture;
	table->MarkExternalTextureFrameAvailable =
	&FlutterEngineMarkExternalTextureFrameAvailable;
	table->UnregisterExternalTexture = &FlutterEngineUnregisterExternalTexture;
	table->UpdateAccessibilityFeatures =
	&FlutterEngineUpdateAccessibilityFeatures;
	table->NotifyDisplayUpdate = &FlutterEngineNotifyDisplayUpdate;
	table->AddView = &FlutterEngineAddView;
	table->RemoveView = &FlutterEngineRemoveView;
	return kSuccess;
	}