Revert of mus: Enable system 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"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/accelerator.h"
 #include "components/mus/ws/display.h"
 #include "components/mus/ws/event_dispatcher_delegate.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_delegate.h"
 #include "components/mus/ws/window_coordinate_conversions.h"
 #include "components/mus/ws/window_finder.h"
@@ skipping 46 matching lines @@
 
 }  // namespace
 
 ////////////////////////////////////////////////////////////////////////////////
 
 EventDispatcher::EventDispatcher(EventDispatcherDelegate* delegate)
     : delegate_(delegate),
       root_(nullptr),
       capture_window_(nullptr),
       capture_window_in_nonclient_area_(false),
-      modal_window_controller_(this),
       mouse_button_down_(false),
       mouse_cursor_source_window_(nullptr) {}
 
 EventDispatcher::~EventDispatcher() {
+  std::set<ServerWindow*> pointer_targets;
   if (capture_window_) {
-    UnobserveWindow(capture_window_);
+    pointer_targets.insert(capture_window_);
+    capture_window_->RemoveObserver(this);
     capture_window_ = nullptr;
   }
   for (const auto& pair : pointer_targets_) {
-    if (pair.second.window)
-      UnobserveWindow(pair.second.window);
+    if (pair.second.window &&
+        pointer_targets.insert(pair.second.window).second) {
+      pair.second.window->RemoveObserver(this);
+    }
   }
   pointer_targets_.clear();
 }
 
 void EventDispatcher::Reset() {
   if (capture_window_) {
     CancelPointerEventsToTarget(capture_window_);
     DCHECK(capture_window_ == nullptr);
   }
 
@@ skipping 13 matching lines @@
   // process any events in views during window construction.
   delegate_->OnMouseCursorLocationChanged(screen_location);
 }
 
 bool EventDispatcher::SetCaptureWindow(ServerWindow* window,
                                        bool in_nonclient_area) {
   if (window == capture_window_)
     return true;
 
   // A window that is blocked by a modal window cannot gain capture.
-  if (window && modal_window_controller_.IsWindowBlocked(window))
+  if (window && window->IsBlockedByModalWindow())
     return false;
 
   if (capture_window_) {
     // Stop observing old capture window. |pointer_targets_| are cleared on
     // initial setting of a capture window.
     delegate_->OnServerWindowCaptureLost(capture_window_);
-    UnobserveWindow(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;
-      UnobserveWindow(target);
+      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.
       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) {
-    ObserveWindow(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::AddSystemModalWindow(ServerWindow* window) {
-  modal_window_controller_.AddSystemModalWindow(window);
-}
-
-void EventDispatcher::ReleaseCaptureBlockedByModalWindow(
-    const ServerWindow* modal_window) {
-  if (!capture_window_)
-    return;
-
-  if (modal_window_controller_.IsWindowBlockedBy(capture_window_,
-                                                 modal_window)) {
-    SetCaptureWindow(nullptr, false);
-  }
-}
-
-void EventDispatcher::ReleaseCaptureBlockedByAnyModalWindow() {
-  if (!capture_window_)
-    return;
-
-  if (modal_window_controller_.IsWindowBlocked(capture_window_))
-    SetCaptureWindow(nullptr, false);
-}
-
 void EventDispatcher::UpdateCursorProviderByLastKnownLocation() {
   if (!mouse_button_down_) {
     gfx::Point location = mouse_pointer_last_location_;
     mouse_cursor_source_window_ =
         FindDeepestVisibleWindowForEvents(root_, surface_id_, &location);
   }
 }
 
 bool EventDispatcher::AddAccelerator(uint32_t id,
                                      mojom::EventMatcherPtr event_matcher) {
@@ skipping 125 matching lines @@
       StopTrackingPointer(pointer_id);
     if (!AreAnyPointersDown())
       delegate_->ReleaseNativeCapture();
   }
 }
 
 void EventDispatcher::StartTrackingPointer(
     int32_t pointer_id,
     const PointerTarget& pointer_target) {
   DCHECK(!IsTrackingPointer(pointer_id));
-  ObserveWindow(pointer_target.window);
+  if (!IsObservingWindow(pointer_target.window))
+    pointer_target.window->AddObserver(this);
   pointer_targets_[pointer_id] = pointer_target;
 }
 
 void EventDispatcher::StopTrackingPointer(int32_t pointer_id) {
   DCHECK(IsTrackingPointer(pointer_id));
   ServerWindow* window = pointer_targets_[pointer_id].window;
   pointer_targets_.erase(pointer_id);
-  if (window)
-    UnobserveWindow(window);
+  if (window && !IsObservingWindow(window))
+    window->RemoveObserver(this);
 }
 
 void EventDispatcher::UpdateTargetForPointer(int32_t pointer_id,
                                              const ui::LocatedEvent& event) {
   if (!IsTrackingPointer(pointer_id)) {
     StartTrackingPointer(pointer_id, PointerTargetForEvent(event));
     return;
   }
 
   const PointerTarget pointer_target = PointerTargetForEvent(event);
@@ skipping 21 matching lines @@
   StopTrackingPointer(pointer_id);
   StartTrackingPointer(pointer_id, pointer_target);
 }
 
 EventDispatcher::PointerTarget EventDispatcher::PointerTargetForEvent(
     const ui::LocatedEvent& event) const {
   PointerTarget pointer_target;
   gfx::Point location(event.location());
   ServerWindow* target_window =
       FindDeepestVisibleWindowForEvents(root_, surface_id_, &location);
-  pointer_target.window =
-      modal_window_controller_.GetTargetForWindow(target_window);
+  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_) {
@@ skipping 15 matching lines @@
   transform.TransformPoint(&location);
   std::unique_ptr<ui::Event> clone = ui::Event::Clone(event);
   clone->AsLocatedEvent()->set_location(location);
   // TODO(jonross): add post-target accelerator support once accelerators
   // support pointer events.
   delegate_->DispatchInputEventToWindow(target.window, target.in_nonclient_area,
                                         *clone, nullptr);
 }
 
 void EventDispatcher::CancelPointerEventsToTarget(ServerWindow* window) {
+  window->RemoveObserver(this);
+
   if (capture_window_ == window) {
-    UnobserveWindow(window);
     capture_window_ = nullptr;
     mouse_button_down_ = false;
     // A window only cares to be informed that it lost capture if it explicitly
     // requested capture. A window can lose capture if another window gains
     // explicit capture.
     delegate_->OnServerWindowCaptureLost(window);
     delegate_->ReleaseNativeCapture();
     UpdateCursorProviderByLastKnownLocation();
     return;
   }
 
   for (auto& pair : pointer_targets_) {
-    if (pair.second.window == window) {
-      UnobserveWindow(window);
+    if (pair.second.window == window)
       pair.second.window = nullptr;
-    }
   }
 }
 
-void EventDispatcher::ObserveWindow(ServerWindow* window) {
-  auto res = observed_windows_.insert(std::make_pair(window, 0u));
-  res.first->second++;
-  if (res.second)
-    window->AddObserver(this);
-}
-
-void EventDispatcher::UnobserveWindow(ServerWindow* window) {
-  auto it = observed_windows_.find(window);
-  DCHECK(it != observed_windows_.end());
-  DCHECK_LT(0u, it->second);
-  it->second--;
-  if (!it->second) {
-    window->RemoveObserver(this);
-    observed_windows_.erase(it);
+bool EventDispatcher::IsObservingWindow(ServerWindow* window) {
+  for (const auto& pair : pointer_targets_) {
+    if (pair.second.window == window)
+      return true;
   }
+  return false;
 }
 
 Accelerator* EventDispatcher::FindAccelerator(
     const ui::KeyEvent& event,
     const mojom::AcceleratorPhase phase) {
   for (const auto& pair : accelerators_) {
     if (pair.second->MatchesEvent(event, phase)) {
       return pair.second.get();
     }
   }
@@ skipping 12 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace mus