Clang format slam.

net/cert/crl_set.cc

 // Copyright (c) 2012 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/base64.h"
 #include "base/format_macros.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
@@ skipping 21 matching lines @@
   if (inflateInit(&z) != Z_OK)
     return false;
   bool ret = false;
   int r = inflate(&z, Z_FINISH);
   if (r != Z_STREAM_END)
     goto err;
   if (z.avail_in || z.avail_out)
     goto err;
   ret = true;
 
- err:
+err:
   inflateEnd(&z);
   return ret;
 }
 
-CRLSet::CRLSet()
-    : sequence_(0),
-      not_after_(0) {
+CRLSet::CRLSet() : sequence_(0), not_after_(0) {
 }
 
 CRLSet::~CRLSet() {
 }
 
 // CRLSet format:
 //
 // uint16le header_len
 // byte[header_len] header_bytes
 // repeated {
@@ skipping 66 matching lines @@
   uint16 header_len;
   memcpy(&header_len, data->data(), 2);  // assumes little-endian.
   data->remove_prefix(2);
 
   if (data->size() < header_len)
     return NULL;
 
   const base::StringPiece header_bytes(data->data(), header_len);
   data->remove_prefix(header_len);
 
-  scoped_ptr<base::Value> header(base::JSONReader::Read(
-      header_bytes, base::JSON_ALLOW_TRAILING_COMMAS));
+  scoped_ptr<base::Value> header(
+      base::JSONReader::Read(header_bytes, base::JSON_ALLOW_TRAILING_COMMAS));
   if (header.get() == NULL)
     return NULL;
 
   if (!header->IsType(base::Value::TYPE_DICTIONARY))
     return NULL;
   return reinterpret_cast<base::DictionaryValue*>(header.release());
 }
 
 // kCurrentFileVersion is the version of the CRLSet file format that we
 // currently implement.
 static const int kCurrentFileVersion = 0;
 
-static bool ReadCRL(base::StringPiece* data, std::string* out_parent_spki_hash,
+static bool ReadCRL(base::StringPiece* data,
+                    std::string* out_parent_spki_hash,
                     std::vector<std::string>* out_serials) {
   if (data->size() < crypto::kSHA256Length)
     return false;
   *out_parent_spki_hash = std::string(data->data(), crypto::kSHA256Length);
   data->remove_prefix(crypto::kSHA256Length);
 
   if (data->size() < sizeof(uint32))
     return false;
   uint32 num_serials;
   memcpy(&num_serials, data->data(), sizeof(uint32));  // assumes little endian
@@ skipping 32 matching lines @@
     if (!base::Base64Decode(spki_sha256_base64, &spki_sha256))
       return false;
     blocked_spkis_.push_back(spki_sha256);
   }
 
   return true;
 }
 
 // static
 bool CRLSet::Parse(base::StringPiece data, scoped_refptr<CRLSet>* out_crl_set) {
-  // Other parts of Chrome assume that we're little endian, so we don't lose
-  // anything by doing this.
+// Other parts of Chrome assume that we're little endian, so we don't lose
+// anything by doing this.
 #if defined(__BYTE_ORDER)
   // Linux check
   COMPILE_ASSERT(__BYTE_ORDER == __LITTLE_ENDIAN, assumes_little_endian);
 #elif defined(__BIG_ENDIAN__)
-  // Mac check
-  #error assumes little endian
+// Mac check
+#error assumes little endian
 #endif
 
   scoped_ptr<base::DictionaryValue> header_dict(ReadHeader(&data));
   if (!header_dict.get())
     return false;
 
   std::string contents;
   if (!header_dict->GetString("ContentType", &contents))
     return false;
   if (contents != "CRLSet")
@@ skipping 79 matching lines @@
 
 bool ReadDeltaCRL(base::StringPiece* data,
                   const std::vector<std::string>& old_serials,
                   std::vector<std::string>* out_serials) {
   std::vector<uint8> changes;
   if (!ReadChanges(data, &changes))
     return false;
 
   size_t i = 0;
   for (std::vector<uint8>::const_iterator k = changes.begin();
-       k != changes.end(); ++k) {
+       k != changes.end();
+       ++k) {
     if (*k == SYMBOL_SAME) {
       if (i >= old_serials.size())
         return false;
       out_serials->push_back(old_serials[i]);
       i++;
     } else if (*k == SYMBOL_INSERT) {
       uint8 serial_length;
       if (data->size() < sizeof(uint8))
         return false;
       memcpy(&serial_length, data->data(), sizeof(uint8));
@@ skipping 34 matching lines @@
     return false;
 
   int version;
   if (!header_dict->GetInteger("Version", &version) ||
       version != kCurrentFileVersion) {
     return false;
   }
 
   int sequence, delta_from;
   if (!header_dict->GetInteger("Sequence", &sequence) ||
-      !header_dict->GetInteger("DeltaFrom", &delta_from) ||
-      delta_from < 0 ||
+      !header_dict->GetInteger("DeltaFrom", &delta_from) || delta_from < 0 ||
       static_cast<uint32>(delta_from) != sequence_) {
     return false;
   }
 
   double not_after;
   if (!header_dict->GetDouble("NotAfter", &not_after)) {
     // NotAfter is optional for now.
     not_after = 0;
   }
   if (not_after < 0)
     return false;
 
   scoped_refptr<CRLSet> crl_set(new CRLSet);
   crl_set->sequence_ = static_cast<uint32>(sequence);
   crl_set->not_after_ = static_cast<uint64>(not_after);
 
   if (!crl_set->CopyBlockedSPKIsFromHeader(header_dict.get()))
     return false;
 
   std::vector<uint8> crl_changes;
 
   if (!ReadChanges(&data, &crl_changes))
     return false;
 
   size_t i = 0, j = 0;
   for (std::vector<uint8>::const_iterator k = crl_changes.begin();
-       k != crl_changes.end(); ++k) {
+       k != crl_changes.end();
+       ++k) {
     if (*k == SYMBOL_SAME) {
       if (i >= crls_.size())
         return false;
       crl_set->crls_.push_back(crls_[i]);
       crl_set->crls_index_by_issuer_[crls_[i].first] = j;
       i++;
       j++;
     } else if (*k == SYMBOL_INSERT) {
       std::string parent_spki_hash;
       std::vector<std::string> serials;
@@ skipping 60 matching lines @@
       "\"Version\":0,"
       "\"ContentType\":\"CRLSet\","
       "\"Sequence\":%u,"
       "\"DeltaFrom\":0,"
       "\"NumParents\":%u,"
       "\"BlockedSPKIs\":[",
       static_cast<unsigned>(sequence_),
       static_cast<unsigned>(crls_.size()));
 
   for (std::vector<std::string>::const_iterator i = blocked_spkis_.begin();
-       i != blocked_spkis_.end(); ++i) {
+       i != blocked_spkis_.end();
+       ++i) {
     std::string spki_hash_base64;
     base::Base64Encode(*i, &spki_hash_base64);
 
     if (i != blocked_spkis_.begin())
       header += ",";
     header += "\"" + spki_hash_base64 + "\"";
   }
   header += "]";
   if (not_after_ != 0)
     header += base::StringPrintf(",\"NotAfter\":%" PRIu64, not_after_);
   header += "}";
 
   size_t len = 2 /* header len */ + header.size();
 
   for (CRLList::const_iterator i = crls_.begin(); i != crls_.end(); ++i) {
     len += i->first.size() + 4 /* num serials */;
     for (std::vector<std::string>::const_iterator j = i->second.begin();
-         j != i->second.end(); ++j) {
+         j != i->second.end();
+         ++j) {
       len += 1 /* serial length */ + j->size();
     }
   }
 
   std::string ret;
   char* out = WriteInto(&ret, len + 1 /* to include final NUL */);
   size_t off = 0;
   out[off++] = header.size();
   out[off++] = header.size() >> 8;
   memcpy(out + off, header.data(), header.size());
   off += header.size();
 
   for (CRLList::const_iterator i = crls_.begin(); i != crls_.end(); ++i) {
     memcpy(out + off, i->first.data(), i->first.size());
     off += i->first.size();
     const uint32 num_serials = i->second.size();
     memcpy(out + off, &num_serials, sizeof(num_serials));
     off += sizeof(num_serials);
 
     for (std::vector<std::string>::const_iterator j = i->second.begin();
-         j != i->second.end(); ++j) {
+         j != i->second.end();
+         ++j) {
       out[off++] = j->size();
       memcpy(out + off, j->data(), j->size());
       off += j->size();
     }
   }
 
   CHECK_EQ(off, len);
   return ret;
 }
 
 CRLSet::Result CRLSet::CheckSPKI(const base::StringPiece& spki_hash) const {
   for (std::vector<std::string>::const_iterator i = blocked_spkis_.begin();
-       i != blocked_spkis_.end(); ++i) {
+       i != blocked_spkis_.end();
+       ++i) {
     if (spki_hash.size() == i->size() &&
         memcmp(spki_hash.data(), i->data(), i->size()) == 0) {
       return REVOKED;
     }
   }
 
   return GOOD;
 }
 
 CRLSet::Result CRLSet::CheckSerial(
@@ skipping 11 matching lines @@
   while (serial.size() > 1 && serial[0] == 0x00)
     serial.remove_prefix(1);
 
   std::map<std::string, size_t>::const_iterator i =
       crls_index_by_issuer_.find(issuer_spki_hash.as_string());
   if (i == crls_index_by_issuer_.end())
     return UNKNOWN;
   const std::vector<std::string>& serials = crls_[i->second].second;
 
   for (std::vector<std::string>::const_iterator i = serials.begin();
-       i != serials.end(); ++i) {
+       i != serials.end();
+       ++i) {
     if (base::StringPiece(*i) == serial)
       return REVOKED;
   }
 
   return GOOD;
 }
 
 bool CRLSet::IsExpired() const {
   if (not_after_ == 0)
     return false;
@@ skipping 33 matching lines @@
     crl_set->crls_index_by_issuer_[spki] = 0;
   }
 
   if (!serial_number.empty())
     crl_set->crls_[0].second.push_back(serial_number);
 
   return crl_set;
 }
 
 }  // namespace net