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

net/base/mime_util_unittest.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 "net/base/mime_util.h"
+
+#include <algorithm>
+
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "build/build_config.h"
-#include "net/base/mime_util.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 TEST(MimeUtilTest, ExtensionTest) {
   // String: png\0css
   base::FilePath::StringType containsNullByte;
   containsNullByte.append(FILE_PATH_LITERAL("png"));
   containsNullByte.append(1, FILE_PATH_LITERAL('\0'));
   containsNullByte.append(FILE_PATH_LITERAL("css"));
@@ skipping 210 matching lines @@
   EXPECT_TRUE(IsValidTopLevelMimeType("X-video"));
 
   EXPECT_FALSE(IsValidTopLevelMimeType("x-"));
 }
 
 TEST(MimeUtilTest, TestGetExtensionsForMimeType) {
   const struct {
     const char* const mime_type;
     size_t min_expected_size;
     const char* const contained_result;
+    bool no_matches;
   } tests[] = {
-    { "text/plain", 2, "txt" },
-    { "*",          0, NULL  },
-    { "message/*",  1, "eml" },
-    { "MeSsAge/*",  1, "eml" },
-    { "image/bmp",  1, "bmp" },
-    { "video/*",    6, "mp4" },
+    {"text/plain", 2, "txt"},
+    {"text/pl", 0, NULL, true},
+    {"*", 0, NULL},
+    {"", 0, NULL, true},
+    {"message/*", 1, "eml"},
+    {"MeSsAge/*", 1, "eml"},
+    {"message/", 0, NULL, true},
+    {"image/bmp", 1, "bmp"},
+    {"video/*", 6, "mp4"},
 #if defined(OS_LINUX) || defined(OS_ANDROID) || defined(OS_IOS)
-    { "video/*",    6, "mpg" },
+    {"video/*", 6, "mpg"},
 #else
-    { "video/*",    6, "mpeg" },
+    {"video/*", 6, "mpeg"},
 #endif
-    { "audio/*",    6, "oga" },
-    { "aUDIo/*",    6, "wav" },
+    {"audio/*", 6, "oga"},
+    {"aUDIo/*", 6, "wav"},
   };
 
-  for (size_t i = 0; i < arraysize(tests); ++i) {
+  for (const auto& test : tests) {
     std::vector<base::FilePath::StringType> extensions;
-    GetExtensionsForMimeType(tests[i].mime_type, &extensions);
-    ASSERT_TRUE(tests[i].min_expected_size <= extensions.size());
+    GetExtensionsForMimeType(test.mime_type, &extensions);
+    ASSERT_LE(test.min_expected_size, extensions.size());
 
-    if (!tests[i].contained_result)
-      continue;
+    if (test.no_matches)
+      ASSERT_EQ(0u, extensions.size());
 
-    bool found = false;
-    for (size_t j = 0; !found && j < extensions.size(); ++j) {
-#if defined(OS_WIN)
-      if (extensions[j] == base::UTF8ToWide(tests[i].contained_result))
-        found = true;
-#else
-      if (extensions[j] == tests[i].contained_result)
-        found = true;
-#endif
+    if (test.contained_result) {
+      // Convert ASCII to FilePath::StringType.
+      base::FilePath::StringType contained_result(
+          test.contained_result,
+          test.contained_result + strlen(test.contained_result));
+
+      bool found = std::find(extensions.begin(), extensions.end(),
+                             contained_result) != extensions.end();
+
+      ASSERT_TRUE(found) << "Must find at least the contained result within "
+                         << test.mime_type;
     }
-    ASSERT_TRUE(found) << "Must find at least the contained result within "
-                       << tests[i].mime_type;
   }
 }
 
 TEST(MimeUtilTest, TestGenerateMimeMultipartBoundary) {
   std::string boundary1 = GenerateMimeMultipartBoundary();
   std::string boundary2 = GenerateMimeMultipartBoundary();
 
   // RFC 1341 says: the boundary parameter [...] consists of 1 to 70 characters.
   EXPECT_GE(70u, boundary1.size());
   EXPECT_GE(70u, boundary2.size());
@@ skipping 30 matching lines @@
   std::string post_data;
   AddMultipartValueForUpload("value name", "value", "boundary",
                              "content type", &post_data);
   AddMultipartValueForUpload("value name", "value", "boundary",
                              "", &post_data);
   AddMultipartFinalDelimiterForUpload("boundary", &post_data);
   EXPECT_STREQ(ref_output, post_data.c_str());
 }
 
 }  // namespace net