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

skia/ext/vector_platform_device_linux.cc

 // Copyright (c) 2009 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 "skia/ext/vector_platform_device.h"
 
 #include <cairo.h>
 #include <cairo-ft.h>
 
 #include <ft2build.h>
 #include FT_FREETYPE_H
 
 #include <map>
 
+#include "base/lazy_instance.h"
 #include "base/logging.h"
-#include "base/singleton.h"
 #include "skia/ext/bitmap_platform_device.h"
 #include "third_party/skia/include/core/SkFontHost.h"
 #include "third_party/skia/include/core/SkStream.h"
 #include "third_party/skia/include/core/SkTypeface.h"
 
 namespace {
 
 struct FontInfo {
   SkStream* font_stream;
   FT_Face ft_face;
   cairo_font_face_t* cairo_face;
   cairo_user_data_key_t data_key;
 };
 
 typedef std::map<uint32_t, FontInfo> MapFontId2FontInfo;
+static base::LazyInstance<MapFontId2FontInfo> g_map_font_id_to_font_info(
+    base::LINKER_INITIALIZED);
 
 // Wrapper for FT_Library that handles initialization and cleanup, and allows
 // us to use a singleton.
 class FtLibrary {
  public:
   FtLibrary() : library_(NULL) {
     FT_Error ft_error = FT_Init_FreeType(&library_);
     if (ft_error) {
       DLOG(ERROR) << "Cannot initialize FreeType library for " \
                   << "VectorPlatformDevice.";
     }
   }
 
   ~FtLibrary() {
     if (library_) {
       FT_Error ft_error = FT_Done_FreeType(library_);
       library_ = NULL;
       DCHECK_EQ(ft_error, 0);
     }
   }
 
   FT_Library library() { return library_; }
 
  private:
   FT_Library library_;
 };
+static base::LazyInstance<FtLibrary> g_ft_library(base::LINKER_INITIALIZED);
 
 // Verify cairo surface after creation/modification.
 bool IsContextValid(cairo_t* context) {
   return cairo_status(context) == CAIRO_STATUS_SUCCESS;
 }
 
 }  // namespace
 
 namespace skia {
 
@@ skipping 517 matching lines @@
   m.yx = matrix[SkMatrix::kMSkewY];
   m.yy = matrix[SkMatrix::kMScaleY];
   m.y0 = matrix[SkMatrix::kMTransY];
   cairo_set_matrix(context_, &m);
 }
 
 bool VectorPlatformDevice::SelectFontById(uint32_t font_id) {
   DCHECK(IsContextValid(context_));
   DCHECK(SkFontHost::ValidFontID(font_id));
 
-  FtLibrary* ft_library = Singleton<FtLibrary>::get();
+  FtLibrary* ft_library = g_ft_library.Pointer();
   if (!ft_library->library())
     return false;
 
   // Checks if we have a cache hit.
-  MapFontId2FontInfo* g_font_cache = Singleton<MapFontId2FontInfo>::get();
+  MapFontId2FontInfo* g_font_cache = g_map_font_id_to_font_info.Pointer();
   DCHECK(g_font_cache);
 
   MapFontId2FontInfo::iterator it = g_font_cache->find(font_id);
   if (it != g_font_cache->end()) {
     cairo_set_font_face(context_, it->second.cairo_face);
     if (IsContextValid(context_)) {
       return true;
     } else {
       NOTREACHED() << "Cannot set font face in Cairo!";
       return false;
@@ skipping 49 matching lines @@
   if (IsContextValid(context_)) {
     return true;
   }
 
   DLOG(ERROR) << "Connot set font face in Cairo!";
   return false;
 }
 
 // static
 void VectorPlatformDevice::ClearFontCache() {
-  MapFontId2FontInfo* g_font_cache = Singleton<MapFontId2FontInfo>::get();
+  MapFontId2FontInfo* g_font_cache = g_map_font_id_to_font_info.Pointer();
   DCHECK(g_font_cache);
 
   for (MapFontId2FontInfo::iterator it = g_font_cache->begin();
        it !=g_font_cache->end();
        ++it) {
     DCHECK(it->second.cairo_face);
     DCHECK(it->second.font_stream);
 
     cairo_font_face_destroy(it->second.cairo_face);
     // |it->second.ft_face| is handled by Cairo.
     it->second.font_stream->unref();
   }
   g_font_cache->clear();
 }
 
 }  // namespace skia