- Add different types for persistent and weak persistent handles

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 254 matching lines @@
                               start_validity_date,
                               end_validity_date };
   return Dart_New(x509_class, Dart_Null(), 4, arguments);
 }
 
 
 void SSLFilter::Init(Dart_Handle dart_this) {
   if (!library_initialized_) {
     InitializeLibrary(NULL, "", true, false);
   }
-  string_start_ = ThrowIfError(
-      Dart_NewPersistentHandle(DartUtils::NewString("start")));
-  string_length_ = ThrowIfError(
-      Dart_NewPersistentHandle(DartUtils::NewString("length")));
+  ASSERT(string_start_ == NULL);
+  string_start_ = Dart_NewPersistentHandle(DartUtils::NewString("start"));
+  ASSERT(string_start_ != NULL);
+  ASSERT(string_length_ == NULL);
+  string_length_ = Dart_NewPersistentHandle(DartUtils::NewString("length"));
+  ASSERT(string_length_ != NULL);
+  ASSERT(bad_certificate_callback_ == NULL);
+  bad_certificate_callback_ = Dart_NewPersistentHandle(Dart_Null());
+  ASSERT(bad_certificate_callback_ != NULL);
 
   InitializeBuffers(dart_this);
   filter_ = memio_CreateIOLayer(kMemioBufferSize);
 }
 
 
 void SSLFilter::InitializeBuffers(Dart_Handle dart_this) {
   // Create SSLFilter buffers as ExternalUint8Array objects.
   Dart_Handle dart_buffers_object = ThrowIfError(
       Dart_GetField(dart_this, DartUtils::NewString("buffers")));
@@ skipping 17 matching lines @@
     Dart_ThrowException(DartUtils::NewString(
         "Invalid encrypted buffer size in _ExternalBuffer"));
   }
   buffer_size_ = static_cast<int>(buffer_size);
   encrypted_buffer_size_ = static_cast<int>(encrypted_buffer_size);
 
 
   Dart_Handle data_identifier = DartUtils::NewString("data");
   for (int i = 0; i < kNumBuffers; ++i) {
     int size = isEncrypted(i) ? encrypted_buffer_size_ : buffer_size_;
-    dart_buffer_objects_[i] = ThrowIfError(
-        Dart_NewPersistentHandle(Dart_ListGetAt(dart_buffers_object, i)));
+    dart_buffer_objects_[i] =
+        Dart_NewPersistentHandle(Dart_ListGetAt(dart_buffers_object, i));
+    ASSERT(dart_buffer_objects_[i] != NULL);
     buffers_[i] = new uint8_t[size];
     Dart_Handle data = ThrowIfError(
-        Dart_NewExternalTypedData(kUint8, buffers_[i], size, NULL, NULL));
-    ThrowIfError(Dart_SetField(dart_buffer_objects_[i],
+        Dart_NewExternalTypedData(kUint8, buffers_[i], size));
+    ThrowIfError(Dart_SetField(Dart_HandleFromPersistent(dart_buffer_objects_[i]),
                                data_identifier,
                                data));
   }
 }
 
 
 void SSLFilter::RegisterHandshakeCompleteCallback(Dart_Handle complete) {
   ASSERT(NULL == handshake_complete_);
-  handshake_complete_ = ThrowIfError(Dart_NewPersistentHandle(complete));
+  handshake_complete_ = Dart_NewPersistentHandle(complete);
+  ASSERT(handshake_complete_ != NULL);
 }
 
 
 void SSLFilter::RegisterBadCertificateCallback(Dart_Handle callback) {
-  if (NULL != bad_certificate_callback_) {
-    Dart_DeletePersistentHandle(bad_certificate_callback_);
-  }
-  bad_certificate_callback_ = ThrowIfError(Dart_NewPersistentHandle(callback));
+  ASSERT(bad_certificate_callback_ != NULL);

[siva, 2013/05/28 17:37:18]

Why has this been changed to eagerly create bad_certificate_callback_
instead of the way it was being done before?

[Ivan Posva, 2013/05/28 21:12:20]

It was more regular this way by avoiding extra (bad_certificate_callback() ==
NULL) tests, especially in the accessor it does not have to check for NULL with
this pattern.

+  Dart_DeletePersistentHandle(bad_certificate_callback_);
+  bad_certificate_callback_ = Dart_NewPersistentHandle(callback);
+  ASSERT(bad_certificate_callback_ != NULL);
 }
 
 static const char* builtin_roots_module =
 #if defined(TARGET_OS_LINUX) || defined(TARGET_OS_ANDROID)
     "name=\"Root Certs\" library=\"libnssckbi.so\"";
 #elif defined(TARGET_OS_MACOS)
     "name=\"Root Certs\" library=\"libnssckbi.dylib\"";
 #elif defined(TARGET_OS_WINDOWS)
     "name=\"Root Certs\" library=\"nssckbi.dll\"";
 #else
@@ skipping 71 matching lines @@
   if (!retry) {
     return PL_strdup(static_cast<char*>(arg));  // Freed by NSS internals.
   }
   return NULL;
 }
 
 
 SECStatus BadCertificateCallback(void* filter, PRFileDesc* fd) {
   SSLFilter* ssl_filter = static_cast<SSLFilter*>(filter);
   Dart_Handle callback = ssl_filter->bad_certificate_callback();
-  if (callback == NULL || Dart_IsNull(callback)) return SECFailure;
+  if (Dart_IsNull(callback)) return SECFailure;
 
   Dart_EnterScope();
   Dart_Handle x509_object = ssl_filter->PeerCertificate();
   Dart_Handle result =
       ThrowIfError(Dart_InvokeClosure(callback, 1, &x509_object));
   bool c_result = Dart_IsBoolean(result) && DartUtils::GetBooleanValue(result);
   Dart_ExitScope();
   return c_result ? SECSuccess : SECFailure;
 }
 
@@ skipping 134 matching lines @@
 
   memio_SetPeerName(filter_, &host_address);
   PR_FreeAddrInfo(info);
 }
 
 
 void SSLFilter::Handshake() {
   SECStatus status = SSL_ForceHandshake(filter_);
   if (status == SECSuccess) {
     if (in_handshake_) {
-      ThrowIfError(Dart_InvokeClosure(handshake_complete_, 0, NULL));
+      ThrowIfError(Dart_InvokeClosure(Dart_HandleFromPersistent(handshake_complete_), 0, NULL));
       in_handshake_ = false;
     }
   } else {
     PRErrorCode error = PR_GetError();
     if (error == PR_WOULD_BLOCK_ERROR) {
       if (!in_handshake_) {
         in_handshake_ = true;
       }
     } else {
       if (is_server_) {
         ThrowPRException("Unexpected handshake error in server");
       } else {
         ThrowPRException("Unexpected handshake error in client");
       }
     }
   }
 }
 
 
 void SSLFilter::Destroy() {
   for (int i = 0; i < kNumBuffers; ++i) {
     Dart_DeletePersistentHandle(dart_buffer_objects_[i]);
     delete[] buffers_[i];
   }
   Dart_DeletePersistentHandle(string_start_);
   Dart_DeletePersistentHandle(string_length_);
   Dart_DeletePersistentHandle(handshake_complete_);
-  if (bad_certificate_callback_ != NULL) {
-    Dart_DeletePersistentHandle(bad_certificate_callback_);
-  }
+  Dart_DeletePersistentHandle(bad_certificate_callback_);
   free(client_certificate_name_);
 
   PR_Close(filter_);
 }
 
 
 intptr_t SSLFilter::ProcessBuffer(int buffer_index) {
   int size = isEncrypted(buffer_index) ? encrypted_buffer_size_ : buffer_size_;
-  Dart_Handle buffer_object = dart_buffer_objects_[buffer_index];
+  Dart_Handle buffer_object = Dart_HandleFromPersistent(dart_buffer_objects_[buffer_index]);
   Dart_Handle start_object = ThrowIfError(
-      Dart_GetField(buffer_object, string_start_));
+      Dart_GetField(buffer_object, Dart_HandleFromPersistent(string_start_)));
   Dart_Handle length_object = ThrowIfError(
-      Dart_GetField(buffer_object, string_length_));
+      Dart_GetField(buffer_object, Dart_HandleFromPersistent(string_length_)));
   int64_t unsafe_start = DartUtils::GetIntegerValue(start_object);
   int64_t unsafe_length = DartUtils::GetIntegerValue(length_object);
   ASSERT(unsafe_start >= 0);
   ASSERT(unsafe_start < size);
   ASSERT(unsafe_length >= 0);
   ASSERT(unsafe_length <= size);
   int start = static_cast<int>(unsafe_start);
   int length = static_cast<int>(unsafe_length);
   uint8_t* buffer = buffers_[buffer_index];
 
@@ skipping 75 matching lines @@
         bytes_processed = 0;
       }
       break;
     }
   }
   return bytes_processed;
 }
 
 }  // namespace bin
 }  // namespace dart