Home | History | Annotate | Download | only in libgtk2ui 
      1 // Copyright 2013 The Chromium Authors. All rights reserved.
      2 // Use of this source code is governed by a BSD-style license that can be
      3 // found in the LICENSE file.
      4 
      5 #include "chrome/browser/ui/libgtk2ui/app_indicator_icon.h"
      6 
      7 #include <dlfcn.h>
      8 #include <gtk/gtk.h>
      9 
     10 #include "base/bind.h"
     11 #include "base/environment.h"
     12 #include "base/files/file_util.h"
     13 #include "base/md5.h"
     14 #include "base/memory/ref_counted_memory.h"
     15 #include "base/nix/xdg_util.h"
     16 #include "base/strings/stringprintf.h"
     17 #include "base/strings/utf_string_conversions.h"
     18 #include "base/threading/sequenced_worker_pool.h"
     19 #include "chrome/browser/ui/libgtk2ui/app_indicator_icon_menu.h"
     20 #include "content/public/browser/browser_thread.h"
     21 #include "ui/base/models/menu_model.h"
     22 #include "ui/gfx/image/image.h"
     23 #include "ui/gfx/image/image_skia.h"
     24 
     25 namespace {
     26 
     27 typedef enum {
     28   APP_INDICATOR_CATEGORY_APPLICATION_STATUS,
     29   APP_INDICATOR_CATEGORY_COMMUNICATIONS,
     30   APP_INDICATOR_CATEGORY_SYSTEM_SERVICES,
     31   APP_INDICATOR_CATEGORY_HARDWARE,
     32   APP_INDICATOR_CATEGORY_OTHER
     33 } AppIndicatorCategory;
     34 
     35 typedef enum {
     36   APP_INDICATOR_STATUS_PASSIVE,
     37   APP_INDICATOR_STATUS_ACTIVE,
     38   APP_INDICATOR_STATUS_ATTENTION
     39 } AppIndicatorStatus;
     40 
     41 typedef AppIndicator* (*app_indicator_new_func)(const gchar* id,
     42                                                 const gchar* icon_name,
     43                                                 AppIndicatorCategory category);
     44 
     45 typedef AppIndicator* (*app_indicator_new_with_path_func)(
     46     const gchar* id,
     47     const gchar* icon_name,
     48     AppIndicatorCategory category,
     49     const gchar* icon_theme_path);
     50 
     51 typedef void (*app_indicator_set_status_func)(AppIndicator* self,
     52                                               AppIndicatorStatus status);
     53 
     54 typedef void (*app_indicator_set_attention_icon_full_func)(
     55     AppIndicator* self,
     56     const gchar* icon_name,
     57     const gchar* icon_desc);
     58 
     59 typedef void (*app_indicator_set_menu_func)(AppIndicator* self, GtkMenu* menu);
     60 
     61 typedef void (*app_indicator_set_icon_full_func)(AppIndicator* self,
     62                                                  const gchar* icon_name,
     63                                                  const gchar* icon_desc);
     64 
     65 typedef void (*app_indicator_set_icon_theme_path_func)(
     66     AppIndicator* self,
     67     const gchar* icon_theme_path);
     68 
     69 bool g_attempted_load = false;
     70 bool g_opened = false;
     71 
     72 // Retrieved functions from libappindicator.
     73 app_indicator_new_func app_indicator_new = NULL;
     74 app_indicator_new_with_path_func app_indicator_new_with_path = NULL;
     75 app_indicator_set_status_func app_indicator_set_status = NULL;
     76 app_indicator_set_attention_icon_full_func
     77     app_indicator_set_attention_icon_full = NULL;
     78 app_indicator_set_menu_func app_indicator_set_menu = NULL;
     79 app_indicator_set_icon_full_func app_indicator_set_icon_full = NULL;
     80 app_indicator_set_icon_theme_path_func app_indicator_set_icon_theme_path = NULL;
     81 
     82 void EnsureMethodsLoaded() {
     83   if (g_attempted_load)
     84     return;
     85 
     86   g_attempted_load = true;
     87 
     88   // Only use libappindicator where it is needed to support dbus based status
     89   // icons. In particular, libappindicator does not support a click action.
     90   scoped_ptr<base::Environment> env(base::Environment::Create());
     91   base::nix::DesktopEnvironment environment =
     92       base::nix::GetDesktopEnvironment(env.get());
     93   if (environment != base::nix::DESKTOP_ENVIRONMENT_KDE4 &&
     94       environment != base::nix::DESKTOP_ENVIRONMENT_UNITY) {
     95     return;
     96   }
     97 
     98   void* indicator_lib = dlopen("libappindicator.so", RTLD_LAZY);
     99   if (!indicator_lib) {
    100     indicator_lib = dlopen("libappindicator.so.1", RTLD_LAZY);
    101   }
    102   if (!indicator_lib) {
    103     indicator_lib = dlopen("libappindicator.so.0", RTLD_LAZY);
    104   }
    105   if (!indicator_lib) {
    106     return;
    107   }
    108 
    109   g_opened = true;
    110 
    111   app_indicator_new = reinterpret_cast<app_indicator_new_func>(
    112       dlsym(indicator_lib, "app_indicator_new"));
    113 
    114   app_indicator_new_with_path =
    115       reinterpret_cast<app_indicator_new_with_path_func>(
    116           dlsym(indicator_lib, "app_indicator_new_with_path"));
    117 
    118   app_indicator_set_status = reinterpret_cast<app_indicator_set_status_func>(
    119       dlsym(indicator_lib, "app_indicator_set_status"));
    120 
    121   app_indicator_set_attention_icon_full =
    122       reinterpret_cast<app_indicator_set_attention_icon_full_func>(
    123           dlsym(indicator_lib, "app_indicator_set_attention_icon_full"));
    124 
    125   app_indicator_set_menu = reinterpret_cast<app_indicator_set_menu_func>(
    126       dlsym(indicator_lib, "app_indicator_set_menu"));
    127 
    128   app_indicator_set_icon_full =
    129       reinterpret_cast<app_indicator_set_icon_full_func>(
    130           dlsym(indicator_lib, "app_indicator_set_icon_full"));
    131 
    132   app_indicator_set_icon_theme_path =
    133       reinterpret_cast<app_indicator_set_icon_theme_path_func>(
    134           dlsym(indicator_lib, "app_indicator_set_icon_theme_path"));
    135 }
    136 
    137 // Returns whether a temporary directory should be created for each app
    138 // indicator image.
    139 bool ShouldCreateTempDirectoryPerImage(bool using_kde4) {
    140   // Create a new temporary directory for each image on Unity since using a
    141   // single temporary directory seems to have issues when changing icons in
    142   // quick succession.
    143   return !using_kde4;
    144 }
    145 
    146 // Returns the subdirectory of |temp_dir| in which the app indicator image
    147 // should be saved.
    148 base::FilePath GetImageDirectoryPath(bool using_kde4,
    149                                      const base::FilePath& temp_dir) {
    150   // On KDE4, an image located in a directory ending with
    151   // "icons/hicolor/16x16/apps" can be used as the app indicator image because
    152   // "/usr/share/icons/hicolor/16x16/apps" exists.
    153   return using_kde4 ?
    154       temp_dir.AppendASCII("icons").AppendASCII("hicolor").AppendASCII("16x16").
    155           AppendASCII("apps") :
    156       temp_dir;
    157 }
    158 
    159 std::string GetImageFileNameForKDE4(
    160     const scoped_refptr<base::RefCountedMemory>& png_data) {
    161   // On KDE4, the name of the image file for each different looking bitmap must
    162   // be unique. It must also be unique across runs of Chrome.
    163   base::MD5Digest digest;
    164   base::MD5Sum(png_data->front_as<char>(), png_data->size(), &digest);
    165   return base::StringPrintf("chrome_app_indicator_%s.png",
    166                             base::MD5DigestToBase16(digest).c_str());
    167 }
    168 
    169 std::string GetImageFileNameForNonKDE4(int icon_change_count,
    170                                        const std::string& id) {
    171   return base::StringPrintf("%s_%d.png", id.c_str(), icon_change_count);
    172 }
    173 
    174 // Returns the "icon theme path" given the file path of the app indicator image.
    175 std::string GetIconThemePath(bool using_kde4,
    176                              const base::FilePath& image_path) {
    177   return using_kde4 ?
    178       image_path.DirName().DirName().DirName().DirName().value() :
    179       image_path.DirName().value();
    180 }
    181 
    182 base::FilePath CreateTempImageFile(bool using_kde4,
    183                                    gfx::ImageSkia* image_ptr,
    184                                    int icon_change_count,
    185                                    std::string id,
    186                                    const base::FilePath& previous_file_path) {
    187   scoped_ptr<gfx::ImageSkia> image(image_ptr);
    188 
    189   scoped_refptr<base::RefCountedMemory> png_data =
    190       gfx::Image(*image.get()).As1xPNGBytes();
    191   if (png_data->size() == 0) {
    192     // If the bitmap could not be encoded to PNG format, skip it.
    193     LOG(WARNING) << "Could not encode icon";
    194     return base::FilePath();
    195   }
    196 
    197   base::FilePath new_file_path;
    198   if (previous_file_path.empty() ||
    199       ShouldCreateTempDirectoryPerImage(using_kde4)) {
    200     base::FilePath tmp_dir;
    201     if (!base::CreateNewTempDirectory(base::FilePath::StringType(), &tmp_dir))
    202       return base::FilePath();
    203     new_file_path = GetImageDirectoryPath(using_kde4, tmp_dir);
    204     if (new_file_path != tmp_dir) {
    205       if (!base::CreateDirectory(new_file_path))
    206         return base::FilePath();
    207     }
    208   } else {
    209     new_file_path = previous_file_path.DirName();
    210   }
    211 
    212   new_file_path = new_file_path.Append(using_kde4 ?
    213       GetImageFileNameForKDE4(png_data) :
    214       GetImageFileNameForNonKDE4(icon_change_count, id));
    215 
    216   int bytes_written =
    217       base::WriteFile(new_file_path,
    218                       png_data->front_as<char>(), png_data->size());
    219 
    220   if (bytes_written != static_cast<int>(png_data->size()))
    221     return base::FilePath();
    222   return new_file_path;
    223 }
    224 
    225 void DeleteTempDirectory(const base::FilePath& dir_path) {
    226   if (dir_path.empty())
    227     return;
    228   base::DeleteFile(dir_path, true);
    229 }
    230 
    231 }  // namespace
    232 
    233 namespace libgtk2ui {
    234 
    235 AppIndicatorIcon::AppIndicatorIcon(std::string id,
    236                                    const gfx::ImageSkia& image,
    237                                    const base::string16& tool_tip)
    238     : id_(id),
    239       using_kde4_(false),
    240       icon_(NULL),
    241       menu_model_(NULL),
    242       icon_change_count_(0),
    243       weak_factory_(this) {
    244   scoped_ptr<base::Environment> env(base::Environment::Create());
    245   using_kde4_ = base::nix::GetDesktopEnvironment(env.get()) ==
    246       base::nix::DESKTOP_ENVIRONMENT_KDE4;
    247 
    248   EnsureMethodsLoaded();
    249   tool_tip_ = base::UTF16ToUTF8(tool_tip);
    250   SetImage(image);
    251 }
    252 AppIndicatorIcon::~AppIndicatorIcon() {
    253   if (icon_) {
    254     app_indicator_set_status(icon_, APP_INDICATOR_STATUS_PASSIVE);
    255     g_object_unref(icon_);
    256     content::BrowserThread::GetBlockingPool()->PostTask(
    257         FROM_HERE,
    258         base::Bind(&DeleteTempDirectory, icon_file_path_.DirName()));
    259   }
    260 }
    261 
    262 // static
    263 bool AppIndicatorIcon::CouldOpen() {
    264   EnsureMethodsLoaded();
    265   return g_opened;
    266 }
    267 
    268 void AppIndicatorIcon::SetImage(const gfx::ImageSkia& image) {
    269   if (!g_opened)
    270     return;
    271 
    272   ++icon_change_count_;
    273 
    274   // We create a deep copy of the image since it may have been freed by the time
    275   // it's accessed in the other thread.
    276   scoped_ptr<gfx::ImageSkia> safe_image(image.DeepCopy());
    277   base::PostTaskAndReplyWithResult(
    278       content::BrowserThread::GetBlockingPool()
    279           ->GetTaskRunnerWithShutdownBehavior(
    280                 base::SequencedWorkerPool::SKIP_ON_SHUTDOWN).get(),
    281       FROM_HERE,
    282       base::Bind(&CreateTempImageFile,
    283                  using_kde4_,
    284                  safe_image.release(),
    285                  icon_change_count_,
    286                  id_,
    287                  icon_file_path_),
    288       base::Bind(&AppIndicatorIcon::SetImageFromFile,
    289                  weak_factory_.GetWeakPtr()));
    290 }
    291 
    292 void AppIndicatorIcon::SetToolTip(const base::string16& tool_tip) {
    293   DCHECK(!tool_tip_.empty());
    294   tool_tip_ = base::UTF16ToUTF8(tool_tip);
    295   UpdateClickActionReplacementMenuItem();
    296 }
    297 
    298 void AppIndicatorIcon::UpdatePlatformContextMenu(ui::MenuModel* model) {
    299   if (!g_opened)
    300     return;
    301 
    302   menu_model_ = model;
    303 
    304   // The icon is created asynchronously so it might not exist when the menu is
    305   // set.
    306   if (icon_)
    307     SetMenu();
    308 }
    309 
    310 void AppIndicatorIcon::RefreshPlatformContextMenu() {
    311   menu_->Refresh();
    312 }
    313 
    314 void AppIndicatorIcon::SetImageFromFile(const base::FilePath& icon_file_path) {
    315   DCHECK_CURRENTLY_ON(content::BrowserThread::UI);
    316   if (icon_file_path.empty())
    317     return;
    318 
    319   base::FilePath old_path = icon_file_path_;
    320   icon_file_path_ = icon_file_path;
    321 
    322   std::string icon_name =
    323       icon_file_path_.BaseName().RemoveExtension().value();
    324   std::string icon_dir = GetIconThemePath(using_kde4_, icon_file_path);
    325   if (!icon_) {
    326     icon_ =
    327         app_indicator_new_with_path(id_.c_str(),
    328                                     icon_name.c_str(),
    329                                     APP_INDICATOR_CATEGORY_APPLICATION_STATUS,
    330                                     icon_dir.c_str());
    331     app_indicator_set_status(icon_, APP_INDICATOR_STATUS_ACTIVE);
    332     SetMenu();
    333   } else {
    334     // Currently we are creating a new temp directory every time the icon is
    335     // set. So we need to set the directory each time.
    336     app_indicator_set_icon_theme_path(icon_, icon_dir.c_str());
    337     app_indicator_set_icon_full(icon_, icon_name.c_str(), "icon");
    338 
    339     if (ShouldCreateTempDirectoryPerImage(using_kde4_)) {
    340       // Delete previous icon directory.
    341       content::BrowserThread::GetBlockingPool()->PostTask(
    342           FROM_HERE,
    343           base::Bind(&DeleteTempDirectory, old_path.DirName()));
    344     }
    345   }
    346 }
    347 
    348 void AppIndicatorIcon::SetMenu() {
    349   menu_.reset(new AppIndicatorIconMenu(menu_model_));
    350   UpdateClickActionReplacementMenuItem();
    351   app_indicator_set_menu(icon_, menu_->GetGtkMenu());
    352 }
    353 
    354 void AppIndicatorIcon::UpdateClickActionReplacementMenuItem() {
    355   // The menu may not have been created yet.
    356   if (!menu_.get())
    357     return;
    358 
    359   if (!delegate()->HasClickAction() && menu_model_)
    360     return;
    361 
    362   DCHECK(!tool_tip_.empty());
    363   menu_->UpdateClickActionReplacementMenuItem(
    364       tool_tip_.c_str(),
    365       base::Bind(&AppIndicatorIcon::OnClickActionReplacementMenuItemActivated,
    366                  base::Unretained(this)));
    367 }
    368 
    369 void AppIndicatorIcon::OnClickActionReplacementMenuItemActivated() {
    370   if (delegate())
    371     delegate()->OnClick();
    372 }
    373 
    374 }  // namespace libgtk2ui
    375