Support accept attribute for an <input type=file> element.

BUG=54009
TEST=none

Review URL: http://codereview.chromium.org/3311016

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@58868 0039d316-1c4b-4281-b951-d872f2087c98

2 files changed, 199 insertions, 0 deletions

diff --git a/net/base/mime_util.cc b/net/base/mime_util.cc
index 5863b68..629270a 100644
--- a/net/base/mime_util.cc
+++ b/net/base/mime_util.cc
@@ -11,6 +11,7 @@
 #include "base/hash_tables.h"
 #include "base/logging.h"
 #include "base/singleton.h"
+#include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 
@@ -531,4 +532,179 @@ void ParseCodecString(const std::string& codecs,
   GetMimeUtil()->ParseCodecString(codecs, codecs_out, strip);
 }
 
+namespace {
+
+// From http://www.w3schools.com/media/media_mimeref.asp and
+// http://plugindoc.mozdev.org/winmime.php
+static const char* kStandardImageTypes[] = {
+  "image/bmp",
+  "image/cis-cod",
+  "image/gif",
+  "image/ief",
+  "image/jpeg",
+  "image/pict",
+  "image/pipeg",
+  "image/png",
+  "image/svg+xml",
+  "image/tiff",
+  "image/x-cmu-raster",
+  "image/x-cmx",
+  "image/x-icon",
+  "image/x-portable-anymap",
+  "image/x-portable-bitmap",
+  "image/x-portable-graymap",
+  "image/x-portable-pixmap",
+  "image/x-rgb",
+  "image/x-xbitmap",
+  "image/x-xpixmap",
+  "image/x-xwindowdump"
+};
+static const char* kStandardAudioTypes[] = {
+  "audio/aac",
+  "audio/aiff",
+  "audio/amr",
+  "audio/basic",
+  "audio/midi",
+  "audio/mp3",
+  "audio/mp4",
+  "audio/mpeg",
+  "audio/mpeg3",
+  "audio/ogg",
+  "audio/vorbis",
+  "audio/wav",
+  "audio/webm",
+  "audio/x-m4a",
+  "audio/x-ms-wma",
+  "audio/vnd.rn-realaudio",
+  "audio/vnd.wave"
+};
+static const char* kStandardVideoTypes[] = {
+  "video/avi",
+  "video/divx",
+  "video/flc",
+  "video/mp4",
+  "video/mpeg",
+  "video/ogg",
+  "video/quicktime",
+  "video/sd-video",
+  "video/webm",
+  "video/x-dv",
+  "video/x-m4v",
+  "video/x-mpeg",
+  "video/x-ms-asf",
+  "video/x-ms-wmv"
+};
+
+void GetExtensionsFromHardCodedMappings(
+    const MimeInfo* mappings,
+    size_t mappings_len,
+    const std::string& leading_mime_type,
+    base::hash_set<FilePath::StringType>* extensions) {
+  FilePath::StringType extension;
+  for (size_t i = 0; i < mappings_len; ++i) {
+    if (StartsWithASCII(mappings[i].mime_type, leading_mime_type, false)) {
+      std::vector<string> this_extensions;
+      base::SplitStringUsingSubstr(mappings[i].extensions,
+                                   ",",
+                                   &this_extensions);
+      for (size_t j = 0; j < this_extensions.size(); ++j) {
+#if defined(OS_WIN)
+        FilePath::StringType extension(UTF8ToWide(this_extensions[j]));
+#else
+        FilePath::StringType extension(this_extensions[j]);
+#endif
+        extensions->insert(extension);
+      }
+    }
+  }
+}
+
+void GetExtensionsHelper(
+    const char** standard_types,
+    size_t standard_types_len,
+    const std::string& leading_mime_type,
+    base::hash_set<FilePath::StringType>* extensions) {
+  FilePath::StringType extension;
+  for (size_t i = 0; i < standard_types_len; ++i) {
+    if (net::GetPreferredExtensionForMimeType(standard_types[i], &extension))
+      extensions->insert(extension);
+  }
+
+  // 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(primary_mappings,
+                                     arraysize(primary_mappings),
+                                     leading_mime_type,
+                                     extensions);
+
+  GetExtensionsFromHardCodedMappings(secondary_mappings,
+                                     arraysize(secondary_mappings),
+                                     leading_mime_type,
+                                     extensions);
+}
+
+// Note that the elements in the source set will be appended to the target
+// vector.
+template<class T>
+void HashSetToVector(base::hash_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;
+  for (typename base::hash_set<T>::iterator iter = source->begin();
+       iter != source->end(); ++iter, ++i) {
+    target->at(old_target_size + i) = *iter;
+  }
+}
+
+}
+
+void GetImageExtensions(std::vector<FilePath::StringType>* extensions) {
+  base::hash_set<FilePath::StringType> unique_extensions;
+  GetExtensionsHelper(kStandardImageTypes,
+                      arraysize(kStandardImageTypes),
+                      "image/",
+                      &unique_extensions);
+  HashSetToVector(&unique_extensions, extensions);
+}
+
+void GetAudioExtensions(std::vector<FilePath::StringType>* extensions) {
+  base::hash_set<FilePath::StringType> unique_extensions;
+  GetExtensionsHelper(kStandardAudioTypes,
+                      arraysize(kStandardAudioTypes),
+                      "audio/",
+                      &unique_extensions);
+  HashSetToVector(&unique_extensions, extensions);
+}
+
+void GetVideoExtensions(std::vector<FilePath::StringType>* extensions) {
+  base::hash_set<FilePath::StringType> unique_extensions;
+  GetExtensionsHelper(kStandardVideoTypes,
+                      arraysize(kStandardVideoTypes),
+                      "video/",
+                      &unique_extensions);
+  HashSetToVector(&unique_extensions, extensions);
+}
+
+void GetExtensionsForMimeType(const std::string& mime_type,
+                              std::vector<FilePath::StringType>* extensions) {
+  base::hash_set<FilePath::StringType> unique_extensions;
+  FilePath::StringType extension;
+  if (net::GetPreferredExtensionForMimeType(mime_type, &extension))
+    unique_extensions.insert(extension);
+
+  // 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(primary_mappings,
+                                     arraysize(primary_mappings),
+                                     mime_type,
+                                     &unique_extensions);
+
+  GetExtensionsFromHardCodedMappings(secondary_mappings,
+                                     arraysize(secondary_mappings),
+                                     mime_type,
+                                     &unique_extensions);
+
+  HashSetToVector(&unique_extensions, extensions);
+}
+
 }  // namespace net
diff --git a/net/base/mime_util.h b/net/base/mime_util.h
index fbbe478..249a25b 100644
--- a/net/base/mime_util.h
+++ b/net/base/mime_util.h
@@ -71,6 +71,29 @@ bool IsStrictMediaMimeType(const std::string& mime_type);
 bool IsSupportedStrictMediaMimeType(const std::string& mime_type,
     const std::vector<std::string>& codecs);
 
+// Get the extensions for images files.
+// Note that we do not erase the existing elements in the the provided vector.
+// Instead, we append the result to it.
+void GetImageExtensions(std::vector<FilePath::StringType>* extensions);
+
+// Get the extensions for audio files.
+// Note that we do not erase the existing elements in the the provided vector.
+// Instead, we append the result to it.
+void GetAudioExtensions(std::vector<FilePath::StringType>* extensions);
+
+// Get the extensions for video files.
+// Note that we do not erase the existing elements in the the provided vector.
+// Instead, we append the result to it.
+void GetVideoExtensions(std::vector<FilePath::StringType>* extensions);
+
+// Get the extensions associated with the given mime type.
+// There could be multiple extensions for a given mime type, like "html,htm"
+// for "text/html".
+// Note that we do not erase the existing elements in the the provided vector.
+// Instead, we append the result to it.
+void GetExtensionsForMimeType(const std::string& mime_type,
+                              std::vector<FilePath::StringType>* extensions);
+
 }  // namespace net
 
 #endif  // NET_BASE_MIME_UTIL_H__