Clang format slam.

net/tools/dump_cache/url_to_filename_encoder.h

 // Copyright (c) 2010 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.
 
 // URL filename encoder goals:
 //
 // 1. Allow URLs with arbitrary path-segment length, generating filenames
 //    with a maximum of 128 characters.
 // 2. Provide a somewhat human readable filenames, for easy debugging flow.
 // 3. Provide reverse-mapping from filenames back to URLs.
@@ skipping 76 matching lines @@
 namespace net {
 
 // Helper class for converting a URL into a filename.
 class UrlToFilenameEncoder {
  public:
   // Given a |url| and a |base_path|, returns a filename which represents this
   // |url|. |url| may include URL escaping such as %21 for !
   // |legacy_escape| indicates that this function should use the old-style
   // of encoding.
   // TODO(mbelshe): delete the legacy_escape code.
-  static std::string Encode(const std::string& url, std::string base_path,
+  static std::string Encode(const std::string& url,
+                            std::string base_path,
                             bool legacy_escape) {
     std::string filename;
     if (!legacy_escape) {
       std::string url_no_scheme = UrlUtilities::GetUrlHostPath(url);
       EncodeSegment(base_path, url_no_scheme, '/', &filename);
 #ifdef WIN32
       ReplaceAll(&filename, "/", "\\");
 #endif
     } else {
       std::string clean_url(url);
-      if (clean_url.length() && clean_url[clean_url.length()-1] == '/')
+      if (clean_url.length() && clean_url[clean_url.length() - 1] == '/')
         clean_url.append("index.html");
 
       std::string host = UrlUtilities::GetUrlHost(clean_url);
       filename.append(base_path);
       filename.append(host);
 #ifdef WIN32
       filename.append("\\");
 #else
       filename.append("/");
 #endif
@@ skipping 24 matching lines @@
     return filename;
   }
 
   // Rewrite HTML in a form that the SPDY in-memory server
   // can read.
   // |filename_prefix| is prepended without escaping.
   // |escaped_ending| is the URL to be encoded into a filename. It may have URL
   // escaped characters (like %21 for !).
   // |dir_separator| is "/" on Unix, "\" on Windows.
   // |encoded_filename| is the resultant filename.
-  static void EncodeSegment(
-      const std::string& filename_prefix,
-      const std::string& escaped_ending,
-      char dir_separator,
-      std::string* encoded_filename);
+  static void EncodeSegment(const std::string& filename_prefix,
+                            const std::string& escaped_ending,
+                            char dir_separator,
+                            std::string* encoded_filename);
 
   // Decodes a filename that was encoded with EncodeSegment,
   // yielding back the original URL.
   static bool Decode(const std::string& encoded_filename,
                      char dir_separator,
                      std::string* decoded_url);
 
   static const char kEscapeChar;
   static const char kTruncationChar;
   static const size_t kMaximumSubdirectoryLength;
 
   friend class UrlToFilenameEncoderTest;
 
  private:
   // Appends a segment of the path, special-casing "." and "..", and
   // ensuring that the segment does not exceed the path length.  If it does,
   // it chops the end off the segment, writes the segment with a separator of
   // ",-/", and then rewrites segment to contain just the truncated piece so
   // it can be used in the next iteration.
   // |segment| is a read/write parameter containing segment to write
   // Note: this should not be called with empty segment.
   static void AppendSegment(std::string* segment, std::string* dest);
 
   // Allow reading of old slurped files.
   static std::string LegacyEscape(const std::string& path);
 
   // Replace all instances of |from| within |str| as |to|.
-  static void ReplaceAll(std::string* str, const std::string& from,
+  static void ReplaceAll(std::string* str,
+                         const std::string& from,
                          const std::string& to) {
     std::string::size_type pos(0);
     while ((pos = str->find(from, pos)) != std::string::npos) {
       str->replace(pos, from.size(), to);
       pos += from.size();
     }
   }
 
   // Replace all instances of "/" with "\" in |path|.
   static void ConvertToSlashes(std::string* path) {
     const std::string slash("/");
     const std::string backslash("\\");
     ReplaceAll(path, slash, backslash);
   }
 
   // Replace all instances of "\\" with "%5C%5C" in |path|.
   static void StripDoubleSlashes(std::string* path) {
     const std::string doubleslash("\\\\");
     const std::string escaped_doubleslash("%5C%5C");
     ReplaceAll(path, doubleslash, escaped_doubleslash);
   }
 };
 
 }  // namespace net
 
 #endif  // NET_TOOLS_DUMP_CACHE_URL_TO_FILENAME_ENCODER_H_