Auto create ApiLocalScope before calling native functions, this ensures that

runtime/bin/secure_socket.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/secure_socket.h"
 
 #include <errno.h>
 #include <fcntl.h>
 #include <sys/stat.h>
 #include <stdio.h>
@@ skipping 88 matching lines @@
   Dart_Handle dart_this = ThrowIfError(Dart_GetNativeArgument(args, 0));
   ASSERT(Dart_IsInstance(dart_this));
   ThrowIfError(Dart_SetNativeInstanceField(
       dart_this,
       kSSLFilterNativeFieldIndex,
       reinterpret_cast<intptr_t>(filter)));
 }
 
 
 void FUNCTION_NAME(SecureSocket_Init)(Dart_NativeArguments args) {
-  Dart_EnterScope();
   Dart_Handle dart_this = ThrowIfError(Dart_GetNativeArgument(args, 0));
   SSLFilter* filter = new SSLFilter;
   SetFilter(args, filter);
   filter->Init(dart_this);
-  Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(SecureSocket_Connect)(Dart_NativeArguments args) {
-  Dart_EnterScope();
   Dart_Handle host_name_object = ThrowIfError(Dart_GetNativeArgument(args, 1));
   Dart_Handle host_sockaddr_storage_object =
       ThrowIfError(Dart_GetNativeArgument(args, 2));
   Dart_Handle port_object = ThrowIfError(Dart_GetNativeArgument(args, 3));
   bool is_server = DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 4));
   Dart_Handle certificate_name_object =
       ThrowIfError(Dart_GetNativeArgument(args, 5));
   bool request_client_certificate =
       DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 6));
   bool require_client_certificate =
@@ skipping 31 matching lines @@
   ASSERT(!is_server || certificate_name != NULL);
 
   GetFilter(args)->Connect(host_name,
                            &raw_addr,
                            static_cast<int>(port),
                            is_server,
                            certificate_name,
                            request_client_certificate,
                            require_client_certificate,
                            send_client_certificate);
-  Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(SecureSocket_Destroy)(Dart_NativeArguments args) {
-  Dart_EnterScope();
   SSLFilter* filter = GetFilter(args);
   SetFilter(args, NULL);
   filter->Destroy();
   delete filter;
-  Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(SecureSocket_Handshake)(Dart_NativeArguments args) {
-  Dart_EnterScope();
   GetFilter(args)->Handshake();
-  Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(SecureSocket_Renegotiate)(Dart_NativeArguments args) {
-  Dart_EnterScope();
   bool use_session_cache =
       DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 1));
   bool request_client_certificate =
       DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 2));
   bool require_client_certificate =
       DartUtils::GetBooleanValue(Dart_GetNativeArgument(args, 3));
   GetFilter(args)->Renegotiate(use_session_cache,
                                request_client_certificate,
                                require_client_certificate);
-  Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(SecureSocket_RegisterHandshakeCompleteCallback)(
     Dart_NativeArguments args) {
-  Dart_EnterScope();
   Dart_Handle handshake_complete =
       ThrowIfError(Dart_GetNativeArgument(args, 1));
   if (!Dart_IsClosure(handshake_complete)) {
     Dart_ThrowException(DartUtils::NewDartArgumentError(
         "Illegal argument to RegisterHandshakeCompleteCallback"));
   }
   GetFilter(args)->RegisterHandshakeCompleteCallback(handshake_complete);
-  Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(SecureSocket_RegisterBadCertificateCallback)(
     Dart_NativeArguments args) {
-  Dart_EnterScope();
   Dart_Handle callback =
       ThrowIfError(Dart_GetNativeArgument(args, 1));
   if (!Dart_IsClosure(callback) && !Dart_IsNull(callback)) {
     Dart_ThrowException(DartUtils::NewDartArgumentError(
         "Illegal argument to RegisterBadCertificateCallback"));
   }
   GetFilter(args)->RegisterBadCertificateCallback(callback);
-  Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(SecureSocket_InitializeLibrary)
     (Dart_NativeArguments args) {
-  Dart_EnterScope();
   Dart_Handle certificate_database_object =
       ThrowIfError(Dart_GetNativeArgument(args, 0));
   // Check that the type is string, and get the UTF-8 C string value from it.
   const char* certificate_database = NULL;
   if (Dart_IsString(certificate_database_object)) {
     ThrowIfError(Dart_StringToCString(certificate_database_object,
                                       &certificate_database));
   } else if (!Dart_IsNull(certificate_database_object)) {
     Dart_ThrowException(DartUtils::NewDartArgumentError(
         "Non-String certificate directory argument to SetCertificateDatabase"));
@@ skipping 19 matching lines @@
   // Check that the type is boolean, and get the boolean value from it.
   bool builtin_roots = true;
   if (Dart_IsBoolean(builtin_roots_object)) {
     ThrowIfError(Dart_BooleanValue(builtin_roots_object, &builtin_roots));
   } else {
     Dart_ThrowException(DartUtils::NewDartArgumentError(
         "UseBuiltinRoots argument to SetCertificateDatabase is not a bool"));
   }
 
   SSLFilter::InitializeLibrary(certificate_database, password, builtin_roots);
-  Dart_ExitScope();
 }
 
 
 static Dart_Handle X509FromCertificate(CERTCertificate* certificate) {
   PRTime start_validity;
   PRTime end_validity;
   SECStatus status =
       CERT_GetCertTimes(certificate, &start_validity, &end_validity);
   if (status != SECSuccess) {
     ThrowPRException("CertificateException",
@@ skipping 23 matching lines @@
   Dart_Handle arguments[] = { subject_name_object,
                               issuer_name_object,
                               start_validity_date,
                               end_validity_date };
   return Dart_New(x509_type, Dart_Null(), 4, arguments);
 }
 
 
 void FUNCTION_NAME(SecureSocket_AddCertificate)
     (Dart_NativeArguments args) {
-  Dart_EnterScope();
   Dart_Handle certificate_object =
       ThrowIfError(Dart_GetNativeArgument(args, 0));
   Dart_Handle trust_object = ThrowIfError(Dart_GetNativeArgument(args, 1));
 
   if (!Dart_IsList(certificate_object) || !Dart_IsString(trust_object)) {
     Dart_ThrowException(DartUtils::NewDartArgumentError(
         "Bad argument to SecureSocket.addCertificate"));
   }
 
   intptr_t length;
@@ skipping 19 matching lines @@
   if (status != SECSuccess) {
     ThrowPRException("CertificateException", "Trust string cannot be decoded");
   }
 
   status = CERT_ChangeCertTrust(CERT_GetDefaultCertDB(), cert, &trust);
   if (status != SECSuccess) {
     ThrowPRException("CertificateException", "Cannot set trust attributes");
   }
 
   Dart_SetReturnValue(args, X509FromCertificate(cert));
-  Dart_ExitScope();
   return;
 }
 
 
 
 void FUNCTION_NAME(SecureSocket_PeerCertificate)
     (Dart_NativeArguments args) {
-  Dart_EnterScope();
   Dart_SetReturnValue(args, GetFilter(args)->PeerCertificate());
-  Dart_ExitScope();
 }
 
 
 void FUNCTION_NAME(SecureSocket_FilterPointer)(Dart_NativeArguments args) {
-  Dart_EnterScope();
   intptr_t filter_pointer = reinterpret_cast<intptr_t>(GetFilter(args));
   Dart_SetReturnValue(args, Dart_NewInteger(filter_pointer));
-  Dart_ExitScope();
 }
 
 
 /**
  * Pushes data through the SSL filter, reading and writing from circular
  * buffers shared with Dart.
  *
  * The Dart _SecureFilterImpl class contains 4 ExternalByteArrays used to
  * pass encrypted and plaintext data to and from the C++ SSLFilter object.
  *
@@ skipping 642 matching lines @@
   return bytes_processed;
 }
 
 
 Dart_Port SSLFilter::GetServicePort() {
   return filter_service_.GetServicePort();
 }
 
 
 void FUNCTION_NAME(SecureSocket_NewServicePort)(Dart_NativeArguments args) {
-  Dart_EnterScope();
   Dart_SetReturnValue(args, Dart_Null());
   Dart_Port service_port = SSLFilter::GetServicePort();
   if (service_port != ILLEGAL_PORT) {
     // Return a send port for the service port.
     Dart_Handle send_port = Dart_NewSendPort(service_port);
     Dart_SetReturnValue(args, send_port);
   }
-  Dart_ExitScope();
 }
 
 
 }  // namespace bin
 }  // namespace dart