Clang format slam.

net/base/escape.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 "net/base/escape.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
@@ skipping 22 matching lines @@
     return ((map[c >> 5] & (1 << (c & 31))) != 0);
   }
 
   uint32 map[8];
 };
 
 // Given text to escape and a Charmap defining which values to escape,
 // return an escaped string.  If use_plus is true, spaces are converted
 // to +, otherwise, if spaces are in the charmap, they are converted to
 // %20.
-std::string Escape(const std::string& text, const Charmap& charmap,
+std::string Escape(const std::string& text,
+                   const Charmap& charmap,
                    bool use_plus) {
   std::string escaped;
   escaped.reserve(text.length() * 3);
   for (unsigned int i = 0; i < text.length(); ++i) {
     unsigned char c = static_cast<unsigned char>(text[i]);
     if (use_plus && ' ' == c) {
       escaped.push_back('+');
     } else if (charmap.Contains(c)) {
       escaped.push_back('%');
       escaped.push_back(IntToHex(c >> 4));
@@ skipping 19 matching lines @@
 // representation in a URL. This means that unescaping will change the URL, and
 // you could get different behavior if you copy and paste the URL, or press
 // enter in the URL bar. The list of characters that fall into this category
 // are the ones labeled PASS (allow either escaped or unescaped) in the big
 // lookup table at the top of url/url_canon_path.cc.  Also, characters
 // that have CHAR_QUERY set in url/url_canon_internal.cc but are not
 // allowed in query strings according to http://www.ietf.org/rfc/rfc3261.txt are
 // not unescaped, to avoid turning a valid url according to spec into an
 // invalid one.
 const char kUrlUnescape[128] = {
-//   NULL, control chars...
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-     0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-//  ' ' !  "  #  $  %  &  '  (  )  *  +  ,  -  .  /
-     0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
-//   0  1  2  3  4  5  6  7  8  9  :  ;  <  =  >  ?
-     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0,
-//   @  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O
-     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-//   P  Q  R  S  T  U  V  W  X  Y  Z  [  \  ]  ^  _
-     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
-//   `  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o
-     0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-//   p  q  r  s  t  u  v  w  x  y  z  {  |  }  ~  <NBSP>
-     1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0
-};
+    //   NULL, control chars...
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+    //  ' ' !  "  #  $  %  &  '  (  )  *  +  ,  -  .  /
+    0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0,
+    //   0  1  2  3  4  5  6  7  8  9  :  ;  <  =  >  ?
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 1, 0,
+    //   @  A  B  C  D  E  F  G  H  I  J  K  L  M  N  O
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    //   P  Q  R  S  T  U  V  W  X  Y  Z  [  \  ]  ^  _
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1,
+    //   `  a  b  c  d  e  f  g  h  i  j  k  l  m  n  o
+    0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
+    //   p  q  r  s  t  u  v  w  x  y  z  {  |  }  ~  <NBSP>
+    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 1, 0};
 
 // Attempts to unescape the sequence at |index| within |escaped_text|.  If
 // successful, sets |value| to the unescaped value.  Returns whether
 // unescaping succeeded.
-template<typename STR>
+template <typename STR>
 bool UnescapeUnsignedCharAtIndex(const STR& escaped_text,
                                  size_t index,
                                  unsigned char* value) {
   if ((index + 2) >= escaped_text.size())
     return false;
   if (escaped_text[index] != '%')
     return false;
   const typename STR::value_type most_sig_digit(
       static_cast<typename STR::value_type>(escaped_text[index + 1]));
   const typename STR::value_type least_sig_digit(
       static_cast<typename STR::value_type>(escaped_text[index + 2]));
   if (IsHexDigit(most_sig_digit) && IsHexDigit(least_sig_digit)) {
-    *value = HexDigitToInt(most_sig_digit) * 16 +
-      HexDigitToInt(least_sig_digit);
+    *value =
+        HexDigitToInt(most_sig_digit) * 16 + HexDigitToInt(least_sig_digit);
     return true;
   }
   return false;
 }
 
 // Unescapes |escaped_text| according to |rules|, returning the resulting
 // string.  Fills in an |adjustments| parameter, if non-NULL, so it reflects
 // the alterations done to the string that are not one-character-to-one-
 // character.  The resulting |adjustments| will always be sorted by increasing
 // offset.
-template<typename STR>
+template <typename STR>
 STR UnescapeURLWithAdjustmentsImpl(
     const STR& escaped_text,
     UnescapeRule::Type rules,
     base::OffsetAdjuster::Adjustments* adjustments) {
   if (adjustments)
     adjustments->clear();
   // Do not unescape anything, return the |escaped_text| text.
   if (rules == UnescapeRule::NONE)
     return escaped_text;
 
@@ skipping 43 matching lines @@
         i += 5;
         continue;
       }
 
       // Check for other BiDi control characters.
       if ((first_byte == 0xE2) &&
           UnescapeUnsignedCharAtIndex(escaped_text, i + 3, &second_byte) &&
           ((second_byte == 0x80) || (second_byte == 0x81))) {
         unsigned char third_byte;
         if (UnescapeUnsignedCharAtIndex(escaped_text, i + 6, &third_byte) &&
-            ((second_byte == 0x80) ?
-             ((third_byte == 0x8E) || (third_byte == 0x8F) ||
-              ((third_byte >= 0xAA) && (third_byte <= 0xAE))) :
-             ((third_byte >= 0xA6) && (third_byte <= 0xA9)))) {
+            ((second_byte == 0x80)
+                 ? ((third_byte == 0x8E) || (third_byte == 0x8F) ||
+                    ((third_byte >= 0xAA) && (third_byte <= 0xAE)))
+                 : ((third_byte >= 0xA6) && (third_byte <= 0xA9)))) {
           result.append(escaped_text, i, 9);
           i += 8;
           continue;
         }
       }
 
       if (first_byte >= 0x80 ||  // Unescape all high-bit characters.
           // For 7-bit characters, the lookup table tells us all valid chars.
           (kUrlUnescape[first_byte] ||
            // ...and we allow some additional unescaping when flags are set.
@@ skipping 24 matching lines @@
 
   return result;
 }
 
 template <class str>
 void AppendEscapedCharForHTMLImpl(typename str::value_type c, str* output) {
   static const struct {
     char key;
     const char* replacement;
   } kCharsToEscape[] = {
-    { '<', "&lt;" },
-    { '>', "&gt;" },
-    { '&', "&amp;" },
-    { '"', "&quot;" },
-    { '\'', "&#39;" },
-  };
+        {'<', "&lt;"},
+        {'>', "&gt;"},
+        {'&', "&amp;"},
+        {'"', "&quot;"},
+        {'\'', "&#39;"},
+    };
   size_t k;
   for (k = 0; k < ARRAYSIZE_UNSAFE(kCharsToEscape); ++k) {
     if (c == kCharsToEscape[k].key) {
       const char* p = kCharsToEscape[k].replacement;
       while (*p)
         output->push_back(*p++);
       break;
     }
   }
   if (k == ARRAYSIZE_UNSAFE(kCharsToEscape))
     output->push_back(c);
 }
 
 template <class str>
 str EscapeForHTMLImpl(const str& input) {
   str result;
   result.reserve(input.size());  // Optimize for no escaping.
 
   for (typename str::const_iterator i = input.begin(); i != input.end(); ++i)
     AppendEscapedCharForHTMLImpl(*i, &result);
 
   return result;
 }
 
 // Everything except alphanumerics and !'()*-._~
 // See RFC 2396 for the list of reserved characters.
-static const Charmap kQueryCharmap = {{
-  0xffffffffL, 0xfc00987dL, 0x78000001L, 0xb8000001L,
-  0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL
-}};
+static const Charmap kQueryCharmap = {{0xffffffffL, 0xfc00987dL, 0x78000001L,
+                                       0xb8000001L, 0xffffffffL, 0xffffffffL,
+                                       0xffffffffL, 0xffffffffL}};
 
 // non-printable, non-7bit, and (including space)  "#%:<>?[\]^`{|}
-static const Charmap kPathCharmap = {{
-  0xffffffffL, 0xd400002dL, 0x78000000L, 0xb8000001L,
-  0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL
-}};
+static const Charmap kPathCharmap = {{0xffffffffL, 0xd400002dL, 0x78000000L,
+                                      0xb8000001L, 0xffffffffL, 0xffffffffL,
+                                      0xffffffffL, 0xffffffffL}};
 
 // non-printable, non-7bit, and (including space) ?>=<;+'&%$#"![\]^`{|}
-static const Charmap kUrlEscape = {{
-  0xffffffffL, 0xf80008fdL, 0x78000001L, 0xb8000001L,
-  0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL
-}};
+static const Charmap kUrlEscape = {{0xffffffffL, 0xf80008fdL, 0x78000001L,
+                                    0xb8000001L, 0xffffffffL, 0xffffffffL,
+                                    0xffffffffL, 0xffffffffL}};
 
 // non-7bit
-static const Charmap kNonASCIICharmap = {{
-  0x00000000L, 0x00000000L, 0x00000000L, 0x00000000L,
-  0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL
-}};
+static const Charmap kNonASCIICharmap = {{0x00000000L, 0x00000000L, 0x00000000L,
+                                          0x00000000L, 0xffffffffL, 0xffffffffL,
+                                          0xffffffffL, 0xffffffffL}};
 
 // Everything except alphanumerics, the reserved characters(;/?:@&=+$,) and
 // !'()*-._~%
-static const Charmap kExternalHandlerCharmap = {{
-  0xffffffffL, 0x5000080dL, 0x68000000L, 0xb8000001L,
-  0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL
-}};
+static const Charmap kExternalHandlerCharmap = {
+    {0xffffffffL, 0x5000080dL, 0x68000000L, 0xb8000001L, 0xffffffffL,
+     0xffffffffL, 0xffffffffL, 0xffffffffL}};
 
 }  // namespace
 
 std::string EscapeQueryParamValue(const std::string& text, bool use_plus) {
   return Escape(text, kQueryCharmap, use_plus);
 }
 
 std::string EscapePath(const std::string& path) {
   return Escape(path, kPathCharmap, false);
 }
@@ skipping 36 matching lines @@
                                                  UnescapeRule::Type rules) {
   return UnescapeAndDecodeUTF8URLComponentWithAdjustments(text, rules, NULL);
 }
 
 base::string16 UnescapeAndDecodeUTF8URLComponentWithAdjustments(
     const std::string& text,
     UnescapeRule::Type rules,
     base::OffsetAdjuster::Adjustments* adjustments) {
   base::string16 result;
   base::OffsetAdjuster::Adjustments unescape_adjustments;
-  std::string unescaped_url(UnescapeURLWithAdjustmentsImpl(
-      text, rules, &unescape_adjustments));
-  if (base::UTF8ToUTF16WithAdjustments(unescaped_url.data(),
-                                       unescaped_url.length(),
-                                       &result, adjustments)) {
+  std::string unescaped_url(
+      UnescapeURLWithAdjustmentsImpl(text, rules, &unescape_adjustments));
+  if (base::UTF8ToUTF16WithAdjustments(
+          unescaped_url.data(), unescaped_url.length(), &result, adjustments)) {
     // Character set looks like it's valid.
     if (adjustments) {
       base::OffsetAdjuster::MergeSequentialAdjustments(unescape_adjustments,
                                                        adjustments);
     }
     return result;
   }
   // Character set is not valid.  Return the escaped version.
   return base::UTF8ToUTF16WithAdjustments(text, adjustments);
 }
 
 base::string16 UnescapeForHTML(const base::string16& input) {
   static const struct {
     const char* ampersand_code;
     const char replacement;
   } kEscapeToChars[] = {
-    { "&lt;", '<' },
-    { "&gt;", '>' },
-    { "&amp;", '&' },
-    { "&quot;", '"' },
-    { "&#39;", '\''},
-  };
+        {"&lt;", '<'},
+        {"&gt;", '>'},
+        {"&amp;", '&'},
+        {"&quot;", '"'},
+        {"&#39;", '\''},
+    };
 
   if (input.find(base::ASCIIToUTF16("&")) == std::string::npos)
     return input;
 
   base::string16 ampersand_chars[ARRAYSIZE_UNSAFE(kEscapeToChars)];
   base::string16 text(input);
-  for (base::string16::iterator iter = text.begin();
-       iter != text.end(); ++iter) {
+  for (base::string16::iterator iter = text.begin(); iter != text.end();
+       ++iter) {
     if (*iter == '&') {
       // Potential ampersand encode char.
       size_t index = iter - text.begin();
       for (size_t i = 0; i < ARRAYSIZE_UNSAFE(kEscapeToChars); i++) {
         if (ampersand_chars[i].empty()) {
           ampersand_chars[i] =
               base::ASCIIToUTF16(kEscapeToChars[i].ampersand_code);
         }
         if (text.find(ampersand_chars[i], index) == index) {
-          text.replace(iter, iter + ampersand_chars[i].length(),
-                       1, kEscapeToChars[i].replacement);
+          text.replace(iter,
+                       iter + ampersand_chars[i].length(),
+                       1,
+                       kEscapeToChars[i].replacement);
           break;
         }
       }
     }
   }
   return text;
 }
 
 }  // namespace net