Access singletons with a new GetInstance() method instead of Singleton<T>.

base/mime_util_xdg.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 "base/mime_util.h"
 
 #include <gtk/gtk.h>
 #include <sys/time.h>
 #include <time.h>
 
@@ skipping 10 matching lines @@
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/third_party/xdg_mime/xdgmime.h"
 
 namespace {
 
 class IconTheme;
 
 class MimeUtilConstants {
  public:
+  static MimeUtilConstants* GetInstance() {
+    return Singleton<MimeUtilConstants>::get();
+  }
 
   // In seconds, specified by icon theme specs.
   const int kUpdateInterval;
 
   // Store icon directories and their mtimes.
   std::map<FilePath, int>* icon_dirs_;
 
   // Store icon formats.
   std::vector<std::string> icon_formats_;
 
@@ skipping 109 matching lines @@
 };
 
 IconTheme::IconTheme(const std::string& name)
   : index_theme_loaded_(false),
     info_array_(NULL) {
   // Iterate on all icon directories to find directories of the specified
   // theme and load the first encountered index.theme.
   std::map<FilePath, int>::iterator iter;
   FilePath theme_path;
   std::map<FilePath, int>* icon_dirs =
-      Singleton<MimeUtilConstants>::get()->icon_dirs_;
+      MimeUtilConstants::GetInstance()->icon_dirs_;
   for (iter = icon_dirs->begin(); iter != icon_dirs->end(); ++iter) {
     theme_path = iter->first.Append(name);
     if (!file_util::DirectoryExists(theme_path))
       continue;
     FilePath theme_index = theme_path.Append("index.theme");
     if (!index_theme_loaded_ && file_util::PathExists(theme_index)) {
       if (!LoadIndexTheme(theme_index))
         return;
       index_theme_loaded_ = true;
     }
@@ skipping 40 matching lines @@
   // Inheriting from itself means the theme is buggy but we shouldn't crash.
   if (theme && theme != this)
     return theme->GetIconPath(icon_name, size, inherits);
   else
     return FilePath();
 }
 
 IconTheme* IconTheme::LoadTheme(const std::string& theme_name) {
   scoped_ptr<IconTheme> theme;
   std::map<std::string, IconTheme*>* icon_themes =
-      Singleton<MimeUtilConstants>::get()->icon_themes_;
+      MimeUtilConstants::GetInstance()->icon_themes_;
   if (icon_themes->find(theme_name) != icon_themes->end()) {
     theme.reset((*icon_themes)[theme_name]);
   } else {
     theme.reset(new IconTheme(theme_name));
     if (!theme->IsValid())
       theme.reset();
     (*icon_themes)[theme_name] = theme.get();
   }
   return theme.release();
 }
 
 FilePath IconTheme::GetIconPathUnderSubdir(const std::string& icon_name,
                                            const std::string& subdir) {
   FilePath icon_path;
   std::list<FilePath>::iterator dir_iter;
   std::vector<std::string>* icon_formats =
-      &Singleton<MimeUtilConstants>::get()->icon_formats_;
+      &MimeUtilConstants::GetInstance()->icon_formats_;
   for (dir_iter = dirs_.begin(); dir_iter != dirs_.end(); ++dir_iter) {
     for (size_t i = 0; i < icon_formats->size(); ++i) {
       icon_path = dir_iter->Append(subdir);
       icon_path = icon_path.Append(icon_name + (*icon_formats)[i]);
       if (file_util::PathExists(icon_path))
         return icon_path;
     }
   }
   return FilePath();
 }
@@ skipping 127 matching lines @@
   }
   subdirs_[dir] = num++;
   info_array_ = new SubDirInfo[num];
   return true;
 }
 
 // Make sure |dir| exists and add it to the list of icon directories.
 void TryAddIconDir(const FilePath& dir) {
   if (!file_util::DirectoryExists(dir))
     return;
-  (*Singleton<MimeUtilConstants>::get()->icon_dirs_)[dir] = 0;
+  (*MimeUtilConstants::GetInstance()->icon_dirs_)[dir] = 0;
 }
 
 // For a xdg directory |dir|, add the appropriate icon sub-directories.
 void AddXDGDataDir(const FilePath& dir) {
   if (!file_util::DirectoryExists(dir))
     return;
   TryAddIconDir(dir.Append("icons"));
   TryAddIconDir(dir.Append("pixmaps"));
 }
 
 // Add all the xdg icon directories.
 void InitIconDir() {
-  Singleton<MimeUtilConstants>::get()->icon_dirs_->clear();
+  MimeUtilConstants::GetInstance()->icon_dirs_->clear();
   FilePath home = file_util::GetHomeDir();
   if (!home.empty()) {
       FilePath legacy_data_dir(home);
       legacy_data_dir = legacy_data_dir.AppendASCII(".icons");
       if (file_util::DirectoryExists(legacy_data_dir))
         TryAddIconDir(legacy_data_dir);
   }
   const char* env = getenv("XDG_DATA_HOME");
   if (env) {
     AddXDGDataDir(FilePath(env));
@@ skipping 18 matching lines @@
     AddXDGDataDir(FilePath(xdg_data_dirs.substr(pos)));
   }
 }
 
 // Per xdg theme spec, we should check the icon directories every so often for
 // newly added icons. This isn't quite right.
 void EnsureUpdated() {
   struct timeval t;
   gettimeofday(&t, NULL);
   time_t now = t.tv_sec;
-  MimeUtilConstants* constants = Singleton<MimeUtilConstants>::get();
+  MimeUtilConstants* constants = MimeUtilConstants::GetInstance();
 
   if (constants->last_check_time_ == 0) {
     constants->icon_dirs_ = new std::map<FilePath, int>;
     constants->icon_themes_ = new std::map<std::string, IconTheme*>;
     InitIconDir();
     constants->last_check_time_ = now;
   } else {
     // TODO(thestig): something changed. start over. Upstream fix to Google
     // Gadgets for Linux.
     if (now > constants->last_check_time_ + constants->kUpdateInterval) {
     }
   }
 }
 
 // Find a fallback icon if we cannot find it in the default theme.
 FilePath LookupFallbackIcon(const std::string& icon_name) {
   FilePath icon;
-  MimeUtilConstants* constants = Singleton<MimeUtilConstants>::get();
+  MimeUtilConstants* constants = MimeUtilConstants::GetInstance();
   std::map<FilePath, int>::iterator iter;
   std::map<FilePath, int>* icon_dirs = constants->icon_dirs_;
   std::vector<std::string>* icon_formats = &constants->icon_formats_;
   for (iter = icon_dirs->begin(); iter != icon_dirs->end(); ++iter) {
     for (size_t i = 0; i < icon_formats->size(); ++i) {
       icon = iter->first.Append(icon_name + (*icon_formats)[i]);
       if (file_util::PathExists(icon))
         return icon;
     }
   }
   return FilePath();
 }
 
 // Initialize the list of default themes.
 void InitDefaultThemes() {
   IconTheme** default_themes =
-      Singleton<MimeUtilConstants>::get()->default_themes_;
+      MimeUtilConstants::GetInstance()->default_themes_;
 
   char* env = getenv("KDE_FULL_SESSION");
   if (env) {
     // KDE
     std::string kde_default_theme;
     std::string kde_fallback_theme;
 
     // TODO(thestig): Figure out how to get the current icon theme on KDE.
     // Setting stored in ~/.kde/share/config/kdeglobals under Icons -> Theme.
     default_themes[0] = NULL;
 
     // Try some reasonable defaults for KDE.
     env = getenv("KDE_SESSION_VERSION");
     if (!env || env[0] != '4') {
       // KDE 3
       kde_default_theme = "default.kde";
       kde_fallback_theme = "crystalsvg";
     } else {
       // KDE 4
       kde_default_theme = "default.kde4";
       kde_fallback_theme = "oxygen";
     }
     default_themes[1] = IconTheme::LoadTheme(kde_default_theme);
     default_themes[2] = IconTheme::LoadTheme(kde_fallback_theme);
   } else {
     // Assume it's Gnome and use GTK to figure out the theme.
     default_themes[1] = IconTheme::LoadTheme(
-        Singleton<MimeUtilConstants>::get()->gtk_theme_name_);
+        MimeUtilConstants::GetInstance()->gtk_theme_name_);
     default_themes[2] = IconTheme::LoadTheme("gnome");
   }
   // hicolor needs to be last per icon theme spec.
   default_themes[3] = IconTheme::LoadTheme("hicolor");
 
   for (size_t i = 0; i < MimeUtilConstants::kDefaultThemeNum; i++) {
     if (default_themes[i] == NULL)
       continue;
     // NULL out duplicate pointers.
     for (size_t j = i + 1; j < MimeUtilConstants::kDefaultThemeNum; j++) {
       if (default_themes[j] == default_themes[i])
         default_themes[j] = NULL;
     }
   }
 }
 
 // Try to find an icon with the name |icon_name| that's |size| pixels.
 FilePath LookupIconInDefaultTheme(const std::string& icon_name, int size) {
   EnsureUpdated();
-  MimeUtilConstants* constants = Singleton<MimeUtilConstants>::get();
+  MimeUtilConstants* constants = MimeUtilConstants::GetInstance();
   std::map<std::string, IconTheme*>* icon_themes = constants->icon_themes_;
   if (icon_themes->size() == 0)
     InitDefaultThemes();
 
   FilePath icon_path;
   IconTheme** default_themes = constants->default_themes_;
   for (size_t i = 0; i < MimeUtilConstants::kDefaultThemeNum; i++) {
     if (default_themes[i]) {
       icon_path = default_themes[i]->GetIconPath(icon_name, size, true);
       if (!icon_path.empty())
@@ skipping 19 matching lines @@
 }
 
 std::string GetDataMimeType(const std::string& data) {
   return xdg_mime_get_mime_type_for_data(data.data(), data.length(), NULL);
 }
 
 void DetectGtkTheme() {
   // If the theme name is already loaded, do nothing. Chrome doesn't respond
   // to changes in the system theme, so we never need to set this more than
   // once.
-  if (!Singleton<MimeUtilConstants>::get()->gtk_theme_name_.empty())
+  if (!MimeUtilConstants::GetInstance()->gtk_theme_name_.empty())
     return;
 
   // We should only be called on the UI thread.
   DCHECK_EQ(MessageLoop::TYPE_UI, MessageLoop::current()->type());
 
   gchar* gtk_theme_name;
   g_object_get(gtk_settings_get_default(),
                "gtk-icon-theme-name",
                &gtk_theme_name, NULL);
-  Singleton<MimeUtilConstants>::get()->gtk_theme_name_.assign(gtk_theme_name);
+  MimeUtilConstants::GetInstance()->gtk_theme_name_.assign(gtk_theme_name);
   g_free(gtk_theme_name);
 }
 
 FilePath GetMimeIcon(const std::string& mime_type, size_t size) {
   std::vector<std::string> icon_names;
   std::string icon_name;
   FilePath icon_file;
 
   const char* icon = xdg_mime_get_icon(mime_type.c_str());
   icon_name = std::string(icon ? icon : "");
@@ skipping 29 matching lines @@
     } else {
       icon_file = LookupIconInDefaultTheme(icon_names[i], size);
       if (!icon_file.empty())
         return icon_file;
     }
   }
   return FilePath();
 }
 
 }  // namespace mime_util