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 {

 // Send a response from the engine.
 static void send_response(
     FLUTTER_API_SYMBOL(FlutterEngine) engine,
     const std::string& channel,
     const FlutterPlatformMessageResponseHandle* response_handle,
     const uint8_t* message,
     size_t message_size) {
   if (response_handle == nullptr) {
     return;
   }

   FlutterTask task;
   task.runner = new _FlutterTaskRunner(1234, channel, response_handle, message,
                                        message_size);
   task.task = task.runner->task;
   engine->platform_post_task_callback(task, 0, engine->user_data);
 }

 // Send a message from the engine.
 static void send_message(FLUTTER_API_SYMBOL(FlutterEngine) engine,
                          const std::string& channel,
                          const uint8_t* message,
                          size_t message_size) {
   FlutterTask task;
   task.runner =
       new _FlutterTaskRunner(1234, channel, nullptr, message, message_size);
   task.task = task.runner->task;
   engine->platform_post_task_callback(task, 0, engine->user_data);
 }

 static void invoke_method(FLUTTER_API_SYMBOL(FlutterEngine) engine,
                           const std::string& channel,
                           const gchar* name,
                           FlValue* args) {
   g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
   g_autoptr(GError) error = nullptr;
   g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
       FL_METHOD_CODEC(codec), name, args, &error);
   EXPECT_NE(message, nullptr);
   EXPECT_EQ(error, nullptr);

   FlutterTask task;
   task.runner = new _FlutterTaskRunner(
       1234, channel, nullptr,
       static_cast<const uint8_t*>(g_bytes_get_data(message, nullptr)),
       g_bytes_get_size(message));
   task.task = task.runner->task;
   engine->platform_post_task_callback(task, 0, engine->user_data);
 }

 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);

   if (strcmp(message->channel, "test/echo") == 0) {
     // Responds with the same message received.
     send_response(engine, message->channel, message->response_handle,
                   message->message, message->message_size);
   } else if (strcmp(message->channel, "test/send-message") == 0) {
     // Triggers the engine to send a message.
     send_response(engine, message->channel, message->response_handle, nullptr,
                   0);
     send_message(engine, "test/messages", message->message,
                  message->message_size);
   } else if (strcmp(message->channel, "test/standard-method") == 0) {
     g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
     g_autoptr(GBytes) m = g_bytes_new(message->message, message->message_size);
     g_autofree gchar* name = nullptr;
     g_autoptr(FlValue) args = nullptr;
     g_autoptr(GError) error = nullptr;
     EXPECT_TRUE(fl_method_codec_decode_method_call(FL_METHOD_CODEC(codec), m,
                                                    &name, &args, &error));
     EXPECT_EQ(error, nullptr);

     g_autoptr(GBytes) response = nullptr;
     if (strcmp(name, "Echo") == 0) {
       // Returns args as a success result.
       response = fl_method_codec_encode_success_envelope(FL_METHOD_CODEC(codec),
                                                          args, &error);
       EXPECT_EQ(error, nullptr);
     } else if (strcmp(name, "Error") == 0) {
       // Returns an error result.
       const gchar* code = nullptr;
       const gchar* message = nullptr;
       FlValue* details = nullptr;
       if (fl_value_get_length(args) >= 2) {
         FlValue* code_value = fl_value_get_list_value(args, 0);
         EXPECT_EQ(fl_value_get_type(code_value), FL_VALUE_TYPE_STRING);
         code = fl_value_get_string(code_value);
         FlValue* message_value = fl_value_get_list_value(args, 1);
         message = fl_value_get_type(message_value) == FL_VALUE_TYPE_STRING
                       ? fl_value_get_string(message_value)
                       : nullptr;
       }
       if (fl_value_get_length(args) >= 3) {
         details = fl_value_get_list_value(args, 2);
       }
       response = fl_method_codec_encode_error_envelope(
           FL_METHOD_CODEC(codec), code, message, details, &error);
       EXPECT_EQ(error, nullptr);
     } else if (strcmp(name, "InvokeMethod") == 0) {
       // Gets the engine to call the shell.
       if (fl_value_get_length(args) == 3) {
         FlValue* channel_value = fl_value_get_list_value(args, 0);
         EXPECT_EQ(fl_value_get_type(channel_value), FL_VALUE_TYPE_STRING);
         const gchar* channel = fl_value_get_string(channel_value);
         FlValue* name_value = fl_value_get_list_value(args, 1);
         EXPECT_EQ(fl_value_get_type(name_value), FL_VALUE_TYPE_STRING);
         const gchar* name = fl_value_get_string(name_value);
         FlValue* method_args = fl_value_get_list_value(args, 2);
         invoke_method(engine, channel, name, method_args);
       }
       response = fl_method_codec_encode_success_envelope(FL_METHOD_CODEC(codec),
                                                          nullptr, &error);
       EXPECT_EQ(error, nullptr);
     } else {
       // Returns "not implemented".
       response = g_bytes_new(nullptr, 0);
     }

     send_response(
         engine, message->channel, message->response_handle,
         static_cast<const uint8_t*>(g_bytes_get_data(response, nullptr)),
         g_bytes_get_size(response));
   } else if (strcmp(message->channel, "test/nullptr-response") == 0) {
     // Sends a null response.
     send_response(engine, message->channel, message->response_handle, nullptr,
                   0);
   } else if (strcmp(message->channel, "test/standard-event") == 0) {
     // Send a message so the shell can check the events sent.
     send_message(engine, "test/events", message->message,
                  message->message_size);
   } else if (strcmp(message->channel, "test/failure") == 0) {
     // Generates an internal error.
     return kInternalInconsistency;
   } else if (strcmp(message->channel, "test/key-event-handled") == 0 ||
              strcmp(message->channel, "test/key-event-not-handled") == 0) {
     bool value = strcmp(message->channel, "test/key-event-handled") == 0;
     g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
     g_autoptr(FlValue) handledValue = fl_value_new_map();
     fl_value_set_string_take(handledValue, "handled", fl_value_new_bool(value));
     g_autoptr(GBytes) response = fl_message_codec_encode_message(
         FL_MESSAGE_CODEC(codec), handledValue, nullptr);
     send_response(
         engine, message->channel, message->response_handle,
         static_cast<const uint8_t*>(g_bytes_get_data(response, nullptr)),
         g_bytes_get_size(response));
   } else if (strcmp(message->channel, "test/key-event-delayed") == 0) {
     static std::unique_ptr<const FlutterPlatformMessageResponseHandle>
         delayed_response_handle = nullptr;
     g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
     g_autoptr(FlValue) handledValue = fl_value_new_map();
     fl_value_set_string_take(handledValue, "handled", fl_value_new_bool(true));
     g_autoptr(GBytes) response = fl_message_codec_encode_message(
         FL_MESSAGE_CODEC(codec), handledValue, nullptr);
     if (delayed_response_handle == nullptr) {
       delayed_response_handle.reset(message->response_handle);
     } else {
       send_response(
           engine, message->channel, message->response_handle,
           static_cast<const uint8_t*>(g_bytes_get_data(response, nullptr)),
           g_bytes_get_size(response));
       send_response(
           engine, message->channel, delayed_response_handle.release(),
           static_cast<const uint8_t*>(g_bytes_get_data(response, nullptr)),
           g_bytes_get_size(response));
     }
   }

   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);

   // Send a message so the shell can check the responses received.
   if (handle->channel != "test/responses") {
     send_message(engine, "test/responses", data, data_length);
   }

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

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

	// Send a response from the engine.
	static void send_response(
	FLUTTER_API_SYMBOL(FlutterEngine) engine,
	const std::string& channel,
	const FlutterPlatformMessageResponseHandle* response_handle,
	const uint8_t* message,
	size_t message_size) {
	if (response_handle == nullptr) {
	return;
	}

	FlutterTask task;
	task.runner = new _FlutterTaskRunner(1234, channel, response_handle, message,
	message_size);
	task.task = task.runner->task;
	engine->platform_post_task_callback(task, 0, engine->user_data);
	}

	// Send a message from the engine.
	static void send_message(FLUTTER_API_SYMBOL(FlutterEngine) engine,
	const std::string& channel,
	const uint8_t* message,
	size_t message_size) {
	FlutterTask task;
	task.runner =
	new _FlutterTaskRunner(1234, channel, nullptr, message, message_size);
	task.task = task.runner->task;
	engine->platform_post_task_callback(task, 0, engine->user_data);
	}

	static void invoke_method(FLUTTER_API_SYMBOL(FlutterEngine) engine,
	const std::string& channel,
	const gchar* name,
	FlValue* args) {
	g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
	g_autoptr(GError) error = nullptr;
	g_autoptr(GBytes) message = fl_method_codec_encode_method_call(
	FL_METHOD_CODEC(codec), name, args, &error);
	EXPECT_NE(message, nullptr);
	EXPECT_EQ(error, nullptr);

	FlutterTask task;
	task.runner = new _FlutterTaskRunner(
	1234, channel, nullptr,
	static_cast<const uint8_t*>(g_bytes_get_data(message, nullptr)),
	g_bytes_get_size(message));
	task.task = task.runner->task;
	engine->platform_post_task_callback(task, 0, engine->user_data);
	}

	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);

	if (strcmp(message->channel, "test/echo") == 0) {
	// Responds with the same message received.
	send_response(engine, message->channel, message->response_handle,
	message->message, message->message_size);
	} else if (strcmp(message->channel, "test/send-message") == 0) {
	// Triggers the engine to send a message.
	send_response(engine, message->channel, message->response_handle, nullptr,
	0);
	send_message(engine, "test/messages", message->message,
	message->message_size);
	} else if (strcmp(message->channel, "test/standard-method") == 0) {
	g_autoptr(FlStandardMethodCodec) codec = fl_standard_method_codec_new();
	g_autoptr(GBytes) m = g_bytes_new(message->message, message->message_size);
	g_autofree gchar* name = nullptr;
	g_autoptr(FlValue) args = nullptr;
	g_autoptr(GError) error = nullptr;
	EXPECT_TRUE(fl_method_codec_decode_method_call(FL_METHOD_CODEC(codec), m,
	&name, &args, &error));
	EXPECT_EQ(error, nullptr);

	g_autoptr(GBytes) response = nullptr;
	if (strcmp(name, "Echo") == 0) {
	// Returns args as a success result.
	response = fl_method_codec_encode_success_envelope(FL_METHOD_CODEC(codec),
	args, &error);
	EXPECT_EQ(error, nullptr);
	} else if (strcmp(name, "Error") == 0) {
	// Returns an error result.
	const gchar* code = nullptr;
	const gchar* message = nullptr;
	FlValue* details = nullptr;
	if (fl_value_get_length(args) >= 2) {
	FlValue* code_value = fl_value_get_list_value(args, 0);
	EXPECT_EQ(fl_value_get_type(code_value), FL_VALUE_TYPE_STRING);
	code = fl_value_get_string(code_value);
	FlValue* message_value = fl_value_get_list_value(args, 1);
	message = fl_value_get_type(message_value) == FL_VALUE_TYPE_STRING
	? fl_value_get_string(message_value)
	: nullptr;
	}
	if (fl_value_get_length(args) >= 3) {
	details = fl_value_get_list_value(args, 2);
	}
	response = fl_method_codec_encode_error_envelope(
	FL_METHOD_CODEC(codec), code, message, details, &error);
	EXPECT_EQ(error, nullptr);
	} else if (strcmp(name, "InvokeMethod") == 0) {
	// Gets the engine to call the shell.
	if (fl_value_get_length(args) == 3) {
	FlValue* channel_value = fl_value_get_list_value(args, 0);
	EXPECT_EQ(fl_value_get_type(channel_value), FL_VALUE_TYPE_STRING);
	const gchar* channel = fl_value_get_string(channel_value);
	FlValue* name_value = fl_value_get_list_value(args, 1);
	EXPECT_EQ(fl_value_get_type(name_value), FL_VALUE_TYPE_STRING);
	const gchar* name = fl_value_get_string(name_value);
	FlValue* method_args = fl_value_get_list_value(args, 2);
	invoke_method(engine, channel, name, method_args);
	}
	response = fl_method_codec_encode_success_envelope(FL_METHOD_CODEC(codec),
	nullptr, &error);
	EXPECT_EQ(error, nullptr);
	} else {
	// Returns "not implemented".
	response = g_bytes_new(nullptr, 0);
	}

	send_response(
	engine, message->channel, message->response_handle,
	static_cast<const uint8_t*>(g_bytes_get_data(response, nullptr)),
	g_bytes_get_size(response));
	} else if (strcmp(message->channel, "test/nullptr-response") == 0) {
	// Sends a null response.
	send_response(engine, message->channel, message->response_handle, nullptr,
	0);
	} else if (strcmp(message->channel, "test/standard-event") == 0) {
	// Send a message so the shell can check the events sent.
	send_message(engine, "test/events", message->message,
	message->message_size);
	} else if (strcmp(message->channel, "test/failure") == 0) {
	// Generates an internal error.
	return kInternalInconsistency;
	} else if (strcmp(message->channel, "test/key-event-handled") == 0 \|\|
	strcmp(message->channel, "test/key-event-not-handled") == 0) {
	bool value = strcmp(message->channel, "test/key-event-handled") == 0;
	g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
	g_autoptr(FlValue) handledValue = fl_value_new_map();
	fl_value_set_string_take(handledValue, "handled", fl_value_new_bool(value));
	g_autoptr(GBytes) response = fl_message_codec_encode_message(
	FL_MESSAGE_CODEC(codec), handledValue, nullptr);
	send_response(
	engine, message->channel, message->response_handle,
	static_cast<const uint8_t*>(g_bytes_get_data(response, nullptr)),
	g_bytes_get_size(response));
	} else if (strcmp(message->channel, "test/key-event-delayed") == 0) {
	static std::unique_ptr<const FlutterPlatformMessageResponseHandle>
	delayed_response_handle = nullptr;
	g_autoptr(FlJsonMessageCodec) codec = fl_json_message_codec_new();
	g_autoptr(FlValue) handledValue = fl_value_new_map();
	fl_value_set_string_take(handledValue, "handled", fl_value_new_bool(true));
	g_autoptr(GBytes) response = fl_message_codec_encode_message(
	FL_MESSAGE_CODEC(codec), handledValue, nullptr);
	if (delayed_response_handle == nullptr) {
	delayed_response_handle.reset(message->response_handle);
	} else {
	send_response(
	engine, message->channel, message->response_handle,
	static_cast<const uint8_t*>(g_bytes_get_data(response, nullptr)),
	g_bytes_get_size(response));
	send_response(
	engine, message->channel, delayed_response_handle.release(),
	static_cast<const uint8_t*>(g_bytes_get_data(response, nullptr)),
	g_bytes_get_size(response));
	}
	}

	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);

	// Send a message so the shell can check the responses received.
	if (handle->channel != "test/responses") {
	send_message(engine, "test/responses", data, data_length);
	}

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

	} // 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;
	return kSuccess;
	}