Move more file_util functions to base namespace.

base/nix/mime_util_xdg.cc

 // Copyright (c) 2012 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/nix/mime_util_xdg.h"
 
 #include <cstdlib>
 #include <list>
 #include <map>
 #include <vector>
@@ skipping 14 matching lines @@
 
 namespace base {
 namespace nix {
 
 namespace {
 
 class IconTheme;
 
 // None of the XDG stuff is thread-safe, so serialize all access under
 // this lock.
-base::LazyInstance<base::Lock>::Leaky
-    g_mime_util_xdg_lock = LAZY_INSTANCE_INITIALIZER;
+LazyInstance<Lock>::Leaky g_mime_util_xdg_lock = LAZY_INSTANCE_INITIALIZER;
 
 class MimeUtilConstants {
  public:
   typedef std::map<std::string, IconTheme*> IconThemeMap;
-  typedef std::map<FilePath, base::Time> IconDirMtimeMap;
+  typedef std::map<FilePath, Time> IconDirMtimeMap;
   typedef std::vector<std::string> IconFormats;
 
   // 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];
 
-  base::TimeTicks last_check_time_;
+  TimeTicks last_check_time_;
 
   // The current icon theme, usually set through GTK theme integration.
   std::string icon_theme_name_;
 
  private:
   MimeUtilConstants() {
     icon_formats_.push_back(".png");
     icon_formats_.push_back(".svg");
     icon_formats_.push_back(".xpm");
 
@@ skipping 76 matching lines @@
   std::list<FilePath> dirs_;
 
   // store the subdirs of this theme and array index of |info_array_|.
   std::map<std::string, int> subdirs_;
   scoped_ptr<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) {
-  base::ThreadRestrictions::AssertIOAllowed();
+  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_;
   for (iter = icon_dirs->begin(); iter != icon_dirs->end(); ++iter) {
     theme_path = iter->first.Append(name);
     if (!DirectoryExists(theme_path))
       continue;
@@ skipping 101 matching lines @@
       continue;
     } 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);
+    SplitStringDontTrim(entry, '=', &r);
     if (r.size() < 2)
       continue;
 
     TrimWhitespaceASCII(r[0], TRIM_ALL, &key);
     for (size_t i = 1; i < r.size(); i++)
       value.append(r[i]);
     TrimWhitespaceASCII(value, TRIM_ALL, &value);
 
     if (current_info) {
       if (key == "Size") {
@@ skipping 83 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) {
+bool CheckDirExistsAndGetMtime(const FilePath& dir, Time* last_modified) {
   if (!DirectoryExists(dir))
     return false;
-  base::PlatformFileInfo file_info;
-  if (!file_util::GetFileInfo(dir, &file_info))
+  PlatformFileInfo file_info;
+  if (!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) {
-  base::Time last_modified;
+  Time last_modified;
   if (!CheckDirExistsAndGetMtime(dir, &last_modified))
     return;
   MimeUtilConstants::GetInstance()->icon_dirs_[dir] = last_modified;
 }
 
 // For a xdg directory |dir|, add the appropriate icon sub-directories.
 void AddXDGDataDir(const FilePath& dir) {
   if (!DirectoryExists(dir))
     return;
   TryAddIconDir(dir.Append("icons"));
@@ skipping 30 matching lines @@
       AddXDGDataDir(FilePath(xdg_data_dirs.substr(pos, epos - pos)));
       pos = epos + 1;
     }
     AddXDGDataDir(FilePath(xdg_data_dirs.substr(pos)));
   }
 }
 
 void EnsureUpdated() {
   MimeUtilConstants* constants = MimeUtilConstants::GetInstance();
   if (constants->last_check_time_.is_null()) {
-    constants->last_check_time_ = base::TimeTicks::Now();
+    constants->last_check_time_ = TimeTicks::Now();
     InitIconDir();
     return;
   }
 
   // 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_;
+  TimeDelta time_since_last_check =
+      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;
+      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();
@@ skipping 16 matching lines @@
     }
   }
   return FilePath();
 }
 
 // Initialize the list of default themes.
 void InitDefaultThemes() {
   IconTheme** default_themes =
       MimeUtilConstants::GetInstance()->default_themes_;
 
-  scoped_ptr<base::Environment> env(base::Environment::Create());
+  scoped_ptr<Environment> env(Environment::Create());
   base::nix::DesktopEnvironment desktop_env =
       base::nix::GetDesktopEnvironment(env.get());
   if (desktop_env == base::nix::DESKTOP_ENVIRONMENT_KDE3 ||
       desktop_env == base::nix::DESKTOP_ENVIRONMENT_KDE4) {
     // 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.
@@ skipping 54 matching lines @@
 MimeUtilConstants::~MimeUtilConstants() {
   for (size_t i = 0; i < kDefaultThemeNum; i++)
     delete default_themes_[i];
 }
 
 }  // namespace
 
 std::string GetFileMimeType(const FilePath& filepath) {
   if (filepath.empty())
     return std::string();
-  base::ThreadRestrictions::AssertIOAllowed();
-  base::AutoLock scoped_lock(g_mime_util_xdg_lock.Get());
+  ThreadRestrictions::AssertIOAllowed();
+  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.Get());
+  ThreadRestrictions::AssertIOAllowed();
+  AutoLock scoped_lock(g_mime_util_xdg_lock.Get());
   return xdg_mime_get_mime_type_for_data(data.data(), data.length(), NULL);
 }
 
 void SetIconThemeName(const std::string& name) {
   // 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()->icon_theme_name_.empty())
     return;
 
   MimeUtilConstants::GetInstance()->icon_theme_name_ = name;
 }
 
 FilePath GetMimeIcon(const std::string& mime_type, size_t size) {
-  base::ThreadRestrictions::AssertIOAllowed();
+  ThreadRestrictions::AssertIOAllowed();
   std::vector<std::string> icon_names;
   std::string icon_name;
   FilePath icon_file;
 
   if (!mime_type.empty()) {
-    base::AutoLock scoped_lock(g_mime_util_xdg_lock.Get());
+    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 27 matching lines @@
       icon_file = LookupIconInDefaultTheme(icon_names[i], size);
       if (!icon_file.empty())
         return icon_file;
     }
   }
   return FilePath();
 }
 
 }  // namespace nix
 }  // namespace base