Linux: Refactor X11DesktopHandler

ui/views/widget/desktop_aura/desktop_window_tree_host_x11.h

 // Copyright (c) 2012 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.
 
 #ifndef UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_WINDOW_TREE_HOST_X11_H_
 #define UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_WINDOW_TREE_HOST_X11_H_
 
 #include <stddef.h>
 #include <stdint.h>
 #include <X11/extensions/shape.h>
@@ skipping 54 matching lines @@
   gfx::Rect GetX11RootWindowBounds() const;
 
   // Returns the current bounds in terms of the X11 Root Window including the
   // borders provided by the window manager (if any).
   gfx::Rect GetX11RootWindowOuterBounds() const;
 
   // Returns the window shape if the window is not rectangular. Returns NULL
   // otherwise.
   ::Region GetWindowShape() const;
 
-  // Called by X11DesktopHandler to notify us that the native windowing system
-  // has changed our activation.
-  void HandleNativeWidgetActivationChanged(bool active);
-
   void AddObserver(DesktopWindowTreeHostObserverX11* observer);
   void RemoveObserver(DesktopWindowTreeHostObserverX11* observer);
 
   // Swaps the current handler for events in the non client view with |handler|.
   void SwapNonClientEventHandler(std::unique_ptr<ui::EventHandler> handler);
 
   // Runs the |func| callback for each content-window, and deallocates the
   // internal list of open windows.
   static void CleanUpWindowList(void (*func)(aura::Window* window));
 
@@ skipping 90 matching lines @@
   // window size to the monitor size causes the WM to set the EWMH for
   // fullscreen.
   gfx::Size AdjustSize(const gfx::Size& requested_size);
 
   // Called when |xwindow_|'s _NET_WM_STATE property is updated.
   void OnWMStateUpdated();
 
   // Called when |xwindow_|'s _NET_FRAME_EXTENTS property is updated.
   void OnFrameExtentsUpdated();
 
+  // Record the activation state.
+  void BeforeActivationStateChanged();
+
+  // Handle the state change since BeforeActivationStateChanged().
+  void AfterActivationStateChanged();
+
+  // Called on an XEnterWindowEvent, XLeaveWindowEvent, XIEnterEvent, or an
+  // XILeaveEvent.
+  void OnCrossingEvent(bool enter,
+                       bool focus_in_window_or_ancestor,
+                       int mode,
+                       int detail);
+
+  // Called on an XFocusInEvent, XFocusOutEvent, XIFocusInEvent, or an
+  // XIFocusOutEvent.
+  void OnFocusEvent(bool focus_in, int mode, int detail);
+
   // Makes a round trip to the X server to get the enclosing workspace for this
   // window.  Returns true iff |workspace_| was changed.
   bool UpdateWorkspace();
 
   // Updates |xwindow_|'s minimum and maximum size.
   void UpdateMinAndMaxSize();
 
   // Updates |xwindow_|'s _NET_WM_USER_TIME if |xwindow_| is active.
   void UpdateWMUserTime(const ui::PlatformEvent& event);
 
@@ skipping 60 matching lines @@
 
   // The native root window.
   ::Window x_root_window_;
 
   ui::X11AtomCache atom_cache_;
 
   // Is the window mapped to the screen?
   bool window_mapped_;
 
   // Should we wait for an UnmapNotify before trying to remap the window?
+  // If |wait_for_unmap_| is true, we have sent an XUnmapWindow request to the
+  // server and have yet to receive an UnmapNotify.
   bool wait_for_unmap_;
 
   // The bounds of |xwindow_|.
   gfx::Rect bounds_in_pixels_;
 
   // Whenever the bounds are set, we keep the previous set of bounds around so
   // we can have a better chance of getting the real
   // |restored_bounds_in_pixels_|. Window managers tend to send a Configure
   // message with the maximized bounds, and then set the window maximized
   // property. (We don't rely on this for when we request that the window be
@@ skipping 70 matching lines @@
   static std::list<XID>* open_windows_;
 
   base::string16 window_title_;
 
   // Whether we currently are flashing our frame. This feature is implemented
   // by setting the urgency hint with the window manager, which can draw
   // attention to the window or completely ignore the hint. We stop flashing
   // the frame when |xwindow_| gains focus or handles a mouse button event.
   bool urgency_hint_set_;
 
+  // Does |xwindow_| have the pointer grab (XI2 or normal)?
+  bool has_pointer_grab_;
+
   bool activatable_;
 
+  // The focus-tracking state variables are as described in
+  // gtk/docs/focus_tracking.txt
+  //
+  // |xwindow_| is active iff:
+  //     (|has_window_focus_| || |has_pointer_focus_|) &&
+  //     !|ignore_keyboard_input_|
+
+  // Is the pointer in |xwindow_| or one of its children?
+  bool has_pointer_;
+
+  // Is |xwindow_| or one of its children focused?
+  bool has_window_focus_;
+
+  // (An ancestor window or the PointerRoot is focused) && |has_pointer_|.
+  // |has_pointer_focus_| == true is the odd case where we will receive keyboard
+  // input when |has_window_focus_| == false.  |has_window_focus_| and
+  // |has_pointer_focus_| are mutually exclusive.
+  bool has_pointer_focus_;
+
+  // X11 does not support defocusing windows; you can only focus a different
+  // window.  If we would like to be defocused, we just ignore keyboard input we
+  // no longer care about.
+  bool ignore_keyboard_input_;
+
+  // Used for tracking activation state in {Before|After}ActivationStateChanged.
+  bool was_active_;
+  bool had_pointer_;
+  bool had_pointer_grab_;
+  bool had_window_focus_;
+
   base::CancelableCallback<void()> delayed_resize_task_;
 
   base::WeakPtrFactory<DesktopWindowTreeHostX11> close_widget_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(DesktopWindowTreeHostX11);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_WIDGET_DESKTOP_AURA_DESKTOP_WINDOW_TREE_HOST_X11_H_