Style cleanup in preparation for auto-linting base/.

base/crypto/rsa_private_key.cc

 // Copyright (c) 2009 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 "base/crypto/rsa_private_key.h"
 
 #include <iostream>
 #include <list>
 
 #include "base/logging.h"
@@ skipping 35 matching lines @@
 
 const uint8 PrivateKeyInfoCodec::kRsaAlgorithmIdentifier[] = {
   0x30, 0x0D, 0x06, 0x09, 0x2A, 0x86, 0x48, 0x86, 0xF7, 0x0D, 0x01, 0x01, 0x01,
   0x05, 0x00
 };
 
 void PrivateKeyInfoCodec::PrependBytes(uint8* val,
                                        int start,
                                        int num_bytes,
                                        std::list<uint8>* data) {
-  while(num_bytes > 0) {
+  while (num_bytes > 0) {
     --num_bytes;
     data->push_front(val[start + num_bytes]);
   }
 }
 
 void PrivateKeyInfoCodec::PrependLength(size_t size, std::list<uint8>* data) {
   // The high bit is used to indicate whether additional octets are needed to
   // represent the length.
   if (size < 0x80) {
     data->push_front(static_cast<uint8>(size));
@@ skipping 214 matching lines @@
                                              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());
    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--;
   }
   PrependBytes(val, start, num_bytes, data);
 
   // ASN.1 integers are signed. To encode a positive integer whose sign bit
@@ skipping 51 matching lines @@
   int pad = expected_size - temp.size();
   int index = 0;
   if (out->size() == expected_size + 1) {
     READ_ASSERT(out->front() == 0x00);
     pad++;
     index++;
   } else {
     READ_ASSERT(out->size() <= expected_size);
   }
 
-  while(pad) {
+  while (pad) {
     out->push_back(0x00);
     pad--;
   }
   out->insert(out->end(), temp.begin(), temp.end());
 
   // Reverse output if little-endian.
   if (!big_endian_)
     reverse(out->begin(), out->end());
   return true;
 }
 
 }  // namespace base