mash: changes event dispatch to consider non-client area of all windows

services/ui/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 "services/ui/ws/event_dispatcher.h"
 
 #include <algorithm>
 
 #include "base/memory/ptr_util.h"
 #include "base/time/time.h"
@@ skipping 19 matching lines @@
 
 bool IsOnlyOneMouseButtonDown(int flags) {
   const uint32_t button_only_flags =
       flags & (ui::EF_LEFT_MOUSE_BUTTON | ui::EF_MIDDLE_MOUSE_BUTTON |
                ui::EF_RIGHT_MOUSE_BUTTON);
   return button_only_flags == ui::EF_LEFT_MOUSE_BUTTON ||
          button_only_flags == ui::EF_MIDDLE_MOUSE_BUTTON ||
          button_only_flags == ui::EF_RIGHT_MOUSE_BUTTON;
 }
 
-bool IsLocationInNonclientArea(const ServerWindow* target,
-                               const gfx::Point& location) {
-  if (!target->parent())
-    return false;
-
-  gfx::Rect client_area(target->bounds().size());
-  client_area.Inset(target->client_area());
-  if (client_area.Contains(location))
-    return false;
-
-  for (const auto& rect : target->additional_client_areas()) {
-    if (rect.Contains(location))
-      return false;
-  }
-
-  return true;
-}
-
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 EventDispatcher::EventDispatcher(EventDispatcherDelegate* delegate)
     : delegate_(delegate),
       capture_window_(nullptr),
       capture_window_client_id_(kInvalidClientId),
       modal_window_controller_(this),
       mouse_button_down_(false),
@@ skipping 146 matching lines @@
 void EventDispatcher::ReleaseCaptureBlockedByAnyModalWindow() {
   if (!capture_window_)
     return;
 
   if (modal_window_controller_.IsWindowBlocked(capture_window_))
     SetCaptureWindow(nullptr, kInvalidClientId);
 }
 
 void EventDispatcher::UpdateNonClientAreaForCurrentWindow() {
   if (mouse_cursor_source_window_) {
-    gfx::Point location = mouse_pointer_last_location_;
-    ServerWindow* target = FindDeepestVisibleWindowForEvents(&location);
-    if (target == mouse_cursor_source_window_) {
-      mouse_cursor_in_non_client_area_ =
-          mouse_cursor_source_window_
-              ? IsLocationInNonclientArea(mouse_cursor_source_window_, location)
-              : false;
+    DeepestWindow deepest_window =
+        FindDeepestVisibleWindowForEvents(mouse_pointer_last_location_);
+    if (deepest_window.window == mouse_cursor_source_window_) {
+      mouse_cursor_in_non_client_area_ = mouse_cursor_source_window_
+                                             ? deepest_window.in_non_client_area
+                                             : false;
     }
   }
 }
 
 void EventDispatcher::UpdateCursorProviderByLastKnownLocation() {
   if (!mouse_button_down_) {
-    gfx::Point location = mouse_pointer_last_location_;
-    mouse_cursor_source_window_ = FindDeepestVisibleWindowForEvents(&location);
-    if (!mouse_cursor_source_window_) {
-      location = mouse_pointer_last_location_;
+    DeepestWindow deepest_window =
+        FindDeepestVisibleWindowForEvents(mouse_pointer_last_location_);
+    mouse_cursor_source_window_ = deepest_window.window;
+    if (mouse_cursor_source_window_) {
+      mouse_cursor_in_non_client_area_ = deepest_window.in_non_client_area;
+    } else {
+      gfx::Point location = mouse_pointer_last_location_;
       mouse_cursor_source_window_ =
           delegate_->GetRootWindowContaining(&location);
+      mouse_cursor_in_non_client_area_ = true;
     }
-
-    mouse_cursor_in_non_client_area_ =
-        mouse_cursor_source_window_
-            ? IsLocationInNonclientArea(mouse_cursor_source_window_, location)
-            : false;
   }
 }
 
 bool EventDispatcher::AddAccelerator(uint32_t id,
                                      mojom::EventMatcherPtr event_matcher) {
   std::unique_ptr<Accelerator> accelerator(new Accelerator(id, *event_matcher));
   // If an accelerator with the same id or matcher already exists, then abort.
   for (const auto& pair : accelerators_) {
     if (pair.first == id || accelerator->EqualEventMatcher(pair.second.get()))
       return false;
@@ skipping 201 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::LocatedEvent& event) {
   PointerTarget pointer_target;
-  gfx::Point location(event.root_location());
-  ServerWindow* target_window = FindDeepestVisibleWindowForEvents(&location);
+  DeepestWindow deepest_window =
+      FindDeepestVisibleWindowForEvents(event.root_location());
   pointer_target.window =
-      modal_window_controller_.GetTargetForWindow(target_window);
+      modal_window_controller_.GetTargetForWindow(deepest_window.window);
   pointer_target.is_mouse_event = event.IsMousePointerEvent();
   pointer_target.in_nonclient_area =
-      target_window != pointer_target.window || !pointer_target.window ||
-      IsLocationInNonclientArea(pointer_target.window, location);
+      deepest_window.window != pointer_target.window ||
+      !pointer_target.window || deepest_window.in_non_client_area;
   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;
   }
   return false;
@@ skipping 71 matching lines @@
 Accelerator* EventDispatcher::FindAccelerator(
     const ui::KeyEvent& event,
     const ui::mojom::AcceleratorPhase phase) {
   for (const auto& pair : accelerators_) {
     if (pair.second->MatchesEvent(event, phase))
       return pair.second.get();
   }
   return nullptr;
 }
 
-ServerWindow* EventDispatcher::FindDeepestVisibleWindowForEvents(
-    gfx::Point* location) {
-  ServerWindow* root = delegate_->GetRootWindowContaining(location);
-  if (!root)
-    return nullptr;
-
-  return ui::ws::FindDeepestVisibleWindowForEvents(root, location);
+DeepestWindow EventDispatcher::FindDeepestVisibleWindowForEvents(
+    const gfx::Point& location) {
+  gfx::Point relative_location(location);
+  // For the case of no root.
+  ServerWindow* root = delegate_->GetRootWindowContaining(&relative_location);
+  return root ? ui::ws::FindDeepestVisibleWindowForEvents(root,
+                                                          relative_location)
+              : DeepestWindow();
 }
 
 void EventDispatcher::CancelImplicitCaptureExcept(ServerWindow* window,
                                                   ClientSpecificId client_id) {
   for (const auto& pair : pointer_targets_) {
     ServerWindow* target = pair.second.window;
     if (!target)
       continue;
     UnobserveWindow(target);
     if (target == window)
@@ skipping 52 matching lines @@
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 void EventDispatcher::OnDragCursorUpdated() {
   delegate_->UpdateNativeCursorFromDispatcher();
 }
 
 }  // namespace ws
 }  // namespace ui