tester_main.cc File Reference

#include <cstdlib>
#include <cstring>
#include <iostream>
#include "flutter/assets/asset_manager.h"
#include "flutter/assets/directory_asset_bundle.h"
#include "flutter/flow/embedded_views.h"
#include "flutter/fml/build_config.h"
#include "flutter/fml/file.h"
#include "flutter/fml/make_copyable.h"
#include "flutter/fml/message_loop.h"
#include "flutter/fml/paths.h"
#include "flutter/fml/synchronization/waitable_event.h"
#include "flutter/fml/task_runner.h"
#include "flutter/shell/common/platform_view.h"
#include "flutter/shell/common/rasterizer.h"
#include "flutter/shell/common/shell.h"
#include "flutter/shell/common/switches.h"
#include "flutter/shell/common/thread_host.h"
#include "flutter/shell/gpu/gpu_surface_software.h"
#include "third_party/abseil-cpp/absl/base/no_destructor.h"
#include "third_party/dart/runtime/include/bin/dart_io_api.h"
#include "third_party/dart/runtime/include/dart_api.h"
#include "third_party/skia/include/core/SkSurface.h"
#include "flutter/shell/testing/tester_context.h"
#include "flutter/shell/testing/tester_context_mtl_factory.h"
#include "flutter/shell/testing/tester_context_vk_factory.h"

Go to the source code of this file.

Classes
class	flutter::TesterExternalViewEmbedder
class	flutter::TesterGPUSurfaceSoftware
class	flutter::TesterPlatformView
class	flutter::ScriptCompletionTaskObserver

Namespaces
namespace	flutter

Macros
#define	FML_USED_ON_EMBEDDER
#define	EXPORTED   __attribute__((visibility("default")))

Functions
static void	flutter::ConfigureShell (Shell *shell)
static void	flutter::UnblockSIGPROF ()
int	flutter::RunTester (const flutter::Settings &settings, bool run_forever, bool multithreaded)
EXPORTED Dart_Handle	flutter::LoadLibraryFromKernel (const char *path)
EXPORTED Dart_Handle	flutter::LookupEntryPoint (const char *uri, const char *name)
EXPORTED void	flutter::Spawn (const char *entrypoint, const char *route)
EXPORTED void	flutter::ForceShutdownIsolate ()
int	main (int argc, char *argv[])

Variables
static absl::NoDestructor< std::unique_ptr< Shell > >	flutter::g_shell

Macro Definition Documentation

EXPORTED

#define EXPORTED   __attribute__((visibility("default")))

Definition at line 457 of file tester_main.cc.

FML_USED_ON_EMBEDDER

#define FML_USED_ON_EMBEDDER

Definition at line 5 of file tester_main.cc.

Function Documentation

main()

int main	(	int	argc,
		char *	argv[]
	)

Definition at line 557 of file tester_main.cc.

                                 {
  dart::bin::SetExecutableName(argv[0]);
  dart::bin::SetExecutableArguments(argc - 1, argv);
 
  auto command_line = fml::CommandLineFromPlatformOrArgcArgv(argc, argv);
 
  if (command_line.HasOption(flutter::FlagForSwitch(flutter::Switch::Help))) {
    flutter::PrintUsage("flutter_tester");
    return EXIT_SUCCESS;
  }
 
  auto settings = flutter::SettingsFromCommandLine(command_line);
  if (!command_line.positional_args().empty()) {
    // The tester may not use the switch for the main dart file path. Specifying
    // it as a positional argument instead.
    settings.application_kernel_asset = command_line.positional_args()[0];
  }
 
  if (settings.application_kernel_asset.empty()) {
    FML_LOG(ERROR) << "Dart kernel file not specified.";
    return EXIT_FAILURE;
  }
 
  settings.leak_vm = false;
  settings.enable_platform_isolates = true;
 
  if (settings.icu_data_path.empty()) {
    settings.icu_data_path = "icudtl.dat";
  }
 
  // The tools that read logs get confused if there is a log tag specified.
  settings.log_tag = "";
 
  settings.log_message_callback = [](const std::string& tag,
                                     const std::string& message) {
    if (!tag.empty()) {
      std::cout << tag << ": ";
    }
    std::cout << message << std::endl;
  };
 
  settings.task_observer_add = [](intptr_t key, const fml::closure& callback) {
    fml::TaskQueueId queue_id = fml::MessageLoop::GetCurrentTaskQueueId();
    fml::MessageLoopTaskQueues::GetInstance()->AddTaskObserver(queue_id, key,
                                                               callback);
    return queue_id;
  };
 
  settings.task_observer_remove = [](fml::TaskQueueId queue_id, intptr_t key) {
    fml::MessageLoopTaskQueues::GetInstance()->RemoveTaskObserver(queue_id,
                                                                  key);
  };
 
  settings.unhandled_exception_callback = [](const std::string& error,
                                             const std::string& stack_trace) {
    FML_LOG(ERROR) << "Unhandled exception" << std::endl
                   << "Exception: " << error << std::endl
                   << "Stack trace: " << stack_trace;
    ::exit(1);
    return true;
  };
 
#if defined(FML_OS_WIN)
  CoInitializeEx(nullptr, COINIT_MULTITHREADED);
#endif  // defined(FML_OS_WIN)
 
  return flutter::RunTester(settings,
                            command_line.HasOption(flutter::FlagForSwitch(
                                flutter::Switch::RunForever)),
                            command_line.HasOption(flutter::FlagForSwitch(
                                flutter::Switch::ForceMultithreading)));
}

References fml::MessageLoopTaskQueues::AddTaskObserver(), argv, callback, fml::CommandLineFromPlatformOrArgcArgv(), error, flutter::FlagForSwitch(), FML_LOG, fml::MessageLoop::GetCurrentTaskQueueId(), fml::MessageLoopTaskQueues::GetInstance(), key, message, flutter::PrintUsage(), fml::MessageLoopTaskQueues::RemoveTaskObserver(), flutter::RunTester(), and flutter::SettingsFromCommandLine().