Allow the native resolver to setup whether it needs the Dart API scope to

runtime/vm/dart_api_impl_test.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "bin/builtin.h"
 #include "include/dart_api.h"
 #include "include/dart_debugger_api.h"
 #include "include/dart_mirrors_api.h"
 #include "include/dart_native_api.h"
 #include "platform/assert.h"
@@ skipping 352 matching lines @@
   EXPECT(Dart_IsError(result));
   result = Dart_GetActivationFrame(stacktrace, -1, &frame);
   EXPECT(Dart_IsError(result));
 
   Dart_SetReturnValue(args, Dart_NewInteger(42));
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction CurrentStackTraceNativeLookup(
-    Dart_Handle name, int argument_count) {
+    Dart_Handle name, int argument_count, bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   return reinterpret_cast<Dart_NativeFunction>(&CurrentStackTraceNative);
 }
 
 
 TEST_CASE(CurrentStacktraceInfo) {
   const char* kScriptChars =
       "inspectStack() native 'CurrentStackTraceNatve';\n"
       "foo(n) => n == 1 ? inspectStack() : foo(n-1);\n"
       "testMain() => foo(50);\n";
 
@@ skipping 67 matching lines @@
   EXPECT(Dart_IsClosure(closure));
   Dart_Handle result = Dart_InvokeClosure(closure, 0, NULL);
   EXPECT(Dart_IsError(result));
   result = Dart_PropagateError(result);
   EXPECT_VALID(result);  // We do not expect to reach here.
   UNREACHABLE();
 }
 
 
 static Dart_NativeFunction PropagateError_native_lookup(
-    Dart_Handle name, int argument_count) {
+    Dart_Handle name, int argument_count, bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   return reinterpret_cast<Dart_NativeFunction>(&PropagateErrorNative);
 }
 
 
 TEST_CASE(Dart_PropagateError) {
   const char* kScriptChars =
       "raiseCompileError() {\n"
       "  return missing_semicolon\n"
       "}\n"
       "\n"
@@ skipping 787 matching lines @@
   Dart_EnterScope();
   Dart_Handle byte_data = Dart_NewTypedData(Dart_TypedData_kByteData, kLength);
   EXPECT_VALID(byte_data);
   EXPECT_EQ(Dart_TypedData_kByteData, Dart_GetTypeOfTypedData(byte_data));
   Dart_SetReturnValue(args, byte_data);
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction ByteDataNativeResolver(Dart_Handle name,
-                                                  int arg_count) {
+                                                  int arg_count,
+                                                  bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   return &ByteDataNativeFunction;
 }
 
 
 TEST_CASE(ByteDataAccess) {
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
       "  static equals(a, b) {\n"
       "    if (a != b) {\n"
@@ skipping 37 matching lines @@
   Dart_Handle external_byte_data = Dart_NewExternalTypedData(
       Dart_TypedData_kByteData, data, 16);
   EXPECT_VALID(external_byte_data);
   EXPECT_EQ(Dart_TypedData_kByteData,
             Dart_GetTypeOfTypedData(external_byte_data));
   Dart_SetReturnValue(args, external_byte_data);
   Dart_ExitScope();
 }
 
 
-static Dart_NativeFunction ExternalByteDataNativeResolver(Dart_Handle name,
-                                                          int arg_count) {
+static Dart_NativeFunction ExternalByteDataNativeResolver(
+    Dart_Handle name, int arg_count, bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   return &ExternalByteDataNativeFunction;
 }
 
 
 TEST_CASE(ExternalByteDataAccess) {
   // TODO(asiva): Once we have getInt16LE and getInt16BE support use the
   // appropriate getter instead of the host endian format used now.
   const char* kScriptChars =
       "import 'dart:typed_data';\n"
       "class Expect {\n"
@@ skipping 2234 matching lines @@
   EXPECT_STREQ("myerror", Dart_GetError(result));
 }
 
 
 void NativeFieldLookup(Dart_NativeArguments args) {
   UNREACHABLE();
 }
 
 
 static Dart_NativeFunction native_field_lookup(Dart_Handle name,
-                                               int argument_count) {
+                                               int argument_count,
+                                               bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   return reinterpret_cast<Dart_NativeFunction>(&NativeFieldLookup);
 }
 
 
 TEST_CASE(InjectNativeFields1) {
   const char* kScriptChars =
       "class NativeFields extends NativeFieldsWrapper {\n"
       "  NativeFields(int i, int j) : fld1 = i, fld2 = j {}\n"
       "  int fld1;\n"
       "  final int fld2;\n"
@@ skipping 1143 matching lines @@
 }
 
 
 void ExceptionNative(Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_ThrowException(NewString("Hello from ExceptionNative!"));
   UNREACHABLE();
 }
 
 
-static Dart_NativeFunction native_lookup(Dart_Handle name, int argument_count) {
+static Dart_NativeFunction native_lookup(Dart_Handle name,
+                                         int argument_count,
+                                         bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   return reinterpret_cast<Dart_NativeFunction>(&ExceptionNative);
 }
 
 
 TEST_CASE(ThrowException) {
   const char* kScriptChars =
       "int test() native \"ThrowException_native\";";
   Dart_Handle result;
   Isolate* isolate = Isolate::Current();
   EXPECT(isolate != NULL);
@@ skipping 23 matching lines @@
 
 
 void NativeArgumentCounter(Dart_NativeArguments args) {
   Dart_EnterScope();
   int count = Dart_GetNativeArgumentCount(args);
   Dart_SetReturnValue(args, Dart_NewInteger(count));
   Dart_ExitScope();
 }
 
 
-static Dart_NativeFunction gnac_lookup(Dart_Handle name, int argument_count) {
+static Dart_NativeFunction gnac_lookup(Dart_Handle name,
+                                       int argument_count,
+                                       bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   return reinterpret_cast<Dart_NativeFunction>(&NativeArgumentCounter);
 }
 
 
 TEST_CASE(GetNativeArgumentCount) {
   const char* kScriptChars =
       "class MyObject {"
       "  int method1(int i, int j) native 'Name_Does_Not_Matter';"
       "}"
       "testMain() {"
@@ skipping 873 matching lines @@
 
 
 static void PatchNativeFunction(Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_SetReturnValue(args, Dart_Null());
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction PatchNativeResolver(Dart_Handle name,
-                                               int arg_count) {
+                                               int arg_count,
+                                               bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   return &PatchNativeFunction;
 }
 
 
 TEST_CASE(ParsePatchLibrary) {
   const char* kLibraryChars =
   "library patched_library;\n"
   "class A {\n"
   "  final fvalue;\n"
   "  var _f;\n"
@@ skipping 173 matching lines @@
 
 
 static void MyNativeFunction2(Dart_NativeArguments args) {
   Dart_EnterScope();
   Dart_SetReturnValue(args, Dart_NewInteger(123456));
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction MyNativeResolver1(Dart_Handle name,
-                                             int arg_count) {
+                                             int arg_count,
+                                             bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   return &MyNativeFunction1;
 }
 
 
 static Dart_NativeFunction MyNativeResolver2(Dart_Handle name,
-                                             int arg_count) {
+                                             int arg_count,
+                                             bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   return &MyNativeFunction2;
 }
 
 
 TEST_CASE(SetNativeResolver) {
   const char* kScriptChars =
       "class Test {"
       "  static foo() native \"SomeNativeFunction\";"
       "  static bar() native \"SomeNativeFunction2\";"
       "  static baz() native \"SomeNativeFunction3\";"
@@ skipping 440 matching lines @@
     MonitorLocker ml(sync);
     main_entered = true;
     ml.Notify();
   }
   Dart_SetReturnValue(args, Dart_Null());
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction IsolateInterruptTestNativeLookup(
-    Dart_Handle name, int argument_count) {
+    Dart_Handle name, int argument_count, bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   return reinterpret_cast<Dart_NativeFunction>(&MarkMainEntered);
 }
 
 
 void BusyLoop_start(uword unused) {
   const char* kScriptChars =
       "class Native {\n"
       "  static void markMainEntered() native 'MarkMainEntered';\n"
       "}\n"
       "\n"
@@ skipping 284 matching lines @@
   Dart_Handle arg2 = Dart_GetNativeArgument(args, 2);
   Dart_Handle arg3 = Dart_GetNativeArgument(args, 3);
   Dart_SetReturnValue(args, Dart_NewInteger(GetValue(arg1) +
                                             GetValue(arg2) +
                                             GetValue(arg3)));
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction MyNativeClosureResolver(Dart_Handle name,
-                                                   int arg_count) {
+                                                   int arg_count,
+                                                   bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   const Object& obj = Object::Handle(Api::UnwrapHandle(name));
   if (!obj.IsString()) {
     return NULL;
   }
   const char* function_name = obj.ToCString();
   const char* kNativeFoo1 = "NativeFoo1";
   const char* kNativeFoo2 = "NativeFoo2";
   const char* kNativeFoo3 = "NativeFoo3";
   const char* kNativeFoo4 = "NativeFoo4";
   if (!strncmp(function_name, kNativeFoo1, strlen(kNativeFoo1))) {
@@ skipping 122 matching lines @@
   Dart_Handle arg1 = Dart_GetNativeArgument(args, 0);
   Dart_Handle arg2 = Dart_GetNativeArgument(args, 1);
   Dart_Handle arg3 = Dart_GetNativeArgument(args, 2);
   Dart_SetReturnValue(args, Dart_NewInteger(GetValue(arg1) +
                                             GetValue(arg2) +
                                             GetValue(arg3)));
   Dart_ExitScope();
 }
 
 
-static Dart_NativeFunction MyStaticNativeClosureResolver(Dart_Handle name,
-                                                         int arg_count) {
+static Dart_NativeFunction MyStaticNativeClosureResolver(
+    Dart_Handle name, int arg_count, bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   const Object& obj = Object::Handle(Api::UnwrapHandle(name));
   if (!obj.IsString()) {
     return NULL;
   }
   const char* function_name = obj.ToCString();
   const char* kNativeFoo1 = "StaticNativeFoo1";
   const char* kNativeFoo2 = "StaticNativeFoo2";
   const char* kNativeFoo3 = "StaticNativeFoo3";
   const char* kNativeFoo4 = "StaticNativeFoo4";
   if (!strncmp(function_name, kNativeFoo1, strlen(kNativeFoo1))) {
@@ skipping 785 matching lines @@
                               size,
                               str_data,
                               &ExternalStringDeoptimize_Finalize);
   EXPECT_VALID(result);
   EXPECT(Dart_IsExternalString(result));
   Dart_ExitScope();
 }
 
 
 static Dart_NativeFunction ExternalStringDeoptimize_native_lookup(
-    Dart_Handle name, int argument_count) {
+    Dart_Handle name, int argument_count, bool* auto_setup_scope) {
+  ASSERT(auto_setup_scope != NULL);
+  *auto_setup_scope = false;
   return reinterpret_cast<Dart_NativeFunction>(&A_change_str_native);
 }
 
 
 // Do not use guarding mechanism on externalizable classes, since their class
 // can change on the fly,
 TEST_CASE(GuardExternalizedString) {
   const char* kScriptChars =
       "main() {\n"
       "  var a = new A('hello');\n"
@@ skipping 147 matching lines @@
                                    NewString("main"),
                                    1,
                                    dart_args);
   int64_t value = 0;
   result = Dart_IntegerToInt64(result, &value);
   EXPECT_VALID(result);
   EXPECT_EQ(6, value);
 }
 
 }  // namespace dart