Update to NSS 3.12.7 and NSPR 4.8.6....

nss/mozilla/security/nss/lib/base/arena.c

 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
  * 1.1 (the "License"); you may not use this file except in compliance with
  * the License. You may obtain a copy of the License at
  * http://www.mozilla.org/MPL/
  *
  * Software distributed under the License is distributed on an "AS IS" basis,
  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
@@ skipping 17 matching lines @@
  * under the terms of either the GPL or the LGPL, and not to allow others to
  * use your version of this file under the terms of the MPL, indicate your
  * decision by deleting the provisions above and replace them with the notice
  * and other provisions required by the GPL or the LGPL. If you do not delete
  * the provisions above, a recipient may use your version of this file under
  * the terms of any one of the MPL, the GPL or the LGPL.
  *
  * ***** END LICENSE BLOCK ***** */
 
 #ifdef DEBUG
-static const char CVS_ID[] = "@(#) $RCSfile: arena.c,v $ $Revision: 1.12 $ $Date: 2008/05/13 01:22:35 $";
+static const char CVS_ID[] = "@(#) $RCSfile: arena.c,v $ $Revision: 1.13 $ $Date: 2010/03/15 08:29:31 $";
 #endif /* DEBUG */
 
 /*
  * arena.c
  *
  * This contains the implementation of NSS's thread-safe arenas.
  */
 
 #ifndef BASE_H
 #include "base.h"
@@ skipping 970 matching lines @@
  *  A pointer to the replacement segment of memory
  */
 
 NSS_EXTERN void *
 nss_ZRealloc
 (
   void *pointer,
   PRUint32 newSize
 )
 {
+  NSSArena *arena;
   struct pointer_header *h, *new_h;
   PRUint32 my_newSize = newSize + sizeof(struct pointer_header);
   void *rv;
 
   if( my_newSize < sizeof(struct pointer_header) ) {
     /* Wrapped */
     nss_SetError(NSS_ERROR_NO_MEMORY);
     return (void *)NULL;
   }
 
   if( (void *)NULL == pointer ) {
     nss_SetError(NSS_ERROR_INVALID_POINTER);
     return (void *)NULL;
   }
 
   h = (struct pointer_header *)((char *)pointer
     - sizeof(struct pointer_header));
 
   /* Check any magic here */
 
   if( newSize == h->size ) {
     /* saves thrashing */
     return pointer;
   }
 
-  if( (NSSArena *)NULL == h->arena ) {
+  arena = h->arena;
+  if (!arena) {
     /* Heap */
     new_h = (struct pointer_header *)PR_Calloc(1, my_newSize);
     if( (struct pointer_header *)NULL == new_h ) {
       nss_SetError(NSS_ERROR_NO_MEMORY);
       return (void *)NULL;
     }
 
     new_h->arena = (NSSArena *)NULL;
     new_h->size = newSize;
     rv = (void *)((char *)new_h + sizeof(struct pointer_header));
 
     if( newSize > h->size ) {
       (void)nsslibc_memcpy(rv, pointer, h->size);
       (void)nsslibc_memset(&((char *)rv)[ h->size ], 
                            0, (newSize - h->size));
     } else {
       (void)nsslibc_memcpy(rv, pointer, newSize);
     }
 
     (void)nsslibc_memset(pointer, 0, h->size);
     h->size = 0;
     PR_Free(h);
 
     return rv;
   } else {
     void *p;
     /* Arena */
 #ifdef NSSDEBUG
-    if( PR_SUCCESS != nssArena_verifyPointer(h->arena) ) {
+    if (PR_SUCCESS != nssArena_verifyPointer(arena)) {
       return (void *)NULL;
     }
 #endif /* NSSDEBUG */
 
-    if( (PRLock *)NULL == h->arena->lock ) {
+    if (!arena->lock) {
       /* Just got destroyed.. so this pointer is invalid */
       nss_SetError(NSS_ERROR_INVALID_POINTER);
       return (void *)NULL;
     }
-    PR_Lock(h->arena->lock);
+    PR_Lock(arena->lock);
 
 #ifdef ARENA_THREADMARK
-    if( (PRThread *)NULL != h->arena->marking_thread ) {
-      if( PR_GetCurrentThread() != h->arena->marking_thread ) {
-        PR_Unlock(h->arena->lock);
+    if (arena->marking_thread) {
+      if (PR_GetCurrentThread() != arena->marking_thread) {
+        PR_Unlock(arena->lock);
         nss_SetError(NSS_ERROR_ARENA_MARKED_BY_ANOTHER_THREAD);
         return (void *)NULL;
       }
     }
 #endif /* ARENA_THREADMARK */
 
     if( newSize < h->size ) {
       /*
        * We have no general way of returning memory to the arena
        * (mark/release doesn't work because things may have been
        * allocated after this object), so the memory is gone
        * anyway.  We might as well just return the same pointer to
        * the user, saying "yeah, uh-hunh, you can only use less of
        * it now."  We'll zero the leftover part, of course.  And
        * in fact we might as well *not* adjust h->size-- this way,
        * if the user reallocs back up to something not greater than
        * the original size, then voila, there's the memory!  This
        * way a thrash big/small/big/small doesn't burn up the arena.
        */
       char *extra = &((char *)pointer)[ newSize ];
       (void)nsslibc_memset(extra, 0, (h->size - newSize));
-      PR_Unlock(h->arena->lock);
+      PR_Unlock(arena->lock);
       return pointer;
     }
 
-    PR_ARENA_ALLOCATE(p, &h->arena->pool, my_newSize);
+    PR_ARENA_ALLOCATE(p, &arena->pool, my_newSize);
     if( (void *)NULL == p ) {
-      PR_Unlock(h->arena->lock);
+      PR_Unlock(arena->lock);
       nss_SetError(NSS_ERROR_NO_MEMORY);
       return (void *)NULL;
     }
 
     new_h = (struct pointer_header *)p;
-    new_h->arena = h->arena;
+    new_h->arena = arena;
     new_h->size = newSize;
     rv = (void *)((char *)new_h + sizeof(struct pointer_header));
     if (rv != pointer) {
         (void)nsslibc_memcpy(rv, pointer, h->size);
         (void)nsslibc_memset(pointer, 0, h->size);
     }
     (void)nsslibc_memset(&((char *)rv)[ h->size ], 0, (newSize - h->size));
     h->arena = (NSSArena *)NULL;
     h->size = 0;
-    PR_Unlock(new_h->arena->lock);
+    PR_Unlock(arena->lock);
     return rv;
   }
   /*NOTREACHED*/
 }
 
 PRStatus 
 nssArena_Shutdown(void)
 {
   PRStatus rv = PR_SUCCESS;
 #ifdef DEBUG
   rv = nssPointerTracker_finalize(&arena_pointer_tracker);
 #endif
   return rv;
 }