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

runtime/vm/native_arguments.h

 // 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.
 
 #ifndef VM_NATIVE_ARGUMENTS_H_
 #define VM_NATIVE_ARGUMENTS_H_
 
 #include "platform/assert.h"
 #include "vm/globals.h"
 #include "vm/handles_impl.h"
@@ skipping 113 matching lines @@
   static intptr_t isolate_offset() {
     return OFFSET_OF(NativeArguments, isolate_);
   }
   static intptr_t argc_tag_offset() {
     return OFFSET_OF(NativeArguments, argc_tag_);
   }
   static intptr_t argv_offset() { return OFFSET_OF(NativeArguments, argv_); }
   static intptr_t retval_offset() {
     return OFFSET_OF(NativeArguments, retval_);
   }
+  static intptr_t AutoSetupScopeMask() {
+    return AutoSetupScopeBits::mask_in_place();
+  }
 
   static int ParameterCountForResolution(const Function& function) {
     ASSERT(function.is_native());
     ASSERT(!function.IsConstructor());  // Not supported.
     int count = function.NumParameters();
     if (function.is_static() && function.IsClosureFunction()) {
       // The closure object is hidden and not accessible from native code.
       // However, if the function is an instance closure function, the captured
       // receiver located in the context is made accessible in native code at
       // index 0, thereby hidding the closure object at index 0.
       count--;
     }
     return count;
   }
 
   static int ComputeArgcTag(const Function& function) {
     ASSERT(function.is_native());
     ASSERT(!function.IsConstructor());  // Not supported.
     int tag = ArgcBits::encode(function.NumParameters());
     int function_bits = 0;
     if (!function.is_static()) {
       function_bits |= kInstanceFunctionBit;
     }
     if (function.IsClosureFunction()) {
       function_bits |= kClosureFunctionBit;
     }
-    return FunctionBits::update(function_bits, tag);
+    tag = FunctionBits::update(function_bits, tag);
+    if (function.IsNativeAutoSetupScope()) {
+      tag = AutoSetupScopeBits::update(1, tag);
+    }
+    return tag;
   }
 
  private:
   enum {
     kInstanceFunctionBit = 1,
     kClosureFunctionBit = 2,
   };
   enum ArgcTagBits {
     kArgcBit = 0,
     kArgcSize = 24,
     kFunctionBit = 24,
     kFunctionSize = 2,
+    kAutoSetupScopeBit = 26,
   };
   class ArgcBits : public BitField<int, kArgcBit, kArgcSize> {};
   class FunctionBits : public BitField<int, kFunctionBit, kFunctionSize> {};
+  class AutoSetupScopeBits : public BitField<int, kAutoSetupScopeBit, 1> {};
   friend class Api;
   friend class BootstrapNatives;
   friend class Simulator;
 
   // Since this function is passed a RawObject directly, we need to be
   // exceedingly careful when we use it.  If there are any other side
   // effects in the statement that may cause GC, it could lead to
   // bugs.
   void SetReturnUnsafe(RawObject* value) const {
     *retval_ = value;
@@ skipping 22 matching lines @@
 
   Isolate* isolate_;  // Current isolate pointer.
   int argc_tag_;  // Encodes argument count and invoked native call type.
   RawObject*(*argv_)[];  // Pointer to an array of arguments to runtime call.
   RawObject** retval_;  // Pointer to the return value area.
 };
 
 }  // namespace dart
 
 #endif  // VM_NATIVE_ARGUMENTS_H_