wm: Update a lot of code to use structs from geometry.h.

window_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/window_manager.h"
 
 #include <cstring>
 #include <ctime>
 #include <list>
 #include <queue>
@@ skipping 190 matching lines @@
 
 WindowManager::WindowManager(EventLoop* event_loop,
                              XConnection* xconn,
                              Compositor* compositor,
                              DBusInterface* dbus)
     : event_loop_(event_loop),
       xconn_(xconn),
       compositor_(compositor),
       dbus_(dbus),
       root_(0),
-      width_(0),
-      height_(0),
       wm_xid_(0),
       stage_(NULL),
       stage_xid_(0),
       overlay_xid_(0),
       startup_pixmap_(0),
       mapped_xids_(new Stacker<XWindow>),
       stacked_xids_(new Stacker<XWindow>),
       damage_debugging_enabled_(false),
       active_window_xid_(0),
       query_keyboard_state_timeout_id_(-1),
@@ skipping 94 matching lines @@
     // DisableCompositing callback, which does the actual disabling.
     unredirected_fullscreen_xid_ = window_to_unredirect;
     if (!disable_compositing_task_is_pending_) {
       event_loop_->PostTask(
           NewPermanentCallback(this, &WindowManager::DisableCompositing));
       disable_compositing_task_is_pending_ = true;
     }
   }
 
   if (!was_compositing && should_composite) {
-    xconn_->SetWindowBoundingRegionToRect(overlay_xid_,
-                                          Rect(0, 0, width_, height_));
+    xconn_->SetWindowBoundingRegionToRect(overlay_xid_, root_bounds_);
     DLOG(INFO) << "Turned compositing on";
     compositor_->set_should_draw_frame(true);
   }
 }
 
 bool WindowManager::Init() {
   CHECK(!root_) << "Init() may only be called once";
   root_ = xconn_->GetRootWindow();
   xconn_->SelectRandREventsOnWindow(root_);
   xconn_->SelectInputOnWindow(root_, StructureNotifyMask, true);
   XConnection::WindowGeometry root_geometry;
   CHECK(xconn_->GetWindowGeometry(root_, &root_geometry));
-  width_ = root_geometry.bounds.width;
-  height_ = root_geometry.bounds.height;
+  root_bounds_ = root_geometry.bounds;
   root_depth_ = root_geometry.depth;
 
   if (FLAGS_unredirect_fullscreen_window) {
     // Disable automatic background painting for the root window.  It
     // should never be visible, and the automatic updates cause flickering
     // when enabling and disabling compositing.
     xconn_->SetWindowBackgroundPixmap(root_, None);
   }
 
   // Create the atom cache first; RegisterExistence() needs it.
   atom_cache_.reset(new AtomCache(xconn_));
 
   CHECK(RegisterExistence());
   SetEwmhGeneralProperties();
   SetEwmhSizeProperties();
 
   // First make sure that we'll get notified if the login state changes
   // and then query its current value.
   CHECK(xconn_->SelectInputOnWindow(root_, PropertyChangeMask, true));
   int logged_in_value = 0;
   xconn_->GetIntProperty(
       root_, GetXAtom(ATOM_CHROME_LOGGED_IN), &logged_in_value);
   logged_in_ = logged_in_value;
 
   stage_ = compositor_->GetDefaultStage();
   stage_xid_ = stage_->GetStageXWindow();
   stage_->SetName("stage");
-  stage_->SetSize(width_, height_);
+  stage_->SetSize(root_bounds_.width, root_bounds_.height);
   stage_->SetStageColor(Compositor::Color(FLAGS_background_color));
   stage_->Show();
 
   wm_ipc_.reset(new WmIpc(xconn_, atom_cache_.get()));
 
   stacking_manager_.reset(
       new StackingManager(xconn_, compositor_, atom_cache_.get()));
   focus_manager_.reset(new FocusManager(this));
 
   if (FLAGS_report_metrics) {
@@ skipping 663 matching lines @@
       root_, GetXAtom(ATOM_NET_SUPPORTED), XA_ATOM, supported);
 
   return success;
 }
 
 bool WindowManager::SetEwmhSizeProperties() {
   bool success = true;
 
   // We don't use pseudo-large desktops, so this is just the screen size.
   vector<int> geometry;
-  geometry.push_back(width_);
-  geometry.push_back(height_);
+  geometry.push_back(root_bounds_.width);
+  geometry.push_back(root_bounds_.height);
   success &= xconn_->SetIntArrayProperty(
       root_, GetXAtom(ATOM_NET_DESKTOP_GEOMETRY), XA_CARDINAL, geometry);
 
   // The viewport (top-left corner of the desktop) is just (0, 0) for us.
   vector<int> viewport(2, 0);
   success &= xconn_->SetIntArrayProperty(
       root_, GetXAtom(ATOM_NET_DESKTOP_VIEWPORT), XA_CARDINAL, viewport);
 
   success &= SetEwmhWorkareaProperty();
 
   return success;
 }
 
 bool WindowManager::SetEwmhWorkareaProperty() {
   // _NET_WORKAREA describes the region of the screen "minus space occupied
   // by dock and panel windows", so we subtract out the space used by panel
   // docks. :-P  Chrome can use this to guess the initial size for new
   // windows.
   int panel_manager_left_width = 0, panel_manager_right_width = 0;
   if (panel_manager_.get()) {
     // We invoke this before the panel manager has been created to try to
     // get the hints set as soon as possible.
     panel_manager_->GetArea(&panel_manager_left_width,
                             &panel_manager_right_width);
   }
   vector<int> workarea;
   workarea.push_back(panel_manager_left_width);  // x
   workarea.push_back(0);  // y
   workarea.push_back(
-      width_ - panel_manager_left_width - panel_manager_right_width);
-  workarea.push_back(height_);
+      root_bounds_.width -
+      panel_manager_left_width -
+      panel_manager_right_width);
+  workarea.push_back(root_bounds_.height);
   return xconn_->SetIntArrayProperty(
       root_, GetXAtom(ATOM_NET_WORKAREA), XA_CARDINAL, workarea);
 }
 
 void WindowManager::RegisterKeyBindings() {
 #ifndef NDEBUG
   static const uint32_t kCtrlAltShiftMask =
       KeyBindings::kControlMask |
       KeyBindings::kAltMask |
       KeyBindings::kShiftMask;
@@ skipping 148 matching lines @@
       for (vector<XAtom>::const_iterator it =
              win->wm_window_type_xatoms().begin();
            it != win->wm_window_type_xatoms().end(); ++it) {
         if (*it == combo_xatom || *it == dropdown_xatom || *it == menu_xatom ||
             *it == popup_xatom) {
           win->SetShadowType(Shadow::TYPE_RECTANGULAR);
           break;
         }
       }
     }
-
-    win->ShowComposited();
     return;
   }
 
   if (mapped_xids_->Contains(win->xid())) {
     LOG(WARNING) << "Handling mapped window " << win->xid_str()
                  << ", which is already listed in |mapped_xids_|";
   } else {
     mapped_xids_->AddOnTop(win->xid());
     UpdateClientListProperty();
     // This only includes mapped windows, so we need to update it now.
     UpdateClientListStackingProperty();
   }
 
   SetWmStateProperty(win->xid(), 1);  // NormalState
 }
 
-void WindowManager::HandleScreenResize(int new_width, int new_height) {
+void WindowManager::HandleScreenResize(const Size& new_size) {
   // We move windows offscreen to prevent them from receiving input.
   // Check that the screen doesn't get so huge that they end up onscreen.
-  DCHECK_LE(new_width, Window::kOffscreenX);
-  DCHECK_LE(new_height, Window::kOffscreenY);
+  DCHECK_LE(new_size.width, Window::kOffscreenX);
+  DCHECK_LE(new_size.height, Window::kOffscreenY);
 
   // The window manager sometimes tries to fetch an updated
   // pixmap for a resized window while the window is unredirected, resulting
   // in a black screen until compositing is toggled on and off again.
   // To avoid this, disable compositing while resizing.
   scoped_ptr<ScopedCompositingRequest> comp_request(
       CreateScopedCompositingRequest());
 
-  width_ = new_width;
-  height_ = new_height;
+  root_bounds_.resize(new_size, GRAVITY_NORTHWEST);
   SetEwmhSizeProperties();
-  stage_->SetSize(width_, height_);
+  stage_->SetSize(root_bounds_.width, root_bounds_.height);
   FOR_EACH_EVENT_CONSUMER(event_consumers_, HandleScreenResize());
 }
 
 bool WindowManager::SetWmStateProperty(XWindow xid, int state) {
   vector<int> values;
   values.push_back(state);
   values.push_back(0);  // we don't use icons
   XAtom xatom = GetXAtom(ATOM_WM_STATE);
   return xconn_->SetIntArrayProperty(xid, xatom, xatom, values);
 }
@@ skipping 46 matching lines @@
 }
 
 void WindowManager::HandleButtonPress(const XButtonEvent& e) {
   DLOG(INFO) << "Handling button press in window " << XidStr(e.window)
              << " at relative (" << e.x << ", " << e.y << "), absolute ("
              << e.x_root << ", " << e.y_root << ") with button " << e.button;
   Window* win = GetWindow(e.window);
   if (win)
     focus_manager_->HandleButtonPressInWindow(win, e.time);
 
+  const Point relative_pos(e.x, e.y);
+  const Point absolute_pos(e.x_root, e.y_root);
   FOR_EACH_INTERESTED_EVENT_CONSUMER(
       window_event_consumers_,
       e.window,
-      HandleButtonPress(e.window, e.x, e.y, e.x_root,
-                        e.y_root, e.button, e.time));
+      HandleButtonPress(
+          e.window, relative_pos, absolute_pos, e.button, e.time));
 }
 
 void WindowManager::HandleButtonRelease(const XButtonEvent& e) {
   DLOG(INFO) << "Handling button release in window " << XidStr(e.window)
              << " at relative (" << e.x << ", " << e.y << "), absolute ("
              << e.x_root << ", " << e.y_root << ") with button " << e.button;
+
+  const Point relative_pos(e.x, e.y);
+  const Point absolute_pos(e.x_root, e.y_root);
   FOR_EACH_INTERESTED_EVENT_CONSUMER(
       window_event_consumers_,
       e.window,
-      HandleButtonRelease(e.window, e.x, e.y, e.x_root,
-                          e.y_root, e.button, e.time));
+      HandleButtonRelease(
+          e.window, relative_pos, absolute_pos, e.button, e.time));
 }
 
 void WindowManager::HandleClientMessage(const XClientMessageEvent& e) {
   // _NET_WM_PING responses are spammy; don't log them.
   if (!(e.message_type == GetXAtom(ATOM_WM_PROTOCOLS) &&
         e.format == XConnection::kLongFormat &&
         static_cast<XAtom>(e.data.l[0]) == GetXAtom(ATOM_NET_WM_PING))) {
     DLOG(INFO) << "Handling client message for window " << XidStr(e.window)
                << " with type " << XidStr(e.message_type) << " ("
                << GetXAtomName(e.message_type) << ") and format " << e.format;
@@ skipping 30 matching lines @@
           e.window,
           HandleClientMessage(e.window, e.message_type, e.data.l));
     } else {
       LOG(WARNING) << "Ignoring client message event with unsupported format "
                    << e.format << " (we only handle 32-bit data currently)";
     }
   }
 }
 
 void WindowManager::HandleConfigureNotify(const XConfigureEvent& e) {
-  if (e.window == root_ && (e.width != width_ || e.height != height_)) {
+  const Rect bounds(e.x, e.y, e.width, e.height);
+
+  if (e.window == root_ && bounds.size() != root_bounds_.size()) {
     DLOG(INFO) << "Got configure notify saying that root window has been "
-               << "resized to " << e.width << "x" << e.height;
-    HandleScreenResize(e.width, e.height);
+               << "resized to " << bounds.size();
+    HandleScreenResize(bounds.size());
     return;
   }
 
   // Even though _NET_CLIENT_LIST_STACKING only contains client windows
   // that we're managing, we also need to keep track of other (e.g.
   // override-redirect, or even untracked) windows: we receive
   // notifications of the form "X is on top of Y", so we need to know where
   // Y is even if we're not managing it so that we can stack X correctly.
 
   // If this isn't an immediate child of the root window, ignore the
@@ skipping 25 matching lines @@
                      << " said that it's stacked above " << XidStr(e.above)
                      << ", which we don't know about";
       }
       stacked_xids_->AddOnBottom(e.window);
     }
   }
 
   Window* win = GetWindow(e.window);
   if (!win)
     return;
-  DLOG(INFO) << "Handling configure notify for " << XidStr(e.window)
-             << " to pos (" << e.x << ", " << e.y << ") and size "
-             << e.width << "x" << e.height << ", above " << XidStr(e.above);
+  DLOG(INFO) << "Handling configure notify for " << win->xid_str()
+             << " to " << bounds << ", above " << XidStr(e.above);
 
-  // There are several cases to consider here:
-  //
-  // - Override-redirect windows' calls to configure themselves are honored
-  //   by the X server without any intervention on our part, so we only
-  //   need to update their composited positions here.
-  // - Regular non-override-redirect windows' configuration calls are
-  //   passed to us as ConfigureRequest events, so we would've already
-  //   updated both their X and composited configuration in
-  //   HandleConfigureRequest().  We don't need to do anything here.
-  // - For both types of window, we may have decided to move or resize the
-  //   window ourselves earlier through a direct call to Window::Move() or
-  //   Resize().  In that case, we would've already updated their
-  //   composited position (or at least started the animation) then.
-
-  if (win->override_redirect()) {
-    win->MoveComposited(e.x, e.y, 0);
-    win->SaveClientPosition(e.x, e.y);
-    win->SaveClientSize(e.width, e.height);
-
-    // When we see a stacking change for an override-redirect window, we
-    // attempt to restack its actor correspondingly.  If we don't have an
-    // actor for the X window directly under it, we walk down the stack
-    // until we find one.
-    XWindow above_xid = e.above;
-    while (above_xid) {
-      Window* above_win = GetWindow(above_xid);
-      Compositor::Actor* above_actor =
-          above_win ? above_win->actor() :
-          stacking_manager_->GetActorIfLayerXid(above_xid);
-
-      if (above_actor) {
-        DLOG(INFO) << "Stacking override-redirect window " << win->xid_str()
-                   << "'s actor above window " << XidStr(above_xid) << "'s";
-        win->StackCompositedAbove(above_actor, NULL, false);
-        break;
-      }
-      const XWindow* above_ptr = stacked_xids_->GetUnder(above_xid);
-      above_xid = above_ptr ? *above_ptr : 0;
-    }
-  } else {
-    if (restacked) {
-      // _NET_CLIENT_LIST_STACKING only includes managed (i.e.
-      // non-override-redirect) windows, so we only update it when a
-      // managed window's stacking position changed.
-      UpdateClientListStackingProperty();
-    }
+  if (!win->override_redirect() && restacked) {
+    // _NET_CLIENT_LIST_STACKING only includes managed (i.e.
+    // non-override-redirect) windows, so we only update it when a
+    // managed window's stacking position changed.
+    UpdateClientListStackingProperty();
   }
 
-  win->HandleConfigureNotify(e.width, e.height);
+  // Notify the window so it can reset its pixmap if the size changed, or update
+  // its actor's position and stacking if it's an override-redirect window.
+  win->HandleConfigureNotify(bounds, e.above);
 }
 
 void WindowManager::HandleConfigureRequest(const XConfigureRequestEvent& e) {
   Window* win = GetWindow(e.window);
   if (!win)
     return;
 
   DLOG(INFO)
       << "Handling configure request for " << XidStr(e.window)
       << " to pos ("
       << ((e.value_mask & CWX) ? StringPrintf("%d", e.x) : string("undef"))
       << ", "
       << ((e.value_mask & CWY) ? StringPrintf("%d", e.y) : string("undef"))
       << ") and size "
       << ((e.value_mask & CWWidth) ?
           StringPrintf("%d", e.width) : string("undef "))
       << "x"
       << ((e.value_mask & CWHeight) ?
           StringPrintf("%d", e.height) : string(" undef"));
   if (win->override_redirect()) {
     LOG(WARNING) << "Huh?  Got a ConfigureRequest event for override-redirect "
                  << "window " << win->xid_str();
   }
 
-  const int req_x = (e.value_mask & CWX) ? e.x : win->client_x();
-  const int req_y = (e.value_mask & CWY) ? e.y : win->client_y();
-  const int req_width =
-      (e.value_mask & CWWidth) ? e.width : win->client_width();
-  const int req_height =
-      (e.value_mask & CWHeight) ? e.height : win->client_height();
+  const Rect requested_bounds(
+      (e.value_mask & CWX) ? e.x : win->client_x(),
+      (e.value_mask & CWY) ? e.y : win->client_y(),
+      (e.value_mask & CWWidth) ? e.width : win->client_width(),
+      (e.value_mask & CWHeight) ? e.height : win->client_height());
 
   // The X server should reject bogus requests before they get to us, but
   // just in case...
-  if (req_width <= 0 || req_height <= 0) {
+  if (requested_bounds.width <= 0 || requested_bounds.height <= 0) {
     LOG(WARNING) << "Ignoring request to resize window " << win->xid_str()
-                 << " to " << req_width << "x" << req_height;
+                 << " to " << requested_bounds.size();
     return;
   }
 
   if (!win->mapped()) {
     // If the window is unmapped, it's unlikely that any event consumers
     // will know what to do with it.  Do whatever we were asked to do.
-    if (req_x != win->client_x() || req_y != win->client_y()) {
-      win->MoveClient(req_x, req_y);
-      win->MoveComposited(req_x, req_y, 0);
+    if (requested_bounds.position() != win->client_origin()) {
+      win->MoveClient(requested_bounds.x, requested_bounds.y);
+      win->MoveComposited(requested_bounds.x, requested_bounds.y, 0);
     }
-    if (req_width != win->client_width() || req_height != win->client_height())
-      win->ResizeClient(req_width, req_height, GRAVITY_NORTHWEST);
+    if (requested_bounds.size() != win->client_size())
+      win->Resize(requested_bounds.size(), GRAVITY_NORTHWEST);
   } else {
     FOR_EACH_INTERESTED_EVENT_CONSUMER(
         window_event_consumers_,
         e.window,
-        HandleWindowConfigureRequest(win, req_x, req_y, req_width, req_height));
+        HandleWindowConfigureRequest(win, requested_bounds));
   }
 }
 
 void WindowManager::HandleCreateNotify(const XCreateWindowEvent& e) {
   if (GetWindow(e.window)) {
     LOG(WARNING) << "Ignoring create notify for already-known window "
                  << XidStr(e.window);
     return;
   }
 
@@ skipping 76 matching lines @@
     ec_it->second->OwnDestroyedWindow(destroyed_win, e.window);
     destroyed_window_event_consumers_.erase(ec_it);
   }
 
   client_windows_.erase(e.window);
   win = NULL;  // erasing from client_windows_ deletes window.
 }
 
 void WindowManager::HandleEnterNotify(const XEnterWindowEvent& e) {
   DLOG(INFO) << "Handling enter notify for " << XidStr(e.window);
+  const Point relative_pos(e.x, e.y);
+  const Point absolute_pos(e.x_root, e.y_root);
   FOR_EACH_INTERESTED_EVENT_CONSUMER(
       window_event_consumers_,
       e.window,
-      HandlePointerEnter(e.window, e.x, e.y, e.x_root, e.y_root, e.time));
+      HandlePointerEnter(e.window, relative_pos, absolute_pos, e.time));
 }
 
 void WindowManager::HandleKeyPress(const XKeyEvent& e) {
   // We grab the keyboard while shutting down or signing out; ignore any events
   // that we get.
   if (IsSessionEnding())
     return;
   key_bindings_->HandleKeyPress(e.keycode, e.state, e.time);
 }
 
 void WindowManager::HandleKeyRelease(const XKeyEvent& e) {
   if (IsSessionEnding())
     return;
   key_bindings_->HandleKeyRelease(e.keycode, e.state, e.time);
 }
 
 void WindowManager::HandleLeaveNotify(const XLeaveWindowEvent& e) {
   DLOG(INFO) << "Handling leave notify for " << XidStr(e.window);
+  const Point relative_pos(e.x, e.y);
+  const Point absolute_pos(e.x_root, e.y_root);
   FOR_EACH_INTERESTED_EVENT_CONSUMER(
       window_event_consumers_,
       e.window,
-      HandlePointerLeave(e.window, e.x, e.y, e.x_root, e.y_root, e.time));
+      HandlePointerLeave(e.window, relative_pos, absolute_pos, e.time));
 }
 
 void WindowManager::HandleMapNotify(const XMapEvent& e) {
   DLOG(INFO) << "Handling map notify for " << XidStr(e.window);
   Window* win = GetWindow(e.window);
   if (!win || win->mapped())
     return;
   HandleMappedWindow(win);
 }
 
@@ skipping 42 matching lines @@
                << win->type();
 }
 
 void WindowManager::HandleMappingNotify(const XMappingEvent& e) {
   DLOG(INFO) << "Handling (keyboard) mapping notify";
   xconn()->RefreshKeyboardMap(e.request, e.first_keycode, e.count);
   key_bindings_->RefreshKeyMappings();
 }
 
 void WindowManager::HandleMotionNotify(const XMotionEvent& e) {
+  const Point relative_pos(e.x, e.y);
+  const Point absolute_pos(e.x_root, e.y_root);
   FOR_EACH_INTERESTED_EVENT_CONSUMER(
       window_event_consumers_,
       e.window,
-      HandlePointerMotion(e.window, e.x, e.y, e.x_root, e.y_root, e.time));
+      HandlePointerMotion(e.window, relative_pos, absolute_pos, e.time));
 }
 
 void WindowManager::HandlePropertyNotify(const XPropertyEvent& e) {
   if (e.window == root_ && e.atom == GetXAtom(ATOM_CHROME_LOGGED_IN)) {
     int value = 0;
     bool logged_in = xconn_->GetIntProperty(root_, e.atom, &value) && value;
     SetLoggedInState(logged_in, false);  // initial=false
     return;
   }
 
@@ skipping 135 matching lines @@
 
 void WindowManager::HandleUnmapNotify(const XUnmapEvent& e) {
   DLOG(INFO) << "Handling unmap notify for " << XidStr(e.window);
   Window* win = GetWindow(e.window);
   if (!win || !win->mapped())
     return;
 
   win->HandleUnmapNotify();
   FOR_EACH_EVENT_CONSUMER(event_consumers_, HandleWindowUnmap(win));
 
-  if (win->override_redirect()) {
-    win->HideComposited();
-    return;
-  }
+  if (!win->override_redirect()) {
+    SetWmStateProperty(e.window, 0);  // WithdrawnState
 
-  SetWmStateProperty(e.window, 0);  // WithdrawnState
+    // Notify the focus manager last in case any event consumers need to do
+    // something special when they see the focused window getting unmapped.
+    focus_manager_->HandleWindowUnmap(win);
 
-  // Notify the focus manager last in case any event consumers need to do
-  // something special when they see the focused window getting unmapped.
-  focus_manager_->HandleWindowUnmap(win);
-
-  if (mapped_xids_->Contains(win->xid())) {
-    mapped_xids_->Remove(win->xid());
-    UpdateClientListProperty();
-    UpdateClientListStackingProperty();
+    if (mapped_xids_->Contains(win->xid())) {
+      mapped_xids_->Remove(win->xid());
+      UpdateClientListProperty();
+      UpdateClientListStackingProperty();
+    }
   }
 }
 
 XWindow WindowManager::GetArbitraryChromeWindow() {
   for (WindowMap::const_iterator i = client_windows_.begin();
        i != client_windows_.end(); ++i) {
     if (WmIpcWindowTypeIsChrome(i->second->type()))
       return i->first;
   }
   return 0;
@@ skipping 26 matching lines @@
 
   if (system(command.c_str()) < 0) {
     LOG(ERROR) << "Taking screenshot via \"" << command << "\" failed";
   } else {
     LOG(INFO) << "Saved screenshot to " << filename;
   }
 }
 
 void WindowManager::CreateStartupBackground() {
   startup_pixmap_ =
-      xconn_->CreatePixmap(root_, Size(width_, height_), root_depth_);
+      xconn_->CreatePixmap(root_, root_bounds_.size(), root_depth_);
   xconn_->CopyArea(root_,            // src
                    startup_pixmap_,  // dest
                    Point(0, 0),      // src_pos
                    Point(0, 0),      // dest_pos
-                   Size(width_, height_));
+                   root_bounds_.size());
   Compositor::TexturePixmapActor* pixmap_actor =
       compositor_->CreateTexturePixmap();
   pixmap_actor->SetPixmap(startup_pixmap_);
   startup_background_.reset(pixmap_actor);
   startup_background_->SetName("startup background");
   stage_->AddActor(startup_background_.get());
   stacking_manager_->StackActorAtTopOfLayer(
       startup_background_.get(), StackingManager::LAYER_BACKGROUND);
   startup_background_->Show();
 }
@@ skipping 31 matching lines @@
   event_consumers_.erase(login_controller_.get());
   login_controller_.reset();
 }
 
 void WindowManager::PingChrome() {
   chrome_watchdog_->SendPingToChrome(GetCurrentTimeFromServer(),
                                      kPingChromeTimeoutMs);
 }
 
 }  // namespace window_manager