Flutter Engine
 
Loading...
Searching...
No Matches
Namespaces | Macros | Functions
builtin_libraries.cc File Reference
#include "builtin_libraries.h"
#include <lib/fdio/namespace.h>
#include <lib/zx/channel.h>
#include <optional>
#include "dart-pkg/fuchsia/sdk_ext/fuchsia.h"
#include "flutter/fml/logging.h"
#include "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"
#include "logging.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:40

Definition at line 32 of file builtin_libraries.cc.

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

◆ REGISTER_FUNCTION

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

Definition at line 28 of file builtin_libraries.cc.

Variable Documentation

◆ argument_count

int argument_count

Definition at line 41 of file builtin_libraries.cc.

◆ function

Dart_NativeFunction function

Definition at line 40 of file builtin_libraries.cc.

◆ name

const char* name

Definition at line 39 of file builtin_libraries.cc.