Make system tray icons not show up as blurry on KDE

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 <dlfcn.h>
 #include <gtk/gtk.h>
 
 #include "base/bind.h"
 #include "base/environment.h"
 #include "base/files/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 "third_party/skia/include/core/SkBitmap.h"
+#include "third_party/skia/include/core/SkCanvas.h"
 #include "ui/base/models/menu_model.h"
+#include "ui/gfx/codec/png_codec.h"
 #include "ui/gfx/image/image.h"
 #include "ui/gfx/image/image_skia.h"
 
 namespace {
 
 typedef enum {
   APP_INDICATOR_CATEGORY_APPLICATION_STATUS,
   APP_INDICATOR_CATEGORY_COMMUNICATIONS,
   APP_INDICATOR_CATEGORY_SYSTEM_SERVICES,
   APP_INDICATOR_CATEGORY_HARDWARE,
@@ skipping 95 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"));
 }
 
-// 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;
-}
-
-// 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.
-  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) {
-  // On KDE4, the name of the image file for each different looking bitmap must
-  // be unique. It must also be unique across runs of Chrome.
-  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,
-                                   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 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();
-  }
-
-  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;
+// Writes |bitmap| to a file at |path|. Returns true if successful.
+bool WriteFile(const base::FilePath& path, const SkBitmap& bitmap) {
+  std::vector<unsigned char> png_data;
+  if (!gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, false, &png_data))
+    return false;
+  int bytes_written = base::WriteFile(
+      path, reinterpret_cast<char*>(&png_data[0]), png_data.size());
+  return (bytes_written == static_cast<int>(png_data.size()));
 }
 
 void DeleteTempDirectory(const base::FilePath& dir_path) {
   if (dir_path.empty())
     return;
   base::DeleteFile(dir_path, true);
 }
 
 }  // namespace
 
@@ skipping 15 matching lines @@
   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(&DeleteTempDirectory, icon_file_path_.DirName()));
+        base::Bind(&DeleteTempDirectory, temp_dir_.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(
+  // Copy the bitmap because it may be freed by the time it's accessed in
+  // another thread.
+  SkBitmap safe_bitmap = *image.bitmap();
+
+  scoped_refptr<base::TaskRunner> task_runner =
       content::BrowserThread::GetBlockingPool()
           ->GetTaskRunnerWithShutdownBehavior(
-                base::SequencedWorkerPool::SKIP_ON_SHUTDOWN).get(),
-      FROM_HERE,
-      base::Bind(&CreateTempImageFile,
-                 using_kde4_,
-                 safe_image.release(),
-                 icon_change_count_,
-                 id_,
-                 icon_file_path_),
-      base::Bind(&AppIndicatorIcon::SetImageFromFile,
-                 weak_factory_.GetWeakPtr()));
+                base::SequencedWorkerPool::SKIP_ON_SHUTDOWN);
+  if (using_kde4_) {
+    base::PostTaskAndReplyWithResult(
+        task_runner.get(), FROM_HERE,
+        base::Bind(AppIndicatorIcon::WriteKDE4TempImageOnWorkerThread,
+                   safe_bitmap, temp_dir_),
+        base::Bind(&AppIndicatorIcon::SetImageFromFile,
+                   weak_factory_.GetWeakPtr()));
+  } else {
+    base::PostTaskAndReplyWithResult(
+        task_runner.get(), FROM_HERE,
+        base::Bind(AppIndicatorIcon::WriteUnityTempImageOnWorkerThread,
+                   safe_bitmap, icon_change_count_, id_),
+        base::Bind(&AppIndicatorIcon::SetImageFromFile,
+                   weak_factory_.GetWeakPtr()));
+  }
 }
 
 void AppIndicatorIcon::SetToolTip(const base::string16& tool_tip) {
   DCHECK(!tool_tip_.empty());
   tool_tip_ = base::UTF16ToUTF8(tool_tip);
   UpdateClickActionReplacementMenuItem();
 }
 
 void AppIndicatorIcon::UpdatePlatformContextMenu(ui::MenuModel* model) {
   if (!g_opened)
     return;
 
   menu_model_ = model;
 
   // The icon is created asynchronously so it might not exist when the menu is
   // set.
   if (icon_)
     SetMenu();
 }
 
 void AppIndicatorIcon::RefreshPlatformContextMenu() {
   menu_->Refresh();
 }
 
-void AppIndicatorIcon::SetImageFromFile(const base::FilePath& icon_file_path) {
+// static
+AppIndicatorIcon::SetImageFromFileParams
+AppIndicatorIcon::WriteKDE4TempImageOnWorkerThread(
+    const SkBitmap& bitmap,
+    const base::FilePath& existing_temp_dir) {
+  base::FilePath temp_dir = existing_temp_dir;
+  if (temp_dir.empty() &&
+      !base::CreateNewTempDirectory(base::FilePath::StringType(), &temp_dir)) {
+    LOG(WARNING) << "Could not create temporary directory";
+    return SetImageFromFileParams();
+  }
+
+  base::FilePath icon_theme_path = temp_dir.AppendASCII("icons");
+
+  // On KDE4, an image located in a directory ending with
+  // "icons/hicolor/24x24/apps" can be used as the app indicator image because
+  // "/usr/share/icons/hicolor/24x24/apps" exists.
+  base::FilePath image_dir = icon_theme_path.AppendASCII("hicolor")
+                                 .AppendASCII("24x24")
+                                 .AppendASCII("apps");
+
+  if (!base::CreateDirectory(image_dir))
+    return SetImageFromFileParams();
+
+  // On KDE4, the name of the image file for each different looking bitmap must
+  // be unique. It must also be unique across runs of Chrome.
+  std::vector<unsigned char> bitmap_png_data;
+  if (!gfx::PNGCodec::EncodeBGRASkBitmap(bitmap, false, &bitmap_png_data)) {
+    LOG(WARNING) << "Could not encode icon";
+    return SetImageFromFileParams();
+  }
+  base::MD5Digest digest;
+  base::MD5Sum(reinterpret_cast<char*>(&bitmap_png_data[0]),
+               bitmap_png_data.size(), &digest);
+  std::string icon_name = base::StringPrintf(
+      "chrome_app_indicator2_%s", base::MD5DigestToBase16(digest).c_str());
+
+  // If |bitmap| is not 24x24, KDE does some really ugly resizing. Pad |bitmap|
+  // with transparent pixels to make it 24x24.
+  const int kDesiredSize = 24;
+  SkBitmap scaled_bitmap;
+  scaled_bitmap.allocN32Pixels(kDesiredSize, kDesiredSize);
+  scaled_bitmap.eraseARGB(0, 0, 0, 0);
+  SkCanvas canvas(scaled_bitmap);
+  canvas.drawBitmap(bitmap, (kDesiredSize - bitmap.width()) / 2,
+                    (kDesiredSize - bitmap.height()) / 2);
+
+  base::FilePath image_path = image_dir.Append(icon_name + ".png");
+  if (!WriteFile(image_path, scaled_bitmap))
+    return SetImageFromFileParams();
+
+  SetImageFromFileParams params;
+  params.parent_temp_dir = temp_dir;
+  params.icon_theme_path = icon_theme_path.value();
+  params.icon_name = icon_name;
+  return params;
+}
+
+// static
+AppIndicatorIcon::SetImageFromFileParams
+AppIndicatorIcon::WriteUnityTempImageOnWorkerThread(const SkBitmap& bitmap,
+                                                    int icon_change_count,
+                                                    const std::string& id) {
+  // 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.
+  base::FilePath temp_dir;
+  if (!base::CreateNewTempDirectory(base::FilePath::StringType(), &temp_dir)) {
+    LOG(WARNING) << "Could not create temporary directory";
+    return SetImageFromFileParams();
+  }
+
+  std::string icon_name =
+      base::StringPrintf("%s_%d", id.c_str(), icon_change_count);
+  base::FilePath image_path = temp_dir.Append(icon_name + ".png");
+  SetImageFromFileParams params;
+  if (WriteFile(image_path, bitmap)) {
+    params.parent_temp_dir = temp_dir;
+    params.icon_theme_path = temp_dir.value();
+    params.icon_name = icon_name;
+  }
+  return params;
+}
+
+void AppIndicatorIcon::SetImageFromFile(const SetImageFromFileParams& params) {
   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
-  if (icon_file_path.empty())
+  if (params.icon_theme_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 = GetIconThemePath(using_kde4_, icon_file_path);
   if (!icon_) {
     icon_ =
         app_indicator_new_with_path(id_.c_str(),
-                                    icon_name.c_str(),
+                                    params.icon_name.c_str(),
                                     APP_INDICATOR_CATEGORY_APPLICATION_STATUS,
-                                    icon_dir.c_str());
+                                    params.icon_theme_path.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");
+    app_indicator_set_icon_theme_path(icon_, params.icon_theme_path.c_str());
+    app_indicator_set_icon_full(icon_, params.icon_name.c_str(), "icon");
+  }
 
-    if (ShouldCreateTempDirectoryPerImage(using_kde4_)) {
-      // Delete previous icon directory.
-      content::BrowserThread::GetBlockingPool()->PostTask(
-          FROM_HERE,
-          base::Bind(&DeleteTempDirectory, old_path.DirName()));
-    }
+  if (temp_dir_ != params.parent_temp_dir) {
+    content::BrowserThread::GetBlockingPool()->PostTask(
+        FROM_HERE,
+        base::Bind(&DeleteTempDirectory, temp_dir_));
+    temp_dir_ = params.parent_temp_dir;
   }
 }
 
 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