Fix certificate and keychain installation on Android.

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 319 matching lines @@
   // behavior - css files will be displayed:
   "text/css",
   "text/vnd.chromium.ftp-dir",
   "text/",
   "image/svg+xml",  // SVG is text-based XML, even though it has an image/ type
   "application/xml",
   "application/atom+xml",
   "application/rss+xml",
   "application/xhtml+xml",
   "application/json",
-  "application/x-x509-user-cert",
   "multipart/related",  // For MHTML support.
   "multipart/x-mixed-replace"
   // Note: ADDING a new type here will probably render it AS HTML. This can
   // result in cross site scripting.
 };
 
+// Dictionary of cryptographic file mime types.
+struct CryptoFileTypeInfo {
+  const char* mime_type;
+  CryptoFileType file_type;
+};
+
+static const CryptoFileTypeInfo  supported_crypto_types[] = {
+    { "application/x-x509-user-cert", CRYPTO_FILE_TYPE_X509_USER_CERT },
+#if defined(OS_ANDROID)
+    { "application/x-x509-ca-cert",   CRYPTO_FILE_TYPE_X509_CA_CERT },

[Ryan Sleevi, 2012/10/24 22:01:25]

Does Android not also need to handle application/x-x509-root-cert?

From the perspective of Keychain's Intents, ca- and root- should be the same
(that is, they install trusted certs). For other OSes, ca-cert installs
intermediates, *but they are not automagically trusted* (although transitively,
they do chain to a trusted root). Consider them "supplementary" certs.

[digit1, 2012/10/25 13:57:38]

I've asked the Android folks responsible for this.

+    { "application/x-pkcs12",         CRYPTO_FILE_TYPE_PKCS12_KEYCHAIN },
+#endif
+};
+
 // These types are excluded from the logic that allows all text/ types because
 // while they are technically text, it's very unlikely that a user expects to
 // see them rendered in text form.
 static const char* const unsupported_text_types[] = {
   "text/calendar",
   "text/x-calendar",
   "text/x-vcalendar",
   "text/vcalendar",
   "text/vcard",
   "text/x-vcard",
@@ skipping 67 matching lines @@
   return !codecs.empty();
 }
 
 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.
   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_crypto_types); ++i)
+    non_image_map_.insert(supported_crypto_types[i].mime_type);
   for (size_t i = 0; i < arraysize(unsupported_text_types); ++i)
     unsupported_text_map_.insert(unsupported_text_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(common_media_types); ++i)
     non_image_map_.insert(common_media_types[i]);
 #if defined(GOOGLE_CHROME_BUILD) || defined(USE_PROPRIETARY_CODECS)
   for (size_t i = 0; i < arraysize(proprietary_media_types); ++i)
     non_image_map_.insert(proprietary_media_types[i]);
 #endif
@@ skipping 98 matching lines @@
     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[] = {
+static const char* const legal_top_level_types[] = {

[Ryan Sleevi, 2012/10/24 22:01:25]

unrelated change? (but good change none the less, just not for this CL)

[digit1, 2012/10/25 13:57:38]

Sure, I've moved this to https://codereview.chromium.org/11263039/

   "application/",
   "audio/",
   "example/",
   "image/",
   "message/",
   "model/",
   "multipart/",
   "text/",
   "video/",
 };
@@ skipping 144 matching lines @@
 void ParseCodecString(const std::string& codecs,
                       std::vector<std::string>* codecs_out,
                       const bool strip) {
   g_mime_util.Get().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[] = {
+static const char* const kStandardImageTypes[] = {
   "image/bmp",
   "image/cis-cod",
   "image/gif",
   "image/ief",
   "image/jpeg",
   "image/webp",
   "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[] = {
+static const char* const 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[] = {
+static const char* const 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"
 };
 
 struct StandardType {
   const char* leading_mime_type;
-  const char** standard_types;
+  const char* const* standard_types;
   size_t standard_types_len;
 };
 static const StandardType kStandardTypes[] = {
   { "image/", kStandardImageTypes, arraysize(kStandardImageTypes) },
   { "audio/", kStandardAudioTypes, arraysize(kStandardAudioTypes) },
   { "video/", kStandardVideoTypes, arraysize(kStandardVideoTypes) },
   { NULL, NULL, 0 }
 };
 
 void GetExtensionsFromHardCodedMappings(
@@ skipping 12 matching lines @@
         FilePath::StringType extension(UTF8ToWide(this_extensions[j]));
 #else
         FilePath::StringType extension(this_extensions[j]);
 #endif
         extensions->insert(extension);
       }
     }
   }
 }
 
-void GetExtensionsHelper(const char** standard_types,
+void GetExtensionsHelper(const char* const* standard_types,
                          size_t standard_types_len,
                          const std::string& leading_mime_type,
                          base::hash_set<FilePath::StringType>* extensions) {
   for (size_t i = 0; i < standard_types_len; ++i) {
     g_mime_util.Get().GetPlatformExtensionsForMimeType(standard_types[i],
                                                        extensions);
   }
 
   // Also look up the extensions from hard-coded mappings in case that some
   // supported extensions are not registered in the system registry, like ogg.
@@ skipping 92 matching lines @@
 
 const std::string GetIANAMediaType(const std::string& mime_type) {
   for (size_t i = 0; i < arraysize(kIanaMediaTypes); ++i) {
     if (StartsWithASCII(mime_type, kIanaMediaTypes[i].matcher, true)) {
       return kIanaMediaTypes[i].name;
     }
   }
   return "";
 }
 
+CryptoFileType GetCryptoFileTypeForMimeType(
+    const std::string& mime_type) {
+  // Don't create a map, there is only one entry in the table,
+  // except on Android.
+  for (size_t i = 0; i < arraysize(supported_crypto_types); ++i) {
+      if (mime_type == net::supported_crypto_types[i].mime_type)
+          return net::supported_crypto_types[i].file_type;
+  }
+  return CRYPTO_FILE_TYPE_UNKNOWN;
+}
+
+bool IsSupportedCryptoMimeType(const std::string& mime_type) {
+  CryptoFileType file_type = GetCryptoFileTypeForMimeType(mime_type);
+  return file_type != CRYPTO_FILE_TYPE_UNKNOWN;
+}
+
 }  // namespace net