Clang format slam.

net/base/filename_util.cc

 // Copyright 2014 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/filename_util.h"
 
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/i18n/file_util_icu.h"
 #include "base/path_service.h"
@@ skipping 59 matching lines @@
       url.ExtractFileName(),
       UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS);
 
   // The URL's path should be escaped UTF-8, but may not be.
   std::string decoded_filename = unescaped_url_filename;
   if (!IsStringUTF8(decoded_filename)) {
     // TODO(jshin): this is probably not robust enough. To be sure, we need
     // encoding detection.
     base::string16 utf16_output;
     if (!referrer_charset.empty() &&
-        net::ConvertToUTF16(unescaped_url_filename,
-                            referrer_charset.c_str(),
-                            &utf16_output)) {
+        net::ConvertToUTF16(
+            unescaped_url_filename, referrer_charset.c_str(), &utf16_output)) {
       decoded_filename = base::UTF16ToUTF8(utf16_output);
     } else {
-      decoded_filename = base::WideToUTF8(
-          base::SysNativeMBToWide(unescaped_url_filename));
+      decoded_filename =
+          base::WideToUTF8(base::SysNativeMBToWide(unescaped_url_filename));
     }
   }
   // If the URL contains a (possibly empty) query, assume it is a generator, and
   // allow the determined extension to be overwritten.
   *should_overwrite_extension = !decoded_filename.empty() && url.has_query();
 
   return decoded_filename;
 }
 
 // Returns whether the specified extension is automatically integrated into the
@@ skipping 18 matching lines @@
 
 // Returns whether the specified file name is a reserved name on windows.
 // This includes names like "com2.zip" (which correspond to devices) and
 // desktop.ini and thumbs.db which have special meaning to the windows shell.
 bool IsReservedName(const base::FilePath::StringType& filename) {
   // This list is taken from the MSDN article "Naming a file"
   // http://msdn2.microsoft.com/en-us/library/aa365247(VS.85).aspx
   // I also added clock$ because GetSaveFileName seems to consider it as a
   // reserved name too.
   static const char* const known_devices[] = {
-    "con", "prn", "aux", "nul", "com1", "com2", "com3", "com4", "com5",
-    "com6", "com7", "com8", "com9", "lpt1", "lpt2", "lpt3", "lpt4",
-    "lpt5", "lpt6", "lpt7", "lpt8", "lpt9", "clock$"
-  };
+      "con",  "prn",  "aux",  "nul",  "com1", "com2", "com3",  "com4",
+      "com5", "com6", "com7", "com8", "com9", "lpt1", "lpt2",  "lpt3",
+      "lpt4", "lpt5", "lpt6", "lpt7", "lpt8", "lpt9", "clock$"};
 #if defined(OS_WIN)
   std::string filename_lower = StringToLowerASCII(base::WideToUTF8(filename));
 #elif defined(OS_POSIX)
   std::string filename_lower = StringToLowerASCII(filename);
 #endif
 
   for (size_t i = 0; i < arraysize(known_devices); ++i) {
     // Exact match.
     if (filename_lower == known_devices[i])
       return true;
     // Starts with "DEVICE.".
     if (filename_lower.find(std::string(known_devices[i]) + ".") == 0)
       return true;
   }
 
-  static const char* const magic_names[] = {
-    // These file names are used by the "Customize folder" feature of the shell.
-    "desktop.ini",
-    "thumbs.db",
+  static const char* const magic_names[] = {// These file names are used by the
+                                            // "Customize folder" feature of the
+                                            // shell.
+                                            "desktop.ini", "thumbs.db",
   };
 
   for (size_t i = 0; i < arraysize(magic_names); ++i) {
     if (filename_lower == magic_names[i])
       return true;
   }
 
   return false;
 }
 
-
 // Examines the current extension in |file_name| and modifies it if necessary in
 // order to ensure the filename is safe.  If |file_name| doesn't contain an
 // extension or if |ignore_extension| is true, then a new extension will be
 // constructed based on the |mime_type|.
 //
 // We're addressing two things here:
 //
 // 1) Usability.  If there is no reliable file extension, we want to guess a
 //    reasonable file extension based on the content type.
 //
@@ skipping 70 matching lines @@
     url_string.push_back(base::FilePath::kSeparators[0]);
   }
   url_string.append(path.value());
 
   // Now do replacement of some characters. Since we assume the input is a
   // literal filename, anything the URL parser might consider special should
   // be escaped here.
 
   // must be the first substitution since others will introduce percents as the
   // escape character
-  ReplaceSubstringsAfterOffset(&url_string, 0,
-      FILE_PATH_LITERAL("%"), FILE_PATH_LITERAL("%25"));
+  ReplaceSubstringsAfterOffset(
+      &url_string, 0, FILE_PATH_LITERAL("%"), FILE_PATH_LITERAL("%25"));
 
   // semicolon is supposed to be some kind of separator according to RFC 2396
-  ReplaceSubstringsAfterOffset(&url_string, 0,
-      FILE_PATH_LITERAL(";"), FILE_PATH_LITERAL("%3B"));
+  ReplaceSubstringsAfterOffset(
+      &url_string, 0, FILE_PATH_LITERAL(";"), FILE_PATH_LITERAL("%3B"));
 
-  ReplaceSubstringsAfterOffset(&url_string, 0,
-      FILE_PATH_LITERAL("#"), FILE_PATH_LITERAL("%23"));
+  ReplaceSubstringsAfterOffset(
+      &url_string, 0, FILE_PATH_LITERAL("#"), FILE_PATH_LITERAL("%23"));
 
-  ReplaceSubstringsAfterOffset(&url_string, 0,
-      FILE_PATH_LITERAL("?"), FILE_PATH_LITERAL("%3F"));
+  ReplaceSubstringsAfterOffset(
+      &url_string, 0, FILE_PATH_LITERAL("?"), FILE_PATH_LITERAL("%3F"));
 
 #if defined(OS_POSIX)
-  ReplaceSubstringsAfterOffset(&url_string, 0,
-      FILE_PATH_LITERAL("\\"), FILE_PATH_LITERAL("%5C"));
+  ReplaceSubstringsAfterOffset(
+      &url_string, 0, FILE_PATH_LITERAL("\\"), FILE_PATH_LITERAL("%5C"));
 #endif
 
   return GURL(url_string);
 }
 
 bool FileURLToFilePath(const GURL& url, base::FilePath* file_path) {
   *file_path = base::FilePath();
   base::FilePath::StringType& file_path_str =
       const_cast<base::FilePath::StringType&>(file_path->value());
   file_path_str.clear();
@@ skipping 13 matching lines @@
     if (first_non_slash != std::string::npos && first_non_slash > 0)
       path.erase(0, first_non_slash);
   } else {
     // URL contains a host: this means it's UNC. We keep the preceeding slash
     // on the path.
     path = "\\\\";
     path.append(host);
     path.append(url.path());
   }
   std::replace(path.begin(), path.end(), '/', '\\');
-#else  // defined(OS_WIN)
+#else   // defined(OS_WIN)
   // Firefox seems to ignore the "host" of a file url if there is one. That is,
   // file://foo/bar.txt maps to /bar.txt.
   // TODO(dhg): This should probably take into account UNCs which could
   // include a hostname other than localhost or blank
   std::string path = url.path();
 #endif  // !defined(OS_WIN)
 
   if (path.empty())
     return false;
 
   // GURL stores strings as percent-encoded 8-bit, this will undo if possible.
-  path = UnescapeURLComponent(path,
-      UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS);
+  path = UnescapeURLComponent(
+      path, UnescapeRule::SPACES | UnescapeRule::URL_SPECIAL_CHARS);
 
 #if defined(OS_WIN)
   if (IsStringUTF8(path)) {
     file_path_str.assign(base::UTF8ToWide(path));
     // We used to try too hard and see if |path| made up entirely of
     // the 1st 256 characters in the Unicode was a zero-extended UTF-16.
     // If so, we converted it to 'Latin-1' and checked if the result was UTF-8.
     // If the check passed, we converted the result to UTF-8.
     // Otherwise, we treated the result as the native OS encoding.
     // However, that led to http://crbug.com/4619 and http://crbug.com/14153
   } else {
     // Not UTF-8, assume encoding is native codepage and we're done. We know we
     // are giving the conversion function a nonempty string, and it may fail if
     // the given string is not in the current encoding and give us an empty
     // string back. We detect this and report failure.
     file_path_str = base::SysNativeMBToWide(path);
   }
-#else  // defined(OS_WIN)
+#else   // defined(OS_WIN)
   // Collapse multiple path slashes into a single path slash.
   std::string new_path;
   do {
     new_path = path;
     ReplaceSubstringsAfterOffset(&new_path, 0, "//", "/");
     path.swap(new_path);
   } while (new_path != path);
 
   file_path_str.assign(path);
 #endif  // !defined(OS_WIN)
 
   return !file_path_str.empty();
 }
 
 bool IsSafePortablePathComponent(const base::FilePath& component) {
   base::string16 component16;
   base::FilePath::StringType sanitized = component.value();
   SanitizeGeneratedFileName(&sanitized, true);
   base::FilePath::StringType extension = component.Extension();
   if (!extension.empty())
     extension.erase(extension.begin());  // Erase preceding '.'.
-  return !component.empty() &&
-         (component == component.BaseName()) &&
+  return !component.empty() && (component == component.BaseName()) &&
          (component == component.StripTrailingSeparators()) &&
          FilePathToString16(component, &component16) &&
          file_util::IsFilenameLegal(component16) &&
          !IsShellIntegratedExtension(extension) &&
-         (sanitized == component.value()) &&
-         !IsReservedName(component.value());
+         (sanitized == component.value()) && !IsReservedName(component.value());
 }
 
 bool IsSafePortableRelativePath(const base::FilePath& path) {
   if (path.empty() || path.IsAbsolute() || path.EndsWithSeparator())
     return false;
   std::vector<base::FilePath::StringType> components;
   path.GetComponents(&components);
   if (components.empty())
     return false;
   for (size_t i = 0; i < components.size() - 1; ++i) {
@@ skipping 30 matching lines @@
                                     const std::string& referrer_charset,
                                     const std::string& suggested_name,
                                     const std::string& mime_type,
                                     const std::string& default_name) {
   // TODO: this function to be updated to match the httpbis recommendations.
   // Talk to abarth for the latest news.
 
   // We don't translate this fallback string, "download". If localization is
   // needed, the caller should provide localized fallback in |default_name|.
   static const base::FilePath::CharType kFinalFallbackName[] =
-    FILE_PATH_LITERAL("download");
+      FILE_PATH_LITERAL("download");
   std::string filename;  // In UTF-8
   bool overwrite_extension = false;
 
   // Try to extract a filename from content-disposition first.
   if (!content_disposition.empty()) {
     HttpContentDisposition header(content_disposition, referrer_charset);
     filename = header.filename();
   }
 
   // Then try to use the suggested name.
   if (filename.empty() && !suggested_name.empty())
     filename = suggested_name;
 
   // Now try extracting the filename from the URL.  GetFileNameFromURL() only
   // looks at the last component of the URL and doesn't return the hostname as a
   // failover.
   if (filename.empty())
     filename = GetFileNameFromURL(url, referrer_charset, &overwrite_extension);
 
   // Finally try the URL hostname, but only if there's no default specified in
   // |default_name|.  Some schemes (e.g.: file:, about:, data:) do not have a
   // host name.
-  if (filename.empty() &&
-      default_name.empty() &&
-      url.is_valid() &&
+  if (filename.empty() && default_name.empty() && url.is_valid() &&
       !url.host().empty()) {
     // TODO(jungshik) : Decode a 'punycoded' IDN hostname. (bug 1264451)
     filename = url.host();
   }
 
   bool replace_trailing = false;
   base::FilePath::StringType result_str, default_name_str;
 #if defined(OS_WIN)
   replace_trailing = true;
   result_str = base::UTF8ToUTF16(filename);
   default_name_str = base::UTF8ToUTF16(default_name);
 #else
   result_str = filename;
   default_name_str = default_name;
 #endif
   SanitizeGeneratedFileName(&result_str, replace_trailing);
   if (result_str.find_last_not_of(FILE_PATH_LITERAL("-_")) ==
       base::FilePath::StringType::npos) {
-    result_str = !default_name_str.empty() ? default_name_str :
-      base::FilePath::StringType(kFinalFallbackName);
+    result_str = !default_name_str.empty()
+                     ? default_name_str
+                     : base::FilePath::StringType(kFinalFallbackName);
     overwrite_extension = false;
   }
   file_util::ReplaceIllegalCharactersInPath(&result_str, '-');
   base::FilePath result(result_str);
   GenerateSafeFileName(mime_type, overwrite_extension, &result);
 
   base::string16 result16;
   if (!FilePathToString16(result, &result16)) {
     result = base::FilePath(default_name_str);
     if (!FilePathToString16(result, &result16)) {
@@ skipping 31 matching lines @@
   // utf8 encoded characters in name.
   file_util::NormalizeFileNameEncoding(&generated_name);
 #endif
 
   DCHECK(!generated_name.empty());
 
   return generated_name;
 }
 
 }  // namespace net