dart_runner Namespace Reference

Namespaces
namespace	testing

Classes
class	DartComponentController
	Starts a Dart component written in CFv2. More...
class	DartRunner
class	DartTestComponentController

Functions
void	InitBuiltinLibrariesForIsolate (const std::string &script_uri, fdio_ns_t *namespc, int stdoutfd, int stderrfd, zx::channel directory_request, bool service_isolate)
bool	IsTestProgram (const fuchsia::data::Dictionary &program_metadata)
Dart_Isolate	CreateServiceIsolate (const char *uri, Dart_IsolateFlags *flags_unused, char **error)
Dart_Handle	GetVMServiceAssetsArchiveCallback ()

Variables
constexpr char	kArgsKey [] = "args"
uint8_t const *const	vm_isolate_snapshot_buffer
uint8_t const *const	isolate_snapshot_buffer

Function Documentation

CreateServiceIsolate()

Dart_Isolate dart_runner::CreateServiceIsolate	(	const char *	uri,
		Dart_IsolateFlags *	flags_unused,
		char **	error
	)

Definition at line 75 of file service_isolate.cc.

                  {
  Dart_SetEmbedderInformationCallback(EmbedderInformationCallback);
 
  const uint8_t *vmservice_data = nullptr, *vmservice_instructions = nullptr;
 
#if defined(AOT_RUNTIME)
  // The VM service was compiled as a separate app.
  const char* snapshot_path = "/pkg/data/vmservice_snapshot.so";
  if (elf_snapshot.Load(nullptr, snapshot_path)) {
    vmservice_data = elf_snapshot.IsolateData();
    vmservice_instructions = elf_snapshot.IsolateInstrs();
    if (vmservice_data == nullptr || vmservice_instructions == nullptr) {
      return nullptr;
    }
  } else {
    // The VM service was compiled as a separate app.
    const char* snapshot_data_path =
        "/pkg/data/vmservice_isolate_snapshot_data.bin";
    const char* snapshot_instructions_path =
        "/pkg/data/vmservice_isolate_snapshot_instructions.bin";
#else
  // The VM service is embedded in the core snapshot.
  const char* snapshot_data_path = "/pkg/data/isolate_core_snapshot_data.bin";
  const char* snapshot_instructions_path =
      "/pkg/data/isolate_core_snapshot_instructions.bin";
#endif
 
    if (!dart_utils::MappedResource::LoadFromNamespace(
            nullptr, snapshot_data_path, mapped_isolate_snapshot_data)) {
      *error = strdup("Failed to load snapshot for service isolate");
      FML_LOG(ERROR) << *error;
      return nullptr;
    }
    if (!dart_utils::MappedResource::LoadFromNamespace(
            nullptr, snapshot_instructions_path,
            mapped_isolate_snapshot_instructions, true /* executable */)) {
      *error = strdup("Failed to load snapshot for service isolate");
      FML_LOG(ERROR) << *error;
      return nullptr;
    }
 
    vmservice_data = mapped_isolate_snapshot_data.address();
    vmservice_instructions = mapped_isolate_snapshot_instructions.address();
#if defined(AOT_RUNTIME)
  }
#endif
 
  Dart_IsolateFlags flags;
  Dart_IsolateFlagsInitialize(&flags);
  flags.null_safety = true;
 
  auto state = new std::shared_ptr<tonic::DartState>(new tonic::DartState());
  Dart_Isolate isolate = Dart_CreateIsolateGroup(
      uri, DART_VM_SERVICE_ISOLATE_NAME, vmservice_data, vmservice_instructions,
      &flags, state, state, error);
  if (!isolate) {
    FML_LOG(ERROR) << "Dart_CreateIsolateGroup failed: " << *error;
    return nullptr;
  }
 
  state->get()->SetIsolate(isolate);
 
  // Setup native entries.
  service_natives = new tonic::DartLibraryNatives();
  service_natives->Register({
      {"VMServiceIO_NotifyServerState", NotifyServerState, 1, true},
      {"VMServiceIO_Shutdown", Shutdown, 0, true},
  });
 
  Dart_EnterScope();
 
  Dart_Handle library =
      Dart_LookupLibrary(Dart_NewStringFromCString("dart:vmservice_io"));
  SHUTDOWN_ON_ERROR(library);
  Dart_Handle result = Dart_SetRootLibrary(library);
  SHUTDOWN_ON_ERROR(result);
  result = Dart_SetNativeResolver(library, GetNativeFunction, GetSymbol);
  SHUTDOWN_ON_ERROR(result);
 
  // _ip = '127.0.0.1'
  result = Dart_SetField(library, Dart_NewStringFromCString("_ip"),
                         Dart_NewStringFromCString("127.0.0.1"));
  SHUTDOWN_ON_ERROR(result);
 
  // _port = 0
  result = Dart_SetField(library, Dart_NewStringFromCString("_port"),
                         Dart_NewInteger(0));
  SHUTDOWN_ON_ERROR(result);
 
  // _autoStart = true
  result = Dart_SetField(library, Dart_NewStringFromCString("_autoStart"),
                         Dart_NewBoolean(true));
  SHUTDOWN_ON_ERROR(result);
 
  // _originCheckDisabled = false
  result =
      Dart_SetField(library, Dart_NewStringFromCString("_originCheckDisabled"),
                    Dart_NewBoolean(false));
  SHUTDOWN_ON_ERROR(result);
 
  // _authCodesDisabled = false
  result =
      Dart_SetField(library, Dart_NewStringFromCString("_authCodesDisabled"),
                    Dart_NewBoolean(false));
  SHUTDOWN_ON_ERROR(result);
 
  InitBuiltinLibrariesForIsolate(std::string(uri), nullptr, fileno(stdout),
                                 fileno(stderr), zx::channel(), true);
 
  // Make runnable.
  Dart_ExitScope();
  Dart_ExitIsolate();
  *error = Dart_IsolateMakeRunnable(isolate);
  if (*error != nullptr) {
    FML_LOG(ERROR) << *error;
    Dart_EnterIsolate(isolate);
    Dart_ShutdownIsolate();
    return nullptr;
  }
  return isolate;
}  // namespace dart_runner

GetVMServiceAssetsArchiveCallback()

Dart_Handle dart_runner::GetVMServiceAssetsArchiveCallback

(

)

Definition at line 200 of file service_isolate.cc.

                                                {
  dart_utils::MappedResource vm_service_tar;
  if (!dart_utils::MappedResource::LoadFromNamespace(
          nullptr, "/pkg/data/observatory.tar", vm_service_tar)) {
    FML_LOG(ERROR) << "Failed to load Observatory assets";
    return nullptr;
  }
  // TODO(rmacnak): Should we avoid copying the tar? Or does the service
  // library not hold onto it anyway?
  return tonic::DartConverter<tonic::Uint8List>::ToDart(
      reinterpret_cast<const uint8_t*>(vm_service_tar.address()),
      vm_service_tar.size());
}

InitBuiltinLibrariesForIsolate()

void dart_runner::InitBuiltinLibrariesForIsolate	(	const std::string &	script_uri,
		fdio_ns_t *	namespc,
		int	stdoutfd,
		int	stderrfd,
		zx::channel	directory_request,
		bool	service_isolate
	)

Definition at line 99 of file builtin_libraries.cc.

                                                          {
  // dart:fuchsia --------------------------------------------------------------
  // dart runner doesn't care about scenic view ref.
  if (!service_isolate) {
    fuchsia::dart::Initialize(std::move(directory_request), std::nullopt);
  }
 
  // dart:fuchsia.builtin ------------------------------------------------------
 
  Dart_Handle builtin_lib = Dart_LookupLibrary(ToDart("dart:fuchsia.builtin"));
  FML_CHECK(!tonic::CheckAndHandleError(builtin_lib));
  Dart_Handle result = Dart_SetNativeResolver(builtin_lib, BuiltinNativeLookup,
                                              BuiltinNativeSymbol);
  FML_CHECK(!tonic::CheckAndHandleError(result));
 
  // dart:io -------------------------------------------------------------------
 
  Dart_Handle io_lib = Dart_LookupLibrary(ToDart("dart:io"));
  FML_CHECK(!tonic::CheckAndHandleError(io_lib));
  result = Dart_SetNativeResolver(io_lib, dart::bin::IONativeLookup,
                                  dart::bin::IONativeSymbol);
  FML_CHECK(!tonic::CheckAndHandleError(result));
 
  // dart:zircon ---------------------------------------------------------------
 
  Dart_Handle zircon_lib = Dart_LookupLibrary(ToDart("dart:zircon"));
  FML_CHECK(!tonic::CheckAndHandleError(zircon_lib));
  // NativeResolver already set by fuchsia::dart::Initialize().
 
  // Core libraries ------------------------------------------------------------
 
  Dart_Handle async_lib = Dart_LookupLibrary(ToDart("dart:async"));
  FML_CHECK(!tonic::CheckAndHandleError(async_lib));
 
  Dart_Handle core_lib = Dart_LookupLibrary(ToDart("dart:core"));
  FML_CHECK(!tonic::CheckAndHandleError(core_lib));
 
  Dart_Handle internal_lib = Dart_LookupLibrary(ToDart("dart:_internal"));
  FML_CHECK(!tonic::CheckAndHandleError(internal_lib));
 
  Dart_Handle isolate_lib = Dart_LookupLibrary(ToDart("dart:isolate"));
  FML_CHECK(!tonic::CheckAndHandleError(isolate_lib));
 
#if !defined(AOT_RUNTIME)
  // AOT: These steps already happened at compile time in gen_snapshot.
 
  // We need to ensure that all the scripts loaded so far are finalized
  // as we are about to invoke some Dart code below to set up closures.
  result = Dart_FinalizeLoading(false);
  FML_CHECK(!tonic::CheckAndHandleError(result));
#endif
 
  // Setup the internal library's 'internalPrint' function.
  Dart_Handle print =
      Dart_Invoke(builtin_lib, ToDart("_getPrintClosure"), 0, nullptr);
  FML_CHECK(!tonic::CheckAndHandleError(print));
 
  result = Dart_SetField(internal_lib, ToDart("_printClosure"), print);
  FML_CHECK(!tonic::CheckAndHandleError(result));
 
  // Set up the 'scheduleImmediate' closure.
  Dart_Handle schedule_immediate_closure;
  if (service_isolate) {
    // Running on dart::ThreadPool.
    schedule_immediate_closure = Dart_Invoke(
        isolate_lib, ToDart("_getIsolateScheduleImmediateClosure"), 0, nullptr);
  } else {
    // Running on async::Loop.
    schedule_immediate_closure = Dart_Invoke(
        builtin_lib, ToDart("_getScheduleMicrotaskClosure"), 0, nullptr);
  }
  FML_CHECK(!tonic::CheckAndHandleError(schedule_immediate_closure));
 
  Dart_Handle schedule_args[1];
  schedule_args[0] = schedule_immediate_closure;
  result = Dart_Invoke(async_lib, ToDart("_setScheduleImmediateClosure"), 1,
                       schedule_args);
  FML_CHECK(!tonic::CheckAndHandleError(result));
 
  // Set up the namespace in dart:io.
  Dart_Handle namespace_type =
      Dart_GetNonNullableType(io_lib, ToDart("_Namespace"), 0, nullptr);
  FML_CHECK(!tonic::CheckAndHandleError(namespace_type));
 
  Dart_Handle namespace_args[1];
  namespace_args[0] = ToDart(reinterpret_cast<intptr_t>(namespc));
  result =
      Dart_Invoke(namespace_type, ToDart("_setupNamespace"), 1, namespace_args);
  FML_CHECK(!tonic::CheckAndHandleError(result));
 
  // Set up the namespace in dart:zircon.
  namespace_type =
      Dart_GetNonNullableType(zircon_lib, ToDart("_Namespace"), 0, nullptr);
  FML_CHECK(!tonic::CheckAndHandleError(namespace_type));
 
  result = Dart_SetField(namespace_type, ToDart("_namespace"),
                         ToDart(reinterpret_cast<intptr_t>(namespc)));
  FML_CHECK(!tonic::CheckAndHandleError(result));
 
  // Set up stdout and stderr.
  Dart_Handle stdio_args[3];
  stdio_args[0] = Dart_NewInteger(0);
  stdio_args[1] = Dart_NewInteger(stdoutfd);
  stdio_args[2] = Dart_NewInteger(stderrfd);
  result = Dart_Invoke(io_lib, ToDart("_setStdioFDs"), 3, stdio_args);
  FML_CHECK(!tonic::CheckAndHandleError(result));
 
  // Disable some dart:io operations.
  Dart_Handle embedder_config_type =
      Dart_GetNonNullableType(io_lib, ToDart("_EmbedderConfig"), 0, nullptr);
  FML_CHECK(!tonic::CheckAndHandleError(embedder_config_type));
 
  result =
      Dart_SetField(embedder_config_type, ToDart("_mayExit"), Dart_False());
  FML_CHECK(!tonic::CheckAndHandleError(result));
 
  // Set the script location.
  result = Dart_SetField(builtin_lib, ToDart("_rawScript"), ToDart(script_uri));
  FML_CHECK(!tonic::CheckAndHandleError(result));
 
  // Setup the uriBase with the base uri of the fidl app.
  Dart_Handle uri_base =
      Dart_Invoke(io_lib, ToDart("_getUriBaseClosure"), 0, nullptr);
  FML_CHECK(!tonic::CheckAndHandleError(uri_base));
 
  result = Dart_SetField(core_lib, ToDart("_uriBaseClosure"), uri_base);
  FML_CHECK(!tonic::CheckAndHandleError(result));
 
  Dart_Handle setup_hooks = ToDart("_setupHooks");
  result = Dart_Invoke(builtin_lib, setup_hooks, 0, nullptr);
  FML_CHECK(!tonic::CheckAndHandleError(result));
  result = Dart_Invoke(io_lib, setup_hooks, 0, nullptr);
  FML_CHECK(!tonic::CheckAndHandleError(result));
  result = Dart_Invoke(isolate_lib, setup_hooks, 0, nullptr);
  FML_CHECK(!tonic::CheckAndHandleError(result));
}

IsTestProgram()

bool dart_runner::IsTestProgram

(

const fuchsia::data::Dictionary &

program_metadata

)

Parses the |args| field from the "program" field to determine if a test component is being executed.

Definition at line 167 of file dart_runner.cc.

                                                                  {
  for (const auto& entry : program_metadata.entries()) {
    if (entry.key.compare(kArgsKey) != 0 || entry.value == nullptr) {
      continue;
    }
    auto args = entry.value->str_vec();
 
    // fml::CommandLine expects the first argument to be the name of the
    // program, so we prepend a dummy argument so we can use fml::CommandLine to
    // parse the arguments for us.
    std::vector<std::string> command_line_args = {""};
    command_line_args.insert(command_line_args.end(), args.begin(), args.end());
    fml::CommandLine parsed_args = fml::CommandLineFromIterators(
        command_line_args.begin(), command_line_args.end());
 
    std::string is_test_str;
    return parsed_args.GetOptionValue("is_test", &is_test_str) &&
           is_test_str == "true";
  }
  return false;
}

Variable Documentation

isolate_snapshot_buffer

uint8_t const* const dart_runner::isolate_snapshot_buffer

extern

kArgsKey

constexpr char dart_runner::kArgsKey[] = "args"

constexpr

Definition at line 163 of file dart_runner.cc.

vm_isolate_snapshot_buffer

uint8_t const* const dart_runner::vm_isolate_snapshot_buffer

extern