Handle mimetype queries for media files...

net/base/mime_util.cc

-// Copyright (c) 2006-2008 The Chromium Authors. All rights reserved.
+// Copyright (c) 2006-2009 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 <string>
 
 #include "net/base/mime_util.h"
 #include "net/base/platform_mime_util.h"
 
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "base/singleton.h"
 #include "base/string_util.h"
 
 using std::string;
 
 namespace net {
 
 // Singleton utility class for mime types.
 class MimeUtil : public PlatformMimeUtil {
  public:
   bool GetMimeTypeFromExtension(const FilePath::StringType& ext,
                                 std::string* mime_type) const;
 
   bool GetMimeTypeFromFile(const FilePath& file_path,
                            std::string* mime_type) const;
 
   bool IsSupportedImageMimeType(const char* mime_type) const;
+  bool IsSupportedMediaMimeType(const char* mime_type) const;
   bool IsSupportedNonImageMimeType(const char* mime_type) const;
   bool IsSupportedJavascriptMimeType(const char* mime_type) const;
 
   bool IsViewSourceMimeType(const char* 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;
 
 private:
   friend struct DefaultSingletonTraits<MimeUtil>;
   MimeUtil() {
     InitializeMimeTypeMaps();
   }
 
   // For faster lookup, keep hash sets.
   void InitializeMimeTypeMaps();
 
   typedef base::hash_set<std::string> MimeMappings;
   MimeMappings image_map_;
+  MimeMappings media_map_;
   MimeMappings non_image_map_;
   MimeMappings javascript_map_;
   MimeMappings view_source_map_;
 }; // class MimeUtil
 
 struct MimeInfo {
   const char* mime_type;
   const char* extensions;  // comma separated list
 };
 
@@ skipping 99 matching lines @@
   "image/jpeg",
   "image/pjpeg",
   "image/jpg",
   "image/png",
   "image/gif",
   "image/bmp",
   "image/x-icon",    // ico
   "image/x-xbitmap"  // xbm
 };
 
+// TODO(hclam): Integrate this list with |secondary_mappings| above.
+static const char* const supported_media_types[] = {
+  // Ogg.
+  "audio/ogg",
+  "video/ogg",
+
+  // MPEG-4.
+  "application/mp4",
+  "audio/mp4",
+  "audio/x-m4a",
+  "video/mp4",
+  "video/x-m4v",
+
+  // MP3.
+  // TODO(hclam): may add "audio/mpeg" and "audio/x-mp3".
+  "audio/mp3",
+
+  // AAC.
+  "audio/aac",
+  "audio/x-aac"
+};
+
 // Note: does not include javascript types list (see supported_javascript_types)
 static const char* const supported_non_image_types[] = {
   "text/html",
   "text/xml",
   "text/xsl",
   "text/plain",
   "text/",
   "image/svg+xml", // SVG is text-based XML, even though it has an image/ type
   "application/xml",
   "application/xhtml+xml",
@@ skipping 31 matching lines @@
   "application/xml",
   "application/rss+xml",
   "application/atom+xml",
   "image/svg+xml"
 };
 
 void MimeUtil::InitializeMimeTypeMaps() {
   for (size_t i = 0; i < arraysize(supported_image_types); ++i)
     image_map_.insert(supported_image_types[i]);
 
-  // Initialize the supported non-image types
+  // Initialize the supported non-image types.
   for (size_t i = 0; i < arraysize(supported_non_image_types); ++i)
     non_image_map_.insert(supported_non_image_types[i]);
   for (size_t i = 0; i < arraysize(supported_javascript_types); ++i)
     non_image_map_.insert(supported_javascript_types[i]);
+  for (size_t i = 0; i < arraysize(supported_media_types); ++i)
+    non_image_map_.insert(supported_media_types[i]);
+
+  // Initialize the supported media types.
+  for (size_t i = 0; i < arraysize(supported_media_types); ++i)
+    media_map_.insert(supported_media_types[i]);
 
   for (size_t i = 0; i < arraysize(supported_javascript_types); ++i)
     javascript_map_.insert(supported_javascript_types[i]);
 
   for (size_t i = 0; i < arraysize(view_source_types); ++i)
     view_source_map_.insert(view_source_types[i]);
 }
 
 bool MimeUtil::IsSupportedImageMimeType(const char* mime_type) const {
   return image_map_.find(mime_type) != image_map_.end();
 }
 
+bool MimeUtil::IsSupportedMediaMimeType(const char* mime_type) const {
+  return media_map_.find(mime_type) != media_map_.end();
+}
+
 bool MimeUtil::IsSupportedNonImageMimeType(const char* mime_type) const {
   return non_image_map_.find(mime_type) != non_image_map_.end();
 }
 
 bool MimeUtil::IsSupportedJavascriptMimeType(const char* mime_type) const {
   return javascript_map_.find(mime_type) != javascript_map_.end();
 }
 
 bool MimeUtil::IsViewSourceMimeType(const char* mime_type) const {
   return view_source_map_.find(mime_type) != view_source_map_.end();
@@ skipping 62 matching lines @@
 
 bool GetPreferredExtensionForMimeType(const std::string& mime_type,
                                       FilePath::StringType* extension) {
   return GetMimeUtil()->GetPreferredExtensionForMimeType(mime_type, extension);
 }
 
 bool IsSupportedImageMimeType(const char* mime_type) {
   return GetMimeUtil()->IsSupportedImageMimeType(mime_type);
 }
 
+bool IsSupportedMediaMimeType(const char* mime_type) {
+  return GetMimeUtil()->IsSupportedMediaMimeType(mime_type);
+}
+
 bool IsSupportedNonImageMimeType(const char* mime_type) {
   return GetMimeUtil()->IsSupportedNonImageMimeType(mime_type);
 }
 
 bool IsSupportedJavascriptMimeType(const char* mime_type) {
   return GetMimeUtil()->IsSupportedJavascriptMimeType(mime_type);
 }
 
 bool IsViewSourceMimeType(const char* mime_type) {
   return GetMimeUtil()->IsViewSourceMimeType(mime_type);
 }
 
 bool IsSupportedMimeType(const std::string& mime_type) {
   return GetMimeUtil()->IsSupportedMimeType(mime_type);
 }
 
 bool MatchesMimeType(const std::string &mime_type_pattern,
                      const std::string &mime_type) {
   return GetMimeUtil()->MatchesMimeType(mime_type_pattern, mime_type);
 }
 
 }  // namespace net