src/ui/gfx/gtk_native_view_id_manager.h

   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 #ifndef UI_GFX_GTK_NATIVE_VIEW_ID_MANAGER_H_
   6 #define UI_GFX_GTK_NATIVE_VIEW_ID_MANAGER_H_
   7
   8 #include <map>
   9
  10 #include "base/synchronization/lock.h"
  11 #include "ui/gfx/gfx_export.h"
  12 #include "ui/gfx/native_widget_types.h"
  13
  14 template <typename T> struct DefaultSingletonTraits;
  15
  16 typedef unsigned long XID;
  17 struct _GtkPreserveWindow;
  18
  19 // NativeViewIds are the opaque values which the renderer holds as a reference
  20 // to a window.
  21 //
  22 // We could make NativeViewIds be the X id of the window. However, at the
  23 // time when we need to tell the renderer about its NativeViewId, an XID isn't
  24 // availible and it goes very much against the grain of the code to make it so.
  25 // Also, we worry that GTK might choose to change the underlying X window id
  26 // when, say, the widget is hidden or repacked. Finally, if we used XIDs then a
  27 // compromised renderer could start asking questions about any X windows on the
  28 // system.
  29 //
  30 // Thus, we have this object. It produces random NativeViewIds from GtkWidget
  31 // pointers and observes the various signals from the widget for when an X
  32 // window is created, destroyed etc. Thus it provides a thread safe mapping
  33 // from NativeViewIds to the current XID for that widget.
  34 class GFX_EXPORT GtkNativeViewManager {
  35  public:
  36   // Returns the singleton instance.
  37   static GtkNativeViewManager* GetInstance();
  38
  39   // Must be called from the UI thread:
  40   //
  41   // Return a NativeViewId for the given widget and attach to the various
  42   // signals emitted by that widget. The NativeViewId is pseudo-randomly
  43   // allocated so that a compromised renderer trying to guess values will fail
  44   // with high probability. The NativeViewId will not be reused for the
  45   // lifetime of the GtkWidget.
  46   gfx::NativeViewId GetIdForWidget(gfx::NativeView widget);
  47
  48   // May be called from any thread:
  49   //
  50   // xid: (output) the resulting X window ID, or 0
  51   // id: a value previously returned from GetIdForWidget
  52   // returns: true if |id| is a valid id, false otherwise.
  53   //
  54   // If the widget referenced by |id| does not current have an X window id,
  55   // |*xid| is set to 0.
  56   bool GetXIDForId(XID* xid, gfx::NativeViewId id);
  57
  58   // May be called from the UI thread:
  59   //
  60   // Same as GetXIDForId except it returns the NativeView (GtkWidget*).
  61   bool GetNativeViewForId(gfx::NativeView* xid, gfx::NativeViewId id);
  62
  63   // Must be called from the UI thread because we may need the associated
  64   // widget to create a window.
  65   //
  66   // Keeping the XID permanent requires a bit of overhead, so it must
  67   // be explicitly requested.
  68   //
  69   // xid: (output) the resulting X window
  70   // id: a value previously returned from GetIdForWidget
  71   // returns: true if |id| is a valid id, false otherwise.
  72   bool GetPermanentXIDForId(XID* xid, gfx::NativeViewId id);
  73
  74   // Can be called from any thread.
  75   // Will return false if the given XID isn't permanent or has already been
  76   // released.
  77   bool AddRefPermanentXID(XID xid);
  78
  79   // Must be called from the UI thread because we may need to access a
  80   // GtkWidget or destroy a GdkWindow.
  81   //
  82   // If the widget associated with the XID is still alive, allow the widget
  83   // to destroy the associated XID when it wants. Otherwise, destroy the
  84   // GdkWindow associated with the XID.
  85   void ReleasePermanentXID(XID xid);
  86
  87   // These are actually private functions, but need to be called from statics.
  88   void OnRealize(gfx::NativeView widget);
  89   void OnUnrealize(gfx::NativeView widget);
  90   void OnDestroy(gfx::NativeView widget);
  91
  92  private:
  93   // This object is a singleton:
  94   GtkNativeViewManager();
  95   ~GtkNativeViewManager();
  96   friend struct DefaultSingletonTraits<GtkNativeViewManager>;
  97
  98   struct NativeViewInfo {
  99     NativeViewInfo() : widget(NULL), x_window_id(0) {
 100     }
 101     gfx::NativeView widget;
 102     XID x_window_id;
 103   };
 104
 105   gfx::NativeViewId GetWidgetId(gfx::NativeView id);
 106
 107   // protects native_view_to_id_ and id_to_info_
 108   base::Lock lock_;
 109
 110   // If asked for an id for the same widget twice, we want to return the same
 111   // id. So this records the current mapping.
 112   std::map<gfx::NativeView, gfx::NativeViewId> native_view_to_id_;
 113   std::map<gfx::NativeViewId, NativeViewInfo> id_to_info_;
 114
 115   struct PermanentXIDInfo {
 116     PermanentXIDInfo() : widget(NULL), ref_count(0) {
 117     }
 118     _GtkPreserveWindow* widget;
 119     int ref_count;
 120   };
 121
 122   // Used to maintain the reference count for permanent XIDs
 123   // (referenced by GetPermanentXIDForId and dereferenced by
 124   // ReleasePermanentXID). Only those XIDs with a positive reference count
 125   // will be in the table.
 126   //
 127   // In general, several GTK widgets may share the same X window. We assume
 128   // that is not true of the widgets stored in this registry.
 129   //
 130   // An XID will map to NULL, if there is an outstanding reference but the
 131   // widget was destroyed. In this case, the destruction of the X window
 132   // is deferred to the dropping of all references.
 133   std::map<XID, PermanentXIDInfo> perm_xid_to_info_;
 134
 135   DISALLOW_COPY_AND_ASSIGN(GtkNativeViewManager);
 136 };
 137
 138 #endif  // UI_GFX_GTK_NATIVE_VIEW_ID_MANAGER_H_