Update NSS to NSS 3.16 RTM

dart/runtime/bin/net/nss_memio.cc

 // Copyright (c) 2008 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 // Written in NSPR style to also be suitable for adding to the NSS demo suite
 
+// Copyright (c) 2013, 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.
+
+// This file is a modified copy of Chromium's src/net/base/nss_memio.c.
+// char* has been changed to uint8_t* everywhere, and C++ casts are used.
+// Revision 257452 (this should agree with "nss_rev" in DEPS).
+
+
 /* memio is a simple NSPR I/O layer that lets you decouple NSS from
  * the real network.  It's rather like openssl's memory bio,
  * and is useful when your app absolutely, positively doesn't
  * want to let NSS do its own networking.
  */
 #include "bin/net/nss_memio.h"
 
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
@@ skipping 32 matching lines @@
     struct memio_buffer readbuf;
 
     /* write requests are satisfied from this buffer */
     struct memio_buffer writebuf;
 
     /* SSL needs to know socket peer's name */
     PRNetAddr peername;
 
     /* if set, empty I/O returns EOF instead of EWOULDBLOCK */
     int eof;
+
+    /* if set, the number of bytes requested from readbuf that were not
+     * fulfilled (due to readbuf being empty) */
+    int read_requested;
 };
 
 /*--------------- private memio_buffer functions ---------------------*/
 
 /* Forward declarations.  */
 
 /* Allocate a memio_buffer of given size. */
 static void memio_buffer_new(struct memio_buffer *mb, int size);
 
 /* Deallocate a memio_buffer allocated by memio_buffer_new. */
@@ skipping 19 matching lines @@
     mb->head = 0;
     mb->tail = 0;
     mb->bufsize = size;
     mb->buf = static_cast<uint8_t*>(malloc(size));
 }
 
 /* Deallocate a memio_buffer allocated by memio_buffer_new. */
 static void memio_buffer_destroy(struct memio_buffer *mb) {
     free(mb->buf);
     mb->buf = NULL;
+    mb->bufsize = 0;
     mb->head = 0;
     mb->tail = 0;
 }
 
 /* How many bytes can be read out of the buffer without wrapping */
 static int memio_buffer_used_contiguous(const struct memio_buffer *mb) {
     return (((mb->tail >= mb->head) ? mb->tail : mb->bufsize) - mb->head);
 }
 
 /* How many bytes exist after the wrap? */
@@ skipping 104 matching lines @@
     if (flags) {
         PR_SetError(PR_NOT_IMPLEMENTED_ERROR, 0);
         return -1;
     }
 
     secret = fd->secret;
     mb = &secret->readbuf;
     PR_ASSERT(mb->bufsize);
     rv = memio_buffer_get(mb, buf, len);
     if (rv == 0 && !secret->eof) {
+        secret->read_requested = len;
+        /* If there is no more data in the buffer, report any pending errors
+         * that were previously observed. Note that both the readbuf and the
+         * writebuf are checked for errors, since the application may have
+         * encountered a socket error while writing that would otherwise not
+         * be reported until the application attempted to write again - which
+         * it may never do.
+         */
         if (mb->last_err)
             PR_SetError(mb->last_err, 0);
+        else if (secret->writebuf.last_err)
+            PR_SetError(secret->writebuf.last_err, 0);
         else
             PR_SetError(PR_WOULD_BLOCK_ERROR, 0);
         return -1;
     }
 
+    secret->read_requested = 0;
     return rv;
 }
 
 static int PR_CALLBACK memio_Read(PRFileDesc *fd, uint8_t *buf, PRInt32 len) {
     /* pull bytes from buffer */
     return memio_Recv(fd, buf, len, 0, PR_INTERVAL_NO_TIMEOUT);
 }
 
 static int PR_CALLBACK memio_Send(PRFileDesc *fd,
                                   const uint8_t *buf,
                                   PRInt32 len,
                                   PRIntn flags,
                                   PRIntervalTime timeout) {
     struct PRFilePrivate *secret;
     struct memio_buffer *mb;
     int rv;
 
     secret = fd->secret;
     mb = &secret->writebuf;
     PR_ASSERT(mb->bufsize);
 
+    /* Note that the read error state is not reported, because it cannot be
+     * reported until all buffered data has been read. If there is an error
+     * with the next layer, attempting to call Send again will report the
+     * error appropriately.
+     */
     if (mb->last_err) {
         PR_SetError(mb->last_err, 0);
         return -1;
     }
     rv = memio_buffer_put(mb, buf, len);
     if (rv == 0) {
         PR_SetError(PR_WOULD_BLOCK_ERROR, 0);
         return -1;
     }
     return rv;
@@ skipping 79 matching lines @@
 
 static PRDescIdentity memio_identity = PR_INVALID_IO_LAYER;
 
 static PRStatus memio_InitializeLayerName(void) {
     memio_identity = PR_GetUniqueIdentity("memio");
     return PR_SUCCESS;
 }
 
 /*--------------- public memio functions -----------------------*/
 
-PRFileDesc *memio_CreateIOLayer(int bufsize) {
+PRFileDesc *memio_CreateIOLayer(int readbufsize, int writebufsize) {
     PRFileDesc *fd;
     struct PRFilePrivate *secret;
     static PRCallOnceType once;
 
     PR_CallOnce(&once, memio_InitializeLayerName);
 
     fd = PR_CreateIOLayerStub(memio_identity, &memio_layer_methods);
     secret = static_cast<PRFilePrivate*>(malloc(sizeof(struct PRFilePrivate)));
     memset(secret, 0, sizeof(*secret));
 
-    memio_buffer_new(&secret->readbuf, bufsize);
-    memio_buffer_new(&secret->writebuf, bufsize);
+    memio_buffer_new(&secret->readbuf, readbufsize);
+    memio_buffer_new(&secret->writebuf, writebufsize);
     fd->secret = secret;
     return fd;
 }
 
 void memio_SetPeerName(PRFileDesc* fd, const PRNetAddr* peername) {
     PRFileDesc *memiofd = PR_GetIdentitiesLayer(fd, memio_identity);
     struct PRFilePrivate *secret = memiofd->secret;
     secret->peername = *peername;
 }
 
 memio_Private* memio_GetSecret(PRFileDesc* fd) {
   PRFileDesc* memiofd = PR_GetIdentitiesLayer(fd, memio_identity);
-  return reinterpret_cast<memio_Private*>(memiofd->secret);
+  struct PRFilePrivate *secret =  memiofd->secret;
+  return reinterpret_cast<memio_Private*>(secret);
+}
+
+int memio_GetReadRequest(memio_Private *secret) {
+  return reinterpret_cast<PRFilePrivate*>(secret)->read_requested;
 }
 
 int memio_GetReadParams(memio_Private* secret, uint8_t** buf) {
   struct memio_buffer* mb =
       &(reinterpret_cast<PRFilePrivate*>(secret)->readbuf);
   PR_ASSERT(mb->bufsize);
 
   *buf = &mb->buf[mb->tail];
   return memio_buffer_unused_contiguous(mb);
 }
 
+int memio_GetReadableBufferSize(memio_Private *secret) {
+  struct memio_buffer* mb =
+      &(reinterpret_cast<PRFilePrivate*>(secret)->readbuf);
+  PR_ASSERT(mb->bufsize);
+
+  return memio_buffer_used_contiguous(mb);
+}
+
 void memio_PutReadResult(memio_Private *secret, int bytes_read) {
   struct memio_buffer* mb =
       &(reinterpret_cast<PRFilePrivate*>(secret)->readbuf);
   PR_ASSERT(mb->bufsize);
 
   if (bytes_read > 0) {
     mb->tail += bytes_read;
     if (mb->tail == mb->bufsize)
       mb->tail = 0;
   } else if (bytes_read == 0) {
@@ skipping 87 matching lines @@
     CHECKEQ(memio_buffer_unused_contiguous(&mb), 0);
     CHECKEQ(memio_buffer_used_contiguous(&mb), 1);
 
     /* TODO: add more cases */
 
     printf("Test passed\n");
     exit(0);
 }
 
 #endif