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

openssl/crypto/md32_common.h

 /* crypto/md32_common.h */
 /* ====================================================================
  * Copyright (c) 1999-2007 The OpenSSL Project.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer. 
@@ skipping 147 matching lines @@
    * Some GNU C inline assembler templates. Note that these are
    * rotates by *constant* number of bits! But that's exactly
    * what we need here...
    *                                    <appro@fy.chalmers.se>
    */
 #  if defined(__i386) || defined(__i386__) || defined(__x86_64) || defined(__x86_64__)
 #   define ROTATE(a,n)  ({ register unsigned int ret;   \
                                 asm (                   \
                                 "roll %1,%0"            \
                                 : "=r"(ret)             \
-                                : "I"(n), "0"(a)        \
+                                : "I"(n), "0"((unsigned int)(a))        \
                                 : "cc");                \
                            ret;                         \
                         })
 #  elif defined(_ARCH_PPC) || defined(_ARCH_PPC64) || \
         defined(__powerpc) || defined(__ppc__) || defined(__powerpc64__)
 #   define ROTATE(a,n)  ({ register unsigned int ret;   \
                                 asm (                   \
                                 "rlwinm %0,%1,%2,0,31"  \
                                 : "=r"(ret)             \
                                 : "r"(a), "I"(n));      \
@@ skipping 107 matching lines @@
         HASH_LONG l;
         size_t n;
 
         if (len==0) return 1;
 
         l=(c->Nl+(((HASH_LONG)len)<<3))&0xffffffffUL;
         /* 95-05-24 eay Fixed a bug with the overflow handling, thanks to
          * Wei Dai <weidai@eskimo.com> for pointing it out. */
         if (l < c->Nl) /* overflow */
                 c->Nh++;
-        c->Nh+=(len>>29);       /* might cause compiler warning on 16-bit */
+        c->Nh+=(HASH_LONG)(len>>29);    /* might cause compiler warning on 16-bit */
         c->Nl=l;
 
         n = c->num;
         if (n != 0)
                 {
                 p=(unsigned char *)c->data;
 
                 if (len >= HASH_CBLOCK || len+n >= HASH_CBLOCK)
                         {
                         memcpy (p+n,data,HASH_CBLOCK-n);
@@ skipping 17 matching lines @@
                 {
                 HASH_BLOCK_DATA_ORDER (c,data,n);
                 n    *= HASH_CBLOCK;
                 data += n;
                 len  -= n;
                 }
 
         if (len != 0)
                 {
                 p = (unsigned char *)c->data;
-                c->num = len;
+                c->num = (unsigned int)len;
                 memcpy (p,data,len);
                 }
         return 1;
         }
 
 
 void HASH_TRANSFORM (HASH_CTX *c, const unsigned char *data)
         {
         HASH_BLOCK_DATA_ORDER (c,data,1);
         }
@@ skipping 31 matching lines @@
 #ifndef HASH_MAKE_STRING
 #error "HASH_MAKE_STRING must be defined!"
 #else
         HASH_MAKE_STRING(c,md);
 #endif
 
         return 1;
         }
 
 #ifndef MD32_REG_T
+#if defined(__alpha) || defined(__sparcv9) || defined(__mips)
 #define MD32_REG_T long
 /*
  * This comment was originaly written for MD5, which is why it
  * discusses A-D. But it basically applies to all 32-bit digests,
  * which is why it was moved to common header file.
  *
  * In case you wonder why A-D are declared as long and not
  * as MD5_LONG. Doing so results in slight performance
  * boost on LP64 architectures. The catch is we don't
  * really care if 32 MSBs of a 64-bit register get polluted
  * with eventual overflows as we *save* only 32 LSBs in
  * *either* case. Now declaring 'em long excuses the compiler
  * from keeping 32 MSBs zeroed resulting in 13% performance
  * improvement under SPARC Solaris7/64 and 5% under AlphaLinux.
  * Well, to be honest it should say that this *prevents* 
  * performance degradation.
  *                              <appro@fy.chalmers.se>
- * Apparently there're LP64 compilers that generate better
- * code if A-D are declared int. Most notably GCC-x86_64
- * generates better code.
+ */
+#else
+/*
+ * Above is not absolute and there are LP64 compilers that
+ * generate better code if MD32_REG_T is defined int. The above
+ * pre-processor condition reflects the circumstances under which
+ * the conclusion was made and is subject to further extension.
  *                              <appro@fy.chalmers.se>
  */
+#define MD32_REG_T int
 #endif
+#endif