src/ui/gfx/gtk_native_view_id_manager.cc

   1 // Copyright (c) 2012 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 "ui/gfx/gtk_native_view_id_manager.h"
   6
   7 #include <gdk/gdkx.h>
   8 #include <gtk/gtk.h>
   9
  10 #include "base/logging.h"
  11 #include "base/memory/singleton.h"
  12 #include "base/rand_util.h"
  13 #include "ui/gfx/gdk_compat.h"
  14 #include "ui/gfx/gtk_compat.h"
  15 #include "ui/gfx/gtk_preserve_window.h"
  16
  17 // -----------------------------------------------------------------------------
  18 // Bounce functions for GTK to callback into a C++ object...
  19
  20 void OnRealize(gfx::NativeView widget, void* arg) {
  21   GtkNativeViewManager* manager = reinterpret_cast<GtkNativeViewManager*>(arg);
  22   manager->OnRealize(widget);
  23 }
  24
  25 void OnUnrealize(gfx::NativeView widget, void *arg) {
  26   GtkNativeViewManager* manager = reinterpret_cast<GtkNativeViewManager*>(arg);
  27   manager->OnUnrealize(widget);
  28 }
  29
  30 static void OnDestroy(GtkObject* obj, void* arg) {
  31   GtkNativeViewManager* manager = reinterpret_cast<GtkNativeViewManager*>(arg);
  32   manager->OnDestroy(reinterpret_cast<GtkWidget*>(obj));
  33 }
  34
  35 // -----------------------------------------------------------------------------
  36
  37
  38 // -----------------------------------------------------------------------------
  39 // Public functions...
  40
  41 GtkNativeViewManager::GtkNativeViewManager() {
  42 }
  43
  44 GtkNativeViewManager::~GtkNativeViewManager() {
  45 }
  46
  47 // static
  48 GtkNativeViewManager* GtkNativeViewManager::GetInstance() {
  49   return Singleton<GtkNativeViewManager>::get();
  50 }
  51
  52 gfx::NativeViewId GtkNativeViewManager::GetIdForWidget(gfx::NativeView widget) {
  53   // This is just for unit tests:
  54   if (!widget)
  55     return 0;
  56
  57   base::AutoLock locked(lock_);
  58
  59   std::map<gfx::NativeView, gfx::NativeViewId>::const_iterator i =
  60     native_view_to_id_.find(widget);
  61
  62   if (i != native_view_to_id_.end())
  63     return i->second;
  64
  65   gfx::NativeViewId new_id =
  66       static_cast<gfx::NativeViewId>(base::RandUint64());
  67   while (id_to_info_.find(new_id) != id_to_info_.end())
  68     new_id = static_cast<gfx::NativeViewId>(base::RandUint64());
  69
  70   NativeViewInfo info;
  71   info.widget = widget;
  72   if (gtk_widget_get_realized(widget)) {
  73     GdkWindow *gdk_window = gtk_widget_get_window(widget);
  74     DCHECK(gdk_window);
  75     info.x_window_id = GDK_WINDOW_XID(gdk_window);
  76   }
  77
  78   native_view_to_id_[widget] = new_id;
  79   id_to_info_[new_id] = info;
  80
  81   g_signal_connect(widget, "realize", G_CALLBACK(::OnRealize), this);
  82   g_signal_connect(widget, "unrealize", G_CALLBACK(::OnUnrealize), this);
  83   g_signal_connect(widget, "destroy", G_CALLBACK(::OnDestroy), this);
  84
  85   return new_id;
  86 }
  87
  88 bool GtkNativeViewManager::GetXIDForId(XID* output, gfx::NativeViewId id) {
  89   base::AutoLock locked(lock_);
  90
  91   std::map<gfx::NativeViewId, NativeViewInfo>::const_iterator i =
  92       id_to_info_.find(id);
  93
  94   if (i == id_to_info_.end())
  95     return false;
  96
  97   *output = i->second.x_window_id;
  98   return true;
  99 }
 100
 101 bool GtkNativeViewManager::GetNativeViewForId(gfx::NativeView* output,
 102                                               gfx::NativeViewId id) {
 103   base::AutoLock locked(lock_);
 104
 105   std::map<gfx::NativeViewId, NativeViewInfo>::const_iterator i =
 106       id_to_info_.find(id);
 107
 108   if (i == id_to_info_.end())
 109     return false;
 110
 111   *output = i->second.widget;
 112   return true;
 113 }
 114
 115 bool GtkNativeViewManager::GetPermanentXIDForId(XID* output,
 116                                                 gfx::NativeViewId id) {
 117   base::AutoLock locked(lock_);
 118
 119   std::map<gfx::NativeViewId, NativeViewInfo>::iterator i =
 120       id_to_info_.find(id);
 121
 122   if (i == id_to_info_.end())
 123     return false;
 124
 125   // We only return permanent XIDs for widgets that allow us to guarantee that
 126   // the XID will not change.
 127   DCHECK(GTK_IS_PRESERVE_WINDOW(i->second.widget));
 128   GtkPreserveWindow* widget =
 129       reinterpret_cast<GtkPreserveWindow*>(i->second.widget);
 130   gtk_preserve_window_set_preserve(widget, TRUE);
 131
 132   *output = GDK_WINDOW_XID(gtk_widget_get_window(i->second.widget));
 133
 134   // Update the reference count on the permanent XID.
 135   PermanentXIDInfo info;
 136   info.widget = widget;
 137   info.ref_count = 1;
 138   std::pair<std::map<XID, PermanentXIDInfo>::iterator, bool> ret =
 139     perm_xid_to_info_.insert(std::make_pair(*output, info));
 140
 141   if (!ret.second) {
 142     DCHECK(ret.first->second.widget == widget);
 143     ret.first->second.ref_count++;
 144   }
 145
 146   return true;
 147 }
 148
 149 bool GtkNativeViewManager::AddRefPermanentXID(XID xid) {
 150   base::AutoLock locked(lock_);
 151
 152   std::map<XID, PermanentXIDInfo>::iterator i =
 153     perm_xid_to_info_.find(xid);
 154
 155   if (i == perm_xid_to_info_.end())
 156     return false;
 157
 158   i->second.ref_count++;
 159
 160   return true;
 161 }
 162
 163 void GtkNativeViewManager::ReleasePermanentXID(XID xid) {
 164   base::AutoLock locked(lock_);
 165
 166   std::map<XID, PermanentXIDInfo>::iterator i =
 167     perm_xid_to_info_.find(xid);
 168
 169   if (i == perm_xid_to_info_.end())
 170     return;
 171
 172   if (i->second.ref_count > 1) {
 173     i->second.ref_count--;
 174   } else {
 175     if (i->second.widget) {
 176       gtk_preserve_window_set_preserve(i->second.widget, FALSE);
 177     } else {
 178       GdkWindow* window = reinterpret_cast<GdkWindow*>(
 179           gdk_x11_window_lookup_for_display(gdk_display_get_default(), xid));
 180       DCHECK(window);
 181       gdk_window_destroy(window);
 182     }
 183     perm_xid_to_info_.erase(i);
 184   }
 185 }
 186
 187 // -----------------------------------------------------------------------------
 188
 189
 190 // -----------------------------------------------------------------------------
 191 // Private functions...
 192
 193 gfx::NativeViewId GtkNativeViewManager::GetWidgetId(gfx::NativeView widget) {
 194   lock_.AssertAcquired();
 195
 196   std::map<gfx::NativeView, gfx::NativeViewId>::const_iterator i =
 197     native_view_to_id_.find(widget);
 198
 199   CHECK(i != native_view_to_id_.end());
 200   return i->second;
 201 }
 202
 203 void GtkNativeViewManager::OnRealize(gfx::NativeView widget) {
 204   base::AutoLock locked(lock_);
 205
 206   const gfx::NativeViewId id = GetWidgetId(widget);
 207   std::map<gfx::NativeViewId, NativeViewInfo>::iterator i =
 208     id_to_info_.find(id);
 209
 210   CHECK(i != id_to_info_.end());
 211
 212   GdkWindow* gdk_window = gtk_widget_get_window(widget);
 213   CHECK(gdk_window);
 214   i->second.x_window_id = GDK_WINDOW_XID(gdk_window);
 215 }
 216
 217 void GtkNativeViewManager::OnUnrealize(gfx::NativeView widget) {
 218   base::AutoLock locked(lock_);
 219
 220   const gfx::NativeViewId id = GetWidgetId(widget);
 221   std::map<gfx::NativeViewId, NativeViewInfo>::iterator i =
 222     id_to_info_.find(id);
 223
 224   CHECK(i != id_to_info_.end());
 225 }
 226
 227 void GtkNativeViewManager::OnDestroy(gfx::NativeView widget) {
 228   base::AutoLock locked(lock_);
 229
 230   std::map<gfx::NativeView, gfx::NativeViewId>::iterator i =
 231     native_view_to_id_.find(widget);
 232   CHECK(i != native_view_to_id_.end());
 233
 234   std::map<gfx::NativeViewId, NativeViewInfo>::iterator j =
 235     id_to_info_.find(i->second);
 236   CHECK(j != id_to_info_.end());
 237
 238   // If the XID is supposed to outlive the widget, mark it
 239   // in the lookup table.
 240   if (GTK_IS_PRESERVE_WINDOW(widget) &&
 241       gtk_preserve_window_get_preserve(
 242           reinterpret_cast<GtkPreserveWindow*>(widget))) {
 243     std::map<XID, PermanentXIDInfo>::iterator k =
 244         perm_xid_to_info_.find(GDK_WINDOW_XID(gtk_widget_get_window(widget)));
 245
 246     if (k != perm_xid_to_info_.end())
 247       k->second.widget = NULL;
 248   }
 249
 250   native_view_to_id_.erase(i);
 251   id_to_info_.erase(j);
 252 }
 253
 254 // -----------------------------------------------------------------------------