git cl format the final third of the net/base directory

net/base/nss_memio.c

 // 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
 
 /* 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 <stdlib.h>
 #include <string.h>
 
 #include <prerror.h>
 #include <prinit.h>
 #include <prlog.h>
 
 #include "nss_memio.h"
 
 /*--------------- private memio types -----------------------*/
 
 /*----------------------------------------------------------------------
  Simple private circular buffer class.  Size cannot be changed once allocated.
 ----------------------------------------------------------------------*/
 
 struct memio_buffer {
-    int head;     /* where to take next byte out of buf */
-    int tail;     /* where to put next byte into buf */
-    int bufsize;  /* number of bytes allocated to buf */
-    /* TODO(port): error handling is pessimistic right now.
-     * Once an error is set, the socket is considered broken
-     * (PR_WOULD_BLOCK_ERROR not included).
-     */
-    PRErrorCode last_err;
-    char *buf;
+  int head;    /* where to take next byte out of buf */
+  int tail;    /* where to put next byte into buf */
+  int bufsize; /* number of bytes allocated to buf */
+               /* TODO(port): error handling is pessimistic right now.

[mef, 2014/10/10 20:38:17]

not sure that this comment should align with those above.

+                * Once an error is set, the socket is considered broken
+                * (PR_WOULD_BLOCK_ERROR not included).
+                */
+  PRErrorCode last_err;
+  char* buf;
 };
 
-
 /* The 'secret' field of a PRFileDesc created by memio_CreateIOLayer points
  * to one of these.
  * In the public header, we use struct memio_Private as a typesafe alias
  * for this.  This causes a few ugly typecasts in the private file, but
  * seems safer.
  */
 struct PRFilePrivate {
-    /* read requests are satisfied from this buffer */
-    struct memio_buffer readbuf;
+  /* read requests are satisfied from this buffer */
+  struct memio_buffer readbuf;
 
-    /* write requests are satisfied from this buffer */
-    struct memio_buffer writebuf;
+  /* write requests are satisfied from this buffer */
+  struct memio_buffer writebuf;
 
-    /* SSL needs to know socket peer's name */
-    PRNetAddr peername;
+  /* SSL needs to know socket peer's name */
+  PRNetAddr peername;
 
-    /* if set, empty I/O returns EOF instead of EWOULDBLOCK */
-    int eof;
+  /* 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;
+  /* 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);
+static void memio_buffer_new(struct memio_buffer* mb, int size);
 
 /* Deallocate a memio_buffer allocated by memio_buffer_new. */
-static void memio_buffer_destroy(struct memio_buffer *mb);
+static void memio_buffer_destroy(struct memio_buffer* mb);
 
 /* How many bytes can be read out of the buffer without wrapping */
-static int memio_buffer_used_contiguous(const struct memio_buffer *mb);
+static int memio_buffer_used_contiguous(const struct memio_buffer* mb);
 
 /* How many bytes exist after the wrap? */
-static int memio_buffer_wrapped_bytes(const struct memio_buffer *mb);
+static int memio_buffer_wrapped_bytes(const struct memio_buffer* mb);
 
 /* How many bytes can be written into the buffer without wrapping */
-static int memio_buffer_unused_contiguous(const struct memio_buffer *mb);
+static int memio_buffer_unused_contiguous(const struct memio_buffer* mb);
 
 /* Write n bytes into the buffer.  Returns number of bytes written. */
-static int memio_buffer_put(struct memio_buffer *mb, const char *buf, int n);
+static int memio_buffer_put(struct memio_buffer* mb, const char* buf, int n);
 
 /* Read n bytes from the buffer.  Returns number of bytes read. */
-static int memio_buffer_get(struct memio_buffer *mb, char *buf, int n);
+static int memio_buffer_get(struct memio_buffer* mb, char* buf, int n);
 
 /* Allocate a memio_buffer of given size. */
-static void memio_buffer_new(struct memio_buffer *mb, int size)
-{
-    mb->head = 0;
-    mb->tail = 0;
-    mb->bufsize = size;
-    mb->buf = malloc(size);
+static void memio_buffer_new(struct memio_buffer* mb, int size) {
+  mb->head = 0;
+  mb->tail = 0;
+  mb->bufsize = size;
+  mb->buf = 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;
+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);
+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? */
-static int memio_buffer_wrapped_bytes(const struct memio_buffer *mb)
-{
-    return (mb->tail >= mb->head) ? 0 : mb->tail;
+static int memio_buffer_wrapped_bytes(const struct memio_buffer* mb) {
+  return (mb->tail >= mb->head) ? 0 : mb->tail;
 }
 
 /* How many bytes can be written into the buffer without wrapping */
-static int memio_buffer_unused_contiguous(const struct memio_buffer *mb)
-{
-    if (mb->head > mb->tail) return mb->head - mb->tail - 1;
-    return mb->bufsize - mb->tail - (mb->head == 0);
+static int memio_buffer_unused_contiguous(const struct memio_buffer* mb) {
+  if (mb->head > mb->tail)
+    return mb->head - mb->tail - 1;
+  return mb->bufsize - mb->tail - (mb->head == 0);
 }
 
 /* Write n bytes into the buffer.  Returns number of bytes written. */
-static int memio_buffer_put(struct memio_buffer *mb, const char *buf, int n)
-{
-    int len;
-    int transferred = 0;
-
-    /* Handle part before wrap */
+static int memio_buffer_put(struct memio_buffer* mb, const char* buf, int n) {
+  int len;
+  int transferred = 0;
+
+  /* Handle part before wrap */

[mef, 2014/10/10 20:38:17]

I think NSS has/had formatting different from Chromium. Not sure what is the
right thing here.

+  len = PR_MIN(n, memio_buffer_unused_contiguous(mb));
+  if (len > 0) {
+    /* Buffer not full */
+    memcpy(&mb->buf[mb->tail], buf, len);
+    mb->tail += len;
+    if (mb->tail == mb->bufsize)
+      mb->tail = 0;
+    n -= len;
+    buf += len;
+    transferred += len;
+
+    /* Handle part after wrap */
     len = PR_MIN(n, memio_buffer_unused_contiguous(mb));
     if (len > 0) {
-        /* Buffer not full */
-        memcpy(&mb->buf[mb->tail], buf, len);
-        mb->tail += len;
-        if (mb->tail == mb->bufsize)
-            mb->tail = 0;
-        n -= len;
-        buf += len;
-        transferred += len;
-
-        /* Handle part after wrap */
-        len = PR_MIN(n, memio_buffer_unused_contiguous(mb));
-        if (len > 0) {
-            /* Output buffer still not full, input buffer still not empty */
-            memcpy(&mb->buf[mb->tail], buf, len);
-            mb->tail += len;
-            if (mb->tail == mb->bufsize)
-                mb->tail = 0;
-            transferred += len;
-        }
+      /* Output buffer still not full, input buffer still not empty */
+      memcpy(&mb->buf[mb->tail], buf, len);
+      mb->tail += len;
+      if (mb->tail == mb->bufsize)
+        mb->tail = 0;
+      transferred += len;
     }
-
-    return transferred;
-}
-
+  }
+
+  return transferred;
+}
 
 /* Read n bytes from the buffer.  Returns number of bytes read. */
-static int memio_buffer_get(struct memio_buffer *mb, char *buf, int n)
-{
-    int len;
-    int transferred = 0;
-
-    /* Handle part before wrap */
+static int memio_buffer_get(struct memio_buffer* mb, char* buf, int n) {
+  int len;
+  int transferred = 0;
+
+  /* Handle part before wrap */
+  len = PR_MIN(n, memio_buffer_used_contiguous(mb));
+  if (len) {
+    memcpy(buf, &mb->buf[mb->head], len);
+    mb->head += len;
+    if (mb->head == mb->bufsize)
+      mb->head = 0;
+    n -= len;
+    buf += len;
+    transferred += len;
+
+    /* Handle part after wrap */
     len = PR_MIN(n, memio_buffer_used_contiguous(mb));
     if (len) {
-        memcpy(buf, &mb->buf[mb->head], len);
-        mb->head += len;
-        if (mb->head == mb->bufsize)
-            mb->head = 0;
-        n -= len;
-        buf += len;
-        transferred += len;
-
-        /* Handle part after wrap */
-        len = PR_MIN(n, memio_buffer_used_contiguous(mb));
-        if (len) {
-            memcpy(buf, &mb->buf[mb->head], len);
-            mb->head += len;
-            if (mb->head == mb->bufsize)
-                mb->head = 0;
-            transferred += len;
-        }
+      memcpy(buf, &mb->buf[mb->head], len);
+      mb->head += len;
+      if (mb->head == mb->bufsize)
+        mb->head = 0;
+      transferred += len;
     }
-
-    return transferred;
+  }
+
+  return transferred;
 }
 
 /*--------------- private memio functions -----------------------*/
 
-static PRStatus PR_CALLBACK memio_Close(PRFileDesc *fd)
-{
-    struct PRFilePrivate *secret = fd->secret;
-    memio_buffer_destroy(&secret->readbuf);
-    memio_buffer_destroy(&secret->writebuf);
-    free(secret);
-    fd->dtor(fd);
-    return PR_SUCCESS;
-}
-
-static PRStatus PR_CALLBACK memio_Shutdown(PRFileDesc *fd, PRIntn how)
-{
-    /* TODO: pass shutdown status to app somehow */
-    return PR_SUCCESS;
+static PRStatus PR_CALLBACK memio_Close(PRFileDesc* fd) {
+  struct PRFilePrivate* secret = fd->secret;
+  memio_buffer_destroy(&secret->readbuf);
+  memio_buffer_destroy(&secret->writebuf);
+  free(secret);
+  fd->dtor(fd);
+  return PR_SUCCESS;
+}
+
+static PRStatus PR_CALLBACK memio_Shutdown(PRFileDesc* fd, PRIntn how) {
+  /* TODO: pass shutdown status to app somehow */
+  return PR_SUCCESS;
 }
 
 /* If there was a network error in the past taking bytes
  * out of the buffer, return it to the next call that
  * tries to read from an empty buffer.
  */
-static int PR_CALLBACK memio_Recv(PRFileDesc *fd, void *buf, PRInt32 len,
-                                  PRIntn flags, PRIntervalTime timeout)
-{
-    struct PRFilePrivate *secret;
-    struct memio_buffer *mb;
-    int rv;
-
-    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, void *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 void *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.
+static int PR_CALLBACK memio_Recv(PRFileDesc* fd,
+                                  void* buf,
+                                  PRInt32 len,
+                                  PRIntn flags,
+                                  PRIntervalTime timeout) {
+  struct PRFilePrivate* secret;
+  struct memio_buffer* mb;
+  int rv;
+
+  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);
-        return -1;
-    }
-    rv = memio_buffer_put(mb, buf, len);
-    if (rv == 0) {
-        PR_SetError(PR_WOULD_BLOCK_ERROR, 0);
-        return -1;
-    }
-    return rv;
-}
-
-static int PR_CALLBACK memio_Write(PRFileDesc *fd, const void *buf, PRInt32 len)
-{
-    /* append bytes to buffer */
-    return memio_Send(fd, buf, len, 0, PR_INTERVAL_NO_TIMEOUT);
-}
-
-static PRStatus PR_CALLBACK memio_GetPeerName(PRFileDesc *fd, PRNetAddr *addr)
-{
-    /* TODO: fail if memio_SetPeerName has not been called */
-    struct PRFilePrivate *secret = fd->secret;
-    *addr = secret->peername;
+    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, void* 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 void* 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;
+}
+
+static int PR_CALLBACK
+    memio_Write(PRFileDesc* fd, const void* buf, PRInt32 len) {
+  /* append bytes to buffer */
+  return memio_Send(fd, buf, len, 0, PR_INTERVAL_NO_TIMEOUT);
+}
+
+static PRStatus PR_CALLBACK memio_GetPeerName(PRFileDesc* fd, PRNetAddr* addr) {
+  /* TODO: fail if memio_SetPeerName has not been called */
+  struct PRFilePrivate* secret = fd->secret;
+  *addr = secret->peername;
+  return PR_SUCCESS;
+}
+
+static PRStatus memio_GetSocketOption(PRFileDesc* fd,
+                                      PRSocketOptionData* data) {
+  /*
+   * Even in the original version for real tcp sockets,
+   * PR_SockOpt_Nonblocking is a special case that does not
+   * translate to a getsockopt() call
+   */
+  if (PR_SockOpt_Nonblocking == data->option) {
+    data->value.non_blocking = PR_TRUE;
     return PR_SUCCESS;
-}
-
-static PRStatus memio_GetSocketOption(PRFileDesc *fd, PRSocketOptionData *data)
-{
-    /*
-     * Even in the original version for real tcp sockets,
-     * PR_SockOpt_Nonblocking is a special case that does not
-     * translate to a getsockopt() call
-     */
-    if (PR_SockOpt_Nonblocking == data->option) {
-        data->value.non_blocking = PR_TRUE;
-        return PR_SUCCESS;
-    }
-    PR_SetError(PR_OPERATION_NOT_SUPPORTED_ERROR, 0);
-    return PR_FAILURE;
+  }
+  PR_SetError(PR_OPERATION_NOT_SUPPORTED_ERROR, 0);
+  return PR_FAILURE;
 }
 
 /*--------------- private memio data -----------------------*/
 
 /*
  * Implement just the bare minimum number of methods needed to make ssl happy.
  *
  * Oddly, PR_Recv calls ssl_Recv calls ssl_SocketIsBlocking calls
  * PR_GetSocketOption, so we have to provide an implementation of
  * PR_GetSocketOption that just says "I'm nonblocking".
  */
 
-static struct PRIOMethods  memio_layer_methods = {
+static struct PRIOMethods memio_layer_methods = {
     PR_DESC_LAYERED,
     memio_Close,
     memio_Read,
     memio_Write,
     NULL,
     NULL,
     NULL,
     NULL,
     NULL,
     NULL,
@@ skipping 20 matching lines @@
     NULL,
     NULL,
     NULL,
     NULL,
     NULL,
     NULL,
 };
 
 static PRDescIdentity memio_identity = PR_INVALID_IO_LAYER;
 
-static PRStatus memio_InitializeLayerName(void)
-{
-    memio_identity = PR_GetUniqueIdentity("memio");
-    return PR_SUCCESS;
+static PRStatus memio_InitializeLayerName(void) {
+  memio_identity = PR_GetUniqueIdentity("memio");
+  return PR_SUCCESS;
 }
 
 /*--------------- public memio functions -----------------------*/
 
-PRFileDesc *memio_CreateIOLayer(int readbufsize, int writebufsize)
-{
-    PRFileDesc *fd;
-    struct PRFilePrivate *secret;
-    static PRCallOnceType once;
+PRFileDesc* memio_CreateIOLayer(int readbufsize, int writebufsize) {
+  PRFileDesc* fd;
+  struct PRFilePrivate* secret;
+  static PRCallOnceType once;
 
-    PR_CallOnce(&once, memio_InitializeLayerName);
+  PR_CallOnce(&once, memio_InitializeLayerName);
 
-    fd = PR_CreateIOLayerStub(memio_identity, &memio_layer_methods);
-    secret = malloc(sizeof(struct PRFilePrivate));
-    memset(secret, 0, sizeof(*secret));
+  fd = PR_CreateIOLayerStub(memio_identity, &memio_layer_methods);
+  secret = malloc(sizeof(struct PRFilePrivate));
+  memset(secret, 0, sizeof(*secret));
 
-    memio_buffer_new(&secret->readbuf, readbufsize);
-    memio_buffer_new(&secret->writebuf, writebufsize);
-    fd->secret = secret;
-    return fd;
+  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;
+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);
-    struct PRFilePrivate *secret =  memiofd->secret;
-    return (memio_Private *)secret;
+memio_Private* memio_GetSecret(PRFileDesc* fd) {
+  PRFileDesc* memiofd = PR_GetIdentitiesLayer(fd, memio_identity);
+  struct PRFilePrivate* secret = memiofd->secret;
+  return (memio_Private*)secret;
 }
 
-int memio_GetReadRequest(memio_Private *secret)
-{
-    return ((PRFilePrivate *)secret)->read_requested;
+int memio_GetReadRequest(memio_Private* secret) {
+  return ((PRFilePrivate*)secret)->read_requested;
 }
 
-int memio_GetReadParams(memio_Private *secret, char **buf)
-{
-    struct memio_buffer* mb = &((PRFilePrivate *)secret)->readbuf;
-    PR_ASSERT(mb->bufsize);
+int memio_GetReadParams(memio_Private* secret, char** buf) {
+  struct memio_buffer* mb = &((PRFilePrivate*)secret)->readbuf;
+  PR_ASSERT(mb->bufsize);
 
-    *buf = &mb->buf[mb->tail];
-    return memio_buffer_unused_contiguous(mb);
+  *buf = &mb->buf[mb->tail];
+  return memio_buffer_unused_contiguous(mb);
 }
 
-int memio_GetReadableBufferSize(memio_Private *secret)
-{
-    struct memio_buffer* mb = &((PRFilePrivate *)secret)->readbuf;
-    PR_ASSERT(mb->bufsize);
+int memio_GetReadableBufferSize(memio_Private* secret) {
+  struct memio_buffer* mb = &((PRFilePrivate*)secret)->readbuf;
+  PR_ASSERT(mb->bufsize);
 
-    return memio_buffer_used_contiguous(mb);
+  return memio_buffer_used_contiguous(mb);
 }
 
-void memio_PutReadResult(memio_Private *secret, int bytes_read)
-{
-    struct memio_buffer* mb = &((PRFilePrivate *)secret)->readbuf;
-    PR_ASSERT(mb->bufsize);
+void memio_PutReadResult(memio_Private* secret, int bytes_read) {
+  struct memio_buffer* mb = &((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) {
-        /* Record EOF condition and report to caller when buffer runs dry */
-        ((PRFilePrivate *)secret)->eof = PR_TRUE;
-    } else /* if (bytes_read < 0) */ {
-        mb->last_err = bytes_read;
-    }
+  if (bytes_read > 0) {
+    mb->tail += bytes_read;
+    if (mb->tail == mb->bufsize)
+      mb->tail = 0;
+  } else if (bytes_read == 0) {
+    /* Record EOF condition and report to caller when buffer runs dry */
+    ((PRFilePrivate*)secret)->eof = PR_TRUE;
+  } else /* if (bytes_read < 0) */ {
+    mb->last_err = bytes_read;
+  }
 }
 
-int memio_GetWriteParams(memio_Private *secret,
-                         const char **buf1, unsigned int *len1,
-                         const char **buf2, unsigned int *len2)
-{
-    struct memio_buffer* mb = &((PRFilePrivate *)secret)->writebuf;
-    PR_ASSERT(mb->bufsize);
+int memio_GetWriteParams(memio_Private* secret,
+                         const char** buf1,
+                         unsigned int* len1,
+                         const char** buf2,
+                         unsigned int* len2) {
+  struct memio_buffer* mb = &((PRFilePrivate*)secret)->writebuf;
+  PR_ASSERT(mb->bufsize);
 
-    if (mb->last_err)
-        return mb->last_err;
+  if (mb->last_err)
+    return mb->last_err;
 
-    *buf1 = &mb->buf[mb->head];
-    *len1 = memio_buffer_used_contiguous(mb);
-    *buf2 = mb->buf;
-    *len2 = memio_buffer_wrapped_bytes(mb);
-    return 0;
+  *buf1 = &mb->buf[mb->head];
+  *len1 = memio_buffer_used_contiguous(mb);
+  *buf2 = mb->buf;
+  *len2 = memio_buffer_wrapped_bytes(mb);
+  return 0;
 }
 
-void memio_PutWriteResult(memio_Private *secret, int bytes_written)
-{
-    struct memio_buffer* mb = &((PRFilePrivate *)secret)->writebuf;
-    PR_ASSERT(mb->bufsize);
+void memio_PutWriteResult(memio_Private* secret, int bytes_written) {
+  struct memio_buffer* mb = &((PRFilePrivate*)secret)->writebuf;
+  PR_ASSERT(mb->bufsize);
 
-    if (bytes_written > 0) {
-        mb->head += bytes_written;
-        if (mb->head >= mb->bufsize)
-            mb->head -= mb->bufsize;
-    } else if (bytes_written < 0) {
-        mb->last_err = bytes_written;
-    }
+  if (bytes_written > 0) {
+    mb->head += bytes_written;
+    if (mb->head >= mb->bufsize)
+      mb->head -= mb->bufsize;
+  } else if (bytes_written < 0) {
+    mb->last_err = bytes_written;
+  }
 }
 
 /*--------------- private memio_buffer self-test -----------------*/
 
 /* Even a trivial unit test is very helpful when doing circular buffers. */
 /*#define TRIVIAL_SELF_TEST*/
 #ifdef TRIVIAL_SELF_TEST
 #include <stdio.h>
 
 #define TEST_BUFLEN 7
 
-#define CHECKEQ(a, b) { \
-    if ((a) != (b)) { \
-        printf("%d != %d, Test failed line %d\n", a, b, __LINE__); \
-        exit(1); \
-    } \
-}
+#define CHECKEQ(a, b)                                            \
+  {                                                              \
+    if ((a) != (b)) {                                            \
+      printf("%d != %d, Test failed line %d\n", a, b, __LINE__); \
+      exit(1);                                                   \
+    }                                                            \
+  }
 
-int main()
-{
-    struct memio_buffer mb;
-    char buf[100];
-    int i;
+int main() {
+  struct memio_buffer mb;
+  char buf[100];
+  int i;
 
-    memio_buffer_new(&mb, TEST_BUFLEN);
+  memio_buffer_new(&mb, TEST_BUFLEN);
 
-    CHECKEQ(memio_buffer_unused_contiguous(&mb), TEST_BUFLEN-1);
-    CHECKEQ(memio_buffer_used_contiguous(&mb), 0);
+  CHECKEQ(memio_buffer_unused_contiguous(&mb), TEST_BUFLEN - 1);
+  CHECKEQ(memio_buffer_used_contiguous(&mb), 0);
 
-    CHECKEQ(memio_buffer_put(&mb, "howdy", 5), 5);
+  CHECKEQ(memio_buffer_put(&mb, "howdy", 5), 5);
 
-    CHECKEQ(memio_buffer_unused_contiguous(&mb), TEST_BUFLEN-1-5);
-    CHECKEQ(memio_buffer_used_contiguous(&mb), 5);
-    CHECKEQ(memio_buffer_wrapped_bytes(&mb), 0);
+  CHECKEQ(memio_buffer_unused_contiguous(&mb), TEST_BUFLEN - 1 - 5);
+  CHECKEQ(memio_buffer_used_contiguous(&mb), 5);
+  CHECKEQ(memio_buffer_wrapped_bytes(&mb), 0);
 
-    CHECKEQ(memio_buffer_put(&mb, "!", 1), 1);
+  CHECKEQ(memio_buffer_put(&mb, "!", 1), 1);
 
-    CHECKEQ(memio_buffer_unused_contiguous(&mb), 0);
-    CHECKEQ(memio_buffer_used_contiguous(&mb), 6);
-    CHECKEQ(memio_buffer_wrapped_bytes(&mb), 0);
+  CHECKEQ(memio_buffer_unused_contiguous(&mb), 0);
+  CHECKEQ(memio_buffer_used_contiguous(&mb), 6);
+  CHECKEQ(memio_buffer_wrapped_bytes(&mb), 0);
 
-    CHECKEQ(memio_buffer_get(&mb, buf, 6), 6);
-    CHECKEQ(memcmp(buf, "howdy!", 6), 0);
+  CHECKEQ(memio_buffer_get(&mb, buf, 6), 6);
+  CHECKEQ(memcmp(buf, "howdy!", 6), 0);
 
-    CHECKEQ(memio_buffer_unused_contiguous(&mb), 1);
-    CHECKEQ(memio_buffer_used_contiguous(&mb), 0);
+  CHECKEQ(memio_buffer_unused_contiguous(&mb), 1);
+  CHECKEQ(memio_buffer_used_contiguous(&mb), 0);
 
-    CHECKEQ(memio_buffer_put(&mb, "01234", 5), 5);
+  CHECKEQ(memio_buffer_put(&mb, "01234", 5), 5);
 
-    CHECKEQ(memio_buffer_used_contiguous(&mb), 1);
-    CHECKEQ(memio_buffer_wrapped_bytes(&mb), 4);
-    CHECKEQ(memio_buffer_unused_contiguous(&mb), TEST_BUFLEN-1-5);
+  CHECKEQ(memio_buffer_used_contiguous(&mb), 1);
+  CHECKEQ(memio_buffer_wrapped_bytes(&mb), 4);
+  CHECKEQ(memio_buffer_unused_contiguous(&mb), TEST_BUFLEN - 1 - 5);
 
-    CHECKEQ(memio_buffer_put(&mb, "5", 1), 1);
+  CHECKEQ(memio_buffer_put(&mb, "5", 1), 1);
 
-    CHECKEQ(memio_buffer_unused_contiguous(&mb), 0);
-    CHECKEQ(memio_buffer_used_contiguous(&mb), 1);
+  CHECKEQ(memio_buffer_unused_contiguous(&mb), 0);
+  CHECKEQ(memio_buffer_used_contiguous(&mb), 1);
 
-    /* TODO: add more cases */
+  /* TODO: add more cases */
 
-    printf("Test passed\n");
-    exit(0);
+  printf("Test passed\n");
+  exit(0);
 }
 
 #endif