Don't blindly do a prefix match when evaluating net::GetExtensionsForMimeType().

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 <unordered_set>
 
@@ skipping 441 matching lines @@
   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 }
 };
 
+template <size_t N>
 void GetExtensionsFromHardCodedMappings(

[xunjieli, 2017/01/31 17:21:29]

nit: Could you add a comment on this function? (highlight the relationship
between |prefix_match| and |mime_type|)

[eroman, 2017/01/31 17:41:30]

Done, good idea.

-    const MimeInfo* mappings,
-    size_t mappings_len,
-    const std::string& leading_mime_type,
+    const MimeInfo (&mappings)[N],
+    const std::string& mime_type,
+    bool prefix_match,
     std::unordered_set<base::FilePath::StringType>* extensions) {
-  for (size_t i = 0; i < mappings_len; ++i) {
-    if (base::StartsWith(mappings[i].mime_type, leading_mime_type,
-                         base::CompareCase::INSENSITIVE_ASCII)) {
+  for (const auto& mapping : mappings) {
+    base::StringPiece cur_mime_type(mapping.mime_type);
+
+    if (base::StartsWith(cur_mime_type, mime_type,
+                         base::CompareCase::INSENSITIVE_ASCII) &&
+        (prefix_match || (cur_mime_type.length() == mime_type.length()))) {
       for (const base::StringPiece& this_extension : base::SplitStringPiece(
-               mappings[i].extensions, ",", base::TRIM_WHITESPACE,
+               mapping.extensions, ",", base::TRIM_WHITESPACE,
                base::SPLIT_WANT_ALL)) {
 #if defined(OS_WIN)
         extensions->insert(base::UTF8ToUTF16(this_extension));
 #else
         extensions->insert(this_extension.as_string());
 #endif
       }
     }
   }
 }
 
 void GetExtensionsHelper(
     const char* const* standard_types,
     size_t standard_types_len,
     const std::string& leading_mime_type,
     std::unordered_set<base::FilePath::StringType>* extensions) {
   for (size_t i = 0; i < standard_types_len; ++i) {
     g_mime_util.Get().GetPlatformExtensionsForMimeType(standard_types[i],
                                                        extensions);
   }
 
   // Also look up the extensions from hard-coded mappings in case that some
   // supported extensions are not registered in the system registry, like ogg.
-  GetExtensionsFromHardCodedMappings(kPrimaryMappings,
-                                     arraysize(kPrimaryMappings),
-                                     leading_mime_type, extensions);
+  GetExtensionsFromHardCodedMappings(kPrimaryMappings, leading_mime_type, true,
+                                     extensions);
 
-  GetExtensionsFromHardCodedMappings(kSecondaryMappings,
-                                     arraysize(kSecondaryMappings),
-                                     leading_mime_type, extensions);
+  GetExtensionsFromHardCodedMappings(kSecondaryMappings, leading_mime_type,
+                                     true, extensions);
 }
 
 // Note that the elements in the source set will be appended to the target
 // vector.
 template <class T>
 void UnorderedSetToVector(std::unordered_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;
@@ skipping 42 matching lines @@
     GetExtensionsHelper(type->standard_types,
                         type->standard_types_len,
                         leading_mime_type,
                         &unique_extensions);
   } else {
     g_mime_util.Get().GetPlatformExtensionsForMimeType(mime_type,
                                                        &unique_extensions);
 
     // Also look up the extensions from hard-coded mappings in case that some
     // supported extensions are not registered in the system registry, like ogg.
-    GetExtensionsFromHardCodedMappings(kPrimaryMappings,
-                                       arraysize(kPrimaryMappings), mime_type,
+    GetExtensionsFromHardCodedMappings(kPrimaryMappings, mime_type, false,
                                        &unique_extensions);
 
-    GetExtensionsFromHardCodedMappings(kSecondaryMappings,
-                                       arraysize(kSecondaryMappings), mime_type,
+    GetExtensionsFromHardCodedMappings(kSecondaryMappings, mime_type, false,
                                        &unique_extensions);
   }
 
   UnorderedSetToVector(&unique_extensions, extensions);
 }
 
 NET_EXPORT std::string GenerateMimeMultipartBoundary() {
   // Based on RFC 1341, section "7.2.1 Multipart: The common syntax":
   //   Because encapsulation boundaries must not appear in the body parts being
   //   encapsulated, a user agent must exercise care to choose a unique
@@ skipping 48 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