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

net/base/mime_util.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 <algorithm>
 #include <iterator>
 #include <map>
 #include <string>
 
 #include "base/containers/hash_tables.h"
@@ skipping 15 matching lines @@
 using std::string;
 
 namespace {
 
 struct MediaType {
   const char name[12];
   const char matcher[13];
 };
 
 static const MediaType kIanaMediaTypes[] = {
-  { "application", "application/" },
-  { "audio", "audio/" },
-  { "example", "example/" },
-  { "image", "image/" },
-  { "message", "message/" },
-  { "model", "model/" },
-  { "multipart", "multipart/" },
-  { "text", "text/" },
-  { "video", "video/" },
+    {"application", "application/"},
+    {"audio", "audio/"},
+    {"example", "example/"},
+    {"image", "image/"},
+    {"message", "message/"},
+    {"model", "model/"},
+    {"multipart", "multipart/"},
+    {"text", "text/"},
+    {"video", "video/"},
 };
 
 }  // namespace
 
 namespace net {
 
 // Singleton utility class for mime types.
 class MimeUtil : public PlatformMimeUtil {
  public:
   enum Codec {
@@ skipping 25 matching lines @@
                                          std::string* mime_type) const;
 
   bool IsSupportedImageMimeType(const std::string& mime_type) const;
   bool IsSupportedMediaMimeType(const std::string& mime_type) const;
   bool IsSupportedNonImageMimeType(const std::string& mime_type) const;
   bool IsUnsupportedTextMimeType(const std::string& mime_type) const;
   bool IsSupportedJavascriptMimeType(const std::string& mime_type) const;
 
   bool IsSupportedMimeType(const std::string& mime_type) const;
 
-  bool MatchesMimeType(const std::string &mime_type_pattern,
-                       const std::string &mime_type) const;
+  bool MatchesMimeType(const std::string& mime_type_pattern,
+                       const std::string& mime_type) const;
 
   bool ParseMimeTypeWithoutParameter(const std::string& type_string,
                                      std::string* top_level_type,
                                      std::string* subtype) const;
 
   bool IsValidTopLevelMimeType(const std::string& type_string) const;
 
   bool AreSupportedMediaCodecs(const std::vector<std::string>& codecs) const;
 
   void ParseCodecString(const std::string& codecs,
@@ skipping 22 matching lines @@
   };
   typedef std::map<std::string, CodecEntry> StringToCodecMappings;
 
   MimeUtil();
 
   // Returns IsSupported if all codec IDs in |codecs| are unambiguous
   // and are supported by the platform. MayBeSupported is returned if
   // at least one codec ID in |codecs| is ambiguous but all the codecs
   // are supported by the platform. IsNotSupported is returned if at
   // least one codec ID  is not supported by the platform.
-  SupportsType AreSupportedCodecs(
-      const CodecSet& supported_codecs,
-      const std::vector<std::string>& codecs) const;
+  SupportsType AreSupportedCodecs(const CodecSet& supported_codecs,
+                                  const std::vector<std::string>& codecs) const;
 
   // For faster lookup, keep hash sets.
   void InitializeMimeTypeMaps();
 
   bool GetMimeTypeFromExtensionHelper(const base::FilePath::StringType& ext,
                                       bool include_platform_types,
                                       std::string* mime_type) const;
 
   // Converts a codec ID into an Codec enum value and indicates
   // whether the conversion was ambiguous.
@@ skipping 45 matching lines @@
 // This variable is Leaky because we need to access it from WorkerPool threads.
 static base::LazyInstance<MimeUtil>::Leaky g_mime_util =
     LAZY_INSTANCE_INITIALIZER;
 
 struct MimeInfo {
   const char* mime_type;
   const char* extensions;  // comma separated list
 };
 
 static const MimeInfo primary_mappings[] = {
-  { "text/html", "html,htm,shtml,shtm" },
-  { "text/css", "css" },
-  { "text/xml", "xml" },
-  { "image/gif", "gif" },
-  { "image/jpeg", "jpeg,jpg" },
-  { "image/webp", "webp" },
-  { "image/png", "png" },
-  { "video/mp4", "mp4,m4v" },
-  { "audio/x-m4a", "m4a" },
-  { "audio/mp3", "mp3" },
-  { "video/ogg", "ogv,ogm" },
-  { "audio/ogg", "ogg,oga,opus" },
-  { "video/webm", "webm" },
-  { "audio/webm", "webm" },
-  { "audio/wav", "wav" },
-  { "application/xhtml+xml", "xhtml,xht,xhtm" },
-  { "application/x-chrome-extension", "crx" },
-  { "multipart/related", "mhtml,mht" }
-};
+    {"text/html", "html,htm,shtml,shtm"},
+    {"text/css", "css"},
+    {"text/xml", "xml"},
+    {"image/gif", "gif"},
+    {"image/jpeg", "jpeg,jpg"},
+    {"image/webp", "webp"},
+    {"image/png", "png"},
+    {"video/mp4", "mp4,m4v"},
+    {"audio/x-m4a", "m4a"},
+    {"audio/mp3", "mp3"},
+    {"video/ogg", "ogv,ogm"},
+    {"audio/ogg", "ogg,oga,opus"},
+    {"video/webm", "webm"},
+    {"audio/webm", "webm"},
+    {"audio/wav", "wav"},
+    {"application/xhtml+xml", "xhtml,xht,xhtm"},
+    {"application/x-chrome-extension", "crx"},
+    {"multipart/related", "mhtml,mht"}};
 
 static const MimeInfo secondary_mappings[] = {
-  { "application/octet-stream", "exe,com,bin" },
-  { "application/gzip", "gz" },
-  { "application/pdf", "pdf" },
-  { "application/postscript", "ps,eps,ai" },
-  { "application/javascript", "js" },
-  { "application/font-woff", "woff" },
-  { "image/bmp", "bmp" },
-  { "image/x-icon", "ico" },
-  { "image/vnd.microsoft.icon", "ico" },
-  { "image/jpeg", "jfif,pjpeg,pjp" },
-  { "image/tiff", "tiff,tif" },
-  { "image/x-xbitmap", "xbm" },
-  { "image/svg+xml", "svg,svgz" },
-  { "image/x-png", "png"},
-  { "message/rfc822", "eml" },
-  { "text/plain", "txt,text" },
-  { "text/html", "ehtml" },
-  { "application/rss+xml", "rss" },
-  { "application/rdf+xml", "rdf" },
-  { "text/xml", "xsl,xbl,xslt" },
-  { "application/vnd.mozilla.xul+xml", "xul" },
-  { "application/x-shockwave-flash", "swf,swl" },
-  { "application/pkcs7-mime", "p7m,p7c,p7z" },
-  { "application/pkcs7-signature", "p7s" },
-  { "application/x-mpegurl", "m3u8" },
+    {"application/octet-stream", "exe,com,bin"},
+    {"application/gzip", "gz"},
+    {"application/pdf", "pdf"},
+    {"application/postscript", "ps,eps,ai"},
+    {"application/javascript", "js"},
+    {"application/font-woff", "woff"},
+    {"image/bmp", "bmp"},
+    {"image/x-icon", "ico"},
+    {"image/vnd.microsoft.icon", "ico"},
+    {"image/jpeg", "jfif,pjpeg,pjp"},
+    {"image/tiff", "tiff,tif"},
+    {"image/x-xbitmap", "xbm"},
+    {"image/svg+xml", "svg,svgz"},
+    {"image/x-png", "png"},
+    {"message/rfc822", "eml"},
+    {"text/plain", "txt,text"},
+    {"text/html", "ehtml"},
+    {"application/rss+xml", "rss"},
+    {"application/rdf+xml", "rdf"},
+    {"text/xml", "xsl,xbl,xslt"},
+    {"application/vnd.mozilla.xul+xml", "xul"},
+    {"application/x-shockwave-flash", "swf,swl"},
+    {"application/pkcs7-mime", "p7m,p7c,p7z"},
+    {"application/pkcs7-signature", "p7s"},
+    {"application/x-mpegurl", "m3u8"},
 };
 
 static const char* FindMimeType(const MimeInfo* mappings,
                                 size_t mappings_len,
                                 const char* ext) {
   size_t ext_len = strlen(ext);
 
   for (size_t i = 0; i < mappings_len; ++i) {
     const char* extensions = mappings[i].extensions;
     for (;;) {
@@ skipping 39 matching lines @@
     return false;
 
   // We implement the same algorithm as Mozilla for mapping a file extension to
   // a mime type.  That is, we first check a hard-coded list (that cannot be
   // overridden), and then if not found there, we defer to the system registry.
   // Finally, we scan a secondary hard-coded list to catch types that we can
   // deduce but that we also want to allow the OS to override.
 
   base::FilePath path_ext(ext);
   const string ext_narrow_str = path_ext.AsUTF8Unsafe();
-  const char* mime_type = FindMimeType(primary_mappings,
-                                       arraysize(primary_mappings),
-                                       ext_narrow_str.c_str());
+  const char* mime_type = FindMimeType(
+      primary_mappings, arraysize(primary_mappings), ext_narrow_str.c_str());
   if (mime_type) {
     *result = mime_type;
     return true;
   }
 
   if (include_platform_types && GetPlatformMimeTypeFromExtension(ext, result))
     return true;
 
-  mime_type = FindMimeType(secondary_mappings, arraysize(secondary_mappings),
+  mime_type = FindMimeType(secondary_mappings,
+                           arraysize(secondary_mappings),
                            ext_narrow_str.c_str());
   if (mime_type) {
     *result = mime_type;
     return true;
   }
 
   return false;
 }
 
 // From WebKit's WebCore/platform/MIMETypeRegistry.cpp:
 
 static const char* const supported_image_types[] = {
-  "image/jpeg",
-  "image/pjpeg",
-  "image/jpg",
-  "image/webp",
-  "image/png",
-  "image/gif",
-  "image/bmp",
-  "image/vnd.microsoft.icon",    // ico
-  "image/x-icon",    // ico
-  "image/x-xbitmap",  // xbm
-  "image/x-png"
-};
+    "image/jpeg",
+    "image/pjpeg",
+    "image/jpg",
+    "image/webp",
+    "image/png",
+    "image/gif",
+    "image/bmp",
+    "image/vnd.microsoft.icon",  // ico
+    "image/x-icon",              // ico
+    "image/x-xbitmap",           // xbm
+    "image/x-png"};
 
 // A list of media types: http://en.wikipedia.org/wiki/Internet_media_type
 // A comprehensive mime type list: http://plugindoc.mozdev.org/winmime.php
 // This set of codecs is supported by all variations of Chromium.
 static const char* const common_media_types[] = {
-  // Ogg.
-  "audio/ogg",
-  "application/ogg",
+    // Ogg.
+    "audio/ogg",
+    "application/ogg",
 #if !defined(OS_ANDROID)  // Android doesn't support Ogg Theora.
-  "video/ogg",
+    "video/ogg",
 #endif
 
-  // WebM.
-  "video/webm",
-  "audio/webm",
+    // WebM.
+    "video/webm",
+    "audio/webm",
 
-  // Wav.
-  "audio/wav",
-  "audio/x-wav",
+    // Wav.
+    "audio/wav",
+    "audio/x-wav",
 
 #if defined(OS_ANDROID)
-  // HLS. Supported by Android ICS and above.
-  "application/vnd.apple.mpegurl",
-  "application/x-mpegurl",
+    // HLS. Supported by Android ICS and above.
+    "application/vnd.apple.mpegurl",
+    "application/x-mpegurl",
 #endif
 };
 
 // List of proprietary types only supported by Google Chrome.
 static const char* const proprietary_media_types[] = {
-  // MPEG-4.
-  "video/mp4",
-  "video/x-m4v",
-  "audio/mp4",
-  "audio/x-m4a",
+    // MPEG-4.
+    "video/mp4",
+    "video/x-m4v",
+    "audio/mp4",
+    "audio/x-m4a",
 
-  // MP3.
-  "audio/mp3",
-  "audio/x-mp3",
-  "audio/mpeg",
+    // MP3.
+    "audio/mp3",
+    "audio/x-mp3",
+    "audio/mpeg",
 
 #if defined(ENABLE_MPEG2TS_STREAM_PARSER)
-  // MPEG-2 TS.
-  "video/mp2t",
+    // MPEG-2 TS.
+    "video/mp2t",
 #endif
 };
 
 // Note:
 // - does not include javascript types list (see supported_javascript_types)
 // - does not include types starting with "text/" (see
 //   IsSupportedNonImageMimeType())
 static const char* const supported_non_image_types[] = {
-  "image/svg+xml",  // SVG is text-based XML, even though it has an image/ type
-  "application/xml",
-  "application/atom+xml",
-  "application/rss+xml",
-  "application/xhtml+xml",
-  "application/json",
-  "multipart/related",  // For MHTML support.
-  "multipart/x-mixed-replace"
-  // Note: ADDING a new type here will probably render it AS HTML. This can
-  // result in cross site scripting.
+    "image/svg+xml",  // SVG is text-based XML, even though it has an image/
+                      // type
+    "application/xml",
+    "application/atom+xml",
+    "application/rss+xml",
+    "application/xhtml+xml",
+    "application/json",
+    "multipart/related",  // For MHTML support.
+    "multipart/x-mixed-replace"
+    // Note: ADDING a new type here will probably render it AS HTML. This can
+    // result in cross site scripting.
 };
 
 // Dictionary of cryptographic file mime types.
 struct CertificateMimeTypeInfo {
   const char* mime_type;
   CertificateMimeType cert_type;
 };
 
 static const CertificateMimeTypeInfo supported_certificate_types[] = {
-  { "application/x-x509-user-cert",
-      CERTIFICATE_MIME_TYPE_X509_USER_CERT },
+    {"application/x-x509-user-cert", CERTIFICATE_MIME_TYPE_X509_USER_CERT},
 #if defined(OS_ANDROID)
-  { "application/x-x509-ca-cert", CERTIFICATE_MIME_TYPE_X509_CA_CERT },
-  { "application/x-pkcs12", CERTIFICATE_MIME_TYPE_PKCS12_ARCHIVE },
+    {"application/x-x509-ca-cert", CERTIFICATE_MIME_TYPE_X509_CA_CERT},
+    {"application/x-pkcs12", CERTIFICATE_MIME_TYPE_PKCS12_ARCHIVE},
 #endif
 };
 
 // These types are excluded from the logic that allows all text/ types because
 // while they are technically text, it's very unlikely that a user expects to
 // see them rendered in text form.
 static const char* const unsupported_text_types[] = {
-  "text/calendar",
-  "text/x-calendar",
-  "text/x-vcalendar",
-  "text/vcalendar",
-  "text/vcard",
-  "text/x-vcard",
-  "text/directory",
-  "text/ldif",
-  "text/qif",
-  "text/x-qif",
-  "text/x-csv",
-  "text/x-vcf",
-  "text/rtf",
-  "text/comma-separated-values",
-  "text/csv",
-  "text/tab-separated-values",
-  "text/tsv",
-  "text/ofx",                           // http://crbug.com/162238
-  "text/vnd.sun.j2me.app-descriptor"    // http://crbug.com/176450
+    "text/calendar",
+    "text/x-calendar",
+    "text/x-vcalendar",
+    "text/vcalendar",
+    "text/vcard",
+    "text/x-vcard",
+    "text/directory",
+    "text/ldif",
+    "text/qif",
+    "text/x-qif",
+    "text/x-csv",
+    "text/x-vcf",
+    "text/rtf",
+    "text/comma-separated-values",
+    "text/csv",
+    "text/tab-separated-values",
+    "text/tsv",
+    "text/ofx",                         // http://crbug.com/162238
+    "text/vnd.sun.j2me.app-descriptor"  // http://crbug.com/176450
 };
 
 //  Mozilla 1.8 and WinIE 7 both accept text/javascript and text/ecmascript.
 //  Mozilla 1.8 accepts application/javascript, application/ecmascript, and
 // application/x-javascript, but WinIE 7 doesn't.
 //  WinIE 7 accepts text/javascript1.1 - text/javascript1.3, text/jscript, and
 // text/livescript, but Mozilla 1.8 doesn't.
 //  Mozilla 1.8 allows leading and trailing whitespace, but WinIE 7 doesn't.
 //  Mozilla 1.8 and WinIE 7 both accept the empty string, but neither accept a
 // whitespace-only string.
 //  We want to accept all the values that either of these browsers accept, but
 // not other values.
 static const char* const supported_javascript_types[] = {
-  "text/javascript",
-  "text/ecmascript",
-  "application/javascript",
-  "application/ecmascript",
-  "application/x-javascript",
-  "text/javascript1.1",
-  "text/javascript1.2",
-  "text/javascript1.3",
-  "text/jscript",
-  "text/livescript"
-};
+    "text/javascript",
+    "text/ecmascript",
+    "application/javascript",
+    "application/ecmascript",
+    "application/x-javascript",
+    "text/javascript1.1",
+    "text/javascript1.2",
+    "text/javascript1.3",
+    "text/jscript",
+    "text/livescript"};
 
 #if defined(OS_ANDROID)
 static bool IsCodecSupportedOnAndroid(MimeUtil::Codec codec) {
   switch (codec) {
     case MimeUtil::INVALID_CODEC:
       return false;
 
     case MimeUtil::PCM:
     case MimeUtil::MP3:
     case MimeUtil::MPEG4_AAC_LC:
@@ skipping 23 matching lines @@
     case MimeUtil::THEORA:
       return false;
   }
 
   return false;
 }
 
 static bool IsMimeTypeSupportedOnAndroid(const std::string& mimeType) {
   // HLS codecs are supported in ICS and above (API level 14)
   if ((!mimeType.compare("application/vnd.apple.mpegurl") ||
-      !mimeType.compare("application/x-mpegurl")) &&
+       !mimeType.compare("application/x-mpegurl")) &&
       base::android::BuildInfo::GetInstance()->sdk_int() < 14) {
     return false;
   }
   return true;
 }
 #endif
 
 struct MediaFormatStrict {
   const char* mime_type;
   const char* codecs_list;
 };
 
 // Following is the list of RFC 6381 compliant codecs:
 //   mp4a.66     - MPEG-2 AAC MAIN
 //   mp4a.67     - MPEG-2 AAC LC
 //   mp4a.68     - MPEG-2 AAC SSR
 //   mp4a.69     - MPEG-2 extension to MPEG-1
 //   mp4a.6B     - MPEG-1 audio
 //   mp4a.40.2   - MPEG-4 AAC LC
 //   mp4a.40.5   - MPEG-4 AAC SBRv1
 //
 //   avc1.42E0xx - H.264 Baseline
 //   avc1.4D40xx - H.264 Main
 //   avc1.6400xx - H.264 High
 static const char kMP4AudioCodecsExpression[] =
     "mp4a.66,mp4a.67,mp4a.68,mp4a.69,mp4a.6B,mp4a.40.2,mp4a.40.5";
 static const char kMP4VideoCodecsExpression[] =
-    "avc1.42E00A,avc1.4D400A,avc1.64000A," \
+    "avc1.42E00A,avc1.4D400A,avc1.64000A,"
     "mp4a.66,mp4a.67,mp4a.68,mp4a.69,mp4a.6B,mp4a.40.2,mp4a.40.5";
 
 static const MediaFormatStrict format_codec_mappings[] = {
-  { "video/webm", "opus,vorbis,vp8,vp8.0,vp9,vp9.0" },
-  { "audio/webm", "opus,vorbis" },
-  { "audio/wav", "1" },
-  { "audio/x-wav", "1" },
-  { "video/ogg", "opus,theora,vorbis" },
-  { "audio/ogg", "opus,vorbis" },
-  { "application/ogg", "opus,theora,vorbis" },
-  { "audio/mpeg", "mp3" },
-  { "audio/mp3", "" },
-  { "audio/x-mp3", "" },
-  { "audio/mp4", kMP4AudioCodecsExpression },
-  { "audio/x-m4a", kMP4AudioCodecsExpression },
-  { "video/mp4", kMP4VideoCodecsExpression },
-  { "video/x-m4v", kMP4VideoCodecsExpression },
-  { "application/x-mpegurl", kMP4VideoCodecsExpression },
-  { "application/vnd.apple.mpegurl", kMP4VideoCodecsExpression }
-};
+    {"video/webm", "opus,vorbis,vp8,vp8.0,vp9,vp9.0"},
+    {"audio/webm", "opus,vorbis"},
+    {"audio/wav", "1"},
+    {"audio/x-wav", "1"},
+    {"video/ogg", "opus,theora,vorbis"},
+    {"audio/ogg", "opus,vorbis"},
+    {"application/ogg", "opus,theora,vorbis"},
+    {"audio/mpeg", "mp3"},
+    {"audio/mp3", ""},
+    {"audio/x-mp3", ""},
+    {"audio/mp4", kMP4AudioCodecsExpression},
+    {"audio/x-m4a", kMP4AudioCodecsExpression},
+    {"video/mp4", kMP4VideoCodecsExpression},
+    {"video/x-m4v", kMP4VideoCodecsExpression},
+    {"application/x-mpegurl", kMP4VideoCodecsExpression},
+    {"application/vnd.apple.mpegurl", kMP4VideoCodecsExpression}};
 
 struct CodecIDMappings {
   const char* const codec_id;
   MimeUtil::Codec codec;
 };
 
 // List of codec IDs that provide enough information to determine the
 // codec and profile being requested.
 //
 // The "mp4a" strings come from RFC 6381.
 static const CodecIDMappings kUnambiguousCodecIDs[] = {
-  { "1", MimeUtil::PCM }, // We only allow this for WAV so it isn't ambiguous.
-  { "mp3", MimeUtil::MP3 },
-  { "mp4a.66", MimeUtil::MPEG2_AAC_MAIN },
-  { "mp4a.67", MimeUtil::MPEG2_AAC_LC },
-  { "mp4a.68", MimeUtil::MPEG2_AAC_SSR },
-  { "mp4a.69", MimeUtil::MP3 },
-  { "mp4a.6B", MimeUtil::MP3 },
-  { "mp4a.40.2", MimeUtil::MPEG4_AAC_LC },
-  { "mp4a.40.5", MimeUtil::MPEG4_AAC_SBRv1 },
-  { "vorbis", MimeUtil::VORBIS },
-  { "opus", MimeUtil::OPUS },
-  { "vp8", MimeUtil::VP8 },
-  { "vp8.0", MimeUtil::VP8 },
-  { "vp9", MimeUtil::VP9 },
-  { "vp9.0", MimeUtil::VP9 },
-  { "theora", MimeUtil::THEORA }
-};
+    {"1", MimeUtil::PCM},  // We only allow this for WAV so it isn't ambiguous.
+    {"mp3", MimeUtil::MP3},
+    {"mp4a.66", MimeUtil::MPEG2_AAC_MAIN},
+    {"mp4a.67", MimeUtil::MPEG2_AAC_LC},
+    {"mp4a.68", MimeUtil::MPEG2_AAC_SSR},
+    {"mp4a.69", MimeUtil::MP3},
+    {"mp4a.6B", MimeUtil::MP3},
+    {"mp4a.40.2", MimeUtil::MPEG4_AAC_LC},
+    {"mp4a.40.5", MimeUtil::MPEG4_AAC_SBRv1},
+    {"vorbis", MimeUtil::VORBIS},
+    {"opus", MimeUtil::OPUS},
+    {"vp8", MimeUtil::VP8},
+    {"vp8.0", MimeUtil::VP8},
+    {"vp9", MimeUtil::VP9},
+    {"vp9.0", MimeUtil::VP9},
+    {"theora", MimeUtil::THEORA}};
 
 // List of codec IDs that are ambiguous and don't provide
 // enough information to determine the codec and profile.
 // The codec in these entries indicate the codec and profile
 // we assume the user is trying to indicate.
 static const CodecIDMappings kAmbiguousCodecIDs[] = {
-  { "mp4a.40", MimeUtil::MPEG4_AAC_LC },
-  { "avc1", MimeUtil::H264_BASELINE },
-  { "avc3", MimeUtil::H264_BASELINE },
+    {"mp4a.40", MimeUtil::MPEG4_AAC_LC},
+    {"avc1", MimeUtil::H264_BASELINE},
+    {"avc3", MimeUtil::H264_BASELINE},
 };
 
 MimeUtil::MimeUtil() : allow_proprietary_codecs_(false) {
   InitializeMimeTypeMaps();
 }
 
 SupportsType MimeUtil::AreSupportedCodecs(
     const CodecSet& supported_codecs,
     const std::vector<std::string>& codecs) const {
   DCHECK(!supported_codecs.empty());
@@ skipping 67 matching lines @@
   }
 
   for (size_t i = 0; i < arraysize(kAmbiguousCodecIDs); ++i) {
     string_to_codec_map_[kAmbiguousCodecIDs[i].codec_id] =
         CodecEntry(kAmbiguousCodecIDs[i].codec, true);
   }
 
   // Initialize the strict supported media types.
   for (size_t i = 0; i < arraysize(format_codec_mappings); ++i) {
     std::vector<std::string> mime_type_codecs;
-    ParseCodecString(format_codec_mappings[i].codecs_list,
-                     &mime_type_codecs,
-                     false);
+    ParseCodecString(
+        format_codec_mappings[i].codecs_list, &mime_type_codecs, false);
 
     CodecSet codecs;
     for (size_t j = 0; j < mime_type_codecs.size(); ++j) {
       Codec codec = INVALID_CODEC;
       bool is_ambiguous = true;
       CHECK(StringToCodec(mime_type_codecs[j], &codec, &is_ambiguous));
       DCHECK(!is_ambiguous);
       codecs.insert(codec);
     }
 
     strict_format_map_[format_codec_mappings[i].mime_type] = codecs;
   }
 }
 
 bool MimeUtil::IsSupportedImageMimeType(const std::string& mime_type) const {
   return image_map_.find(mime_type) != image_map_.end();
 }
 
 bool MimeUtil::IsSupportedMediaMimeType(const std::string& mime_type) const {
   return media_map_.find(mime_type) != media_map_.end();
 }
 
 bool MimeUtil::IsSupportedNonImageMimeType(const std::string& mime_type) const {
   return non_image_map_.find(mime_type) != non_image_map_.end() ||
-      (mime_type.compare(0, 5, "text/") == 0 &&
-       !IsUnsupportedTextMimeType(mime_type)) ||
-      (mime_type.compare(0, 12, "application/") == 0 &&
-       MatchesMimeType("application/*+json", mime_type));
+         (mime_type.compare(0, 5, "text/") == 0 &&
+          !IsUnsupportedTextMimeType(mime_type)) ||
+         (mime_type.compare(0, 12, "application/") == 0 &&
+          MatchesMimeType("application/*+json", mime_type));
 }
 
 bool MimeUtil::IsUnsupportedTextMimeType(const std::string& mime_type) const {
   return unsupported_text_map_.find(mime_type) != unsupported_text_map_.end();
 }
 
 bool MimeUtil::IsSupportedJavascriptMimeType(
     const std::string& mime_type) const {
   return javascript_map_.find(mime_type) != javascript_map_.end();
 }
@@ skipping 10 matching lines @@
 // parameters in the pattern, the match is a success.
 bool MatchesMimeTypeParameters(const std::string& mime_type_pattern,
                                const std::string& mime_type) {
   const std::string::size_type semicolon = mime_type_pattern.find(';');
   const std::string::size_type test_semicolon = mime_type.find(';');
   if (semicolon != std::string::npos) {
     if (test_semicolon == std::string::npos)
       return false;
 
     std::vector<std::string> pattern_parameters;
-    base::SplitString(mime_type_pattern.substr(semicolon + 1),
-                      ';', &pattern_parameters);
+    base::SplitString(
+        mime_type_pattern.substr(semicolon + 1), ';', &pattern_parameters);
 
     std::vector<std::string> test_parameters;
-    base::SplitString(mime_type.substr(test_semicolon + 1),
-                      ';', &test_parameters);
+    base::SplitString(
+        mime_type.substr(test_semicolon + 1), ';', &test_parameters);
 
     sort(pattern_parameters.begin(), pattern_parameters.end());
     sort(test_parameters.begin(), test_parameters.end());
     std::vector<std::string> difference =
-      base::STLSetDifference<std::vector<std::string> >(pattern_parameters,
-                                                        test_parameters);
+        base::STLSetDifference<std::vector<std::string> >(pattern_parameters,
+                                                          test_parameters);
     return difference.size() == 0;
   }
   return true;
 }
 
 // This comparison handles absolute maching and also basic
 // wildcards.  The plugin mime types could be:
 //      application/x-foo
 //      application/*
 //      application/*+xml
@@ skipping 37 matching lines @@
 
   if (!right.empty() &&
       base_type.rfind(right) != base_type.length() - right.length())
     return false;
 
   return MatchesMimeTypeParameters(mime_type_pattern, mime_type);
 }
 
 // See http://www.iana.org/assignments/media-types/media-types.xhtml
 static const char* legal_top_level_types[] = {
-  "application",
-  "audio",
-  "example",
-  "image",
-  "message",
-  "model",
-  "multipart",
-  "text",
-  "video",
+    "application",
+    "audio",
+    "example",
+    "image",
+    "message",
+    "model",
+    "multipart",
+    "text",
+    "video",
 };
 
-bool MimeUtil::ParseMimeTypeWithoutParameter(
-    const std::string& type_string,
-    std::string* top_level_type,
-    std::string* subtype) const {
+bool MimeUtil::ParseMimeTypeWithoutParameter(const std::string& type_string,
+                                             std::string* top_level_type,
+                                             std::string* subtype) const {
   std::vector<std::string> components;
   base::SplitString(type_string, '/', &components);
-  if (components.size() != 2 ||
-      !HttpUtil::IsToken(components[0]) ||
+  if (components.size() != 2 || !HttpUtil::IsToken(components[0]) ||
       !HttpUtil::IsToken(components[1]))
     return false;
 
   if (top_level_type)
     *top_level_type = components[0];
   if (subtype)
     *subtype = components[1];
   return true;
 }
 
@@ skipping 47 matching lines @@
 SupportsType MimeUtil::IsSupportedStrictMediaMimeType(
     const std::string& mime_type,
     const std::vector<std::string>& codecs) const {
   StrictMappings::const_iterator it_strict_map =
       strict_format_map_.find(mime_type);
   if (it_strict_map == strict_format_map_.end())
     return codecs.empty() ? MayBeSupported : IsNotSupported;
 
   if (it_strict_map->second.empty()) {
     // We get here if the mimetype does not expect a codecs parameter.
-    return (codecs.empty() && IsDefaultCodecSupported(mime_type)) ?
-        IsSupported : IsNotSupported;
+    return (codecs.empty() && IsDefaultCodecSupported(mime_type))
+               ? IsSupported
+               : IsNotSupported;
   }
 
   if (codecs.empty()) {
     // We get here if the mimetype expects to get a codecs parameter,
     // but didn't get one. If |mime_type| does not have a default codec
     // the best we can do is say "maybe" because we don't have enough
     // information.
     Codec default_codec = INVALID_CODEC;
     if (!GetDefaultCodec(mime_type, &default_codec))
       return MayBeSupported;
@@ skipping 26 matching lines @@
 // 1 bit: constraint_set3_flag : ignored here.
 // 4 bits: reserved : required to be 0 here.
 //
 // The spec indicates other ways, not implemented here, that a |profile_str|
 // can indicate a baseline conforming decoder is sufficient for decode in Annex
 // A.2.1: "[profile_idc not necessarily 0x42] with constraint_set0_flag set and
 // in which level_idc and constraint_set3_flag represent a level less than or
 // equal to the specified level."
 static bool IsValidH264BaselineProfile(const std::string& profile_str) {
   uint32 constraint_set_bits;
-  if (profile_str.size() != 4 ||
-      profile_str[0] != '4' ||
-      profile_str[1] != '2' ||
-      profile_str[3] != '0' ||
+  if (profile_str.size() != 4 || profile_str[0] != '4' ||
+      profile_str[1] != '2' || profile_str[3] != '0' ||
       !base::HexStringToUInt(base::StringPiece(profile_str.c_str() + 2, 1),
                              &constraint_set_bits)) {
     return false;
   }
 
   return constraint_set_bits >= 8;
 }
 
 static bool IsValidH264Level(const std::string& level_str) {
   uint32 level;
   if (level_str.size() != 2 || !base::HexStringToUInt(level_str, &level))
     return false;
 
   // Valid levels taken from Table A-1 in ISO-14496-10.
   // Essentially |level_str| is toHex(10 * level).
-  return ((level >= 10 && level <= 13) ||
-          (level >= 20 && level <= 22) ||
-          (level >= 30 && level <= 32) ||
-          (level >= 40 && level <= 42) ||
+  return ((level >= 10 && level <= 13) || (level >= 20 && level <= 22) ||
+          (level >= 30 && level <= 32) || (level >= 40 && level <= 42) ||
           (level >= 50 && level <= 51));
 }
 
 // Handle parsing H.264 codec IDs as outlined in RFC 6381 and ISO-14496-10.
 //   avc1.42y0xx, y >= 8 - H.264 Baseline
 //   avc1.4D40xx         - H.264 Main
 //   avc1.6400xx         - H.264 High
 //
 //   avc1.xxxxxx & avc3.xxxxxx are considered ambiguous forms that are trying to
 //   signal H.264 Baseline. For example, the idc_level, profile_idc and
 //   constraint_set3_flag pieces may explicitly require decoder to conform to
 //   baseline profile at the specified level (see Annex A and constraint_set0 in
 //   ISO-14496-10).
 static bool ParseH264CodecID(const std::string& codec_id,
                              MimeUtil::Codec* codec,
                              bool* is_ambiguous) {
   // Make sure we have avc1.xxxxxx or avc3.xxxxxx
-  if (codec_id.size() != 11 ||
-      (!StartsWithASCII(codec_id, "avc1.", true) &&
-       !StartsWithASCII(codec_id, "avc3.", true))) {
+  if (codec_id.size() != 11 || (!StartsWithASCII(codec_id, "avc1.", true) &&
+                                !StartsWithASCII(codec_id, "avc3.", true))) {
     return false;
   }
 
   std::string profile = StringToUpperASCII(codec_id.substr(5, 4));
   if (IsValidH264BaselineProfile(profile)) {
     *codec = MimeUtil::H264_BASELINE;
   } else if (profile == "4D40") {
     *codec = MimeUtil::H264_MAIN;
   } else if (profile == "6400") {
     *codec = MimeUtil::H264_HIGH;
@@ skipping 56 matching lines @@
     case VP9:
     case THEORA:
       return false;
   }
 
   return true;
 }
 
 bool MimeUtil::GetDefaultCodec(const std::string& mime_type,
                                Codec* default_codec) const {
-  if (mime_type == "audio/mpeg" ||
-      mime_type == "audio/mp3" ||
+  if (mime_type == "audio/mpeg" || mime_type == "audio/mp3" ||
       mime_type == "audio/x-mp3") {
     *default_codec = MimeUtil::MP3;
     return true;
   }
 
   return false;
 }
 
-
 bool MimeUtil::IsDefaultCodecSupported(const std::string& mime_type) const {
   Codec default_codec = Codec::INVALID_CODEC;
   if (!GetDefaultCodec(mime_type, &default_codec))
     return false;
   return IsCodecSupported(default_codec);
 }
 
 //----------------------------------------------------------------------------
 // Wrappers for the singleton
 //----------------------------------------------------------------------------
@@ skipping 76 matching lines @@
 void ParseCodecString(const std::string& codecs,
                       std::vector<std::string>* codecs_out,
                       const bool strip) {
   g_mime_util.Get().ParseCodecString(codecs, codecs_out, strip);
 }
 
 namespace {
 
 // From http://www.w3schools.com/media/media_mimeref.asp and
 // http://plugindoc.mozdev.org/winmime.php
-static const char* const kStandardImageTypes[] = {
-  "image/bmp",
-  "image/cis-cod",
-  "image/gif",
-  "image/ief",
-  "image/jpeg",
-  "image/webp",
-  "image/pict",
-  "image/pipeg",
-  "image/png",
-  "image/svg+xml",
-  "image/tiff",
-  "image/vnd.microsoft.icon",
-  "image/x-cmu-raster",
-  "image/x-cmx",
-  "image/x-icon",
-  "image/x-portable-anymap",
-  "image/x-portable-bitmap",
-  "image/x-portable-graymap",
-  "image/x-portable-pixmap",
-  "image/x-rgb",
-  "image/x-xbitmap",
-  "image/x-xpixmap",
-  "image/x-xwindowdump"
-};
-static const char* const kStandardAudioTypes[] = {
-  "audio/aac",
-  "audio/aiff",
-  "audio/amr",
-  "audio/basic",
-  "audio/midi",
-  "audio/mp3",
-  "audio/mp4",
-  "audio/mpeg",
-  "audio/mpeg3",
-  "audio/ogg",
-  "audio/vorbis",
-  "audio/wav",
-  "audio/webm",
-  "audio/x-m4a",
-  "audio/x-ms-wma",
-  "audio/vnd.rn-realaudio",
-  "audio/vnd.wave"
-};
-static const char* const kStandardVideoTypes[] = {
-  "video/avi",
-  "video/divx",
-  "video/flc",
-  "video/mp4",
-  "video/mpeg",
-  "video/ogg",
-  "video/quicktime",
-  "video/sd-video",
-  "video/webm",
-  "video/x-dv",
-  "video/x-m4v",
-  "video/x-mpeg",
-  "video/x-ms-asf",
-  "video/x-ms-wmv"
-};
+static const char* const kStandardImageTypes[] = {"image/bmp",
+                                                  "image/cis-cod",
+                                                  "image/gif",
+                                                  "image/ief",
+                                                  "image/jpeg",
+                                                  "image/webp",
+                                                  "image/pict",
+                                                  "image/pipeg",
+                                                  "image/png",
+                                                  "image/svg+xml",
+                                                  "image/tiff",
+                                                  "image/vnd.microsoft.icon",
+                                                  "image/x-cmu-raster",
+                                                  "image/x-cmx",
+                                                  "image/x-icon",
+                                                  "image/x-portable-anymap",
+                                                  "image/x-portable-bitmap",
+                                                  "image/x-portable-graymap",
+                                                  "image/x-portable-pixmap",
+                                                  "image/x-rgb",
+                                                  "image/x-xbitmap",
+                                                  "image/x-xpixmap",
+                                                  "image/x-xwindowdump"};
+static const char* const kStandardAudioTypes[] = {"audio/aac",
+                                                  "audio/aiff",
+                                                  "audio/amr",
+                                                  "audio/basic",
+                                                  "audio/midi",
+                                                  "audio/mp3",
+                                                  "audio/mp4",
+                                                  "audio/mpeg",
+                                                  "audio/mpeg3",
+                                                  "audio/ogg",
+                                                  "audio/vorbis",
+                                                  "audio/wav",
+                                                  "audio/webm",
+                                                  "audio/x-m4a",
+                                                  "audio/x-ms-wma",
+                                                  "audio/vnd.rn-realaudio",
+                                                  "audio/vnd.wave"};
+static const char* const kStandardVideoTypes[] = {"video/avi",
+                                                  "video/divx",
+                                                  "video/flc",
+                                                  "video/mp4",
+                                                  "video/mpeg",
+                                                  "video/ogg",
+                                                  "video/quicktime",
+                                                  "video/sd-video",
+                                                  "video/webm",
+                                                  "video/x-dv",
+                                                  "video/x-m4v",
+                                                  "video/x-mpeg",
+                                                  "video/x-ms-asf",
+                                                  "video/x-ms-wmv"};
 
 struct StandardType {
   const char* leading_mime_type;
   const char* const* standard_types;
   size_t standard_types_len;
 };
 static const StandardType kStandardTypes[] = {
-  { "image/", kStandardImageTypes, arraysize(kStandardImageTypes) },
-  { "audio/", kStandardAudioTypes, arraysize(kStandardAudioTypes) },
-  { "video/", kStandardVideoTypes, arraysize(kStandardVideoTypes) },
-  { NULL, NULL, 0 }
-};
+    {"image/", kStandardImageTypes, arraysize(kStandardImageTypes)},
+    {"audio/", kStandardAudioTypes, arraysize(kStandardAudioTypes)},
+    {"video/", kStandardVideoTypes, arraysize(kStandardVideoTypes)},
+    {NULL, NULL, 0}};
 
 void GetExtensionsFromHardCodedMappings(
     const MimeInfo* mappings,
     size_t mappings_len,
     const std::string& leading_mime_type,
     base::hash_set<base::FilePath::StringType>* extensions) {
   base::FilePath::StringType extension;
   for (size_t i = 0; i < mappings_len; ++i) {
     if (StartsWithASCII(mappings[i].mime_type, leading_mime_type, false)) {
       std::vector<string> this_extensions;
@@ skipping 29 matching lines @@
                                      extensions);
 
   GetExtensionsFromHardCodedMappings(secondary_mappings,
                                      arraysize(secondary_mappings),
                                      leading_mime_type,
                                      extensions);
 }
 
 // Note that the elements in the source set will be appended to the target
 // vector.
-template<class T>
+template <class T>
 void HashSetToVector(base::hash_set<T>* source, std::vector<T>* target) {
   size_t old_target_size = target->size();
   target->resize(old_target_size + source->size());
   size_t i = 0;
   for (typename base::hash_set<T>::iterator iter = source->begin();
-       iter != source->end(); ++iter, ++i)
+       iter != source->end();
+       ++iter, ++i)
     (*target)[old_target_size + i] = *iter;
 }
 }
 
 void GetExtensionsForMimeType(
     const std::string& unsafe_mime_type,
     std::vector<base::FilePath::StringType>* extensions) {
   if (unsafe_mime_type == "*/*" || unsafe_mime_type == "*")
     return;
 
@@ skipping 55 matching lines @@
   // Don't create a map, there is only one entry in the table,
   // except on Android.
   for (size_t i = 0; i < arraysize(supported_certificate_types); ++i) {
     if (mime_type == net::supported_certificate_types[i].mime_type)
       return net::supported_certificate_types[i].cert_type;
   }
   return CERTIFICATE_MIME_TYPE_UNKNOWN;
 }
 
 bool IsSupportedCertificateMimeType(const std::string& mime_type) {
-  CertificateMimeType file_type =
-      GetCertificateMimeTypeForMimeType(mime_type);
+  CertificateMimeType file_type = GetCertificateMimeTypeForMimeType(mime_type);
   return file_type != CERTIFICATE_MIME_TYPE_UNKNOWN;
 }
 
 void AddMultipartValueForUpload(const std::string& value_name,
                                 const std::string& value,
                                 const std::string& mime_boundary,
                                 const std::string& content_type,
                                 std::string* post_data) {
   DCHECK(post_data);
   // First line is the boundary.
   post_data->append("--" + mime_boundary + "\r\n");
   // Next line is the Content-disposition.
-  post_data->append("Content-Disposition: form-data; name=\"" +
-                    value_name + "\"\r\n");
+  post_data->append("Content-Disposition: form-data; name=\"" + value_name +
+                    "\"\r\n");
   if (!content_type.empty()) {
     // If Content-type is specified, the next line is that.
     post_data->append("Content-Type: " + content_type + "\r\n");
   }
   // Leave an empty line and append the value.
   post_data->append("\r\n" + value + "\r\n");
 }
 
 void AddMultipartFinalDelimiterForUpload(const std::string& mime_boundary,
                                          std::string* post_data) {
   DCHECK(post_data);
   post_data->append("--" + mime_boundary + "--\r\n");
 }
 
 }  // namespace net