Implement ChromeOS mime type extension mappings.

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 146 matching lines @@
   bool allow_proprietary_codecs_;
 
   // 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* 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" },
   { "video/mp4", "mp4,m4v" },
   { "audio/x-m4a", "m4a" },
@@ skipping 27 matching lines @@
   { "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/epub+zip", "epub" },
 };
 
-static const char* FindMimeType(const MimeInfo* mappings,
-                                size_t mappings_len,
-                                const char* ext) {
+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 (;;) {
       size_t end_pos = strcspn(extensions, ",");
       if (end_pos == ext_len &&
           base::strncasecmp(extensions, ext, ext_len) == 0)
         return mappings[i].mime_type;
       extensions += end_pos;
@@ skipping 26 matching lines @@
 
 bool MimeUtil::GetMimeTypeFromExtensionHelper(
     const base::FilePath::StringType& ext,
     bool include_platform_types,
     string* result) const {
   // Avoids crash when unable to handle a long file path. See crbug.com/48733.
   const unsigned kMaxFilePathSize = 65536;
   if (ext.length() > kMaxFilePathSize)
     return false;
 
+  // Reject a string which contains null character.
+  base::FilePath::StringType::size_type nul_pos =
+      ext.find(FILE_PATH_LITERAL('\0'));
+  if (nul_pos != base::FilePath::StringType::npos)
+    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),
@@ skipping 927 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