Make the system tray icons display when using KDE4 and plasma

chrome/browser/ui/libgtk2ui/app_indicator_icon.cc

 // Copyright 2013 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 "chrome/browser/ui/libgtk2ui/app_indicator_icon.h"
 
 #include <gtk/gtk.h>
 #include <dlfcn.h>
 
 #include "base/bind.h"
+#include "base/environment.h"
 #include "base/file_util.h"
+#include "base/md5.h"
 #include "base/memory/ref_counted_memory.h"
+#include "base/nix/xdg_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "base/threading/sequenced_worker_pool.h"
 #include "chrome/browser/ui/libgtk2ui/app_indicator_icon_menu.h"
 #include "content/public/browser/browser_thread.h"
 #include "ui/base/models/menu_model.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace {
@@ skipping 91 matching lines @@
 
   app_indicator_set_icon_full =
       reinterpret_cast<app_indicator_set_icon_full_func>(
           dlsym(indicator_lib, "app_indicator_set_icon_full"));
 
   app_indicator_set_icon_theme_path =
       reinterpret_cast<app_indicator_set_icon_theme_path_func>(
           dlsym(indicator_lib, "app_indicator_set_icon_theme_path"));
 }
 
-base::FilePath CreateTempImageFile(gfx::ImageSkia* image_ptr,
+// Returns whether a temporary directory should be created for each app
+// indicator image.
+bool ShouldCreateTempDirectoryPerImage(bool using_kde4) {
+  // Create a new temporary directory for each image on Unity since using a
+  // single temporary directory seems to have issues when changing icons in
+  // quick succession.
+  return !using_kde4;

[pkotwicz, 2014/06/02 18:41:58]

Creating a temporary directory per icon causes problems on KDE4. I have not
chased down why.

+}
+
+// Returns the subdirectory of |temp_dir| in which the app indicator image
+// should be saved.
+base::FilePath GetImageDirectoryPath(bool using_kde4,
+                                     const base::FilePath& temp_dir) {
+  // On KDE4, an image located in a directory ending with
+  // "icons/hicolor/16x16/apps" can be used as the app indicator image because
+  // "/usr/share/icons/hicolor/16x16/apps" exists.

[pkotwicz, 2014/06/02 18:41:58]

KDE5 (which uses QIconLoader instead of KIconLoader for system tray icons) is
much more reasonable thankfully and parses the index.theme file in the directory
passed into app_indicator_set_icon_theme_path(). On KDE5 the index.theme file is
cached but not across runs of Chrome.

+  return using_kde4 ?
+      temp_dir.AppendASCII("icons").AppendASCII("hicolor").AppendASCII("16x16").
+          AppendASCII("apps") :
+      temp_dir;
+}
+
+std::string GetImageFileNameForKDE4(
+    const scoped_refptr<base::RefCountedMemory>& png_data) {

[pkotwicz, 2014/06/02 18:41:58]

sni-qt (https://launchpad.net/sni-qt) seems to do the same thing

I haven't found any docs as to how to properly clear KDE's icon cache.
KGlobalSettings::emitChange() was the closest I found.

+  // On KDE4, the name of the image file must be unique accross runs of
+  // Chrome.

[Elliot Glaysher, 2014/06/02 20:06:04]

Is this comment correct? The following seems to make a content addressable
resource; the same icon will have the same file name across runs.

+  base::MD5Digest digest;
+  base::MD5Sum(png_data->front_as<char>(), png_data->size(), &digest);
+  return base::StringPrintf("chrome_app_indicator_%s.png",
+                            base::MD5DigestToBase16(digest).c_str());
+}
+
+std::string GetImageFileNameForNonKDE4(int icon_change_count,
+                                       const std::string& id) {
+  return base::StringPrintf("%s_%d.png", id.c_str(), icon_change_count);
+}
+
+// Returns the "icon theme path" given the file path of the app indicator image.
+std::string GetIconThemePath(bool using_kde4,
+                             const base::FilePath& image_path) {
+  return using_kde4 ?
+      image_path.DirName().DirName().DirName().DirName().value() :
+      image_path.DirName().value();
+}
+
+base::FilePath CreateTempImageFile(bool using_kde4,
+                                   gfx::ImageSkia* image_ptr,
                                    int icon_change_count,
-                                   std::string id) {
+                                   std::string id,
+                                   const base::FilePath& previous_file_path) {
   scoped_ptr<gfx::ImageSkia> image(image_ptr);
 
   scoped_refptr<base::RefCountedMemory> png_data =
       gfx::Image(*image.get()).As1xPNGBytes();
   if (png_data->size() == 0) {
     // If the bitmap could not be encoded to PNG format, skip it.
     LOG(WARNING) << "Could not encode icon";
     return base::FilePath();
   }
 
-  base::FilePath temp_dir;
   base::FilePath new_file_path;
+  if (previous_file_path.empty() ||
+      ShouldCreateTempDirectoryPerImage(using_kde4)) {
+    base::FilePath tmp_dir;
+    if (!base::CreateNewTempDirectory(base::FilePath::StringType(), &tmp_dir))
+      return base::FilePath();
+    new_file_path = GetImageDirectoryPath(using_kde4, tmp_dir);
+    if (new_file_path != tmp_dir) {
+      if (!base::CreateDirectory(new_file_path))
+        return base::FilePath();
+    }
+  } else {
+    new_file_path = previous_file_path.DirName();
+  }
 
-  // Create a new temporary directory for each image since using a single
-  // temporary directory seems to have issues when changing icons in quick
-  // succession.
-  if (!base::CreateNewTempDirectory(base::FilePath::StringType(), &temp_dir))
-    return base::FilePath();
-  new_file_path =
-      temp_dir.Append(id + base::StringPrintf("_%d.png", icon_change_count));
+  new_file_path = new_file_path.Append(using_kde4 ?
+      GetImageFileNameForKDE4(png_data) :
+      GetImageFileNameForNonKDE4(icon_change_count, id));
+
   int bytes_written =
       base::WriteFile(new_file_path,
                       png_data->front_as<char>(), png_data->size());
 
   if (bytes_written != static_cast<int>(png_data->size()))
     return base::FilePath();
   return new_file_path;
 }
 
-void DeleteTempImagePath(const base::FilePath& icon_file_path) {
-  if (icon_file_path.empty())
+void DeleteTempDirectory(const base::FilePath& dir_path) {
+  if (dir_path.empty())
     return;
-  base::DeleteFile(icon_file_path, true);
+  base::DeleteFile(dir_path, true);
 }
 
 }  // namespace
 
 namespace libgtk2ui {
 
 AppIndicatorIcon::AppIndicatorIcon(std::string id,
                                    const gfx::ImageSkia& image,
                                    const base::string16& tool_tip)
     : id_(id),
+      using_kde4_(false),
       icon_(NULL),
       menu_model_(NULL),
       icon_change_count_(0),
       weak_factory_(this) {
+  scoped_ptr<base::Environment> env(base::Environment::Create());
+  using_kde4_ = base::nix::GetDesktopEnvironment(env.get()) ==
+      base::nix::DESKTOP_ENVIRONMENT_KDE4;
+
   EnsureMethodsLoaded();
   tool_tip_ = base::UTF16ToUTF8(tool_tip);
   SetImage(image);
 }
 AppIndicatorIcon::~AppIndicatorIcon() {
   if (icon_) {
     app_indicator_set_status(icon_, APP_INDICATOR_STATUS_PASSIVE);
     g_object_unref(icon_);
     content::BrowserThread::GetBlockingPool()->PostTask(
         FROM_HERE,
-        base::Bind(&DeleteTempImagePath, icon_file_path_.DirName()));
+        base::Bind(&DeleteTempDirectory, icon_file_path_.DirName()));
   }
 }
 
 // static
 bool AppIndicatorIcon::CouldOpen() {
   EnsureMethodsLoaded();
   return g_opened;
 }
 
 void AppIndicatorIcon::SetImage(const gfx::ImageSkia& image) {
   if (!g_opened)
     return;
 
   ++icon_change_count_;
 
   // We create a deep copy of the image since it may have been freed by the time
   // it's accessed in the other thread.
   scoped_ptr<gfx::ImageSkia> safe_image(image.DeepCopy());
   base::PostTaskAndReplyWithResult(
       content::BrowserThread::GetBlockingPool()
           ->GetTaskRunnerWithShutdownBehavior(
                 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN).get(),
       FROM_HERE,
       base::Bind(&CreateTempImageFile,
+                 using_kde4_,
                  safe_image.release(),
                  icon_change_count_,
-                 id_),
+                 id_,
+                 icon_file_path_),
       base::Bind(&AppIndicatorIcon::SetImageFromFile,
                  weak_factory_.GetWeakPtr()));
 }
 
 void AppIndicatorIcon::SetPressedImage(const gfx::ImageSkia& image) {
   // Ignore pressed images, since the standard on Linux is to not highlight
   // pressed status icons.
 }
 
 void AppIndicatorIcon::SetToolTip(const base::string16& tool_tip) {
@@ skipping 21 matching lines @@
 void AppIndicatorIcon::SetImageFromFile(const base::FilePath& icon_file_path) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
   if (icon_file_path.empty())
     return;
 
   base::FilePath old_path = icon_file_path_;
   icon_file_path_ = icon_file_path;
 
   std::string icon_name =
       icon_file_path_.BaseName().RemoveExtension().value();
-  std::string icon_dir = icon_file_path_.DirName().value();
+  std::string icon_dir = GetIconThemePath(using_kde4_, icon_file_path);
   if (!icon_) {
     icon_ =
         app_indicator_new_with_path(id_.c_str(),
                                     icon_name.c_str(),
                                     APP_INDICATOR_CATEGORY_APPLICATION_STATUS,
                                     icon_dir.c_str());
     app_indicator_set_status(icon_, APP_INDICATOR_STATUS_ACTIVE);
     SetMenu();
   } else {
     // Currently we are creating a new temp directory every time the icon is
     // set. So we need to set the directory each time.
     app_indicator_set_icon_theme_path(icon_, icon_dir.c_str());
     app_indicator_set_icon_full(icon_, icon_name.c_str(), "icon");
 
-    // Delete previous icon directory.
-    content::BrowserThread::GetBlockingPool()->PostTask(
-        FROM_HERE,
-        base::Bind(&DeleteTempImagePath, old_path.DirName()));
+    if (ShouldCreateTempDirectoryPerImage(using_kde4_)) {
+      // Delete previous icon directory.
+      content::BrowserThread::GetBlockingPool()->PostTask(
+          FROM_HERE,
+          base::Bind(&DeleteTempDirectory, old_path.DirName()));
+    }
   }
 }
 
 void AppIndicatorIcon::SetMenu() {
   menu_.reset(new AppIndicatorIconMenu(menu_model_));
   UpdateClickActionReplacementMenuItem();
   app_indicator_set_menu(icon_, menu_->GetGtkMenu());
 }
 
 void AppIndicatorIcon::UpdateClickActionReplacementMenuItem() {
@@ skipping 10 matching lines @@
       base::Bind(&AppIndicatorIcon::OnClickActionReplacementMenuItemActivated,
                  base::Unretained(this)));
 }
 
 void AppIndicatorIcon::OnClickActionReplacementMenuItemActivated() {
   if (delegate())
     delegate()->OnClick();
 }
 
 }  // namespace libgtk2ui