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

net/base/filename_util_internal.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/files/file_path.h"
 #include "base/files/file_util.h"
 #include "base/strings/string_util.h"
 #include "base/strings/sys_string_conversions.h"
@@ skipping 52 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 (!base::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));
     }
   }
   // 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();
 
@@ skipping 43 matching lines @@
   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",
+      // 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;
 }
 
@@ skipping 19 matching lines @@
     extension.erase(extension.begin());  // Erase preceding '.'.
 
   if ((ignore_extension || extension.empty()) && !mime_type.empty()) {
     base::FilePath::StringType preferred_mime_extension;
     std::vector<base::FilePath::StringType> all_mime_extensions;
     net::GetPreferredExtensionForMimeType(mime_type, &preferred_mime_extension);
     net::GetExtensionsForMimeType(mime_type, &all_mime_extensions);
     // If the existing extension is in the list of valid extensions for the
     // given type, use it. This avoids doing things like pointlessly renaming
     // "foo.jpg" to "foo.jpeg".
-    if (std::find(all_mime_extensions.begin(),
-                  all_mime_extensions.end(),
+    if (std::find(all_mime_extensions.begin(), all_mime_extensions.end(),
                   extension) != all_mime_extensions.end()) {
       // leave |extension| alone
     } else if (!preferred_mime_extension.empty()) {
       extension = preferred_mime_extension;
     }
   }
 
 #if defined(OS_WIN)
   static const base::FilePath::CharType default_extension[] =
       FILE_PATH_LITERAL("download");
 
   // Rename shell-integrated extensions.
   // TODO(asanka): Consider stripping out the bad extension and replacing it
   // with the preferred extension for the MIME type if one is available.
   if (IsShellIntegratedExtension(extension))
     extension.assign(default_extension);
 #endif
 
   *file_name = file_name->ReplaceExtension(extension);
 }
 
 bool FilePathToString16(const base::FilePath& path, base::string16* converted) {
 #if defined(OS_WIN)
-  return base::WideToUTF16(
-      path.value().c_str(), path.value().size(), converted);
+  return base::WideToUTF16(path.value().c_str(), path.value().size(),
+                           converted);
 #elif defined(OS_POSIX)
   std::string component8 = path.AsUTF8Unsafe();
   return !component8.empty() &&
          base::UTF8ToUTF16(component8.c_str(), component8.size(), converted);
 #endif
 }
 
 base::string16 GetSuggestedFilenameImpl(
     const GURL& url,
     const std::string& content_disposition,
@@ skipping 79 matching lines @@
 }
 
 base::FilePath GenerateFileNameImpl(
     const GURL& url,
     const std::string& content_disposition,
     const std::string& referrer_charset,
     const std::string& suggested_name,
     const std::string& mime_type,
     const std::string& default_file_name,
     ReplaceIllegalCharactersCallback replace_illegal_characters_callback) {
-  base::string16 file_name =
-      GetSuggestedFilenameImpl(url,
-                               content_disposition,
-                               referrer_charset,
-                               suggested_name,
-                               mime_type,
-                               default_file_name,
-                               replace_illegal_characters_callback);
+  base::string16 file_name = GetSuggestedFilenameImpl(
+      url, content_disposition, referrer_charset, suggested_name, mime_type,
+      default_file_name, replace_illegal_characters_callback);
 
 #if defined(OS_WIN)
   base::FilePath generated_name(file_name);
 #else
   base::FilePath generated_name(
       base::SysWideToNativeMB(base::UTF16ToWide(file_name)));
 #endif
 
   DCHECK(!generated_name.empty());
 
   return generated_name;
 }
 
 }  // namespace net