Removing x-x509-user-cert mime handler.

components/mime_util/mime_util.cc

 // Copyright 2015 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 "components/mime_util/mime_util.h"
 
 #include "base/containers/hash_tables.h"
 #include "base/lazy_instance.h"
 #include "base/strings/string_util.h"
 #include "build/build_config.h"
 
 #if !defined(OS_IOS)
 // iOS doesn't use and must not depend on //media
 #include "media/base/mime_util.h"
 #endif
 
 namespace mime_util {
 
 namespace {
 
 // Dictionary of cryptographic file mime types.
 struct CertificateMimeTypeInfo {
   const char* const mime_type;
   net::CertificateMimeType cert_type;
 };
 
+#if defined(OS_ANDROID)
 const CertificateMimeTypeInfo kSupportedCertificateTypes[] = {
     {"application/x-x509-user-cert", net::CERTIFICATE_MIME_TYPE_X509_USER_CERT},
-#if defined(OS_ANDROID)
     {"application/x-x509-ca-cert", net::CERTIFICATE_MIME_TYPE_X509_CA_CERT},
     {"application/x-pkcs12", net::CERTIFICATE_MIME_TYPE_PKCS12_ARCHIVE},
+};
 #endif
-};
 
 // From WebKit's WebCore/platform/MIMETypeRegistry.cpp:
 
 const char* const kSupportedImageTypes[] = {"image/jpeg",
                                             "image/pjpeg",
                                             "image/jpg",
                                             "image/webp",
                                             "image/png",
                                             "image/gif",
                                             "image/bmp",
@@ skipping 95 matching lines @@
   for (size_t i = 0; i < arraysize(kSupportedNonImageTypes); ++i)
     non_image_types_.insert(kSupportedNonImageTypes[i]);
   for (size_t i = 0; i < arraysize(kSupportedImageTypes); ++i)
     image_types_.insert(kSupportedImageTypes[i]);
   for (size_t i = 0; i < arraysize(kUnsupportedTextTypes); ++i)
     unsupported_text_types_.insert(kUnsupportedTextTypes[i]);
   for (size_t i = 0; i < arraysize(kSupportedJavascriptTypes); ++i) {
     javascript_types_.insert(kSupportedJavascriptTypes[i]);
     non_image_types_.insert(kSupportedJavascriptTypes[i]);
   }
+#if defined(OS_ANDROID)
   for (size_t i = 0; i < arraysize(kSupportedCertificateTypes); ++i)
     non_image_types_.insert(kSupportedCertificateTypes[i].mime_type);
+#endif
 }
 
 bool MimeUtil::IsSupportedImageMimeType(const std::string& mime_type) const {
   return image_types_.find(base::ToLowerASCII(mime_type)) != image_types_.end();
 }
 
 bool MimeUtil::IsSupportedNonImageMimeType(const std::string& mime_type) const {
   return non_image_types_.find(base::ToLowerASCII(mime_type)) !=
              non_image_types_.end() ||
 #if !defined(OS_IOS)
@@ skipping 51 matching lines @@
       GetCertificateMimeTypeForMimeType(mime_type);
   return file_type != net::CERTIFICATE_MIME_TYPE_UNKNOWN;
 }
 
 bool IsSupportedMimeType(const std::string& mime_type) {
   return g_mime_util.Get().IsSupportedMimeType(mime_type);
 }
 
 net::CertificateMimeType GetCertificateMimeTypeForMimeType(
     const std::string& mime_type) {
+#if defined(OS_ANDROID)
   // Don't create a map, there is only one entry in the table,
   // except on Android.
   for (size_t i = 0; i < arraysize(kSupportedCertificateTypes); ++i) {
     if (base::EqualsCaseInsensitiveASCII(
             mime_type, kSupportedCertificateTypes[i].mime_type)) {
       return kSupportedCertificateTypes[i].cert_type;
     }
   }
+#endif
 
   return net::CERTIFICATE_MIME_TYPE_UNKNOWN;
 }
 
 }  // namespace mime_util