Use the convenience function gdk_screen_get_window_stack to enumerate top-lev...

chrome/browser/dock_info_gtk.cc

 // 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.
 
 #include "chrome/browser/dock_info.h"
 
 #include <gtk/gtk.h>
 
 #include "base/gfx/native_widget_types.h"
 #include "base/logging.h"
 #include "base/task.h"
 #include "chrome/browser/browser_list.h"
 #include "chrome/browser/browser_window.h"
 #include "chrome/browser/gtk/browser_window_gtk.h"
-#include "chrome/common/x11_util.h"
+#include "chrome/common/gtk_util.h"
 
 ////////////////////////////////////////////////////////////////////////////////
 // BaseWindowFinder
 //
 // Base class used to locate a window. A subclass need only override
 // ShouldStopIterating to determine when iteration should stop.
-class BaseWindowFinder : public x11_util::EnumerateWindowsDelegate {
+class BaseWindowFinder : public gtk_util::EnumerateWindowsDelegate {
  public:
   explicit BaseWindowFinder(const std::set<GtkWidget*>& ignore) {
     std::set<GtkWidget*>::iterator iter;
     for (iter = ignore.begin(); iter != ignore.end(); iter++) {
       XID xid = x11_util::GetX11WindowFromGtkWidget(*iter);
       ignore_.insert(xid);
     }
   }
 
   virtual ~BaseWindowFinder() {}
 
  protected:
-  // Returns true if iteration should stop, false otherwise.
-  virtual bool ShouldStopIterating(XID window) {
+  // Returns true if |window| is in the ignore list.
+  bool ShouldIgnoreWindow(XID window) {
     return (ignore_.find(window) != ignore_.end());
   }
 
+  // Returns true if iteration should stop, false otherwise.
+  virtual bool ShouldStopIterating(XID window) {
+    return false;
+  }
+
  private:
   std::set<XID> ignore_;
 
   DISALLOW_COPY_AND_ASSIGN(BaseWindowFinder);
 };
 
 ////////////////////////////////////////////////////////////////////////////////
 // TopMostFinder
 //
 // Helper class to determine if a particular point of a window is not obscured
 // by another window.
 class TopMostFinder : public BaseWindowFinder {
  public:
   // Returns true if |window| is not obscured by another window at the
   // location |screen_loc|, not including the windows in |ignore|.
   static bool IsTopMostWindowAtPoint(XID window,
                                      const gfx::Point& screen_loc,
                                      const std::set<GtkWidget*>& ignore) {
     TopMostFinder finder(window, screen_loc, ignore);
     return finder.is_top_most_;
   }
 
  protected:
   virtual bool ShouldStopIterating(XID window) {
-    if (BaseWindowFinder::ShouldStopIterating(window))
-      return true;
+    if (BaseWindowFinder::ShouldIgnoreWindow(window))
+      return false;
 
     if (window == target_) {
       // Window is topmost, stop iterating.
       is_top_most_ = true;
       return true;
     }
 
     if (x11_util::IsWindowVisible(window)) {
       // The window isn't visible, keep iterating.
       return false;
@@ skipping 12 matching lines @@
   }
 
  private:
   TopMostFinder(XID window,
                 const gfx::Point& screen_loc,
                 const std::set<GtkWidget*>& ignore)
     : BaseWindowFinder(ignore),
       target_(window),
       screen_loc_(screen_loc),
       is_top_most_(false) {
-    XID root = x11_util::GetX11RootWindow();
-    x11_util::EnumerateChildWindows(root, this);
+    gtk_util::EnumerateChildWindows(this);
   }
 
   // The window we're looking for.
   XID target_;
 
   // Location of window to find.
   gfx::Point screen_loc_;
 
   // Is target_ the top most window? This is initially false but set to true
   // in ShouldStopIterating if target_ is passed in.
@@ skipping 17 matching lines @@
     if (finder.result_ &&
         TopMostFinder::IsTopMostWindowAtPoint(finder.result_, screen_loc,
                                               ignore)) {
       return finder.result_;
     }
     return 0;
   }
 
  protected:
   virtual bool ShouldStopIterating(XID window) {
-    if (BaseWindowFinder::ShouldStopIterating(window))
-      return true;
+    if (BaseWindowFinder::ShouldIgnoreWindow(window))
+      return false;
 
     // Check if this window is in our process.
     if (!BrowserWindowGtk::GetBrowserWindowForXID(window))
       return false;
 
     if (!x11_util::IsWindowVisible(window))
       return false;
 
     gfx::Rect rect;
     if (x11_util::GetWindowRect(window, &rect) && rect.Contains(screen_loc_)) {
       result_ = window;
       return true;
     }
 
     return false;
   }
 
  private:
   LocalProcessWindowFinder(const gfx::Point& screen_loc,
                            const std::set<GtkWidget*>& ignore)
     : BaseWindowFinder(ignore),
       screen_loc_(screen_loc),
       result_(0) {
-    XID root = x11_util::GetX11RootWindow();
-    x11_util::EnumerateChildWindows(root, this);
+    gtk_util::EnumerateChildWindows(this);
   }
 
   // Position of the mouse.
   gfx::Point screen_loc_;
 
   // The resulting window. This is initially null but set to true in
   // ShouldStopIterating if an appropriate window is found.
   XID result_;
 
   DISALLOW_COPY_AND_ASSIGN(LocalProcessWindowFinder);
@@ skipping 33 matching lines @@
   gtk_window_get_position(window(), &x, &y);
   gtk_window_get_size(window(), &w, &h);
   bounds->SetRect(x, y, w, h);
   return true;
 }
 
 void DockInfo::SizeOtherWindowTo(const gfx::Rect& bounds) const {
   gtk_window_move(window(), bounds.x(), bounds.y());
   gtk_window_resize(window(), bounds.width(), bounds.height());
 }