Clang format slam.

net/tools/dump_cache/url_to_filename_encoder.cc

 // Copyright (c) 2011 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 <stdlib.h>
 
 #include "base/logging.h"
 #include "base/strings/string_util.h"
 #include "net/base/net_util.h"
 #include "net/tools/dump_cache/url_to_filename_encoder.h"
@@ skipping 13 matching lines @@
   return 1;
 }
 
 #ifdef WIN32
 #define strtoull _strtoui64
 #endif
 
 // A simple parser for long long values. Returns the parsed value if a
 // valid integer is found; else returns deflt
 // UInt64 and Int64 cannot handle decimal numbers with leading 0s.
-uint64 ParseLeadingHex64Value(const char *str, uint64 deflt) {
-  char *error = NULL;
+uint64 ParseLeadingHex64Value(const char* str, uint64 deflt) {
+  char* error = NULL;
   const uint64 value = strtoull(str, &error, 16);
   return (error == str) ? deflt : value;
 }
-
 }
 
 namespace net {
 
 // The escape character choice is made here -- all code and tests in this
 // directory are based off of this constant.  However, our testdata
 // has tons of dependencies on this, so it cannot be changed without
 // re-running those tests and fixing them.
 const char UrlToFilenameEncoder::kEscapeChar = ',';
 const char UrlToFilenameEncoder::kTruncationChar = '-';
@@ skipping 112 matching lines @@
     encoded_filename->append(1, dir_separator);
     encoded_filename->append(segment);
   }
 }
 
 // Note: this decoder is not the exact inverse of the EncodeSegment above,
 // because it does not take into account a prefix.
 bool UrlToFilenameEncoder::Decode(const string& encoded_filename,
                                   char dir_separator,
                                   string* decoded_url) {
-  enum State {
-    kStart,
-    kEscape,
-    kFirstDigit,
-    kTruncate,
-    kEscapeDot
-  };
+  enum State { kStart, kEscape, kFirstDigit, kTruncate, kEscapeDot };
   State state = kStart;
   char hex_buffer[3];
   hex_buffer[2] = '\0';
   for (size_t i = 0; i < encoded_filename.size(); ++i) {
     char ch = encoded_filename[i];
     switch (state) {
       case kStart:
         if (ch == kEscapeChar) {
           state = kEscape;
         } else if (ch == dir_separator) {
@@ skipping 65 matching lines @@
 
   // Note:  We also chop paths into medium sized 'chunks'.
   //        This is due to the incompetence of the windows
   //        filesystem, which still hasn't figured out how
   //        to deal with long filenames.
   int last_slash = 0;
   for (size_t index = 0; index < path.length(); index++) {
     char ch = path[index];
     if (ch == 0x5C)
       last_slash = index;
-    if ((ch == 0x2D) ||                    // hyphen
-        (ch == 0x5C) || (ch == 0x5F) ||    // backslash, underscore
+    if ((ch == 0x2D) ||  // hyphen
+        (ch == 0x5C) ||
+        (ch == 0x5F) ||                    // backslash, underscore
         ((0x30 <= ch) && (ch <= 0x39)) ||  // Digits [0-9]
         ((0x41 <= ch) && (ch <= 0x5A)) ||  // Uppercase [A-Z]
         ((0x61 <= ch) && (ch <= 0x7A))) {  // Lowercase [a-z]
       output.append(&path[index], 1);
     } else {
       char encoded[3];
       encoded[0] = 'x';
       encoded[1] = ch / 16;
       encoded[1] += (encoded[1] >= 10) ? 'A' - 10 : '0';
       encoded[2] = ch % 16;
       encoded[2] += (encoded[2] >= 10) ? 'A' - 10 : '0';
       output.append(encoded, 3);
     }
     if (index - last_slash > kMaximumSubdirectoryLength) {
 #ifdef WIN32
       char slash = '\\';
 #else
       char slash = '/';
 #endif
       output.append(&slash, 1);
       last_slash = index;
     }
   }
   return output;
 }
 
 }  // namespace net