Clang format slam.

net/cookies/parsed_cookie.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.
 
 // Portions of this code based on Mozilla:
 //   (netwerk/cookie/src/nsCookieService.cpp)
 /* ***** BEGIN LICENSE BLOCK *****
  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
  *
  * The contents of this file are subject to the Mozilla Public License Version
@@ skipping 55 matching lines @@
 // Returns true if |c| occurs in |chars|
 // TODO(erikwright): maybe make this take an iterator, could check for end also?
 inline bool CharIsA(const char c, const char* chars) {
   return strchr(chars, c) != NULL;
 }
 // Seek the iterator to the first occurrence of a character in |chars|.
 // Returns true if it hit the end, false otherwise.
 inline bool SeekTo(std::string::const_iterator* it,
                    const std::string::const_iterator& end,
                    const char* chars) {
-  for (; *it != end && !CharIsA(**it, chars); ++(*it)) {}
+  for (; *it != end && !CharIsA(**it, chars); ++(*it)) {
+  }
   return *it == end;
 }
 // Seek the iterator to the first occurrence of a character not in |chars|.
 // Returns true if it hit the end, false otherwise.
 inline bool SeekPast(std::string::const_iterator* it,
                      const std::string::const_iterator& end,
                      const char* chars) {
-  for (; *it != end && CharIsA(**it, chars); ++(*it)) {}
+  for (; *it != end && CharIsA(**it, chars); ++(*it)) {
+  }
   return *it == end;
 }
 inline bool SeekBackPast(std::string::const_iterator* it,
                          const std::string::const_iterator& end,
                          const char* chars) {
-  for (; *it != end && CharIsA(**it, chars); --(*it)) {}
+  for (; *it != end && CharIsA(**it, chars); --(*it)) {
+  }
   return *it == end;
 }
 
 // Validate whether |value| is a valid token according to [RFC2616],
 // Section 2.2.
 bool IsValidToken(const std::string& value) {
   if (value.empty())
     return false;
 
   // Check that |value| has no separators.
@@ skipping 12 matching lines @@
 
 // Validate value, which may be according to RFC 6265
 // cookie-value      = *cookie-octet / ( DQUOTE *cookie-octet DQUOTE )
 // cookie-octet      = %x21 / %x23-2B / %x2D-3A / %x3C-5B / %x5D-7E
 //                      ; US-ASCII characters excluding CTLs,
 //                      ; whitespace DQUOTE, comma, semicolon,
 //                      ; and backslash
 bool IsValidCookieValue(const std::string& value) {
   // Number of characters to skip in validation at beginning and end of string.
   size_t skip = 0;
-  if (value.size() >= 2 && *value.begin() == '"' && *(value.end()-1) == '"')
+  if (value.size() >= 2 && *value.begin() == '"' && *(value.end() - 1) == '"')
     skip = 1;
   for (std::string::const_iterator i = value.begin() + skip;
-       i != value.end() - skip; ++i) {
+       i != value.end() - skip;
+       ++i) {
     bool valid_octet =
-        (*i == 0x21 ||
-         (*i >= 0x23 && *i <= 0x2B) ||
-         (*i >= 0x2D && *i <= 0x3A) ||
-         (*i >= 0x3C && *i <= 0x5B) ||
+        (*i == 0x21 || (*i >= 0x23 && *i <= 0x2B) ||
+         (*i >= 0x2D && *i <= 0x3A) || (*i >= 0x3C && *i <= 0x5B) ||
          (*i >= 0x5D && *i <= 0x7E));
     if (!valid_octet)
       return false;
   }
   return true;
 }
 
 bool IsControlCharacter(unsigned char c) {
-    return (c >= 0) && (c <= 31);
+  return (c >= 0) && (c <= 31);
 }
 
 bool IsValidCookieAttributeValue(const std::string& value) {
   // The greatest common denominator of cookie attribute values is
   // <any CHAR except CTLs or ";"> according to RFC 6265.
   for (std::string::const_iterator i = value.begin(); i != value.end(); ++i) {
     if (IsControlCharacter(*i) || *i == ';')
       return false;
   }
   return true;
 }
 
 }  // namespace
 
 namespace net {
 
 ParsedCookie::ParsedCookie(const std::string& cookie_line)
     : path_index_(0),
       domain_index_(0),
       expires_index_(0),
       maxage_index_(0),
       secure_index_(0),
       httponly_index_(0),
       priority_index_(0) {
-
   if (cookie_line.size() > kMaxCookieSize) {
     VLOG(1) << "Not parsing cookie, too large: " << cookie_line.size();
     return;
   }
 
   ParseTokenValuePairs(cookie_line);
   if (!pairs_.empty())
     SetupAttributes();
 }
 
 ParsedCookie::~ParsedCookie() {
 }
 
 bool ParsedCookie::IsValid() const {
   return !pairs_.empty();
 }
 
 CookiePriority ParsedCookie::Priority() const {
-  return (priority_index_ == 0) ? COOKIE_PRIORITY_DEFAULT :
-      StringToCookiePriority(pairs_[priority_index_].second);
+  return (priority_index_ == 0)
+             ? COOKIE_PRIORITY_DEFAULT
+             : StringToCookiePriority(pairs_[priority_index_].second);
 }
 
 bool ParsedCookie::SetName(const std::string& name) {
   if (!IsValidToken(name))
     return false;
   if (pairs_.empty())
     pairs_.push_back(std::make_pair("", ""));
   pairs_[0].first = name;
   return true;
 }
@@ skipping 30 matching lines @@
 bool ParsedCookie::SetIsHttpOnly(bool is_http_only) {
   return SetBool(&httponly_index_, kHttpOnlyTokenName, is_http_only);
 }
 
 bool ParsedCookie::SetPriority(const std::string& priority) {
   return SetString(&priority_index_, kPriorityTokenName, priority);
 }
 
 std::string ParsedCookie::ToCookieLine() const {
   std::string out;
-  for (PairList::const_iterator it = pairs_.begin();
-       it != pairs_.end(); ++it) {
+  for (PairList::const_iterator it = pairs_.begin(); it != pairs_.end(); ++it) {
     if (!out.empty())
       out.append("; ");
     out.append(it->first);
     if (it->first != kSecureTokenName && it->first != kHttpOnlyTokenName) {
       out.append("=");
       out.append(it->second);
     }
   }
   return out;
 }
 
 std::string::const_iterator ParsedCookie::FindFirstTerminator(
     const std::string& s) {
   std::string::const_iterator end = s.end();
-  size_t term_pos =
-      s.find_first_of(std::string(kTerminator, kTerminatorLen));
+  size_t term_pos = s.find_first_of(std::string(kTerminator, kTerminatorLen));
   if (term_pos != std::string::npos) {
     // We found a character we should treat as an end of string.
     end = s.begin() + term_pos;
   }
   return end;
 }
 
 bool ParsedCookie::ParseToken(std::string::const_iterator* it,
                               const std::string::const_iterator& end,
                               std::string::const_iterator* token_start,
@@ skipping 10 matching lines @@
   // Seek over the token, to the token separator.
   // token_real_end should point at the token separator, i.e. '='.
   // If it == end after the seek, we probably have a token-value.
   SeekTo(it, end, kTokenSeparator);
   token_real_end = *it;
 
   // Ignore any whitespace between the token and the token separator.
   // token_end should point after the last interesting token character,
   // pointing at either whitespace, or at '=' (and equal to token_real_end).
   if (*it != *token_start) {  // We could have an empty token name.
-    --(*it);  // Go back before the token separator.
+    --(*it);                  // Go back before the token separator.
     // Skip over any whitespace to the first non-whitespace character.
     SeekBackPast(it, *token_start, kWhitespace);
     // Point after it.
     ++(*it);
   }
   *token_end = *it;
 
   // Seek us back to the end of the token.
   *it = token_real_end;
   return true;
@@ skipping 141 matching lines @@
                              const std::string& key,
                              const std::string& value) {
   if (value.empty()) {
     ClearAttributePair(*index);
     return true;
   } else {
     return SetAttributePair(index, key, value);
   }
 }
 
-bool ParsedCookie::SetBool(size_t* index,
-                           const std::string& key,
-                           bool value) {
+bool ParsedCookie::SetBool(size_t* index, const std::string& key, bool value) {
   if (!value) {
     ClearAttributePair(*index);
     return true;
   } else {
     return SetAttributePair(index, key, std::string());
   }
 }
 
 bool ParsedCookie::SetAttributePair(size_t* index,
                                     const std::string& key,
@@ skipping 11 matching lines @@
   return true;
 }
 
 void ParsedCookie::ClearAttributePair(size_t index) {
   // The first pair (name/value of cookie at pairs_[0]) cannot be cleared.
   // Cookie attributes that don't have a value at the moment, are represented
   // with an index being equal to 0.
   if (index == 0)
     return;
 
-  size_t* indexes[] = { &path_index_, &domain_index_, &expires_index_,
-                        &maxage_index_, &secure_index_, &httponly_index_,
-                        &priority_index_ };
+  size_t* indexes[] = {&path_index_,    &domain_index_, &expires_index_,
+                       &maxage_index_,  &secure_index_, &httponly_index_,
+                       &priority_index_};
   for (size_t i = 0; i < arraysize(indexes); ++i) {
     if (*indexes[i] == index)
       *indexes[i] = 0;
     else if (*indexes[i] > index)
       --*indexes[i];
   }
   pairs_.erase(pairs_.begin() + index);
 }
 
 }  // namespace