Move function for classifying a string as a mime type into MimeUtil

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 <map>
 #include <string>
 
 #include "net/base/mime_util.h"
 #include "net/base/platform_mime_util.h"
 
@@ skipping 25 matching lines @@
   bool IsSupportedNonImageMimeType(const std::string& mime_type) const;
   bool IsSupportedJavascriptMimeType(const std::string& mime_type) const;
 
   bool IsViewSourceMimeType(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 IsStringMimeType(const std::string& type_string) const;
+
   bool AreSupportedMediaCodecs(const std::vector<std::string>& codecs) const;
 
   void ParseCodecString(const std::string& codecs,
                         std::vector<std::string>* codecs_out,
                         bool strip);
 
   bool IsStrictMediaMimeType(const std::string& mime_type) const;
   bool IsSupportedStrictMediaMimeType(
       const std::string& mime_type,
       const std::vector<std::string>& codecs) const;
@@ skipping 423 matching lines @@
   if (mime_type.find(left) != 0)
     return false;
 
   if (!right.empty() &&
       mime_type.rfind(right) != mime_type.length() - right.length())
     return false;
 
   return true;
 }
 
+bool MimeUtil::IsStringMimeType(const std::string& type_string) const {

[rvargas (doing something else), 2012/06/01 01:51:14]

Shouldn't this build upon IsSupportedMimeType instead?

[Greg Billock, 2012/06/01 04:58:22]

How so? I think this function would basically have to do the same checks anyway,
since IsSupportedMimeTypes is about a whitelist, whereas this is checking
syntactically whether a string is a valid mime type specifier.

[rvargas (doing something else), 2012/06/01 19:11:25]

You're right, the "supported" part makes all the difference :)

+  // MIME types are always ASCII and case-insensitive (at least, the top-level
+  // and secondary types we care about).
+  if (!IsStringASCII(type_string))
+    return false;
+  std::string raw_type = type_string;
+  StringToLowerASCII(&raw_type);

[rvargas (doing something else), 2012/06/01 19:11:25]

either this is not needed, or the comparisons should be case sensitive.

[Greg Billock, 2012/06/05 01:08:56]

Done.

+
+  // See http://www.iana.org/assignments/media-types/index.html
+  if (StartsWithASCII(raw_type, "application/", false) ||

[rvargas (doing something else), 2012/06/01 19:11:25]

Then let's follow the pattern of this class and make this into a static array.

[Greg Billock, 2012/06/05 01:08:56]

Done.

+      StartsWithASCII(raw_type, "audio/", false) ||
+      StartsWithASCII(raw_type, "example/", false) ||
+      StartsWithASCII(raw_type, "image/", false) ||
+      StartsWithASCII(raw_type, "message/", false) ||
+      StartsWithASCII(raw_type, "model/", false) ||
+      StartsWithASCII(raw_type, "multipart/", false) ||
+      StartsWithASCII(raw_type, "text/", false) ||
+      StartsWithASCII(raw_type, "video/", false) ||
+      raw_type == "*/*" || raw_type == "*") {
+    return true;
+  }
+
+  // If there's a "/" separator character, and the token before it is

[rvargas (doing something else), 2012/06/01 01:51:14]

If we have no code to cover this case maybe we can add something specifically
for it. Enumerating mime types again doesn't make much sense.

+  // "x-" + (ascii characters), it is also a MIME type.
+  size_t slash = raw_type.find('/');
+  if (slash < 3 || slash == std::string::npos || slash == raw_type.length() - 1)
+    return false;
+
+  if (StartsWithASCII(raw_type, "x-", false))
+    return true;
+
+  return false;
+}
+
 bool MimeUtil::AreSupportedMediaCodecs(
     const std::vector<std::string>& codecs) const {
   return AreSupportedCodecs(codecs_map_, codecs);
 }
 
 void MimeUtil::ParseCodecString(const std::string& codecs,
                                 std::vector<std::string>* codecs_out,
                                 bool strip) {
   std::string no_quote_codecs;
   TrimString(codecs, "\"", &no_quote_codecs);
@@ skipping 72 matching lines @@
 
 bool IsSupportedMimeType(const std::string& mime_type) {
   return g_mime_util.Get().IsSupportedMimeType(mime_type);
 }
 
 bool MatchesMimeType(const std::string& mime_type_pattern,
                      const std::string& mime_type) {
   return g_mime_util.Get().MatchesMimeType(mime_type_pattern, mime_type);
 }
 
+bool IsStringMimeType(const std::string& type_string) {
+  return g_mime_util.Get().IsStringMimeType(type_string);
+}
+
 bool AreSupportedMediaCodecs(const std::vector<std::string>& codecs) {
   return g_mime_util.Get().AreSupportedMediaCodecs(codecs);
 }
 
 bool IsStrictMediaMimeType(const std::string& mime_type) {
   return g_mime_util.Get().IsStrictMediaMimeType(mime_type);
 }
 
 bool IsSupportedStrictMediaMimeType(const std::string& mime_type,
                                     const std::vector<std::string>& codecs) {
@@ skipping 188 matching lines @@
 // Unless/until WebM files are added to the media layout tests, we need to avoid
 // blacklisting mp4 and H.264 when Theora is not supported (and proprietary
 // codecs are) so that the media tests can still run.
 #if defined(ENABLE_MEDIA_CODEC_THEORA) || !defined(USE_PROPRIETARY_CODECS)
   for (size_t i = 0; i < arraysize(proprietary_media_codecs); ++i)
     codecs->push_back(proprietary_media_codecs[i]);
 #endif
 }
 
 }  // namespace net