autox: Fix race condition and add get_screen_size().

src/platform/autox/autox.py

 #!/usr/bin/python
 #
 # Copyright (c) 2010 The Chromium OS Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 import re
 import select
 import time
 
@@ skipping 23 matching lines @@
 
         ax.send_hotkey("Ctrl+L")
         ax.send_text("http://www.example.org/\n")
 
         # Create a window and wait for it to get the focus.
         win = ax.create_and_map_window(width=200, height=200, title='test')
         info = ax.get_window_info(win.id)
         ax.await_condition(
             lambda: info.is_focused,
             desc='Waiting for window 0x%x to be focused' % win.id)
-        ax.destroy_window(win)
+        win.destroy()
 
         # Create an override-redirect window and check that it appears in
         # the position that it requested.
         popup_win = ax.create_and_map_window(
             x=200, y=200, width=200, height=200,
             title='popup', override_redirect=True)
         popup_info = ax.get_window_info(popup_win.id)
         ax.await_condition(
             lambda: popup_info.get_geometry() == (200, 200, 200, 200),
             desc='Checking window 0x%x\'s geometry' % popup_win.id)
-        ax.destroy_window(popup_win)
+        popup_win.destroy()
     """
 
     # Map of characters that can be passed to send_text() that differ
     # from their X keysym names.
     __chars_to_keysyms = {
         ' ': 'space',
         '\n': 'Return',
         '\t': 'Tab',
         '~': 'asciitilde',
         '!': 'exclam',
@@ skipping 249 matching lines @@
         """
         self.__display.sync()
         while self.__display.pending_events():
             event = self.__display.next_event()
             if event.type == X.ConfigureNotify:
                 info = self.__windows[event.window.id]
                 info.x = event.x
                 info.y = event.y
                 info.width = event.width
                 info.height = event.height
+            elif event.type == X.DestroyNotify:
+                del self.__windows[event.window.id]
             elif event.type == X.Expose:
                 info = self.__windows[event.window.id]
                 info.was_exposed = True
                 if info.expose_callback:
                     info.expose_callback(event)
                 else:
                     event.window.clear_area(
                             event.x, event.y, event.width, event.height)
             elif event.type == X.FocusIn or event.type == X.FocusOut:
                 self.__windows[event.window.id].is_focused = \
@@ skipping 171 matching lines @@
         Args:
             x, y: int position of window
             width, height: int dimensions of window
             title: str containing the window's title
             override_redirect: whether this is an override-redirect
                 ("popup", in GTK's parlance) window.  override-redirect
                 windows are mapped, placed, and sized without any window
                 manager involvement.
 
         Returns:
-            python-xlib Window object (but see destroy_window())
+            python-xlib Window object
         """
+        # Sync before creating the window.  It's possible that we're
+        # reusing the ID from an already-destroyed window that we haven't
+        # seen a DestroyNotify event about yet, and we want to make sure
+        # that its WindowInfo object gets cleaned up before we register ours.
+        self.sync()
+
         win = self.__root.create_window(
             x, y, width, height, border_width=0,
             depth=X.CopyFromParent,
             override_redirect=override_redirect,
             background_pixel=self.__display.screen().white_pixel,
             event_mask = (X.ExposureMask |
                           X.FocusChangeMask |
                           X.StructureNotifyMask))
-
-        info = AutoX.WindowInfo(
+        info = self.WindowInfo(
             x, y, width, height, expose_callback=expose_callback)
         self.__windows[win.id] = info
 
         if title:
             win.set_wm_name(title)
             utf8_atom = self.__display.get_atom('UTF8_STRING')
             win.change_property(
                     self.__display.get_atom('_NET_WM_NAME'),
                     utf8_atom, 8, data=title)
 
         win.map()
         self.await_condition(
             lambda: info.was_exposed,
             desc='Waiting for window 0x%x to be exposed' % win.id)
+
         return win
 
-    def destroy_window(self, window):
-        """Destroy a window returned by create_and_map_window().
-
-        In addition to calling the window's destroy() method, this method
-        cleans up internal state that was being used to track the window.
-
-        Args:
-            window: python-xlib Window object
-        """
-        del self.__windows[window.id]
-        window.destroy()
-
     def get_window_info(self, window_id):
         """Get an object containing information about a window.
 
         Args:
             window_id: int ID of the window
 
         Returns:
             WindowInfo object (should be treated as read-only)
         """
         return self.__windows[window_id]
@@ skipping 25 matching lines @@
         """Get the root window's _NET_ACTIVE_WINDOW property.
 
         Returns:
             int window ID from the property, or None if unset
         """
         reply = self.__root.get_property(
             self.__display.get_atom('_NET_ACTIVE_WINDOW'), Xatom.WINDOW, 0, 1)
         if not reply:
             return None
         return reply.value[0]
+
+    def get_screen_size(self):
+        """Get the current dimensions of the root window.
+
+        Returns:
+            tuple with two ints: (width, height)
+        """
+        reply = self.__root.get_geometry()
+        return (reply.width, reply.height)