OLD | NEW |
| (Empty) |
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_ | |
OLD | NEW |