Program _uriBaseClosure into the DartVM

sky/engine/bindings/builtin_natives.cc

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "sky/engine/config.h"
 #include "sky/engine/bindings/builtin_natives.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 18 matching lines @@
 #define REGISTER_FUNCTION(name, count)                                         \
   { "" #name, name, count },
 #define DECLARE_FUNCTION(name, count)                                          \
   extern void name(Dart_NativeArguments args);
 
 // Lists the native functions implementing basic functionality in
 // the Mojo embedder dart, such as printing, and file I/O.
 #define BUILTIN_NATIVE_LIST(V) \
   V(Logger_PrintString, 1)     \
   V(ScheduleMicrotask, 1)      \
+  V(GetBaseURLString, 0)       \
   V(Timer_create, 3)           \
   V(Timer_cancel, 1)
 
 BUILTIN_NATIVE_LIST(DECLARE_FUNCTION);
 
 static struct NativeEntries {
   const char* name;
   Dart_NativeFunction function;
   int argument_count;
 } BuiltinEntries[] = {BUILTIN_NATIVE_LIST(REGISTER_FUNCTION)};
@@ skipping 45 matching lines @@
   DART_CHECK_VALID(Dart_SetField(
       internal_library, ToDart("_printClosure"), print));
 
   Dart_Handle vm_hooks_name = ToDart("VMLibraryHooks");
   Dart_Handle vm_hooks = Dart_GetClass(internal_library, vm_hooks_name);
   DART_CHECK_VALID(vm_hooks);
   Dart_Handle timer_name = ToDart("timerFactory");
   DART_CHECK_VALID(Dart_SetField(vm_hooks, timer_name, timer));
 }
 
-static void InitAsync(Dart_Handle builtin_library) {
+static void InitDartCore(Dart_Handle builtin) {
+  Dart_Handle get_base_url = GetClosure(builtin, "_getGetBaseURLClosure");
+  Dart_Handle core_library = DartBuiltin::LookupLibrary("dart:core");
+  DART_CHECK_VALID(Dart_SetField(core_library,
+      ToDart("_uriBaseClosure"), get_base_url));
+}
+
+static void InitDartAsync(Dart_Handle builtin_library) {
   Dart_Handle schedule_microtask =
       GetClosure(builtin_library, "_getScheduleMicrotaskClosure");
   Dart_Handle async_library = DartBuiltin::LookupLibrary("dart:async");
   Dart_Handle set_schedule_microtask = ToDart("_setScheduleImmediateClosure");
   DART_CHECK_VALID(Dart_Invoke(async_library, set_schedule_microtask, 1,
                                &schedule_microtask));
 }
 
 void BuiltinNatives::Init() {
   Dart_Handle builtin = Builtin::LoadAndCheckLibrary(Builtin::kBuiltinLibrary);
   DART_CHECK_VALID(builtin);
   InitDartInternal(builtin);
-  InitAsync(builtin);
+  InitDartCore(builtin);
+  InitDartAsync(builtin);
 }
 
 // Implementation of native functions which are used for some
 // test/debug functionality in standalone dart mode.
 void Logger_PrintString(Dart_NativeArguments args) {
   intptr_t length = 0;
   uint8_t* chars = nullptr;
   Dart_Handle str = Dart_GetNativeArgument(args, 0);
   Dart_Handle result = Dart_StringToUTF8(str, &chars, &length);
   if (Dart_IsError(result)) {
@@ skipping 22 matching lines @@
 
 void ScheduleMicrotask(Dart_NativeArguments args) {
   Dart_Handle closure = Dart_GetNativeArgument(args, 0);
   if (LogIfError(closure) || !Dart_IsClosure(closure))
     return;
   DartState* dart_state = DartState::Current();
   Microtask::enqueueMicrotask(base::Bind(&ExecuteMicrotask,
     dart_state->GetWeakPtr(), DartValue::Create(dart_state, closure)));
 }
 
+void GetBaseURLString(Dart_NativeArguments args) {
+  String url = DOMDartState::CurrentDocument()->url().string();
+  Dart_SetReturnValue(args, StringToDart(DartState::Current(), url));
+}
+
 void Timer_create(Dart_NativeArguments args) {
   int64_t milliseconds = 0;
   DART_CHECK_VALID(Dart_GetNativeIntegerArgument(args, 0, &milliseconds));
   Dart_Handle closure = Dart_GetNativeArgument(args, 1);
   DART_CHECK_VALID(closure);
   CHECK(Dart_IsClosure(closure));
   bool repeating = false;
   DART_CHECK_VALID(Dart_GetNativeBooleanArgument(args, 2, &repeating));
 
   DOMDartState* state = DOMDartState::Current();
   int timer_id = DOMTimer::install(state->document(),
                                    ScheduledAction::Create(state, closure),
                                    milliseconds,
                                    !repeating);
   Dart_SetIntegerReturnValue(args, timer_id);
 }
 
 void Timer_cancel(Dart_NativeArguments args) {
   int64_t timer_id = 0;
   DART_CHECK_VALID(Dart_GetNativeIntegerArgument(args, 0, &timer_id));
 
   DOMDartState* state = DOMDartState::Current();
   DOMTimer::removeByID(state->document(), timer_id);
 }
 
 }  // namespace blink