fl_binary_messenger_test.cc

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

// Included first as it collides with the X11 headers.
#include "gtest/gtest.h"

#include <pthread.h>
#include <cstring>

#include "flutter/shell/platform/embedder/embedder.h"
#include "flutter/shell/platform/embedder/test_utils/proc_table_replacement.h"
#include "flutter/shell/platform/linux/fl_binary_messenger_private.h"
#include "flutter/shell/platform/linux/fl_engine_private.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_binary_messenger.h"
#include "flutter/shell/platform/linux/public/flutter_linux/fl_standard_method_codec.h"

// Checks can send a message.
TEST(FlBinaryMessengerTest, Send) {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);

  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  FlutterEngineProcTable* embedder_api = fl_engine_get_embedder_api(engine);

  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);

  FlutterDataCallback response_callback;
  void* response_callback_user_data;
  embedder_api->PlatformMessageCreateResponseHandle = MOCK_ENGINE_PROC(
      PlatformMessageCreateResponseHandle,
      ([&response_callback, &response_callback_user_data](
           auto engine, FlutterDataCallback data_callback, void* user_data,
           FlutterPlatformMessageResponseHandle** response_out) {
        response_callback = data_callback;
        response_callback_user_data = user_data;
        return kSuccess;
      }));
  embedder_api->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&response_callback, &response_callback_user_data](
           auto engine, const FlutterPlatformMessage* message) {
        EXPECT_STREQ(message->channel, "test");
        g_autofree gchar* text =
            g_strndup(reinterpret_cast<const gchar*>(message->message),
                      message->message_size);
        EXPECT_STREQ(text, "Marco!");

        const gchar* response = "Polo!";
        response_callback(reinterpret_cast<const uint8_t*>(response),
                          strlen(response), response_callback_user_data);

        return kSuccess;
      }));

  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  const char* text = "Marco!";
  g_autoptr(GBytes) message = g_bytes_new(text, strlen(text));
  fl_binary_messenger_send_on_channel(
      messenger, "test", message, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        g_autoptr(GError) error = nullptr;
        g_autoptr(GBytes) message = fl_binary_messenger_send_on_channel_finish(
            FL_BINARY_MESSENGER(object), result, &error);
        EXPECT_NE(message, nullptr);
        EXPECT_EQ(error, nullptr);

        g_autofree gchar* text = g_strndup(
            static_cast<const gchar*>(g_bytes_get_data(message, nullptr)),
            g_bytes_get_size(message));
        EXPECT_STREQ(text, "Polo!");

        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);

  g_main_loop_run(loop);
}

// Checks sending nullptr for a message works.
TEST(FlBinaryMessengerTest, SendNullptr) {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  FlutterEngineProcTable* embedder_api = fl_engine_get_embedder_api(engine);

  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);

  bool called = false;
  embedder_api->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&called](auto engine, const FlutterPlatformMessage* message) {
        called = true;

        EXPECT_STREQ(message->channel, "test");
        // Note we don't check message->message as it could be nullptr or a
        // pointer to an buffer - either way it wouldn't be accessed.
        EXPECT_EQ(message->message_size, static_cast<size_t>(0));

        return kSuccess;
      }));

  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  fl_binary_messenger_send_on_channel(messenger, "test", nullptr, nullptr,
                                      nullptr, nullptr);
  EXPECT_TRUE(called);
}

// Checks sending a zero length message works.
TEST(FlBinaryMessengerTest, SendEmpty) {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  FlutterEngineProcTable* embedder_api = fl_engine_get_embedder_api(engine);

  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);

  bool called = false;
  embedder_api->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&called](auto engine, const FlutterPlatformMessage* message) {
        called = true;

        EXPECT_STREQ(message->channel, "test");
        EXPECT_EQ(message->message_size, static_cast<size_t>(0));

        return kSuccess;
      }));
  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  g_autoptr(GBytes) message = g_bytes_new(nullptr, 0);
  fl_binary_messenger_send_on_channel(messenger, "test", message, nullptr,
                                      nullptr, nullptr);
  EXPECT_TRUE(called);
}

// Checks the engine returning a nullptr message work.
TEST(FlBinaryMessengerTest, NullptrResponse) {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);

  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  FlutterEngineProcTable* embedder_api = fl_engine_get_embedder_api(engine);

  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);

  FlutterDataCallback response_callback;
  void* response_callback_user_data;
  embedder_api->PlatformMessageCreateResponseHandle = MOCK_ENGINE_PROC(
      PlatformMessageCreateResponseHandle,
      ([&response_callback, &response_callback_user_data](
           auto engine, FlutterDataCallback data_callback, void* user_data,
           FlutterPlatformMessageResponseHandle** response_out) {
        response_callback = data_callback;
        response_callback_user_data = user_data;
        return kSuccess;
      }));
  embedder_api->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&response_callback, &response_callback_user_data](
           auto engine, const FlutterPlatformMessage* message) {
        EXPECT_STREQ(message->channel, "test");
        g_autofree gchar* text =
            g_strndup(reinterpret_cast<const gchar*>(message->message),
                      message->message_size);
        EXPECT_STREQ(text, "Hello World!");

        response_callback(nullptr, 0, response_callback_user_data);

        return kSuccess;
      }));

  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  const char* text = "Hello World!";
  g_autoptr(GBytes) message = g_bytes_new(text, strlen(text));
  fl_binary_messenger_send_on_channel(
      messenger, "test", message, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        g_autoptr(GError) error = nullptr;
        g_autoptr(GBytes) message = fl_binary_messenger_send_on_channel_finish(
            FL_BINARY_MESSENGER(object), result, &error);
        EXPECT_NE(message, nullptr);
        EXPECT_EQ(error, nullptr);

        EXPECT_EQ(g_bytes_get_size(message), static_cast<gsize>(0));

        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);

  g_main_loop_run(loop);
}

// Checks the engine reporting a send failure is handled.
TEST(FlBinaryMessengerTest, SendFailure) {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);

  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  FlutterEngineProcTable* embedder_api = fl_engine_get_embedder_api(engine);

  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);

  embedder_api->SendPlatformMessage =
      MOCK_ENGINE_PROC(SendPlatformMessage,
                       ([](auto engine, const FlutterPlatformMessage* message) {
                         EXPECT_STREQ(message->channel, "test");
                         return kInternalInconsistency;
                       }));

  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  fl_binary_messenger_send_on_channel(
      messenger, "test", nullptr, nullptr,
      [](GObject* object, GAsyncResult* result, gpointer user_data) {
        g_autoptr(GError) error = nullptr;
        g_autoptr(GBytes) message = fl_binary_messenger_send_on_channel_finish(
            FL_BINARY_MESSENGER(object), result, &error);
        EXPECT_EQ(message, nullptr);
        EXPECT_NE(error, nullptr);
        EXPECT_STREQ(error->message, "Failed to send platform messages");

        g_main_loop_quit(static_cast<GMainLoop*>(user_data));
      },
      loop);

  g_main_loop_run(loop);
}

// Checks can receive a message.
TEST(FlBinaryMessengerTest, Receive) {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  FlutterEngineProcTable* embedder_api = fl_engine_get_embedder_api(engine);

  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);

  bool called = false;
  embedder_api->SendPlatformMessageResponse = MOCK_ENGINE_PROC(
      SendPlatformMessageResponse,
      ([&called](auto engine,
                 const FlutterPlatformMessageResponseHandle* handle,
                 const uint8_t* data, size_t data_length) {
        called = true;

        int fake_handle = *reinterpret_cast<const int*>(handle);
        EXPECT_EQ(fake_handle, 42);

        g_autofree gchar* text =
            g_strndup(reinterpret_cast<const gchar*>(data), data_length);
        EXPECT_STREQ(text, "Polo!");

        return kSuccess;
      }));

  FlBinaryMessenger* messenger = fl_engine_get_binary_messenger(engine);

  // Listen for message.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test",
      [](FlBinaryMessenger* messenger, const gchar* channel, GBytes* message,
         FlBinaryMessengerResponseHandle* response_handle, gpointer user_data) {
        g_autofree gchar* text = g_strndup(
            static_cast<const gchar*>(g_bytes_get_data(message, nullptr)),
            g_bytes_get_size(message));
        EXPECT_STREQ(text, "Marco!");

        const char* response_text = "Polo!";
        g_autoptr(GBytes) response =
            g_bytes_new(response_text, strlen(response_text));
        g_autoptr(GError) error = nullptr;
        EXPECT_TRUE(fl_binary_messenger_send_response(
            messenger, response_handle, response, &error));
        EXPECT_EQ(error, nullptr);
      },
      nullptr, nullptr);

  // Send message from engine.
  const char* message_text = "Marco!";
  g_autoptr(GBytes) message = g_bytes_new(message_text, strlen(message_text));
  int fake_handle = 42;
  fl_binary_messenger_handle_message(
      messenger, "test", message,
      reinterpret_cast<const FlutterPlatformMessageResponseHandle*>(
          &fake_handle));

  EXPECT_TRUE(called);
}

// Checks receieved messages can be responded to on a thread.
TEST(FlBinaryMessengerTest, ReceiveRespondThread) {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);

  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  FlutterEngineProcTable* embedder_api = fl_engine_get_embedder_api(engine);

  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);

  embedder_api->SendPlatformMessageResponse = MOCK_ENGINE_PROC(
      SendPlatformMessageResponse,
      ([&loop](auto engine, const FlutterPlatformMessageResponseHandle* handle,
               const uint8_t* data, size_t data_length) {
        int fake_handle = *reinterpret_cast<const int*>(handle);
        EXPECT_EQ(fake_handle, 42);

        g_autofree gchar* text =
            g_strndup(reinterpret_cast<const gchar*>(data), data_length);
        EXPECT_STREQ(text, "Polo!");

        g_main_loop_quit(loop);

        return kSuccess;
      }));

  FlBinaryMessenger* messenger = fl_engine_get_binary_messenger(engine);

  // Listen for message.
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test",
      [](FlBinaryMessenger* messenger, const gchar* channel, GBytes* message,
         FlBinaryMessengerResponseHandle* response_handle, gpointer user_data) {
        g_autofree gchar* text = g_strndup(
            static_cast<const gchar*>(g_bytes_get_data(message, nullptr)),
            g_bytes_get_size(message));
        EXPECT_STREQ(text, "Marco!");

        // Respond on a thread.
        typedef struct {
          FlBinaryMessenger* messenger;
          FlBinaryMessengerResponseHandle* response_handle;
        } ThreadData;
        ThreadData* data = g_new0(ThreadData, 1);
        data->messenger =
            static_cast<FlBinaryMessenger*>(g_object_ref(messenger));
        data->response_handle = static_cast<FlBinaryMessengerResponseHandle*>(
            g_object_ref(response_handle));
        g_autoptr(GThread) thread = g_thread_new(
            nullptr,
            [](gpointer user_data) {
              g_autofree ThreadData* data = static_cast<ThreadData*>(user_data);
              g_autoptr(FlBinaryMessenger) messenger = data->messenger;
              g_autoptr(FlBinaryMessengerResponseHandle) response_handle =
                  data->response_handle;

              const char* response_text = "Polo!";
              g_autoptr(GBytes) response =
                  g_bytes_new(response_text, strlen(response_text));
              g_autoptr(GError) error = nullptr;
              EXPECT_TRUE(fl_binary_messenger_send_response(
                  data->messenger, data->response_handle, response, &error));
              EXPECT_EQ(error, nullptr);

              return static_cast<gpointer>(nullptr);
            },
            data);
      },
      nullptr, nullptr);

  // Send message from engine.
  const char* message_text = "Marco!";
  g_autoptr(GBytes) message = g_bytes_new(message_text, strlen(message_text));
  int fake_handle = 42;
  fl_binary_messenger_handle_message(
      messenger, "test", message,
      reinterpret_cast<const FlutterPlatformMessageResponseHandle*>(
          &fake_handle));

  g_main_loop_run(loop);
}

// MOCK_ENGINE_PROC is leaky by design.
// NOLINTBEGIN(clang-analyzer-core.StackAddressEscape)

// Checks if the 'resize' command is sent and is well-formed.
TEST(FlBinaryMessengerTest, ResizeChannel) {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  FlutterEngineProcTable* embedder_api = fl_engine_get_embedder_api(engine);

  bool called = false;

  FlutterEngineSendPlatformMessageFnPtr old_handler =
      embedder_api->SendPlatformMessage;
  embedder_api->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&called, old_handler](auto engine,
                              const FlutterPlatformMessage* message) {
        // Expect to receive a message on the "control" channel.
        if (strcmp(message->channel, "dev.flutter/channel-buffers") != 0) {
          return old_handler(engine, message);
        }

        called = true;

        // The expected content was created from the following Dart code:
        //   MethodCall call = MethodCall('resize', ['flutter/test',3]);
        //   StandardMethodCodec().encodeMethodCall(call).buffer.asUint8List();
        const int expected_message_size = 29;
        EXPECT_EQ(message->message_size,
                  static_cast<size_t>(expected_message_size));
        int expected[expected_message_size] = {
            7,   6,   114, 101, 115, 105, 122, 101, 12,  2,
            7,   12,  102, 108, 117, 116, 116, 101, 114, 47,
            116, 101, 115, 116, 3,   3,   0,   0,   0};
        for (size_t i = 0; i < expected_message_size; i++) {
          EXPECT_EQ(message->message[i], expected[i]);
        }

        return kSuccess;
      }));

  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);

  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  fl_binary_messenger_resize_channel(messenger, "flutter/test", 3);

  EXPECT_TRUE(called);
}

// Checks if the 'overflow' command is sent and is well-formed.
TEST(FlBinaryMessengerTest, WarnsOnOverflowChannel) {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  FlutterEngineProcTable* embedder_api = fl_engine_get_embedder_api(engine);

  bool called = false;

  FlutterEngineSendPlatformMessageFnPtr old_handler =
      embedder_api->SendPlatformMessage;
  embedder_api->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&called, old_handler](auto engine,
                              const FlutterPlatformMessage* message) {
        // Expect to receive a message on the "control" channel.
        if (strcmp(message->channel, "dev.flutter/channel-buffers") != 0) {
          return old_handler(engine, message);
        }

        called = true;

        // The expected content was created from the following Dart code:
        //   MethodCall call = MethodCall('overflow',['flutter/test', true]);
        //   StandardMethodCodec().encodeMethodCall(call).buffer.asUint8List();
        const int expected_message_size = 27;
        EXPECT_EQ(message->message_size,
                  static_cast<size_t>(expected_message_size));
        int expected[expected_message_size] = {
            7,   8,   111, 118, 101, 114, 102, 108, 111, 119, 12,  2,   7, 12,
            102, 108, 117, 116, 116, 101, 114, 47,  116, 101, 115, 116, 1};
        for (size_t i = 0; i < expected_message_size; i++) {
          EXPECT_EQ(message->message[i], expected[i]);
        }

        return kSuccess;
      }));

  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);

  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  fl_binary_messenger_set_warns_on_channel_overflow(messenger, "flutter/test",
                                                    false);

  EXPECT_TRUE(called);
}

// Checks if error returned when invoking a command on the control channel
// are handled.
TEST(FlBinaryMessengerTest, ControlChannelErrorResponse) {
  g_autoptr(GMainLoop) loop = g_main_loop_new(nullptr, 0);

  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);
  FlutterEngineProcTable* embedder_api = fl_engine_get_embedder_api(engine);

  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);

  g_autoptr(FlBinaryMessenger) messenger = fl_binary_messenger_new(engine);
  bool called = false;
  FlutterEngineSendPlatformMessageFnPtr old_handler =
      embedder_api->SendPlatformMessage;
  embedder_api->SendPlatformMessage = MOCK_ENGINE_PROC(
      SendPlatformMessage,
      ([&called, old_handler, loop](auto engine,
                                    const FlutterPlatformMessage* message) {
        // Expect to receive a message on the "control" channel.
        if (strcmp(message->channel, "dev.flutter/channel-buffers") != 0) {
          return old_handler(engine, message);
        }

        called = true;

        // Register a callback to quit the main loop when binary messenger work
        // ends.
        g_idle_add(
            [](gpointer user_data) {
              g_main_loop_quit(static_cast<GMainLoop*>(user_data));
              return FALSE;
            },
            loop);

        // Simulates an internal error.
        return kInvalidArguments;
      }));

  fl_binary_messenger_set_warns_on_channel_overflow(messenger, "flutter/test",
                                                    false);

  EXPECT_TRUE(called);

  g_main_loop_run(loop);
}

// NOLINTEND(clang-analyzer-core.StackAddressEscape)

TEST(FlBinaryMessengerTest, DeletingEngineClearsHandlers) {
  g_autoptr(FlDartProject) project = fl_dart_project_new();
  g_autoptr(FlEngine) engine = fl_engine_new(project);

  g_autoptr(GError) error = nullptr;
  EXPECT_TRUE(fl_engine_start(engine, &error));
  EXPECT_EQ(error, nullptr);

  FlBinaryMessenger* messenger = fl_engine_get_binary_messenger(engine);

  // Add handler to check the destroy_notify is called.
  gboolean destroy_notify_called = FALSE;
  fl_binary_messenger_set_message_handler_on_channel(
      messenger, "test",
      [](FlBinaryMessenger* messenger, const gchar* channel, GBytes* message,
         FlBinaryMessengerResponseHandle* response_handle,
         gpointer user_data) {},
      &destroy_notify_called,
      [](gpointer user_data) { *static_cast<gboolean*>(user_data) = TRUE; });

  g_clear_object(&engine);

  ASSERT_TRUE(destroy_notify_called);
}