Reland: mus: Enable system modal windows

components/mus/ws/event_dispatcher.h

 // Copyright 2015 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 COMPONENTS_MUS_WS_EVENT_DISPATCHER_H_
 #define COMPONENTS_MUS_WS_EVENT_DISPATCHER_H_
 
 #include <stdint.h>
 
+#include <list>
 #include <map>
 #include <memory>
 
 #include "base/macros.h"
 #include "cc/surfaces/surface_id.h"
 #include "components/mus/public/interfaces/input_event_matcher.mojom.h"
 #include "components/mus/ws/server_window_observer.h"
 #include "ui/gfx/geometry/rect_f.h"
 
 namespace ui {
@@ skipping 33 matching lines @@
   }
 
   // |capture_window_| will receive all input. See window_tree.mojom for
   // details.
   ServerWindow* capture_window() { return capture_window_; }
   const ServerWindow* capture_window() const { return capture_window_; }
   // Setting capture can fail if the window is blocked by a modal window
   // (indicated by returning |false|).
   bool SetCaptureWindow(ServerWindow* capture_window, bool in_nonclient_area);
 
+  // Adds a system modal window. The window remains modal to system until it is
+  // destroyed. There can exist multiple system modal windows, in which case the
+  // one that is visible and added most recently or shown most recently would be
+  // the active one.
+  void AddSystemModalWindow(ServerWindow* window);
+
+  // Checks if |modal_window| is a visible modal window that blocks current
+  // capture window and if that's the case, releases the capture.
+  void ReleaseCaptureBlockedByModalWindow(const ServerWindow* modal_window);
+
+  // Checks if the current capture window is blocked by any visible modal window
+  // and if that's the case, releases the capture.
+  void ReleaseCaptureBlockedByAnyModalWindow();
+
   // Retrieves the ServerWindow of the last mouse move.
   ServerWindow* mouse_cursor_source_window() const {
     return mouse_cursor_source_window_;
   }
 
   // Possibly updates the cursor. If we aren't in an implicit capture, we take
   // the last known location of the mouse pointer, and look for the
   // ServerWindow* under it.
   void UpdateCursorProviderByLastKnownLocation();
 
   // Adds an accelerator with the given id and event-matcher. If an accelerator
   // already exists with the same id or the same matcher, then the accelerator
   // is not added. Returns whether adding the accelerator was successful or not.
   bool AddAccelerator(uint32_t id, mojom::EventMatcherPtr event_matcher);
   void RemoveAccelerator(uint32_t id);
 
   // Processes the supplied event, informing the delegate as approriate. This
   // may result in generating any number of events.
   void ProcessEvent(const ui::Event& event);
 
  private:
+  using ServerWindowList = std::list<ServerWindow*>;
   friend class test::EventDispatcherTestApi;
 
   // Keeps track of state associated with an active pointer.
   struct PointerTarget {
     PointerTarget()
         : window(nullptr),
           is_mouse_event(false),
           in_nonclient_area(false),
           is_pointer_down(false) {}
 
@@ skipping 47 matching lines @@
 
   // If |target->window| is valid, then passes the event to the delegate.
   void DispatchToPointerTarget(const PointerTarget& target,
                                const ui::LocatedEvent& event);
 
   // Stops sending pointer events to |window|. This does not remove the entry
   // for |window| from |pointer_targets_|, rather it nulls out the window. This
   // way we continue to eat events until the up/cancel is received.
   void CancelPointerEventsToTarget(ServerWindow* window);
 
-  // Returns true if we're currently an observer for |window|. We are an
-  // observer for a window if any pointer events are targeting it.
-  bool IsObservingWindow(ServerWindow* window);
+  // Used to observe a window. Can be called multiple times on a window. To
+  // unobserve a window, UnobserveWindow() should be called the same number of
+  // times.
+  void ObserveWindow(ServerWindow* winodw);
+  void UnobserveWindow(ServerWindow* winodw);
 
   // Returns an Accelerator bound to the specified code/flags, and of the
   // matching |phase|. Otherwise returns null.
   Accelerator* FindAccelerator(const ui::KeyEvent& event,
                                const mojom::AcceleratorPhase phase);
 
+  // Returns the system modal window that is visible and added/shown most
+  // recently, if any.
+  ServerWindow* GetActiveSystemModalWindow() const;
+
+  // Removes system modal window at the given iterator and unobserves it.
+  void RemoveSystemModalWindow(ServerWindowList::iterator it);
+
   // ServerWindowObserver:
   void OnWillChangeWindowHierarchy(ServerWindow* window,
                                    ServerWindow* new_parent,
                                    ServerWindow* old_parent) override;
   void OnWindowVisibilityChanged(ServerWindow* window) override;
   void OnWindowDestroyed(ServerWindow* window) override;
 
   EventDispatcherDelegate* delegate_;
   ServerWindow* root_;
+
   ServerWindow* capture_window_;
+  bool capture_window_in_nonclient_area_;
 
-  bool capture_window_in_nonclient_area_;
+  // List of system modal windows in order they are added/shown.
+  ServerWindowList system_modal_windows_;
+
   bool mouse_button_down_;
   ServerWindow* mouse_cursor_source_window_;
 
   // The on screen location of the mouse pointer. This can be outside the
   // bounds of |mouse_cursor_source_window_|, which can capture the cursor.
   gfx::Point mouse_pointer_last_location_;
 
   cc::SurfaceId surface_id_;
 
   using Entry = std::pair<uint32_t, std::unique_ptr<Accelerator>>;
   std::map<uint32_t, std::unique_ptr<Accelerator>> accelerators_;
 
   using PointerIdToTargetMap = std::map<int32_t, PointerTarget>;
   // |pointer_targets_| contains the active pointers. For a mouse based pointer
   // a PointerTarget is always active (and present in |pointer_targets_|). For
   // touch based pointers the pointer is active while down and removed on
   // cancel or up.
   PointerIdToTargetMap pointer_targets_;
 
+  // Keeps track of number of observe requests for each observed window.
+  std::map<const ServerWindow*, uint8_t> observed_windows_;
+
   DISALLOW_COPY_AND_ASSIGN(EventDispatcher);
 };
 
 }  // namespace ws
 }  // namespace mus
 
 #endif  // COMPONENTS_MUS_WS_EVENT_DISPATCHER_H_