Cleanup: No need to dynamically allocate a couple class members in mime_util_xdg.cc. Also convert...

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>
 
@@ skipping 35 matching lines @@
   // 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();
   }
 
   // Store icon directories and their mtimes.
-  IconDirMtimeMap* icon_dirs_;
+  IconDirMtimeMap icon_dirs_;
 
   // Store icon formats.
   IconFormats icon_formats_;
 
   // Store loaded icon_theme.
-  IconThemeMap* icon_themes_;
+  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()
-      : icon_dirs_(NULL),
-        icon_themes_(NULL),
-        last_check_time_(0) {
+      : 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();
 
   friend struct DefaultSingletonTraits<MimeUtilConstants>;
@@ skipping 24 matching lines @@
     }
     size_t size;  // Nominal size of the icons in this directory.
     Type type;  // Type of the icon size.
     size_t max_size;  // Maximum size that the icons can be scaled to.
     size_t min_size;  // Minimum size that the icons can be scaled to.
     size_t threshold;  // Maximum difference from desired size. 2 by default.
   };
 
   explicit IconTheme(const std::string& name);
 
-  ~IconTheme() {
-    delete[] info_array_;
-  }
+  ~IconTheme() {}
 
   // Returns the path to an icon with the name |icon_name| and a size of |size|
   // pixels. If the icon does not exist, but |inherits| is true, then look for
   // the icon in the parent theme.
   FilePath GetIconPath(const std::string& icon_name, int size, bool inherits);
 
   // Load a theme with the name |theme_name| into memory. Returns null if theme
   // is invalid.
   static IconTheme* LoadTheme(const std::string& theme_name);
 
@@ skipping 19 matching lines @@
 
   // Set directories to search for icons to the comma-separated list |dirs|.
   bool SetDirectories(const std::string& dirs);
 
   bool index_theme_loaded_;  // True if an instance is properly loaded.
   // store the scattered directories of this theme.
   std::list<FilePath> dirs_;
 
   // store the subdirs of this theme and array index of |info_array_|.
   std::map<std::string, int> subdirs_;
-  SubDirInfo* info_array_;  // List of sub-directories.
+  scoped_array<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.
   MimeUtilConstants::IconDirMtimeMap::iterator iter;
   FilePath theme_path;
   MimeUtilConstants::IconDirMtimeMap* icon_dirs =
-      MimeUtilConstants::GetInstance()->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;
   MimeUtilConstants::IconThemeMap* icon_themes =
-      MimeUtilConstants::GetInstance()->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();
 }
@@ skipping 25 matching lines @@
   while (!feof(fp) && !ferror(fp)) {
     std::string buf = ReadLine(fp);
     if (buf == "")
       break;
 
     std::string entry;
     TrimWhitespaceASCII(buf, TRIM_ALL, &entry);
     if (entry.length() == 0 || entry[0] == '#') {
       // Blank line or Comment.
       continue;
-    } else if (entry[0] == '[' && info_array_) {
+    } else if (entry[0] == '[' && info_array_.get()) {
       current_info = NULL;
       std::string subdir = entry.substr(1, entry.length() - 2);
       if (subdirs_.find(subdir) != subdirs_.end())
         current_info = &info_array_[subdirs_[subdir]];
     }
 
     std::string key, value;
     std::vector<std::string> r;
     base::SplitStringDontTrim(entry, '=', &r);
     if (r.size() < 2)
@@ skipping 15 matching lines @@
         else if (value == "Threshold")
           current_info->type = SubDirInfo::Threshold;
       } else if (key == "MaxSize") {
         current_info->max_size = atoi(value.c_str());
       } else if (key == "MinSize") {
         current_info->min_size = atoi(value.c_str());
       } else if (key == "Threshold") {
         current_info->threshold = atoi(value.c_str());
       }
     } else {
-      if (key.compare("Directories") == 0 && !info_array_) {
+      if (key.compare("Directories") == 0 && !info_array_.get()) {
         if (!SetDirectories(value)) break;
       } else if (key.compare("Inherits") == 0) {
         if (value != "hicolor")
           inherits_ = value;
       }
     }
   }
 
   file_util::CloseFile(fp);
-  return info_array_ != NULL;
+  return info_array_.get() != NULL;
 }
 
 size_t IconTheme::MatchesSize(SubDirInfo* info, size_t size) {
   if (info->type == SubDirInfo::Fixed) {
     if (size > info->size)
       return size - info->size;
     else
       return info->size - size;
   } else if (info->type == SubDirInfo::Scalable) {
     if (size < info->min_size)
@@ skipping 42 matching lines @@
     }
     subdirs_[dir] = num++;
     pos = epos + 1;
   }
   TrimWhitespaceASCII(dirs.substr(pos), TRIM_ALL, &dir);
   if (dir.length() == 0) {
     DLOG(WARNING) << "Invalid index.theme: blank subdir";
     return false;
   }
   subdirs_[dir] = num++;
-  info_array_ = new SubDirInfo[num];
+  info_array_.reset(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;
-  (*MimeUtilConstants::GetInstance()->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() {
-  MimeUtilConstants::GetInstance()->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 21 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 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();
   MimeUtilConstants::IconDirMtimeMap::iterator iter;
-  MimeUtilConstants::IconDirMtimeMap* icon_dirs = constants->icon_dirs_;
+  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]);
+      FilePath 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 =
@@ skipping 41 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();
-  MimeUtilConstants::IconThemeMap* 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();
@@ skipping 72 matching lines @@
     } else {
       icon_file = LookupIconInDefaultTheme(icon_names[i], size);
       if (!icon_file.empty())
         return icon_file;
     }
   }
   return FilePath();
 }
 
 }  // namespace mime_util