Roll Chrome into Mojo.

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 156 matching lines @@
 
   // Lookup table for string compare based string -> Codec mappings.
   StringToCodecMappings string_to_codec_map_;
 };  // class MimeUtil
 
 // 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
+  const char* const mime_type;
+  const char* const 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" },
@@ skipping 189 matching lines @@
   "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;
+  const char* const mime_type;
   CertificateMimeType cert_type;
 };
 
 static const CertificateMimeTypeInfo supported_certificate_types[] = {
   { "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 },
 #endif
@@ skipping 92 matching lines @@
   if ((!mimeType.compare("application/vnd.apple.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;
+  const char* const mime_type;
+  const char* const 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.02  - MPEG-4 AAC LC (leading 0 in aud-oti for compatibility)
@@ skipping 279 matching lines @@
     return false;
 
   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[] = {
+static const char* const legal_top_level_types[] = {
   "application",
   "audio",
   "example",
   "image",
   "message",
   "model",
   "multipart",
   "text",
   "video",
 };
@@ skipping 403 matching lines @@
   "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 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 }
 };
 
@@ skipping 142 matching lines @@
   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