Upgrade chrome's OpenSSL to same version Android ships with.

openssl/crypto/mem.c

 /* crypto/mem.c */
 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
  * All rights reserved.
  *
  * This package is an SSL implementation written
  * by Eric Young (eay@cryptsoft.com).
  * The implementation was written so as to conform with Netscapes SSL.
  * 
  * This library is free for commercial and non-commercial use as long as
  * the following conditions are aheared to.  The following conditions
@@ skipping 83 matching lines @@
         { return malloc_locked_func(num); }
 static void *(*malloc_locked_ex_func)(size_t, const char *file, int line)
         = default_malloc_locked_ex;
 
 static void (*free_locked_func)(void *)     = free;
 
 
 
 /* may be changed as long as 'allow_customize_debug' is set */
 /* XXX use correct function pointer types */
-#if defined(CRYPTO_MDEBUG) && !defined(OPENSSL_FIPS)
+#ifdef CRYPTO_MDEBUG
 /* use default functions from mem_dbg.c */
 static void (*malloc_debug_func)(void *,int,const char *,int,int)
         = CRYPTO_dbg_malloc;
 static void (*realloc_debug_func)(void *,void *,int,const char *,int,int)
         = CRYPTO_dbg_realloc;
 static void (*free_debug_func)(void *,int) = CRYPTO_dbg_free;
 static void (*set_debug_options_func)(long) = CRYPTO_dbg_set_options;
 static long (*get_debug_options_func)(void) = CRYPTO_dbg_get_options;
-
-static int  (*push_info_func)(const char *info, const char *file, int line)
-        = CRYPTO_dbg_push_info;
-static int  (*pop_info_func)(void)
-        = CRYPTO_dbg_pop_info;
-static int (*remove_all_info_func)(void)
-        = CRYPTO_dbg_remove_all_info;
-
 #else
 /* applications can use CRYPTO_malloc_debug_init() to select above case
  * at run-time */
 static void (*malloc_debug_func)(void *,int,const char *,int,int) = NULL;
 static void (*realloc_debug_func)(void *,void *,int,const char *,int,int)
         = NULL;
 static void (*free_debug_func)(void *,int) = NULL;
 static void (*set_debug_options_func)(long) = NULL;
 static long (*get_debug_options_func)(void) = NULL;
-
-
-static int  (*push_info_func)(const char *info, const char *file, int line)
-        = NULL;
-static int  (*pop_info_func)(void) = NULL;
-static int (*remove_all_info_func)(void) = NULL;
-
 #endif
 
 
 int CRYPTO_set_mem_functions(void *(*m)(size_t), void *(*r)(void *, size_t),
         void (*f)(void *))
         {
         if (!allow_customize)
                 return 0;
         if ((m == 0) || (r == 0) || (f == 0))
                 return 0;
@@ skipping 55 matching lines @@
         if (!allow_customize_debug)
                 return 0;
         malloc_debug_func=m;
         realloc_debug_func=r;
         free_debug_func=f;
         set_debug_options_func=so;
         get_debug_options_func=go;
         return 1;
         }
 
-void CRYPTO_set_mem_info_functions(
-        int  (*push_info_fn)(const char *info, const char *file, int line),
-        int  (*pop_info_fn)(void),
-        int (*remove_all_info_fn)(void))
-        {
-        push_info_func = push_info_fn;
-        pop_info_func = pop_info_fn;
-        remove_all_info_func = remove_all_info_fn;
-        }
 
 void CRYPTO_get_mem_functions(void *(**m)(size_t), void *(**r)(void *, size_t),
         void (**f)(void *))
         {
         if (m != NULL) *m = (malloc_ex_func == default_malloc_ex) ? 
                              malloc_func : 0;
         if (r != NULL) *r = (realloc_ex_func == default_realloc_ex) ? 
                              realloc_func : 0;
         if (f != NULL) *f=free_func;
         }
@@ skipping 36 matching lines @@
         if (r != NULL) *r=realloc_debug_func;
         if (f != NULL) *f=free_debug_func;
         if (so != NULL) *so=set_debug_options_func;
         if (go != NULL) *go=get_debug_options_func;
         }
 
 
 void *CRYPTO_malloc_locked(int num, const char *file, int line)
         {
         void *ret = NULL;
-        extern unsigned char cleanse_ctr;
 
         if (num <= 0) return NULL;
 
         allow_customize = 0;
         if (malloc_debug_func != NULL)
                 {
                 allow_customize_debug = 0;
                 malloc_debug_func(NULL, num, file, line, 0);
                 }
         ret = malloc_locked_ex_func(num,file,line);
 #ifdef LEVITTE_DEBUG_MEM
         fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);
 #endif
         if (malloc_debug_func != NULL)
                 malloc_debug_func(ret, num, file, line, 1);
 
+#ifndef OPENSSL_CPUID_OBJ
         /* Create a dependency on the value of 'cleanse_ctr' so our memory
          * sanitisation function can't be optimised out. NB: We only do
          * this for >2Kb so the overhead doesn't bother us. */
         if(ret && (num > 2048))
+        {       extern unsigned char cleanse_ctr;
                 ((unsigned char *)ret)[0] = cleanse_ctr;
+        }
+#endif
 
         return ret;
         }
 
 void CRYPTO_free_locked(void *str)
         {
         if (free_debug_func != NULL)
                 free_debug_func(str, 0);
 #ifdef LEVITTE_DEBUG_MEM
         fprintf(stderr, "LEVITTE_DEBUG_MEM:         < 0x%p\n", str);
 #endif
         free_locked_func(str);
         if (free_debug_func != NULL)
                 free_debug_func(NULL, 1);
         }
 
 void *CRYPTO_malloc(int num, const char *file, int line)
         {
         void *ret = NULL;
-        extern unsigned char cleanse_ctr;
 
         if (num <= 0) return NULL;
 
         allow_customize = 0;
         if (malloc_debug_func != NULL)
                 {
                 allow_customize_debug = 0;
                 malloc_debug_func(NULL, num, file, line, 0);
                 }
         ret = malloc_ex_func(num,file,line);
 #ifdef LEVITTE_DEBUG_MEM
         fprintf(stderr, "LEVITTE_DEBUG_MEM:         > 0x%p (%d)\n", ret, num);
 #endif
         if (malloc_debug_func != NULL)
                 malloc_debug_func(ret, num, file, line, 1);
 
+#ifndef OPENSSL_CPUID_OBJ
         /* Create a dependency on the value of 'cleanse_ctr' so our memory
          * sanitisation function can't be optimised out. NB: We only do
          * this for >2Kb so the overhead doesn't bother us. */
         if(ret && (num > 2048))
+        {       extern unsigned char cleanse_ctr;
                 ((unsigned char *)ret)[0] = cleanse_ctr;
+        }
+#endif
 
         return ret;
         }
+char *CRYPTO_strdup(const char *str, const char *file, int line)
+        {
+        char *ret = CRYPTO_malloc(strlen(str)+1, file, line);
+
+        strcpy(ret, str);
+        return ret;
+        }
 
 void *CRYPTO_realloc(void *str, int num, const char *file, int line)
         {
         void *ret = NULL;
 
         if (str == NULL)
                 return CRYPTO_malloc(num, file, line);
 
         if (num <= 0) return NULL;
 
@@ skipping 63 matching lines @@
         if (set_debug_options_func != NULL)
                 set_debug_options_func(bits);
         }
 
 long CRYPTO_get_mem_debug_options(void)
         {
         if (get_debug_options_func != NULL)
                 return get_debug_options_func();
         return 0;
         }
-
-int CRYPTO_push_info_(const char *info, const char *file, int line)
-        {
-        if (push_info_func)
-                return push_info_func(info, file, line);
-        return 1;
-        }
-
-int CRYPTO_pop_info(void)
-        {
-        if (pop_info_func)
-                return pop_info_func();
-        return 1;
-        }
-
-int CRYPTO_remove_all_info(void)
-        {
-        if (remove_all_info_func)
-                return remove_all_info_func();
-        return 1;
-        }