mus: Server-side implementation of modal windows

components/mus/ws/event_dispatcher.cc

 // 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.
 
 #include "components/mus/ws/event_dispatcher.h"
 
 #include <set>
 
 #include "base/time/time.h"
 #include "cc/surfaces/surface_hittest.h"
@@ skipping 34 matching lines @@
     return false;
 
   for (const auto& rect : target->additional_client_areas()) {
     if (rect.Contains(location))
       return false;
   }
 
   return true;
 }
 
+ServerWindow* GetModalTargetForWindow(ServerWindow* target) {
+  for (ServerWindow* window = target; window; window = window->parent()) {
+    for (const auto& transient_child : window->transient_children()) {
+      if (transient_child->is_modal())
+        return GetModalTargetForWindow(transient_child);
+    }
+  }
+  return target;
+}
+
 }  // namespace
 
 class EventMatcher {
  public:
   explicit EventMatcher(const mojom::EventMatcher& matcher)
       : fields_to_match_(NONE),
         event_type_(ui::ET_UNKNOWN),
         event_flags_(ui::EF_NONE),
         ignore_event_flags_(ui::EF_NONE),
         keyboard_code_(ui::VKEY_UNKNOWN),
@@ skipping 371 matching lines @@
   // Technically we're updating in place, but calling start then stop makes for
   // simpler code.
   StopTrackingPointer(pointer_id);
   StartTrackingPointer(pointer_id, pointer_target);
 }
 
 EventDispatcher::PointerTarget EventDispatcher::PointerTargetForEvent(
     const ui::PointerEvent& event) const {
   PointerTarget pointer_target;
   gfx::Point location(event.location());
-  pointer_target.window =
+  ServerWindow* target_window =
       FindDeepestVisibleWindowForEvents(root_, surface_id_, &location);
+  pointer_target.window = GetModalTargetForWindow(target_window);
   pointer_target.is_mouse_event = event.IsMousePointerEvent();
   pointer_target.in_nonclient_area =

[sky, 2016/03/02 18:28:33]

Aren't you going to use an enum to indicate modal?

[mohsen, 2016/03/03 22:54:59]

Not at the moment. That enum would be useful if we send it to the client (e.g.
the window manager). On the server side we only need to know who to send the
event to for which a boolean would be enough (maybe we need to rename it to
something better). For sending this information to the client, I've added a
paragraph and a comment to the design doc. Please take a look:
https://docs.google.com/document/d/1nrDrFEvXbGhqLvH4a1uutg3uFRJsNESZAUcAyYtQ6...

[sky, 2016/03/03 23:50:39]

If you don't send a flag indicating this, I'm not sure how happy some of the
code that the windowmanager usese will be if it sees events outside the bounds
of window. Did you make sure we ignore events outside the bounds of the window
in the clients?

[mohsen, 2016/03/04 16:24:17]

I've tested this code (using window_type_launcher) and it works properly (it
actually activates the modal window which is the desired behavior). The events
on the client side end up in Aura event dispatching code which I think handles
this case properly.

+      target_window != pointer_target.window ||
       IsLocationInNonclientArea(pointer_target.window, location);
   pointer_target.is_pointer_down = event.type() == ui::ET_POINTER_DOWN;
   return pointer_target;
 }
 
 bool EventDispatcher::AreAnyPointersDown() const {
   for (const auto& pair : pointer_targets_) {
     if (pair.second.is_pointer_down)
       return true;
   }
@@ skipping 66 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace mus