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(views::DesktopWindowTreeHostObserverX11* observer);
   void RemoveObserver(views::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

[danakj, 2016/08/26 19:58:43]

btw I didn't want to derail this but I'll throw it out there you can
XSetInputFocus(None) to move focus to nothing. For future fun if you want.
Normally the WM sees this and does something with it, I expect.. so it might be
not what we want anyway depending. Not sure.

+  // 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_