Flutter Engine Uber Docs
Docs for the entire Flutter Engine repo.
 
Loading...
Searching...
No Matches
Namespaces | Macros | Functions
builtin_libraries.cc File Reference
#include "flutter/shell/platform/fuchsia/dart_runner/builtin_libraries.h"
#include <lib/fdio/namespace.h>
#include <lib/zx/channel.h>
#include <optional>
#include "flutter/fml/logging.h"
#include "flutter/shell/platform/fuchsia/dart_pkg/fuchsia/sdk_ext/fuchsia.h"
#include "flutter/shell/platform/fuchsia/runtime/dart/utils/inlines.h"
#include "third_party/dart/runtime/bin/io_natives.h"
#include "third_party/dart/runtime/include/dart_api.h"
#include "third_party/tonic/converter/dart_converter.h"
#include "third_party/tonic/dart_microtask_queue.h"
#include "third_party/tonic/logging/dart_error.h"

Go to the source code of this file.

Namespaces

namespace  dart_runner
 

Macros

#define REGISTER_FUNCTION(name, count)   {#name, name, count},
 
#define DECLARE_FUNCTION(name, count)    extern void name(Dart_NativeArguments args);
 
#define BUILTIN_NATIVE_LIST(V)
 

Functions

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

Macro Definition Documentation

◆ BUILTIN_NATIVE_LIST

#define BUILTIN_NATIVE_LIST (   V)
Value:
V(Logger_PrintString, 1) \
V(ScheduleMicrotask, 1)
function
Dart_NativeFunction function
Definition builtin_libraries.cc:38

Definition at line 30 of file builtin_libraries.cc.

35 {
36 const char* name;
37 Dart_NativeFunction function;
38 int argument_count;
39} kBuiltinEntries[] = {BUILTIN_NATIVE_LIST(REGISTER_FUNCTION)};
40
41Dart_NativeFunction BuiltinNativeLookup(Dart_Handle name,
42 int argument_count,
43 bool* auto_setup_scope) {
44 const char* function_name = nullptr;
45 Dart_Handle result = Dart_StringToCString(name, &function_name);
46 if (Dart_IsError(result)) {
47 Dart_PropagateError(result);
48 }
49 FML_DCHECK(function_name != nullptr);
50 FML_DCHECK(auto_setup_scope != nullptr);
51 *auto_setup_scope = true;
52 size_t num_entries = dart_utils::ArraySize(kBuiltinEntries);
53 for (size_t i = 0; i < num_entries; i++) {
54 const NativeEntry& entry = kBuiltinEntries[i];
55 if (!strcmp(function_name, entry.name) &&
56 (entry.argument_count == argument_count)) {
57 return entry.function;
58 }
59 }
60 return nullptr;
61}
62
63const uint8_t* BuiltinNativeSymbol(Dart_NativeFunction native_function) {
64 size_t num_entries = dart_utils::ArraySize(kBuiltinEntries);
65 for (size_t i = 0; i < num_entries; i++) {
66 const NativeEntry& entry = kBuiltinEntries[i];
67 if (entry.function == native_function)
68 return reinterpret_cast<const uint8_t*>(entry.name);
69 }
70 return nullptr;
71}
72
73void Logger_PrintString(Dart_NativeArguments args) {
74 intptr_t length = 0;
75 uint8_t* chars = nullptr;
76 Dart_Handle str = Dart_GetNativeArgument(args, 0);
77 Dart_Handle result = Dart_StringToUTF8(str, &chars, &length);
78 if (Dart_IsError(result)) {
79 Dart_PropagateError(result);
80 } else {
81 fwrite(chars, 1, length, stdout);
82 fputc('\n', stdout);
83 fflush(stdout);
84 }
85}
86
87void ScheduleMicrotask(Dart_NativeArguments args) {
88 Dart_Handle closure = Dart_GetNativeArgument(args, 0);
89 if (tonic::CheckAndHandleError(closure) || !Dart_IsClosure(closure))
90 return;
91 tonic::DartMicrotaskQueue::GetForCurrentThread()->ScheduleMicrotask(closure);
92}
93
94} // namespace
95
96void InitBuiltinLibrariesForIsolate(const std::string& script_uri,
97 fdio_ns_t* namespc,
98 int stdoutfd,
99 int stderrfd,
100 zx::channel directory_request,
101 bool service_isolate) {
102 // dart:fuchsia --------------------------------------------------------------
103 // dart runner doesn't care about scenic view ref.
104 if (!service_isolate) {
105 fuchsia::dart::Initialize(std::move(directory_request), std::nullopt);
106 }
107
108 // dart:fuchsia.builtin ------------------------------------------------------
109
110 Dart_Handle builtin_lib = Dart_LookupLibrary(ToDart("dart:fuchsia.builtin"));
111 FML_CHECK(!tonic::CheckAndHandleError(builtin_lib));
112 Dart_Handle result = Dart_SetNativeResolver(builtin_lib, BuiltinNativeLookup,
113 BuiltinNativeSymbol);
114 FML_CHECK(!tonic::CheckAndHandleError(result));
115
116 // dart:io -------------------------------------------------------------------
117
118 Dart_Handle io_lib = Dart_LookupLibrary(ToDart("dart:io"));
119 FML_CHECK(!tonic::CheckAndHandleError(io_lib));
120 result = Dart_SetNativeResolver(io_lib, dart::bin::IONativeLookup,
121 dart::bin::IONativeSymbol);
122 FML_CHECK(!tonic::CheckAndHandleError(result));
123
124 // dart:zircon ---------------------------------------------------------------
125
126 Dart_Handle zircon_lib = Dart_LookupLibrary(ToDart("dart:zircon"));
127 FML_CHECK(!tonic::CheckAndHandleError(zircon_lib));
128 // NativeResolver already set by fuchsia::dart::Initialize().
129
130 // Core libraries ------------------------------------------------------------
131
132 Dart_Handle async_lib = Dart_LookupLibrary(ToDart("dart:async"));
133 FML_CHECK(!tonic::CheckAndHandleError(async_lib));
134
135 Dart_Handle core_lib = Dart_LookupLibrary(ToDart("dart:core"));
136 FML_CHECK(!tonic::CheckAndHandleError(core_lib));
137
138 Dart_Handle internal_lib = Dart_LookupLibrary(ToDart("dart:_internal"));
139 FML_CHECK(!tonic::CheckAndHandleError(internal_lib));
140
141 Dart_Handle isolate_lib = Dart_LookupLibrary(ToDart("dart:isolate"));
142 FML_CHECK(!tonic::CheckAndHandleError(isolate_lib));
143
144#if !defined(AOT_RUNTIME)
145 // AOT: These steps already happened at compile time in gen_snapshot.
146
147 // We need to ensure that all the scripts loaded so far are finalized
148 // as we are about to invoke some Dart code below to set up closures.
149 result = Dart_FinalizeLoading(false);
150 FML_CHECK(!tonic::CheckAndHandleError(result));
151#endif
152
153 // Setup the internal library's 'internalPrint' function.
154 Dart_Handle print =
155 Dart_Invoke(builtin_lib, ToDart("_getPrintClosure"), 0, nullptr);
156 FML_CHECK(!tonic::CheckAndHandleError(print));
157
158 result = Dart_SetField(internal_lib, ToDart("_printClosure"), print);
159 FML_CHECK(!tonic::CheckAndHandleError(result));
160
161 // Set up the 'scheduleImmediate' closure.
162 Dart_Handle schedule_immediate_closure;
163 if (service_isolate) {
164 // Running on dart::ThreadPool.
165 schedule_immediate_closure = Dart_Invoke(
166 isolate_lib, ToDart("_getIsolateScheduleImmediateClosure"), 0, nullptr);
167 } else {
168 // Running on async::Loop.
169 schedule_immediate_closure = Dart_Invoke(
170 builtin_lib, ToDart("_getScheduleMicrotaskClosure"), 0, nullptr);
171 }
172 FML_CHECK(!tonic::CheckAndHandleError(schedule_immediate_closure));
173
174 Dart_Handle schedule_args[1];
175 schedule_args[0] = schedule_immediate_closure;
176 result = Dart_Invoke(async_lib, ToDart("_setScheduleImmediateClosure"), 1,
177 schedule_args);
178 FML_CHECK(!tonic::CheckAndHandleError(result));
179
180 // Set up the namespace in dart:io.
181 Dart_Handle namespace_type =
182 Dart_GetNonNullableType(io_lib, ToDart("_Namespace"), 0, nullptr);
183 FML_CHECK(!tonic::CheckAndHandleError(namespace_type));
184
185 Dart_Handle namespace_args[1];
186 namespace_args[0] = ToDart(reinterpret_cast<intptr_t>(namespc));
187 result =
188 Dart_Invoke(namespace_type, ToDart("_setupNamespace"), 1, namespace_args);
189 FML_CHECK(!tonic::CheckAndHandleError(result));
190
191 // Set up the namespace in dart:zircon.
192 namespace_type =
193 Dart_GetNonNullableType(zircon_lib, ToDart("_Namespace"), 0, nullptr);
194 FML_CHECK(!tonic::CheckAndHandleError(namespace_type));
195
196 result = Dart_SetField(namespace_type, ToDart("_namespace"),
197 ToDart(reinterpret_cast<intptr_t>(namespc)));
198 FML_CHECK(!tonic::CheckAndHandleError(result));
199
200 // Set up stdout and stderr.
201 Dart_Handle stdio_args[3];
202 stdio_args[0] = Dart_NewInteger(0);
203 stdio_args[1] = Dart_NewInteger(stdoutfd);
204 stdio_args[2] = Dart_NewInteger(stderrfd);
205 result = Dart_Invoke(io_lib, ToDart("_setStdioFDs"), 3, stdio_args);
206 FML_CHECK(!tonic::CheckAndHandleError(result));
207
208 // Disable some dart:io operations.
209 Dart_Handle embedder_config_type =
210 Dart_GetNonNullableType(io_lib, ToDart("_EmbedderConfig"), 0, nullptr);
211 FML_CHECK(!tonic::CheckAndHandleError(embedder_config_type));
212
213 result =
214 Dart_SetField(embedder_config_type, ToDart("_mayExit"), Dart_False());
215 FML_CHECK(!tonic::CheckAndHandleError(result));
216
217 // Set the script location.
218 result = Dart_SetField(builtin_lib, ToDart("_rawScript"), ToDart(script_uri));
219 FML_CHECK(!tonic::CheckAndHandleError(result));
220
221 // Setup the uriBase with the base uri of the fidl app.
222 Dart_Handle uri_base =
223 Dart_Invoke(io_lib, ToDart("_getUriBaseClosure"), 0, nullptr);
224 FML_CHECK(!tonic::CheckAndHandleError(uri_base));
225
226 result = Dart_SetField(core_lib, ToDart("_uriBaseClosure"), uri_base);
227 FML_CHECK(!tonic::CheckAndHandleError(result));
228
229 Dart_Handle setup_hooks = ToDart("_setupHooks");
230 result = Dart_Invoke(builtin_lib, setup_hooks, 0, nullptr);
231 FML_CHECK(!tonic::CheckAndHandleError(result));
232 result = Dart_Invoke(io_lib, setup_hooks, 0, nullptr);
233 FML_CHECK(!tonic::CheckAndHandleError(result));
234 result = Dart_Invoke(isolate_lib, setup_hooks, 0, nullptr);
235 FML_CHECK(!tonic::CheckAndHandleError(result));
236}
237
238} // namespace dart_runner
name
const char * name
Definition builtin_libraries.cc:37
BUILTIN_NATIVE_LIST
#define BUILTIN_NATIVE_LIST(V)
Definition builtin_libraries.cc:30
REGISTER_FUNCTION
#define REGISTER_FUNCTION(name, count)
Definition builtin_libraries.cc:26
argument_count
int argument_count
Definition builtin_libraries.cc:39
tonic::DartMicrotaskQueue::ScheduleMicrotask
void ScheduleMicrotask(Dart_Handle callback)
Definition dart_microtask_queue.cc:66
tonic::DartMicrotaskQueue::GetForCurrentThread
static DartMicrotaskQueue * GetForCurrentThread()
Definition dart_microtask_queue.cc:62
args
G_BEGIN_DECLS G_MODULE_EXPORT FlValue * args
Definition fl_event_channel.h:89
i
int i
Definition fl_socket_accessible.cc:18
FML_CHECK
#define FML_CHECK(condition)
Definition logging.h:104
FML_DCHECK
#define FML_DCHECK(condition)
Definition logging.h:122
length
size_t length
Definition key_event_handler.cc:41
dart_runner::InitBuiltinLibrariesForIsolate
void InitBuiltinLibrariesForIsolate(const std::string &script_uri, fdio_ns_t *namespc, int stdoutfd, int stderrfd, zx::channel directory_request, bool service_isolate)
Definition builtin_libraries.cc:97
dart_utils::ArraySize
size_t ArraySize(T(&array)[SIZE])
Definition inlines.h:11
flutter::testing::NativeEntry
std::function< void(Dart_NativeArguments)> NativeEntry
Definition test_dart_native_resolver.h:28
fml::closure
std::function< void()> closure
Definition closure.h:14
fuchsia::dart::Initialize
void Initialize(zx::channel directory_request, std::optional< zx::eventpair > view_ref)
Initializes Dart bindings for the Fuchsia application model.
Definition fuchsia.cc:103
tonic::ToDart
Dart_Handle ToDart(const T &object)
Definition dart_converter.h:579
tonic::CheckAndHandleError
bool CheckAndHandleError(Dart_Handle handle)
Definition dart_error.cc:33

◆ DECLARE_FUNCTION

#define DECLARE_FUNCTION (   name,
  count 
)     extern void name(Dart_NativeArguments args);

Definition at line 27 of file builtin_libraries.cc.

◆ REGISTER_FUNCTION

#define REGISTER_FUNCTION (   name,
  count 
)    {#name, name, count},

Definition at line 26 of file builtin_libraries.cc.

Variable Documentation

◆ argument_count

int argument_count

Definition at line 39 of file builtin_libraries.cc.

◆ function

Dart_NativeFunction function

Definition at line 38 of file builtin_libraries.cc.

◆ name

const char* name

Definition at line 37 of file builtin_libraries.cc.