wm: Fix override-redirect window stacking bug.

src/platform/window_manager/stacking_manager.cc

 // 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.
 
 #include "window_manager/stacking_manager.h"
 
 #include <string>
 
 #include "base/string_util.h"
 #include "window_manager/atom_cache.h"
 #include "window_manager/util.h"
 #include "window_manager/window.h"
 #include "window_manager/x_connection.h"
 
-using std::set;
+using std::map;
 using std::string;
 using std::tr1::shared_ptr;
 using window_manager::util::FindWithDefault;
+using window_manager::util::XidStr;
 
 namespace window_manager {
 
 StackingManager::StackingManager(XConnection* xconn,
                                  Compositor* compositor,
                                  AtomCache* atom_cache)
     : xconn_(xconn) {
   XWindow root = xconn_->GetRootWindow();
 
   for (int i = kNumLayers - 1; i >= 0; --i) {
     Layer layer = static_cast<Layer>(i);
     string name = StringPrintf("%s layer", LayerToName(layer));
 
     XWindow xid = xconn_->CreateWindow(root, -1, -1, 1, 1, true, true, 0);
     xconn_->SetStringProperty(xid, atom_cache->GetXAtom(ATOM_WM_NAME), name);
     xconn_->SetStringProperty(
         xid, atom_cache->GetXAtom(ATOM_NET_WM_NAME), name);
     layer_to_xid_[layer] = xid;
-    xids_.insert(xid);
+    xid_to_layer_[xid] = layer;
 
     shared_ptr<Compositor::Actor> actor(compositor->CreateGroup());
-    actor->SetName(name);
+    actor->SetName(StringPrintf("%s %s", name.c_str(), XidStr(xid).c_str()));
     actor->SetVisibility(false);
     compositor->GetDefaultStage()->AddActor(actor.get());
     actor->RaiseToTop();
     layer_to_actor_[layer] = actor;
   }
 }
 
 StackingManager::~StackingManager() {
-  for (set<XWindow>::const_iterator it = xids_.begin(); it != xids_.end(); ++it)
-    xconn_->DestroyWindow(*it);
+  for (map<XWindow, Layer>::const_iterator it = xid_to_layer_.begin();
+       it != xid_to_layer_.end(); ++it)
+    xconn_->DestroyWindow(it->first);
 }
 
 bool StackingManager::StackWindowAtTopOfLayer(Window* win, Layer layer) {
   DCHECK(win);
 
   Compositor::Actor* layer_actor = GetActorForLayer(layer);
 
   // Find the next-lowest layer so we can stack the window's shadow
   // directly above it.
   // TODO: This won't work for the bottom layer; write additional code to
@@ skipping 28 matching lines @@
   if (above)
     win->StackCompositedAbove(sibling->actor(), lower_layer_actor, true);
   else
     win->StackCompositedBelow(sibling->actor(), lower_layer_actor, true);
 
   return above ?
          win->StackClientAbove(sibling->xid()) :
          win->StackClientBelow(sibling->xid());
 }
 
+Compositor::Actor* StackingManager::GetActorIfLayerXid(XWindow xid) {
+  map<XWindow, Layer>::const_iterator it = xid_to_layer_.find(xid);
+  if (it == xid_to_layer_.end())
+    return NULL;
+  return GetActorForLayer(it->second);
+}
+
 // static
 const char* StackingManager::LayerToName(Layer layer) {
   switch (layer) {
     case LAYER_DEBUGGING:                return "debugging";
     case LAYER_HOTKEY_OVERLAY:           return "hotkey overlay";
     case LAYER_FULLSCREEN_PANEL:         return "fullscreen panel";
     case LAYER_DRAGGED_PANEL:            return "dragged panel";
     case LAYER_ACTIVE_TRANSIENT_WINDOW:  return "active transient window";
     case LAYER_PANEL_BAR_INPUT_WINDOW:   return "panel bar input window";
     case LAYER_STATIONARY_PANEL_IN_BAR:  return "static panel in bar";
@@ skipping 14 matching lines @@
   return layer_actor.get();
 }
 
 XWindow StackingManager::GetXidForLayer(Layer layer) {
   XWindow xid = FindWithDefault(layer_to_xid_, layer, static_cast<XWindow>(0));
   CHECK(xid) << "Invalid layer " << layer;
   return xid;
 }
 
 }  // namespace window_manager