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 217 matching lines @@
   mouse_button_down_ = false;
 }
 
 void EventDispatcher::SetMousePointerScreenLocation(
     const gfx::Point& screen_location) {
   DCHECK(pointer_targets_.empty());
   mouse_pointer_last_location_ = screen_location;
   UpdateCursorProviderByLastKnownLocation();
 }
 
-void EventDispatcher::SetCaptureWindow(ServerWindow* window,
+bool EventDispatcher::SetCaptureWindow(ServerWindow* window,
                                        bool in_nonclient_area) {
   if (window == capture_window_)
-    return;
+    return true;
+
+  // A window that is blocked by a modal window cannot gain capture.
+  if (window && window->IsBlockedByModalWindow())
+    return false;
 
   if (capture_window_) {
     // Stop observing old capture window. |pointer_targets_| are cleared on
-    // intial setting of a capture window.
+    // initial setting of a capture window.
     delegate_->OnServerWindowCaptureLost(capture_window_);
     capture_window_->RemoveObserver(this);
   } else {
     // Cancel implicit capture to all other windows.
     std::set<ServerWindow*> unobserved_windows;
     for (const auto& pair : pointer_targets_) {
       ServerWindow* target = pair.second.window;
       if (!target)
         continue;
       if (unobserved_windows.insert(target).second)
         target->RemoveObserver(this);
       if (target == window)
         continue;
 
       ui::EventType event_type = pair.second.is_mouse_event
                                      ? ui::ET_POINTER_EXITED
                                      : ui::ET_POINTER_CANCELLED;
       ui::EventPointerType pointer_type =
           pair.second.is_mouse_event ? ui::EventPointerType::POINTER_TYPE_MOUSE
                                      : ui::EventPointerType::POINTER_TYPE_TOUCH;
       // TODO(jonross): Track previous location in PointerTarget for sending
-      // cancels
+      // cancels.
       ui::PointerEvent event(event_type, pointer_type, gfx::Point(),
                              gfx::Point(), ui::EF_NONE, pair.first,
                              ui::EventTimeForNow());
       DispatchToPointerTarget(pair.second, event);
     }
     pointer_targets_.clear();
   }
 
   // Begin tracking the capture window if it is not yet being observed.
   if (window) {
     window->AddObserver(this);
     if (!capture_window_)
       delegate_->SetNativeCapture();
   } else {
     delegate_->ReleaseNativeCapture();
     if (!mouse_button_down_)
       UpdateCursorProviderByLastKnownLocation();
   }
 
   capture_window_ = window;
   capture_window_in_nonclient_area_ = in_nonclient_area;
+  return true;
 }
 
 void EventDispatcher::UpdateCursorProviderByLastKnownLocation() {
   if (!mouse_button_down_) {
     gfx::Point location = mouse_pointer_last_location_;
     mouse_cursor_source_window_ =
         FindDeepestVisibleWindowForEvents(root_, surface_id_, &location);
   }
 }
 
@@ skipping 164 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 = target_window->GetModalTarget();
   pointer_target.is_mouse_event = event.IsMousePointerEvent();
   pointer_target.in_nonclient_area =
+      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 67 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace mus