Defer window destruction until GPU finished drawing.

gfx/gtk_native_view_id_manager.h

 // 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_
 #pragma once
 
 #include <map>
 
 #include "base/singleton.h"
 #include "gfx/native_widget_types.h"
 
 typedef unsigned long XID;
+struct _GtkPreserveWindow;
 
 // 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.
@@ skipping 38 matching lines @@
   // widget to create a window.
   //
   // Keeping the XID permanent requires a bit of overhead, so it must
   // be explicitly requested.
   //
   // xid: (output) the resulting X window
   // id: a value previously returned from GetIdForWidget
   // returns: true if |id| is a valid id, false otherwise.
   bool GetPermanentXIDForId(XID* xid, gfx::NativeViewId id);
 
+  // Must be called from the UI thread because we may need to access a
+  // GtkWidget or destroy a GdkWindow.
+  //
+  // If the widget associated with the XID is still alive, allow the widget
+  // to destroy the associated XID when it wants. Otherwise, destroy the
+  // GdkWindow associated with the XID.
+  void ReleasePermanentXID(XID xid);
+
   // 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);
 
   Lock& unrealize_lock() { return unrealize_lock_; }
 
  private:
   // This object is a singleton:
   GtkNativeViewManager();
@@ skipping 15 matching lines @@
   Lock unrealize_lock_;
 
   // 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_;
 
+  struct PermanentXIDInfo {
+    PermanentXIDInfo() : widget(NULL), ref_count(0) {
+    }
+    _GtkPreserveWindow* widget;
+    int ref_count;
+  };
+
+  // Used to maintain the reference count for permanent XIDs
+  // (referenced by GetPermanentXIDForId and dereferenced by
+  // ReleasePermanentXID). Only those XIDs with a positive reference count
+  // will be in the table.
+  //
+  // In general, several GTK widgets may share the same X window. We assume
+  // that is not true of the widgets stored in this registry.
+  //
+  // An XID will map to NULL, if there is an outstanding reference but the
+  // widget was destroyed. In this case, the destruction of the X window
+  // is deferred to the dropping of all references.
+  std::map<XID, PermanentXIDInfo> perm_xid_to_info_;
+
   DISALLOW_COPY_AND_ASSIGN(GtkNativeViewManager);
 };
 
 #endif  // GFX_GTK_NATIVE_VIEW_ID_MANAGER_H_