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 IsMimeType(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;
 }
 
+// See http://www.iana.org/assignments/media-types/index.html
+static const char* legal_top_level_types[] = {
+  "application/",
+  "audio/",
+  "example/",
+  "image/",
+  "message/",
+  "model/",
+  "multipart/",
+  "text/",
+  "video/",
+};
+
+bool MimeUtil::IsMimeType(const std::string& type_string) const {
+  // 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;
+
+  if (type_string == "*/*" || type_string == "*")
+    return true;
+
+  for (size_t i = 0; i < arraysize(legal_top_level_types); ++i) {
+    if (StartsWithASCII(type_string, legal_top_level_types[i], false) &&
+        type_string.length() > strlen(legal_top_level_types[i])) {
+      return true;
+    }
+  }
+
+  // If there's a "/" separator character, and the token before it is
+  // "x-" + (ascii characters), it is also a MIME type.
+  size_t slash = type_string.find('/');
+  if (slash < 3 ||
+      slash == std::string::npos || slash == type_string.length() - 1) {
+    return false;
+  }
+
+  if (StartsWithASCII(type_string, "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 IsMimeType(const std::string& type_string) {
+  return g_mime_util.Get().IsMimeType(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