linux: Both gtk and the aura port should set the icon theme name.

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>
 
 #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/nix/xdg_util.h"
 #include "base/string_util.h"
 #include "base/strings/string_split.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_GTK)
-#include <gtk/gtk.h>  // NOLINT
-
-#include "base/message_loop.h"
-#endif
-
 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;
 
 class MimeUtilConstants {
@@ skipping 18 matching lines @@
   IconFormats icon_formats_;
 
   // Store loaded icon_theme.
   IconThemeMap icon_themes_;
 
   // The default theme.
   IconTheme* default_themes_[kDefaultThemeNum];
 
   base::TimeTicks last_check_time_;
 
-#if defined(TOOLKIT_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
+  // 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");
 
     for (size_t i = 0; i < kDefaultThemeNum; ++i)
       default_themes_[i] = NULL;
   }
@@ skipping 442 matching lines @@
       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 {
-#if defined(TOOLKIT_GTK)
     // Assume it's Gnome and use GTK to figure out the theme.
     default_themes[1] = IconTheme::LoadTheme(
-        MimeUtilConstants::GetInstance()->gtk_theme_name_);
+        MimeUtilConstants::GetInstance()->icon_theme_name_);
     default_themes[2] = IconTheme::LoadTheme("gnome");
-#endif
   }
   // 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])
@@ skipping 39 matching lines @@
   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.Get());
   return xdg_mime_get_mime_type_for_data(data.data(), data.length(), NULL);
 }
 
-#if defined(TOOLKIT_GTK)
-void DetectGtkTheme() {
+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()->gtk_theme_name_.empty())
+  if (!MimeUtilConstants::GetInstance()->icon_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);
+  MimeUtilConstants::GetInstance()->icon_theme_name_ = name;
 }
-#endif
 
 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;
 
   if (!mime_type.empty()) {
     base::AutoLock scoped_lock(g_mime_util_xdg_lock.Get());
     const char *icon = xdg_mime_get_icon(mime_type.c_str());
@@ skipping 36 matching lines @@
       icon_file = LookupIconInDefaultTheme(icon_names[i], size);
       if (!icon_file.empty())
         return icon_file;
     }
   }
   return FilePath();
 }
 
 }  // namespace nix
 }  // namespace base