Move some more files to toplevel gfx dir.

TBR=darin
BUG=none
TEST=none


git-svn-id: svn://svn.chromium.org/chrome/trunk/src@41812 0039d316-1c4b-4281-b951-d872f2087c98

1 files changed, 91 insertions, 0 deletions

diff --git a/gfx/gtk_native_view_id_manager.h b/gfx/gtk_native_view_id_manager.h
new file mode 100644
index 0000000..048cd2d
--- /dev/null
+++ b/gfx/gtk_native_view_id_manager.h
@@ -0,0 +1,91 @@
+// Copyright (c) 2009 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.
+
+#ifndef GFX_GTK_NATIVE_VIEW_ID_MANAGER_H_
+#define GFX_GTK_NATIVE_VIEW_ID_MANAGER_H_
+
+#include <map>
+
+#include "base/singleton.h"
+#include "gfx/native_widget_types.h"
+
+typedef unsigned long XID;
+
+// NativeViewIds are the opaque values which the renderer holds as a reference
+// to a window. These ids are often used in sync calls from the renderer and
+// one cannot terminate sync calls on the UI thread as that can lead to
+// deadlocks.
+//
+// Because of this, we have the BACKGROUND_X11 thread for these calls and this
+// thread has a separate X connection in order to answer them. But one cannot
+// use GTK on multiple threads, so the BACKGROUND_X11 thread deals only in Xlib
+// calls and, thus, XIDs.
+//
+// So we could make NativeViewIds be the X id of the window. However, at the
+// time when we need to tell the renderer about its NativeViewId, an XID isn't
+// availible and it goes very much against the grain of the code to make it so.
+// Also, we worry that GTK might choose to change the underlying X window id
+// when, say, the widget is hidden or repacked. Finally, if we used XIDs then a
+// compromised renderer could start asking questions about any X windows on the
+// system.
+//
+// Thus, we have this object. It produces random NativeViewIds from GtkWidget
+// pointers and observes the various signals from the widget for when an X
+// window is created, destroyed etc. Thus it provides a thread safe mapping
+// from NativeViewIds to the current XID for that widget.
+//
+// You get a reference to the global instance with:
+//   Singleton<GtkNativeViewManager>()
+class GtkNativeViewManager {
+ public:
+  // Must be called from the UI thread:
+  //
+  // Return a NativeViewId for the given widget and attach to the various
+  // signals emitted by that widget. The NativeViewId is pseudo-randomly
+  // allocated so that a compromised renderer trying to guess values will fail
+  // with high probability. The NativeViewId will not be reused for the
+  // lifetime of the GtkWidget.
+  gfx::NativeViewId GetIdForWidget(gfx::NativeView widget);
+
+  // May be called from any thread:
+  //
+  // xid: (output) the resulting X window ID, or 0
+  // id: a value previously returned from GetIdForWidget
+  // returns: true if |id| is a valid id, false otherwise.
+  //
+  // If the widget referenced by |id| does not current have an X window id,
+  // |*xid| is set to 0.
+  bool GetXIDForId(XID* xid, gfx::NativeViewId id);
+
+  // These are actually private functions, but need to be called from statics.
+  void OnRealize(gfx::NativeView widget);
+  void OnUnrealize(gfx::NativeView widget);
+  void OnDestroy(gfx::NativeView widget);
+
+ private:
+  // This object is a singleton:
+  GtkNativeViewManager();
+  friend struct DefaultSingletonTraits<GtkNativeViewManager>;
+
+  struct NativeViewInfo {
+    NativeViewInfo()
+        : x_window_id(0) {
+    }
+
+    XID x_window_id;
+  };
+
+  gfx::NativeViewId GetWidgetId(gfx::NativeView id);
+
+  // protects native_view_to_id_ and id_to_info_
+  Lock lock_;
+    // If asked for an id for the same widget twice, we want to return the same
+    // id. So this records the current mapping.
+    std::map<gfx::NativeView, gfx::NativeViewId> native_view_to_id_;
+    std::map<gfx::NativeViewId, NativeViewInfo> id_to_info_;
+
+  DISALLOW_COPY_AND_ASSIGN(GtkNativeViewManager);
+};
+
+#endif  // GFX_GTK_NATIVE_VIEW_ID_MANAGER_H_