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 <algorithm>
 #include <iterator>
 #include <map>
 #include <string>
 
 #include "net/base/mime_util.h"
@@ skipping 321 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 CertificateMimeTypeInfo {
+  const char* mime_type;
+  CertificateMimeType cert_type;
+};
+
+static const CertificateMimeTypeInfo supported_certificate_types[] = {
+    { "application/x-x509-user-cert",

[darin (slow to review), 2012/11/27 05:24:34]

nit: indentation is wrong

[digit1, 2012/11/27 10:19:48]

I treated this a a line-continuation indent. Do you mean you prefer something
like:

  { "application/x-x509-user-cert",
    CERTIFICATE_MIME_TYPE_X509_USER_CERT },

The coding style isn't very  specific about this.

[darin (slow to review), 2012/11/27 21:27:53]

It's an array, much like supported_non_image_types above, so the opening bracket
should be indented by two spaces.

[digit1, 2012/11/27 22:33:04]

Oh snap. Of course, I wasn't looking at the right indentation. Sorry about that.
Done

+        CERTIFICATE_MIME_TYPE_X509_USER_CERT },
+#if defined(OS_ANDROID)
+    { "application/x-x509-ca-cert", CERTIFICATE_MIME_TYPE_X509_CA_CERT },
+    { "application/x-pkcs12",
+        CERTIFICATE_MIME_TYPE_PKCS12_ARCHIVE },
+#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_certificate_types); ++i)
+    non_image_map_.insert(supported_certificate_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 515 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 "";
 }
 
+CertificateMimeType GetCertificateMimeTypeForMimeType(
+    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_certificate_types); ++i) {
+    if (mime_type == net::supported_certificate_types[i].mime_type)
+      return net::supported_certificate_types[i].cert_type;
+  }
+  return CERTIFICATE_MIME_TYPE_UNKNOWN;
+}
+
+bool IsSupportedCertificateMimeType(const std::string& mime_type) {
+  CertificateMimeType file_type =
+      GetCertificateMimeTypeForMimeType(mime_type);
+  return file_type != CERTIFICATE_MIME_TYPE_UNKNOWN;
+}
+
 }  // namespace net