Upstream: Build net_unittests for Android.

crypto/rsa_private_key.cc

 // Copyright (c) 2011 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.
 
 #include "crypto/rsa_private_key.h"
 
 #include <algorithm>
 #include <list>
 
 #include "base/logging.h"
@@ skipping 167 matching lines @@
 }
 
 void PrivateKeyInfoCodec::PrependIntegerImpl(uint8* val,
                                              int num_bytes,
                                              std::list<uint8>* data,
                                              bool big_endian) {
  // Reverse input if little-endian.
  std::vector<uint8> tmp;
  if (!big_endian) {
    tmp.assign(val, val + num_bytes);
-   reverse(tmp.begin(), tmp.end());
+   std::reverse(tmp.begin(), tmp.end());
    val = &tmp.front();
  }
 
   // ASN.1 integers are unpadded byte arrays, so skip any null padding bytes
   // from the most-significant end of the integer.
   int start = 0;
   while (start < (num_bytes - 1) && val[start] == 0x00) {
     start++;
     num_bytes--;
   }
@@ skipping 34 matching lines @@
     index++;
   } else {
     READ_ASSERT(out->size() <= expected_size);
   }
 
   out->insert(out->end(), pad, 0x00);
   out->insert(out->end(), temp.begin(), temp.end());
 
   // Reverse output if little-endian.
   if (!big_endian_)
-    reverse(out->begin(), out->end());
+    std::reverse(out->begin(), out->end());
   return true;
 }
 
 bool PrivateKeyInfoCodec::ReadIntegerImpl(uint8** pos,
                                           uint8* end,
                                           std::vector<uint8>* out,
                                           bool big_endian) {
   uint32 length = 0;
   if (!ReadTypeHeaderAndLength(pos, end, kIntegerTag, &length) || !length)
     return false;
 
   // The first byte can be zero to force positiveness. We can ignore this.
   if (**pos == 0x00) {
     ++(*pos);
     --length;
   }
 
   if (length)
     out->insert(out->end(), *pos, (*pos) + length);
 
   (*pos) += length;
 
   // Reverse output if little-endian.
   if (!big_endian)
-    reverse(out->begin(), out->end());
+    std::reverse(out->begin(), out->end());
   return true;
 }
 
 void PrivateKeyInfoCodec::PrependBytes(uint8* val,
                                        int start,
                                        int num_bytes,
                                        std::list<uint8>* data) {
   while (num_bytes > 0) {
     --num_bytes;
     data->push_front(val[start + num_bytes]);
@@ skipping 96 matching lines @@
   // The version should be zero.
   for (uint32 i = 0; i < length; ++i) {
     READ_ASSERT(**pos == 0x00);
     (*pos)++;
   }
 
   return true;
 }
 
 }  // namespace crypto