Delete mus surfaces hit testing

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 <algorithm>
 
 #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"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "ui/events/event_utils.h"
@@ skipping 179 matching lines @@
   if (!capture_window_)
     return;
 
   if (modal_window_controller_.IsWindowBlocked(capture_window_))
     SetCaptureWindow(nullptr, false);
 }
 
 void EventDispatcher::UpdateNonClientAreaForCurrentWindow() {
   if (mouse_cursor_source_window_) {
     gfx::Point location = mouse_pointer_last_location_;
-    ServerWindow* target =
-        FindDeepestVisibleWindowForEvents(root_, surface_id_, &location);
+    ServerWindow* target = FindDeepestVisibleWindowForEvents(root_, &location);
     if (target == mouse_cursor_source_window_) {
       mouse_cursor_in_non_client_area_ =
           mouse_cursor_source_window_
               ? IsLocationInNonclientArea(mouse_cursor_source_window_, location)
               : false;
     }
   }
 }
 
 void EventDispatcher::UpdateCursorProviderByLastKnownLocation() {
   if (!mouse_button_down_) {
     gfx::Point location = mouse_pointer_last_location_;
     mouse_cursor_source_window_ =
-        FindDeepestVisibleWindowForEvents(root_, surface_id_, &location);
+        FindDeepestVisibleWindowForEvents(root_, &location);
 
     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) {
@@ skipping 175 matching lines @@
   // simpler code.
   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);
+      FindDeepestVisibleWindowForEvents(root_, &location);
   pointer_target.window =
       modal_window_controller_.GetTargetForWindow(target_window);
   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;
   }
   return false;
 }
 
 void EventDispatcher::DispatchToPointerTarget(const PointerTarget& target,
                                               const ui::LocatedEvent& event) {
   if (!target.window) {
     delegate_->OnEventTargetNotFound(event);
     return;
   }
 
   if (target.is_mouse_event)
     mouse_cursor_in_non_client_area_ = target.in_nonclient_area;
 
   gfx::Point location(event.location());
-  gfx::Transform transform(GetTransformToWindow(surface_id_, target.window));
+  gfx::Transform transform(GetTransformToWindow(target.window));
   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) {
@@ skipping 59 matching lines @@
 
 void EventDispatcher::OnWindowDestroyed(ServerWindow* window) {
   CancelPointerEventsToTarget(window);
 
   if (mouse_cursor_source_window_ == window)
     mouse_cursor_source_window_ = nullptr;
 }
 
 }  // namespace ws
 }  // namespace mus