Delete unused code in mimeutil.

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 42 matching lines @@
 
   bool GetWellKnownMimeTypeFromExtension(const FilePath::StringType& ext,
                                          std::string* mime_type) const;
 
   bool IsSupportedImageMimeType(const std::string& mime_type) const;
   bool IsSupportedMediaMimeType(const std::string& mime_type) const;
   bool IsSupportedNonImageMimeType(const std::string& mime_type) const;
   bool IsUnsupportedTextMimeType(const std::string& mime_type) const;
   bool IsSupportedJavascriptMimeType(const std::string& mime_type) const;
 
-  bool IsViewSourceMimeType(const std::string& 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;
 
   bool IsMimeType(const std::string& type_string) const;
 
   bool AreSupportedMediaCodecs(const std::vector<std::string>& codecs) const;
 
   void ParseCodecString(const std::string& codecs,
@@ skipping 23 matching lines @@
 
   bool GetMimeTypeFromExtensionHelper(const FilePath::StringType& ext,
                                       bool include_platform_types,
                                       std::string* mime_type) const;
 
   MimeMappings image_map_;
   MimeMappings media_map_;
   MimeMappings non_image_map_;
   MimeMappings unsupported_text_map_;
   MimeMappings javascript_map_;
-  MimeMappings view_source_map_;
   MimeMappings codecs_map_;
 
   StrictMappings strict_format_map_;
 };  // class MimeUtil
 
 // This variable is Leaky because we need to access it from WorkerPool threads.
 static base::LazyInstance<MimeUtil>::Leaky g_mime_util =
     LAZY_INSTANCE_INITIALIZER;
 
 struct MimeInfo {
@@ skipping 280 matching lines @@
   "application/javascript",
   "application/ecmascript",
   "application/x-javascript",
   "text/javascript1.1",
   "text/javascript1.2",
   "text/javascript1.3",
   "text/jscript",
   "text/livescript"
 };
 
-static const char* const view_source_types[] = {
-  "text/xml",
-  "text/xsl",
-  "application/xml",
-  "application/rss+xml",
-  "application/atom+xml",
-  "image/svg+xml"
-};
-
 struct MediaFormatStrict {
   const char* mime_type;
   const char* codecs_list;
 };
 
 static const MediaFormatStrict format_codec_mappings[] = {
   { "video/webm", "vorbis,vp8,vp8.0" },
   { "audio/webm", "vorbis" },
   { "audio/wav", "1" }
 };
@@ skipping 36 matching lines @@
   for (size_t i = 0; i < arraysize(common_media_types); ++i)
     media_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)
     media_map_.insert(proprietary_media_types[i]);
 #endif
 
   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]);
-
   for (size_t i = 0; i < arraysize(common_media_codecs); ++i)
     codecs_map_.insert(common_media_codecs[i]);
 #if defined(GOOGLE_CHROME_BUILD) || defined(USE_PROPRIETARY_CODECS)
   for (size_t i = 0; i < arraysize(proprietary_media_codecs); ++i)
     codecs_map_.insert(proprietary_media_codecs[i]);
 #endif
 
   // Initialize the strict supported media types.
   for (size_t i = 0; i < arraysize(format_codec_mappings); ++i) {
     std::vector<std::string> mime_type_codecs;
@@ skipping 24 matching lines @@
 
 bool MimeUtil::IsUnsupportedTextMimeType(const std::string& mime_type) const {
   return unsupported_text_map_.find(mime_type) != unsupported_text_map_.end();
 }
 
 bool MimeUtil::IsSupportedJavascriptMimeType(
     const std::string& mime_type) const {
   return javascript_map_.find(mime_type) != javascript_map_.end();
 }
 
-bool MimeUtil::IsViewSourceMimeType(const std::string& mime_type) const {
-  return view_source_map_.find(mime_type) != view_source_map_.end();
-}
-
 // Mirrors WebViewImpl::CanShowMIMEType()
 bool MimeUtil::IsSupportedMimeType(const std::string& mime_type) const {
   return (mime_type.compare(0, 6, "image/") == 0 &&
           IsSupportedImageMimeType(mime_type)) ||
          IsSupportedNonImageMimeType(mime_type);
 }
 
 // Tests for MIME parameter equality. Each parameter in the |mime_type_pattern|
 // must be matched by a parameter in the |mime_type|. If there are no
 // parameters in the pattern, the match is a success.
@@ skipping 194 matching lines @@
 }
 
 bool IsUnsupportedTextMimeType(const std::string& mime_type) {
   return g_mime_util.Get().IsUnsupportedTextMimeType(mime_type);
 }
 
 bool IsSupportedJavascriptMimeType(const std::string& mime_type) {
   return g_mime_util.Get().IsSupportedJavascriptMimeType(mime_type);
 }
 
-bool IsViewSourceMimeType(const std::string& mime_type) {
-  return g_mime_util.Get().IsViewSourceMimeType(mime_type);
-}
-
 bool IsSupportedMimeType(const std::string& mime_type) {
   return g_mime_util.Get().IsSupportedMimeType(mime_type);
 }
 
 bool MatchesMimeType(const std::string& mime_type_pattern,
                      const std::string& mime_type) {
   return g_mime_util.Get().MatchesMimeType(mime_type_pattern, mime_type);
 }
 
 bool IsMimeType(const std::string& type_string) {
@@ skipping 242 matching lines @@
   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