Speed up secure sockets by increasing encrypted buffer size.

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 269 matching lines @@
 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")));
   Dart_Handle dart_buffer_object =
       Dart_ListGetAt(dart_buffers_object, kReadPlaintext);
   Dart_Handle external_buffer_class =
       Dart_InstanceGetClass(dart_buffer_object);
   Dart_Handle dart_buffer_size = ThrowIfError(
       Dart_GetField(external_buffer_class, DartUtils::NewString("SIZE")));
-  buffer_size_ = DartUtils::GetIntegerValue(dart_buffer_size);
-  if (buffer_size_ <= 0 || buffer_size_ > 1024 * 1024) {
+  int64_t buffer_size = DartUtils::GetIntegerValue(dart_buffer_size);
+  Dart_Handle dart_encrypted_buffer_size = ThrowIfError(
+      Dart_GetField(external_buffer_class,
+                    DartUtils::NewString("ENCRYPTED_SIZE")));
+  int64_t encrypted_buffer_size =
+      DartUtils::GetIntegerValue(dart_encrypted_buffer_size);
+  if (buffer_size <= 0 || buffer_size > 1024 * 1024) {
     Dart_ThrowException(
         DartUtils::NewString("Invalid buffer size in _ExternalBuffer"));
   }
+  if (encrypted_buffer_size <= 0 || encrypted_buffer_size > 1024 * 1024) {
+    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)));
-    buffers_[i] = new uint8_t[buffer_size_];
+    buffers_[i] = new uint8_t[size];
     Dart_Handle data = ThrowIfError(
-      Dart_NewExternalByteArray(buffers_[i], buffer_size_, NULL, NULL));
+      Dart_NewExternalByteArray(buffers_[i], size, NULL, NULL));
     ThrowIfError(Dart_SetField(dart_buffer_objects_[i],
                                data_identifier,
                                data));
   }
 }
 
 
 void SSLFilter::RegisterHandshakeCompleteCallback(Dart_Handle complete) {
   ASSERT(NULL == handshake_complete_);
   handshake_complete_ = ThrowIfError(Dart_NewPersistentHandle(complete));
@@ skipping 248 matching lines @@
   if (bad_certificate_callback_ != NULL) {
     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 start_object = ThrowIfError(
       Dart_GetField(buffer_object, string_start_));
   Dart_Handle length_object = ThrowIfError(
       Dart_GetField(buffer_object, 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 < buffer_size_);
+  ASSERT(unsafe_start < size);
   ASSERT(unsafe_length >= 0);
-  ASSERT(unsafe_length <= buffer_size_);
-  intptr_t start = static_cast<intptr_t>(unsafe_start);
-  intptr_t length = static_cast<intptr_t>(unsafe_length);
+  ASSERT(unsafe_length <= size);
+  int start = static_cast<int>(unsafe_start);
+  int length = static_cast<int>(unsafe_length);
   uint8_t* buffer = buffers_[buffer_index];
 
   int bytes_processed = 0;
   switch (buffer_index) {
     case kReadPlaintext: {
-      int bytes_free = buffer_size_ - start - length;
+      int bytes_free = size - start - length;
       bytes_processed = PR_Read(filter_,
                                 buffer + start + length,
                                 bytes_free);
       if (bytes_processed < 0) {
         ASSERT(bytes_processed == -1);
         // TODO(whesse): Handle unexpected errors here.
         PRErrorCode pr_error = PR_GetError();
         if (PR_WOULD_BLOCK_ERROR != pr_error) {
           ThrowPRException("Error reading plaintext from SSLFilter");
         }
         bytes_processed = 0;
       }
       break;
     }
 
     case kWriteEncrypted: {
       const uint8_t* buf1;
       const uint8_t* buf2;
       unsigned int len1;
       unsigned int len2;
-      int bytes_free = buffer_size_ - start - length;
+      int bytes_free = size - start - length;
       memio_Private* secret = memio_GetSecret(filter_);
       memio_GetWriteParams(secret, &buf1, &len1, &buf2, &len2);
       int bytes_to_send =
           dart::Utils::Minimum(len1, static_cast<unsigned>(bytes_free));
       if (bytes_to_send > 0) {
         memmove(buffer + start + length, buf1, bytes_to_send);
         bytes_processed = bytes_to_send;
       }
       bytes_to_send = dart::Utils::Minimum(len2,
           static_cast<unsigned>(bytes_free - bytes_processed));
@@ skipping 37 matching lines @@
         if (PR_WOULD_BLOCK_ERROR != pr_error) {
           ThrowPRException("Error reading plaintext from SSLFilter");
         }
         bytes_processed = 0;
       }
       break;
     }
   }
   return bytes_processed;
 }