git cl format the first third of the net/base directory

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 67 matching lines @@
 // Lastly, we can't unescape anything that doesn't have a canonical
 // 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.
+// clang-format off
 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
 };
+// clang-format on
 
 // 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;
 }
 
 // Returns true if there is an Arabic Language Mark at |index|. |first_byte|
 // is the byte at |index|.
-template<typename STR>
+template <typename STR>
 bool HasArabicLanguageMarkAtIndex(const STR& escaped_text,
                                   unsigned char first_byte,
                                   size_t index) {
   if (first_byte != 0xD8)
     return false;
   unsigned char second_byte;
   if (!UnescapeUnsignedCharAtIndex(escaped_text, index + 3, &second_byte))
     return false;
   return second_byte == 0x9c;
 }
 
 // Returns true if there is a BiDi control char at |index|. |first_byte| is the
 // byte at |index|.
-template<typename STR>
+template <typename STR>
 bool HasThreeByteBidiControlCharAtIndex(const STR& escaped_text,
                                         unsigned char first_byte,
                                         size_t index) {
   if (first_byte != 0xE2)
     return false;
   unsigned char second_byte;
   if (!UnescapeUnsignedCharAtIndex(escaped_text, index + 3, &second_byte))
     return false;
   if (second_byte != 0x80 && second_byte != 0x81)
     return false;
   unsigned char third_byte;
   if (!UnescapeUnsignedCharAtIndex(escaped_text, index + 6, &third_byte))
     return false;
   if (second_byte == 0x80) {
-    return third_byte == 0x8E ||
-           third_byte == 0x8F ||
+    return third_byte == 0x8E || third_byte == 0x8F ||
            (third_byte >= 0xAA && third_byte <= 0xAE);
   }
   return third_byte >= 0xA6 && third_byte <= 0xA9;
 }
 
 // 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 85 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(kCharsToEscape); ++k) {
     if (c == kCharsToEscape[k].key) {
       const char* p = kCharsToEscape[k].replacement;
       while (*p)
         output->push_back(*p++);
       break;
     }
   }
   if (k == arraysize(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, 0x50000025L, 0x50000000L, 0xb8000001L,
-  0xffffffffL, 0xffffffffL, 0xffffffffL, 0xffffffffL
-}};
+static const Charmap kExternalHandlerCharmap = {{0xffffffffL,
+                                                 0x50000025L,
+                                                 0x50000000L,
+                                                 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(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(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