Cleanup: Change a static initializer to a LazyInstance, and add some typedefs.

base/mime_util_xdg.cc

 // Copyright (c) 2011 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>
 
 #include <cstdlib>
 #include <list>
 #include <map>
 #include <vector>
 
 #include "base/file_util.h"
+#include "base/lazy_instance.h"
 #include "base/logging.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/singleton.h"
 #include "base/message_loop.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/synchronization/lock.h"
 #include "base/third_party/xdg_mime/xdgmime.h"
 #include "base/threading/thread_restrictions.h"
 
 namespace {
 
-// None of the XDG stuff is thread-safe, so serialize all accesss under
+// None of the XDG stuff is thread-safe, so serialize all access under
 // this lock.
-base::Lock g_mime_util_xdg_lock;
+static base::LazyInstance<base::Lock>

[willchan no longer on Chromium, 2011/10/28 21:42:25]

I wonder if you should use LeakyLazyInstance. Not sure if we need to delete this
guy.

[Lei Zhang, 2011/10/28 21:54:02]

Would you say that's true of all locks? There's 7 our
base::LazyInstance<base::Lock> instantiations. We can change them all in a
separate CL.

+        g_mime_util_xdg_lock(base::LINKER_INITIALIZED);
 
 class IconTheme;
 
 class MimeUtilConstants {
  public:
+  typedef std::map<std::string, IconTheme*> IconThemeMap;
+  typedef std::map<FilePath, int> IconDirMtimeMap;
+  typedef std::vector<std::string> IconFormats;
+
+  // In seconds, specified by icon theme specs.
+  static const int kUpdateInterval = 5;
+
+  static const size_t kDefaultThemeNum = 4;
+
   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_;
+  IconDirMtimeMap* icon_dirs_;
 
   // Store icon formats.
-  std::vector<std::string> icon_formats_;
+  IconFormats icon_formats_;
 
   // Store loaded icon_theme.
-  std::map<std::string, IconTheme*>* icon_themes_;
-
-  static const size_t kDefaultThemeNum = 4;
+  IconThemeMap* icon_themes_;
 
   // The default theme.
   IconTheme* default_themes_[kDefaultThemeNum];
 
   time_t last_check_time_;
 
   // This is set by DetectGtkTheme(). We cache it so that we can access the
   // theme name from threads that aren't allowed to call
   // gtk_settings_get_default().
   std::string gtk_theme_name_;
 
  private:
   MimeUtilConstants()
-      : kUpdateInterval(5),
-        icon_dirs_(NULL),
+      : icon_dirs_(NULL),
         icon_themes_(NULL),
         last_check_time_(0) {
     icon_formats_.push_back(".png");
     icon_formats_.push_back(".svg");
     icon_formats_.push_back(".xpm");
 
     for (size_t i = 0; i < kDefaultThemeNum; ++i)
       default_themes_[i] = NULL;
   }
   ~MimeUtilConstants();
@@ skipping 78 matching lines @@
   SubDirInfo* info_array_;  // List of sub-directories.
   std::string inherits_;  // Name of the theme this one inherits from.
 };
 
 IconTheme::IconTheme(const std::string& name)
   : index_theme_loaded_(false),
     info_array_(NULL) {
   base::ThreadRestrictions::AssertIOAllowed();
   // 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;
+  MimeUtilConstants::IconDirMtimeMap::iterator iter;
   FilePath theme_path;
-  std::map<FilePath, int>* icon_dirs =
+  MimeUtilConstants::IconDirMtimeMap* 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 @@
   IconTheme* theme = LoadTheme(inherits_);
   // 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 =
+  MimeUtilConstants::IconThemeMap* 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 =
+  MimeUtilConstants::IconFormats* 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 181 matching lines @@
 
 // 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 = 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*>;
+    constants->icon_dirs_ = new MimeUtilConstants::IconDirMtimeMap;
+    constants->icon_themes_ = new MimeUtilConstants::IconThemeMap;
     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 = 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_;
+  MimeUtilConstants::IconDirMtimeMap::iterator iter;
+  MimeUtilConstants::IconDirMtimeMap* icon_dirs = constants->icon_dirs_;
+  MimeUtilConstants::IconFormats* 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();
 }
 
@@ skipping 42 matching lines @@
       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 = MimeUtilConstants::GetInstance();
-  std::map<std::string, IconTheme*>* icon_themes = constants->icon_themes_;
+  MimeUtilConstants::IconThemeMap* icon_themes = constants->icon_themes_;
   if (icon_themes->empty())
     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())
         return icon_path;
     }
   }
   return LookupFallbackIcon(icon_name);
 }
 
 MimeUtilConstants::~MimeUtilConstants() {
   delete icon_dirs_;
   delete icon_themes_;
   for (size_t i = 0; i < kDefaultThemeNum; i++)
     delete default_themes_[i];
 }
 
 }  // namespace
 
 namespace mime_util {
 
 std::string GetFileMimeType(const FilePath& filepath) {
   base::ThreadRestrictions::AssertIOAllowed();
-  base::AutoLock scoped_lock(g_mime_util_xdg_lock);
+  base::AutoLock scoped_lock(g_mime_util_xdg_lock.Get());
   return xdg_mime_get_mime_type_from_file_name(filepath.value().c_str());
 }
 
 std::string GetDataMimeType(const std::string& data) {
   base::ThreadRestrictions::AssertIOAllowed();
-  base::AutoLock scoped_lock(g_mime_util_xdg_lock);
+  base::AutoLock scoped_lock(g_mime_util_xdg_lock.Get());
   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 (!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);
   MimeUtilConstants::GetInstance()->gtk_theme_name_.assign(gtk_theme_name);
   g_free(gtk_theme_name);
 }
 
 FilePath GetMimeIcon(const std::string& mime_type, size_t size) {
   base::ThreadRestrictions::AssertIOAllowed();
   std::vector<std::string> icon_names;
   std::string icon_name;
   FilePath icon_file;
 
   {
-    base::AutoLock scoped_lock(g_mime_util_xdg_lock);
+    base::AutoLock scoped_lock(g_mime_util_xdg_lock.Get());
     const char *icon = xdg_mime_get_icon(mime_type.c_str());
     icon_name = std::string(icon ? icon : "");
   }
 
   if (icon_name.length())
     icon_names.push_back(icon_name);
 
   // For text/plain, try text-plain.
   icon_name = mime_type;
   for (size_t i = icon_name.find('/', 0); i != std::string::npos;
@@ skipping 23 matching lines @@
     } else {
       icon_file = LookupIconInDefaultTheme(icon_names[i], size);
       if (!icon_file.empty())
         return icon_file;
     }
   }
   return FilePath();
 }
 
 }  // namespace mime_util