Apply a few missing const qualifiers in net/

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 696 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 93 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 "";
 }
 
 }  // namespace net