Make members of Singleton<T> private and only visible to the singleton type.

net/base/mime_util.cc

 // Copyright (c) 2010 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"
 
 #include "base/hash_tables.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/singleton.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/utf_string_conversions.h"
 
 using std::string;
 
 namespace net {
 
 // Singleton utility class for mime types.
 class MimeUtil : public PlatformMimeUtil {
@@ skipping 20 matching lines @@
 
   void ParseCodecString(const std::string& codecs,
                         std::vector<std::string>* codecs_out,
                         bool strip);
 
   bool IsStrictMediaMimeType(const std::string& mime_type) const;
   bool IsSupportedStrictMediaMimeType(const std::string& mime_type,
       const std::vector<std::string>& codecs) const;
 
  private:
-  friend struct DefaultSingletonTraits<MimeUtil>;
+  friend struct base::DefaultLazyInstanceTraits<MimeUtil>;
   MimeUtil() {
     InitializeMimeTypeMaps();
   }
 
   // For faster lookup, keep hash sets.
   void InitializeMimeTypeMaps();
 
   typedef base::hash_set<std::string> MimeMappings;
   MimeMappings image_map_;
   MimeMappings media_map_;
   MimeMappings non_image_map_;
   MimeMappings javascript_map_;
   MimeMappings view_source_map_;
   MimeMappings codecs_map_;
 
   typedef std::map<std::string, base::hash_set<std::string> > StrictMappings;
   StrictMappings strict_format_map_;
 };  // class MimeUtil
 
+static base::LazyInstance<MimeUtil> g_mime_util(base::LINKER_INITIALIZED);
+
 struct MimeInfo {
   const char* mime_type;
   const char* extensions;  // comma separated list
 };
 
 static const MimeInfo primary_mappings[] = {
   { "text/html", "html,htm" },
   { "text/css", "css" },
   { "text/xml", "xml" },
   { "image/gif", "gif" },
@@ skipping 382 matching lines @@
       return false;
     }
   }
   return true;
 }
 
 //----------------------------------------------------------------------------
 // Wrappers for the singleton
 //----------------------------------------------------------------------------
 
-static MimeUtil* GetMimeUtil() {
-  return Singleton<MimeUtil>::get();
-}
-
 bool GetMimeTypeFromExtension(const FilePath::StringType& ext,
                               std::string* mime_type) {
-  return GetMimeUtil()->GetMimeTypeFromExtension(ext, mime_type);
+  return g_mime_util.Get().GetMimeTypeFromExtension(ext, mime_type);
 }
 
 bool GetMimeTypeFromFile(const FilePath& file_path, std::string* mime_type) {
-  return GetMimeUtil()->GetMimeTypeFromFile(file_path, mime_type);
+  return g_mime_util.Get().GetMimeTypeFromFile(file_path, mime_type);
 }
 
 bool GetPreferredExtensionForMimeType(const std::string& mime_type,
                                       FilePath::StringType* extension) {
-  return GetMimeUtil()->GetPreferredExtensionForMimeType(mime_type, extension);
+  return g_mime_util.Get().GetPreferredExtensionForMimeType(mime_type,
+                                                            extension);
 }
 
 bool IsSupportedImageMimeType(const char* mime_type) {
-  return GetMimeUtil()->IsSupportedImageMimeType(mime_type);
+  return g_mime_util.Get().IsSupportedImageMimeType(mime_type);
 }
 
 bool IsSupportedMediaMimeType(const char* mime_type) {
-  return GetMimeUtil()->IsSupportedMediaMimeType(mime_type);
+  return g_mime_util.Get().IsSupportedMediaMimeType(mime_type);
 }
 
 bool IsSupportedNonImageMimeType(const char* mime_type) {
-  return GetMimeUtil()->IsSupportedNonImageMimeType(mime_type);
+  return g_mime_util.Get().IsSupportedNonImageMimeType(mime_type);
 }
 
 bool IsSupportedJavascriptMimeType(const char* mime_type) {
-  return GetMimeUtil()->IsSupportedJavascriptMimeType(mime_type);
+  return g_mime_util.Get().IsSupportedJavascriptMimeType(mime_type);
 }
 
 bool IsViewSourceMimeType(const char* mime_type) {
-  return GetMimeUtil()->IsViewSourceMimeType(mime_type);
+  return g_mime_util.Get().IsViewSourceMimeType(mime_type);
 }
 
 bool IsSupportedMimeType(const std::string& mime_type) {
-  return GetMimeUtil()->IsSupportedMimeType(mime_type);
+  return g_mime_util.Get().IsSupportedMimeType(mime_type);
 }
 
 bool MatchesMimeType(const std::string &mime_type_pattern,
                      const std::string &mime_type) {
-  return GetMimeUtil()->MatchesMimeType(mime_type_pattern, mime_type);
+  return g_mime_util.Get().MatchesMimeType(mime_type_pattern, mime_type);
 }
 
 bool AreSupportedMediaCodecs(const std::vector<std::string>& codecs) {
-  return GetMimeUtil()->AreSupportedMediaCodecs(codecs);
+  return g_mime_util.Get().AreSupportedMediaCodecs(codecs);
 }
 
 bool IsStrictMediaMimeType(const std::string& mime_type) {
-  return GetMimeUtil()->IsStrictMediaMimeType(mime_type);
+  return g_mime_util.Get().IsStrictMediaMimeType(mime_type);
 }
 
 bool IsSupportedStrictMediaMimeType(const std::string& mime_type,
                                     const std::vector<std::string>& codecs) {
-  return GetMimeUtil()->IsSupportedStrictMediaMimeType(mime_type, codecs);
+  return g_mime_util.Get().IsSupportedStrictMediaMimeType(mime_type, codecs);
 }
 
 void ParseCodecString(const std::string& codecs,
                       std::vector<std::string>* codecs_out,
                       const bool strip) {
-  GetMimeUtil()->ParseCodecString(codecs, codecs_out, 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[] = {
   "image/bmp",
   "image/cis-cod",
   "image/gif",
@@ skipping 158 matching lines @@
 
   GetExtensionsFromHardCodedMappings(secondary_mappings,
                                      arraysize(secondary_mappings),
                                      mime_type,
                                      &unique_extensions);
 
   HashSetToVector(&unique_extensions, extensions);
 }
 
 }  // namespace net