Linux: Periodically check for changes to the icon directories and refresh icons for mime types pe...

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 <sys/time.h>
-#include <time.h>
 
 #include <cstdlib>
 #include <list>
 #include <map>
 #include <vector>
 
 #include "base/environment.h"
 #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/nix/xdg_util.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"
+#include "base/time.h"
 
 #if defined(TOOLKIT_USES_GTK)
 #include <gtk/gtk.h>
 #endif
 
 namespace {
 
 // None of the XDG stuff is thread-safe, so serialize all access under
 // this lock.
 static base::LazyInstance<base::Lock,
                           base::LeakyLazyInstanceTraits<base::Lock> >
     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::map<FilePath, base::Time> IconDirMtimeMap;
   typedef std::vector<std::string> IconFormats;
 
-  // In seconds, specified by icon theme specs.
-  static const int kUpdateInterval = 5;
+  // Specified by XDG icon theme specs.
+  static const int kUpdateIntervalInSeconds = 5;
 
   static const size_t kDefaultThemeNum = 4;
 
   static MimeUtilConstants* GetInstance() {
     return Singleton<MimeUtilConstants>::get();
   }
 
   // Store icon directories and their mtimes.
   IconDirMtimeMap icon_dirs_;
 
   // Store icon formats.
   IconFormats icon_formats_;
 
   // Store loaded icon_theme.
   IconThemeMap icon_themes_;
 
   // The default theme.
   IconTheme* default_themes_[kDefaultThemeNum];
 
-  time_t last_check_time_;
+  base::TimeTicks last_check_time_;
 
 #if defined(TOOLKIT_USES_GTK)
   // 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_;
 #endif
 
  private:
-  MimeUtilConstants()
-      : last_check_time_(0) {
+  MimeUtilConstants() {
     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 297 matching lines @@
   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_.reset(new SubDirInfo[num]);
   return true;
 }
 
+bool CheckDirExistsAndGetMtime(const FilePath& dir,
+                               base::Time* last_modified) {
+  if (!file_util::DirectoryExists(dir))
+    return false;
+  base::PlatformFileInfo file_info;
+  if (!file_util::GetFileInfo(dir, &file_info))
+    return false;
+  *last_modified = file_info.last_modified;
+  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))
+  base::Time last_modified;
+  if (!CheckDirExistsAndGetMtime(dir, &last_modified))
     return;
-  MimeUtilConstants::GetInstance()->icon_dirs_[dir] = 0;
+  MimeUtilConstants::GetInstance()->icon_dirs_[dir] = last_modified;
 }
 
 // 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();
   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 12 matching lines @@
     std::string xdg_data_dirs = env;
     std::string::size_type pos = 0, epos;
     while ((epos = xdg_data_dirs.find(':', pos)) != std::string::npos) {
       AddXDGDataDir(FilePath(xdg_data_dirs.substr(pos, epos - pos)));
       pos = epos + 1;
     }
     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 = MimeUtilConstants::GetInstance();
+  if (constants->last_check_time_.is_null()) {
+    constants->last_check_time_ = base::TimeTicks::Now();
+    InitIconDir();
+    return;
+  }
 
-  if (constants->last_check_time_ == 0) {
-    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) {
+  // Per xdg theme spec, we should check the icon directories every so often
+  // for newly added icons.
+  base::TimeDelta time_since_last_check =
+      base::TimeTicks::Now() - constants->last_check_time_;
+  if (time_since_last_check.InSeconds() > constants->kUpdateIntervalInSeconds) {
+    constants->last_check_time_ += time_since_last_check;
+
+    bool rescan_icon_dirs = false;
+    MimeUtilConstants::IconDirMtimeMap* icon_dirs = &constants->icon_dirs_;
+    MimeUtilConstants::IconDirMtimeMap::iterator iter;
+    for (iter = icon_dirs->begin(); iter != icon_dirs->end(); ++iter) {
+      base::Time last_modified;
+      if (!CheckDirExistsAndGetMtime(iter->first, &last_modified) ||
+          last_modified != iter->second) {
+        rescan_icon_dirs = true;
+        break;
+      }
+    }
+
+    if (rescan_icon_dirs) {
+      constants->icon_dirs_.clear();
+      constants->icon_themes_.clear();
+      InitIconDir();
     }
   }
 }
 
 // Find a fallback icon if we cannot find it in the default theme.
 FilePath LookupFallbackIcon(const std::string& icon_name) {
   MimeUtilConstants* constants = MimeUtilConstants::GetInstance();
   MimeUtilConstants::IconDirMtimeMap::iterator iter;
   MimeUtilConstants::IconDirMtimeMap* icon_dirs = &constants->icon_dirs_;
   MimeUtilConstants::IconFormats* icon_formats = &constants->icon_formats_;
@@ skipping 167 matching lines @@
     } else {
       icon_file = LookupIconInDefaultTheme(icon_names[i], size);
       if (!icon_file.empty())
         return icon_file;
     }
   }
   return FilePath();
 }
 
 }  // namespace mime_util