window_manager.h

// Copyright (c) 2011 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.

#ifndef WINDOW_MANAGER_WINDOW_MANAGER_H_
#define WINDOW_MANAGER_WINDOW_MANAGER_H_

#include <map>
#include <set>
#include <string>
#include <tr1/memory>
#include <utility>
#include <vector>

extern "C" {
// TODO: Move the event-handling methods (all private) into a separate
// header so that these includes can be removed.
#include <X11/extensions/shape.h>
#include <X11/extensions/sync.h>
#include <X11/extensions/Xdamage.h>
#include <X11/extensions/Xrandr.h>
#include <X11/Xlib.h>
}

#include <gtest/gtest_prod.h>  // for FRIEND_TEST() macro

#include "base/hash_tables.h"
#include "base/memory/scoped_ptr.h"
#include "base/time.h"
#include "cros/chromeos_wm_ipc_enums.h"
#include "window_manager/atom_cache.h"  // for Atom enum
#include "window_manager/compositor/compositor.h"
#include "window_manager/panels/panel_manager.h"
#include "window_manager/wm_ipc.h"
#include "window_manager/x11/x_connection.h"
#include "window_manager/x11/x_types.h"

class MetricsLibrary;  // from metrics/metrics_library.h

namespace window_manager {

class ChromeWatchdog;
class DBusInterface;
class EventConsumer;
class EventLoop;
class FocusManager;
class KeyBindings;
class KeyBindingsActionRegistrar;
class KeyBindingsGroup;
class LayoutManager2;
class LoginController;
class ModalityHandler;
class ScreenLockerHandler;
class StackingManager;
class Window;
class WmIpc;
template<class T> class Stacker;

class WindowManager : public PanelManagerAreaChangeListener,
                      public CompositionChangeListener {
 public:
  // Visibility groups that actors can be added to.
  // See Compositor::SetActiveVisibilityGroups().
  enum VisibilityGroups {
    VISIBILITY_GROUP_SCREEN_LOCKER = 1,
    VISIBILITY_GROUP_SESSION_ENDING = 2,
    VISIBILITY_GROUP_BLANK = 3
  };

  // RAII-type object returned by CreateScopedCompositingRequest() that calls
  // IncrementCompositingRequests() in its constructor and
  // DecrementCompositingRequests() in its destructor.
  class ScopedCompositingRequest {
   public:
    explicit ScopedCompositingRequest(WindowManager* wm);
    ~ScopedCompositingRequest();

   private:
    WindowManager* wm_;  // not owned
    DISALLOW_COPY_AND_ASSIGN(ScopedCompositingRequest);
  };

  WindowManager(EventLoop* event_loop,
                XConnection* xconn,
                Compositor* compositor,
                DBusInterface* dbus);
  virtual ~WindowManager();

  void set_initialize_logging(bool should_init) {
    initialize_logging_ = should_init;
  }

  EventLoop* event_loop() { return event_loop_; }
  XConnection* xconn() { return xconn_; }
  Compositor* compositor() { return compositor_; }
  DBusInterface* dbus() { return dbus_; }
  StackingManager* stacking_manager() { return stacking_manager_.get(); }
  FocusManager* focus_manager() { return focus_manager_.get(); }
  ModalityHandler* modality_handler() { return modality_handler_.get(); }

  XWindow root() const { return root_; }
  const Rect& root_bounds() const { return root_bounds_; }
  Size root_size() const { return root_bounds_.size(); }
  int root_depth() const { return root_depth_; }
  int width() const { return root_bounds_.width; }
  int height() const { return root_bounds_.height; }

  const Stacker<XWindow>& stacked_xids() const {
    return *(stacked_xids_.get());
  }

  Compositor::StageActor* stage() { return stage_; }

  XWindow wm_xid() const { return wm_xid_; }
  XWindow active_window_xid() const { return active_window_xid_; }

  KeyBindings* key_bindings() { return key_bindings_.get(); }
  WmIpc* wm_ipc() { return wm_ipc_.get(); }
  int wm_ipc_version() const { return wm_ipc_version_; }

  bool logged_in() const { return logged_in_; }
  bool damage_debugging_enabled() const { return damage_debugging_enabled_; }

  // Get the title for the window that we create to take ownership of management
  // selections.  This is also used to name our log files.
  static const char* GetWmName() { return "chromeos-wm"; }

  // Begin PanelManagerAreaChangeListener implementation.
  virtual void HandlePanelManagerAreaChange();
  // End PanelManagerAreaChangeListener implementation.

  // Begin CompositionChangeListener implementation.
  // This method is called by the compositor while it's drawing, and is the
  // point at which we disable or enable compositing depending on whether
  // there's a single actor covering the entire screen or not.
  virtual void HandleTopFullscreenActorChange(
      const Compositor::TexturePixmapActor* top_fullscreen_actor);
  // End CompositionChangeListener implementation.

  // Perform initial setup.  This must be called immediately after the
  // WindowManager object is created.
  bool Init();

  // Handle notification from Chrome that the logged-in state has changed.
  // |initial| is true when this method is invoked by Init() and false when
  // it is invoked later in response to a property change.
  void SetLoggedInState(bool logged_in, bool initial);

  // Process all pending events from |x_conn_|, invoking HandleEvent() for each.
  void ProcessPendingEvents();

  // Handle an event from the X server.
  void HandleEvent(XEvent* event);

  // Create a new X window for receiving input.
  XWindow CreateInputWindow(const Rect& bounds, int event_mask);

  // Move and resize the passed-in window.
  // TODO: This isn't limited to input windows.
  bool ConfigureInputWindow(XWindow xid, const Rect& bounds);

  // Get the X server's ID corresponding to the passed-in atom (the Atom
  // enum is defined in atom_cache.h).
  XAtom GetXAtom(Atom atom);

  // Get the name for an atom from the X server.
  const std::string& GetXAtomName(XAtom xatom);

  // Get the current time from the server.  This can be useful for e.g.
  // getting a timestamp to pass to XSetInputFocus() when triggered by an
  // event that doesn't contain a timestamp.
  XTime GetCurrentTimeFromServer();

  // Look up a window in |client_windows_|.  The first version returns NULL
  // if the window doesn't exist, while the second crashes.
  Window* GetWindow(XWindow xid);
  Window* GetWindowOrDie(XWindow xid);

  Window* GetWindowOwningActor(const Compositor::TexturePixmapActor& actor);

  // Focus a window.  Convenience method that just calls
  // focus_manager_->FocusWindow().
  void FocusWindow(Window* win, XTime timestamp);

  // Does a modal window currently have the focus?
  bool IsModalWindowFocused() const;

  // Do something reasonable with the input focus.
  // This is intended to be called by EventConsumers when they give up the
  // focus and aren't sure what to do with it.
  void TakeFocus(XTime timestamp);

  // Set the _NET_ACTIVE_WINDOW property, which contains the ID of the
  // currently-active window (in our case, this is the toplevel window or
  // panel window that has the focus).
  bool SetActiveWindowProperty(XWindow xid);

  // Set the WM_NAME and NET_WM_NAME properties on a window.
  bool SetNamePropertiesForXid(XWindow xid, const std::string& name);

  // Update the _CHROME_VIDEO_TIME property on the root window, which
  // contains the last time that we believed a video was playing in a
  // window.  Note that updates may be rate-limited (see
  // kVideoTimePropertyUpdateSec).  Returns false if we attempted to set
  // the property but failed and true otherwise.
  bool SetVideoTimeProperty(time_t video_time);

  // Handle notification from a window that a new pixmap has been fetched.
  // We notify all of the event consumers that are interested in this
  // window.
  void HandleWindowPixmapFetch(Window* win);

  // Register an event consumer as being interested in non-property-change
  // events on a particular window.
  void RegisterEventConsumerForWindowEvents(
      XWindow xid, EventConsumer* event_consumer);
  void UnregisterEventConsumerForWindowEvents(
      XWindow xid, EventConsumer* event_consumer);

  // Register an event consumer as a listener for changes of a particular
  // property on a particular window.  The consumer's
  // HandleWindowPropertyChange() method will be invoked whenever we
  // receive notification that the property has been changed (after we have
  // already handled the change).
  void RegisterEventConsumerForPropertyChanges(
      XWindow xid, XAtom xatom, EventConsumer* event_consumer);
  void UnregisterEventConsumerForPropertyChanges(
      XWindow xid, XAtom xatom, EventConsumer* event_consumer);

  // Register an event consumer as being interested in a particular type of
  // WmIpc message from Chrome.  The consumer's HandleChromeMessage()
  // method will be passed all messages of this type.
  void RegisterEventConsumerForChromeMessages(
      chromeos::WmIpcMessageType message_type, EventConsumer* event_consumer);
  void UnregisterEventConsumerForChromeMessages(
      chromeos::WmIpcMessageType message_type, EventConsumer* event_consumer);

  // Register an event consumer's interest in taking ownership of a Window
  // object after the underlying X window has been destroyed.  The
  // registration will automatically be removed after the DestroyNotify
  // event, but UnregisterEventConsumerForDestroyedWindow() can be called
  // before the window is deleted to unregister interest (e.g. if the
  // event consumer itself is getting deleted).
  void RegisterEventConsumerForDestroyedWindow(
      XWindow xid, EventConsumer* event_consumer);
  void UnregisterEventConsumerForDestroyedWindow(
      XWindow xid, EventConsumer* event_consumer);

  // Register or unregister a mapping in |sync_alarms_to_windows_| between
  // a Sync extension alarm and the window that created it.
  void RegisterSyncAlarm(XID alarm_id, Window* win);
  void UnregisterSyncAlarm(XID alarm_id);

  bool client_window_debugging_enabled() const {
    return !client_window_debugging_actors_.empty();
  }

  // Callback to show or hide debugging information about client windows.
  void ToggleClientWindowDebugging();

  // Callback to toggle visualization of damage events.
  void ToggleDamageDebugging();

  // Callback to toggle profiler states.
  void ToggleProfiler();

  // Function to update client window debugging info.  Called from the
  // layout manager.
  void UpdateClientWindowDebugging();

  // Get rid of the actor that we display as a background during startup.
  void DropStartupBackground();

  // Get the total number of "real" windows.  Specifically, this is the
  // number of toplevel windows plus the number of panels.
  int GetNumWindows() const;

  // Reset |login_controller_| to NULL.  The login controller itself calls
  // this once the user has logged in and we've seen the first Chrome
  // window come up.  Note that this actually posts
  // DestroyLoginControllerInternal() to the event loop; we're probably
  // getting called in response to an X event, so we don't want to be
  // messing around with the list of event consumers.
  void DestroyLoginController();

  // Send a user action to Chrome so it can send it to UMA.
  // Does nothing if metrics reporting is disabled.
  void ReportUserAction(const std::string& action);

  // Send a histogram sample to Chrome so it can send it to UMA.
  // See metrics_library.h in metrics.git for more details.
  // Does nothing if metrics reporting is disabled.
  void ReportHistogramSample(const std::string& histogram_name,
                             int sample,
                             int min_value,
                             int max_value,
                             int num_buckets);

  // Increment or decrement a counter tracking compositing requests.  When it's
  // greater than zero, we force compositing.  If we're not already compositing,
  // IncrementCompositingRequests() will force us to draw a composited frame
  // before returning.
  void IncrementCompositingRequests();
  void DecrementCompositingRequests();

  // Create and return a new ScopedCompositingRequest object.  The caller
  // should stick it in a scoped_ptr that goes out of scope at the point where
  // the request should be withdrawn.
  ScopedCompositingRequest* CreateScopedCompositingRequest();

 private:
  friend class BasicWindowManagerTest;
  friend class LayoutManager2Test;        // uses |layout_manager_|
  friend class LoginControllerTest;       // uses |login_controller_|
  friend class ModalityHandlerTest;       // uses |modality_handler_|
  friend class PanelTest;                 // uses |panel_manager_|
  friend class PanelBarTest;              // uses |panel_manager_|
  friend class PanelDockTest;             // uses |panel_manager_|
  friend class PanelManagerTest;          // uses |panel_manager_|
  friend class ScreenLockerHandlerTest;   // uses |screen_locker_handler_|
  FRIEND_TEST(ChromeWatchdogTest, Basic);
  FRIEND_TEST(PanelBarTest, ModalDimming);
  FRIEND_TEST(WindowTest, TransientFor);  // uses TrackWindow()
  FRIEND_TEST(WindowManagerTest, RegisterExistence);
  FRIEND_TEST(WindowManagerTest, EventConsumer);
  FRIEND_TEST(WindowManagerTest, ResizeScreen);
  FRIEND_TEST(WindowManagerTest, KeepPanelsAfterRestart);
  FRIEND_TEST(WindowManagerTest, LoggedIn);
  FRIEND_TEST(WindowManagerTest, ConfigureBackground);
  FRIEND_TEST(WindowManagerTest, VideoTimeProperty);
  FRIEND_TEST(WindowManagerTest, HandleTopFullscreenActorChange);
  FRIEND_TEST(WindowManagerTest, ForceCompositing);
  FRIEND_TEST(WindowManagerTest, ResizeScreenWhileCompositing);

  typedef std::map<XWindow, std::set<EventConsumer*> > WindowEventConsumerMap;
  typedef std::map<std::pair<XWindow, XAtom>, std::set<EventConsumer*> >
      PropertyChangeEventConsumerMap;
  typedef std::map<chromeos::WmIpcMessageType, std::set<EventConsumer*> >
      ChromeMessageEventConsumerMap;

  // Minimum number of seconds between updates to the
  // _CHROME_VIDEO_TIME property on the root window.
  static const int kVideoTimePropertyUpdateSec;

  // Is this one of our internally-created windows?
  bool IsInternalWindow(XWindow xid) {
    return (xid == stage_xid_ || xid == overlay_xid_ || xid == wm_xid_);
  }

  // Are we in the process of shutting down or signing out?
  bool IsSessionEnding() const;

  // Get a manager selection as described in ICCCM section 2.8.  |atom| is
  // the selection to take, |manager_win| is the window acquiring the
  // selection, and |timestamp| is the current time.
  bool GetManagerSelection(
      XAtom atom, XWindow manager_win, XTime timestamp);

  // Tell the previous window and compositing managers to exit and register
  // ourselves as the new managers.
  bool RegisterExistence();

  // Set various one-time/unchanging properties on the root window as
  // specified in the Extended Window Manager Hints.
  bool SetEwmhGeneralProperties();

  // Set EWMH properties on the root window relating to the current screen size:
  // _NET_DESKTOP_GEOMETRY, _NET_DESKTOP_VIEWPORT, and _NET_WORKAREA (by way of
  // calling SetEwmhWorkareaProperty()).
  bool SetEwmhSizeProperties();

  // Set the _NET_WORKAREA property on the root window to the screen area
  // minus space used by panel docks.
  bool SetEwmhWorkareaProperty();

  // Register all of our key bindings.  Called by Init().
  void RegisterKeyBindings();

  // Query the X server for all toplevel windows and start tracking (and
  // possibly managing) them.
  bool ManageExistingWindows();

  // Start tracking this window (more specifically, create a Window object
  // for it and register it in |client_windows_|).  Returns NULL for
  // windows that we specifically shouldn't track (e.g. the compositor's
  // stage or the compositing overlay window).
  Window* TrackWindow(XWindow xid, bool override_redirect,
                      XConnection::WindowGeometry& geometry);

  // Handle a window getting mapped.  This is primarily used by
  // HandleMapNotify(), but is abstracted out into a separate method so
  // that ManageExistingWindows() can also use it to handle windows that
  // were already mapped when the WM started.
  void HandleMappedWindow(Window* win);

  // Handle a window getting mapped.  This is primarily used by
  // HandleUnmapNotify(), but is abstracted out into a separate method so we can
  // call it if we see a DestroyNotify event about a still-mapped window (which
  // doesn't seem like it should ever happen, but see http://crosbug.com/13792).
  void HandleUnmappedWindow(Window* win);

  // Handle the screen being resized.
  void HandleScreenResize(const Size& new_size);

  // Set the WM_STATE property on a window.  Per ICCCM 4.1.3.1, |state| can
  // be 0 (WithdrawnState), 1 (NormalState), or 3 (IconicState).  Per
  // 4.1.4, IconicState means that the toplevel window isn't viewable, so
  // we should use NormalState even when drawing a scaled-down version of
  // the window.
  bool SetWmStateProperty(XWindow xid, int state);

  // Update the _NET_CLIENT_LIST and _NET_CLIENT_LIST_STACKING properties
  // on the root window (as described in EWMH).
  bool UpdateClientListProperty();
  bool UpdateClientListStackingProperty();

  // Handlers for various X events.
  void HandleButtonPress(const XButtonEvent& e);
  void HandleButtonRelease(const XButtonEvent& e);
  void HandleClientMessage(const XClientMessageEvent& e);
  void HandleConfigureNotify(const XConfigureEvent& e);
  void HandleConfigureRequest(const XConfigureRequestEvent& e);
  void HandleCreateNotify(const XCreateWindowEvent& e);
  void HandleDamageNotify(const XDamageNotifyEvent& e);
  void HandleDestroyNotify(const XDestroyWindowEvent& e);
  void HandleEnterNotify(const XEnterWindowEvent& e);
  void HandleKeyPress(const XKeyEvent& e);
  void HandleKeyRelease(const XKeyEvent& e);
  void HandleLeaveNotify(const XLeaveWindowEvent& e);
  void HandleMapNotify(const XMapEvent& e);
  void HandleMapRequest(const XMapRequestEvent& e);
  void HandleMappingNotify(const XMappingEvent& e);
  void HandleMotionNotify(const XMotionEvent& e);
  void HandlePropertyNotify(const XPropertyEvent& e);
  void HandleReparentNotify(const XReparentEvent& e);
  void HandleRRScreenChangeNotify(const XRRScreenChangeNotifyEvent& e);
  void HandleShapeNotify(const XShapeEvent& e);
  void HandleSyncAlarmNotify(const XSyncAlarmNotifyEvent& e);
  void HandleUnmapNotify(const XUnmapEvent& e);

  // Get an arbitrary window owned by Chrome.  This can be used when
  // sending a message to Chrome, when the particular window that's used
  // doesn't matter.  Returns 0 if there aren't any Chrome windows.
  XWindow GetArbitraryChromeWindow();

  // Write a screenshot to disk.  If |select_region| is true, the
  // user will have a chance to select a region to capture.  Otherwise, the
  // entire root window will be captured.
  void TakeScreenshot(bool select_region);

  // Initialize |startup_background_| to hold a new actor that displays the
  // initial contents of the root window.  Called by Init().
  void CreateStartupBackground();

  // Helper method that creates actors and stores them in
  // |informational_actors_|.  Called by Init().
  void InitInformationalActors();

  // Callback that clears |informational_actors_|.
  void HandleDropInformationalActorsTimeout();

  // Reshape |overlay_xid_| to be transparent, redirect
  // |unredirected_fullscreen_xid_|, and tell the compositor to stop drawing.
  // We want Compositor::Draw() to finish drawing the current frame before we
  // disable compositing, so that the content on screen is refreshed.  We post
  // this method to the event loop from HandleTopFullscreenActorChange().
  void DisableCompositing();

  // Helper method posted as a task on the event loop by
  // DestroyLoginController().  This actually does the deleting.
  void DestroyLoginControllerInternal();

  // Callback invoked by |chrome_watchdog_timeout_id_| to call
  // chrome_watchdog_->SendPingToChrome().
  void PingChrome();

  EventLoop* event_loop_;   // not owned
  XConnection* xconn_;      // not owned
  Compositor* compositor_;  // not owned
  DBusInterface* dbus_;     // not owned

  XWindow root_;

  // Root window bounds and depth.
  Rect root_bounds_;
  int root_depth_;

  // Offscreen window that we just use for registering as the WM.
  XWindow wm_xid_;
  scoped_ptr<XConnection::WindowDestroyer> wm_xid_destroyer_;

  Compositor::StageActor* stage_;  // not owned

  // Window containing the compositor's stage.
  XWindow stage_xid_;

  // XComposite overlay window.
  XWindow overlay_xid_;

  // If we're started before the user has logged in, this displays the
  // initial contents of the root window.  We use this as a background.
  scoped_ptr<Compositor::TexturePixmapActor> startup_background_;

  // This is the pixmap that gets displayed by |startup_background_|.
  // We copy the root window here.
  XPixmap startup_pixmap_;

  scoped_ptr<AtomCache> atom_cache_;
  scoped_ptr<StackingManager> stacking_manager_;
  scoped_ptr<FocusManager> focus_manager_;

  // Library used to report user action metrics to Chrome.
  // NULL if --report_metrics is false.
  scoped_ptr<MetricsLibrary> metrics_library_;

  // Map from a Sync extension alarm ID to the Window object that's using
  // the alarm to support the _NET_WM_SYNC_REQUEST protocol.
  base::hash_map<XID, Window*> sync_alarms_to_windows_;

  // Windows that are being tracked.
  typedef std::map<XWindow, std::tr1::shared_ptr<Window> > WindowMap;
  WindowMap client_windows_;

  // This is a list of mapped, managed (i.e. not override-redirect) client
  // windows, in most-to-least-recently-mapped order.  Used to set EWMH's
  // _NET_CLIENT_LIST property.
  scoped_ptr<Stacker<XWindow> > mapped_xids_;

  // All immediate children of the root window (even ones that we don't
  // "track", in the sense of having Window objects for them in
  // |client_windows_|) in top-to-bottom stacking order.  EWMH's
  // _NET_CLIENT_LIST_STACKING property contains the managed (i.e. not
  // override-redirect) windows from this list.
  scoped_ptr<Stacker<XWindow> > stacked_xids_;

  // Things that consume events (e.g. LayoutManager2, PanelManager, etc.).
  std::set<EventConsumer*> event_consumers_;

  // Map from windows to event consumers that will be notified if events
  // are received.
  WindowEventConsumerMap window_event_consumers_;

  // Map from (window, atom) pairs to event consumers that will be
  // notified if the corresponding property is changed.
  PropertyChangeEventConsumerMap property_change_event_consumers_;

  // Map from Chrome message types to event consumers that will receive
  // copies of the messages.
  ChromeMessageEventConsumerMap chrome_message_event_consumers_;

  // Map from windows to the event consumer that will receive ownership of
  // the Window object when the underlying X window is destroyed.
  base::hash_map<XWindow, EventConsumer*> destroyed_window_event_consumers_;

  // Actors that are being used to show client windows' positions.
  typedef std::vector<std::tr1::shared_ptr<Compositor::Actor> > ActorVector;
  ActorVector client_window_debugging_actors_;

  // Should we flash regions of the screen in response to damage events?
  bool damage_debugging_enabled_;

  // The last window that was passed to SetActiveWindowProperty().
  XWindow active_window_xid_;

  scoped_ptr<WmIpc> wm_ipc_;
  scoped_ptr<KeyBindings> key_bindings_;
  scoped_ptr<ModalityHandler> modality_handler_;

  // These aren't initialized until the user has logged in.
  scoped_ptr<PanelManager> panel_manager_;
  scoped_ptr<LayoutManager2> layout_manager_;

  // Initialized at startup if the user isn't already logged in, and
  // deletes itself via DestroyLoginController() when the user is logged in
  // and the initial browser window is mapped.
  scoped_ptr<LoginController> login_controller_;

  scoped_ptr<ScreenLockerHandler> screen_locker_handler_;
  scoped_ptr<ChromeWatchdog> chrome_watchdog_;

  // ID for the timeout that calls QueryKeyboardState().
  int query_keyboard_state_timeout_id_;

  // Window that has currently been unredirected (in conjunction with
  // disabling compositing) as a performance optimization because it's
  // fullscreen and covering all other windows.  The value will be zero
  // whenever compositing is enabled, non-zero otherwise.
  XWindow unredirected_fullscreen_xid_;

  // Is there a task currently posted to the event loop to run
  // DisableCompositing()?
  bool disable_compositing_task_is_pending_;

  // Version of the IPC protocol that Chrome is currently using.  See
  // WM_IPC_MESSAGE_WM_NOTIFY_IPC_VERSION in libcros's
  // chromeos_wm_ipc_enums.h for details.
  int wm_ipc_version_;

  // Key binding actions that we've registered.
  scoped_ptr<KeyBindingsActionRegistrar> key_bindings_actions_;

  // Has the user logged in yet?  This affects whether some key bindings
  // are enabled or not and determines how new windows are handled.  This
  // tracks the _CHROME_LOGGED_IN property that Chrome sets on the root
  // window, but never transitions from true to false (the window manager
  // is restarted when the user logs out).
  bool logged_in_;

  // Should we initialize the logging code when we switch between logged-in
  // and logged-out mode?  This defaults to off, since we typically don't
  // want to write log files when called by tests, but main.cc sets it to
  // true.
  bool initialize_logging_;

  // Time at which we last updated the _CHROME_VIDEO_TIME property.  This is
  // a monotonically-increasing time as returned from GetMonotonicTime().
  base::TimeTicks video_property_update_time_;

  // Images that we display onscreen at startup to inform the user about
  // something (e.g. "Unaccelerated graphics", "Debug build", etc.).  Drawing
  // text would be nicer but we don't link against any graphics libraries.
  ActorVector informational_actors_;

  // ID for the timeout that calls HandleDropInformationalActorsTimeout().
  int drop_informational_actors_timeout_id_;

  // ID for the timeout that calls PingChrome().
  int chrome_watchdog_timeout_id_;

  // Number of outstanding requests to force compositing.
  int num_compositing_requests_;

  DISALLOW_COPY_AND_ASSIGN(WindowManager);
};

}  // namespace window_manager

#endif  // WINDOW_MANAGER_WINDOW_MANAGER_H_