Revert "mus: Fix event processing for touch events in unified mode"

This reverts commit 1423331f.

Reason for revert: speculative attempt due to unhappy MSan ChromiumOS bot.
See also crbug.com/806638.

Original change's description:
> mus: Fix event processing for touch events in unified mode
> 
> This refines my earlier work done in: http://crrev.com/c/842467
> 
> Move event target nulling and root location use to WindowTreeClient, to ensure events reach MusUnifiedEventTargeter.
> Otherwise, WindowEventDispatcher::GetInitialEventTarget will use the touch gesture recognizer's target (returned by GetPriorityTargetInRootWindow) before performing the mirror display transformation on the event's location.
> 
> Inline DispatchEventToTarget for additional clarity.
> 
> Bug: 805714
> Test: Mus touch events work in Chrome OS's unified desktop mode.
> Change-Id: Ic4844c85cc24a9f9885e7705ff27cb57b305d245
> Reviewed-on: https://chromium-review.googlesource.com/887250
> Commit-Queue: Michael Wasserman <msw@chromium.org>
> Reviewed-by: Scott Violet <sky@chromium.org>
> Cr-Commit-Position: refs/heads/master@{#532030}

TBR=sky@chromium.org,msw@chromium.org

# Not skipping CQ checks because original CL landed > 1 day ago.

Bug: 805714
Change-Id: I02333546f91d0d0f495153c8556aa9820612673d
Reviewed-on: https://chromium-review.googlesource.com/890841Reviewed-by: Makoto Shimazu <shimazu@chromium.org>
Commit-Queue: Makoto Shimazu <shimazu@chromium.org>
Cr-Commit-Position: refs/heads/master@{#532328}

ash/host/ash_window_tree_host_mus_unified.cc

@@ -31,9 +31,20 @@ class MusUnifiedEventTargeter : public aura::WindowTargeter {
 
   ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
                                       ui::Event* event) override {
-    if (root == src_root_ && !event->target()) {
+    if (root == src_root_) {
       delegate_->SetCurrentEventTargeterSourceHost(src_root_->GetHost());
 
+      if (event->IsLocatedEvent()) {
+        // Mus uses the event's root location (relative to the physical display)
+        // to find the target window's local coordinates, but it incorrectly
+        // assumes that the root location is relative to the unified display.
+        // Pass the root location (now relative to the unified display) into the
+        // event dispatch pipeline, that finds local coordinates for the target.
+        ui::LocatedEvent* located_event = static_cast<ui::LocatedEvent*>(event);
+        located_event->set_location_f(located_event->root_location_f());
+      }
+      if (event->target())
+        ui::Event::DispatcherApi(event).set_target(nullptr);
       ignore_result(
           dst_root_->GetHost()->event_sink()->OnEventFromSource(event));
 

ui/aura/mus/window_tree_client.cc

@@ -166,6 +166,17 @@ std::unique_ptr<ui::Event> MapEvent(const ui::Event& event) {
   return ui::Event::Clone(event);
 }
 
+// Set the |target| to be the target window of this |event| and send it to
+// the EventSink.
+void DispatchEventToTarget(ui::Event* event, WindowMus* target) {
+  ui::Event::DispatcherApi dispatch_helper(event);
+  // Ignore the target for key events. They need to go to the focused window,
+  // which may have changed by the time we process the event.
+  if (!event->IsKeyEvent())
+    dispatch_helper.set_target(target->GetWindow());
+  GetWindowTreeHostMus(target)->SendEventToSink(event);
+}
+
 // Use for acks from mus that are expected to always succeed and if they don't
 // a crash is triggered.
 void OnAckMustSucceed(const base::Location& from_here, bool success) {
@@ -1472,6 +1483,7 @@ void WindowTreeClient::OnWindowInputEvent(
     std::unique_ptr<ui::Event> event,
     bool matches_pointer_watcher) {
   DCHECK(event);
+
   WindowMus* window = GetWindowByServerId(window_id);  // May be null.
 
   if (matches_pointer_watcher && has_pointer_watcher_) {
@@ -1537,24 +1549,17 @@ void WindowTreeClient::OnWindowInputEvent(
 #endif
 
   WindowMus* display_root_window = GetWindowByServerId(display_root_window_id);
-  if (display_root_window && event->IsLocatedEvent() &&
+  if (display_root_window && window && event->IsLocatedEvent() &&
       display::Screen::GetScreen()->GetPrimaryDisplay().id() ==
           display::kUnifiedDisplayId) {
-    // In Ash's unified desktop mode, each physical display mirrors part of a
-    // single virtual display. Dispatch events to the root window of the mirror
-    // display supplying the event, using locations relative to that display.
-    // Use a null target to ensure events reach the MusUnifiedEventTargeter.
-    // This paralells the behavior of unified desktop mode in classic Ash.
-    ui::Event::DispatcherApi(event_to_dispatch).set_target(nullptr);
-    ui::LocatedEvent* located_event = event_to_dispatch->AsLocatedEvent();
-    located_event->set_location_f(located_event->root_location_f());
-    window = display_root_window;
-  } else if (!event->IsKeyEvent()) {
-    // Set |window| as the target, except for key events. Key events go to the
-    // focused window, which may have changed by the time we process the event.
-    ui::Event::DispatcherApi(event_to_dispatch).set_target(window->GetWindow());
-  }
-  GetWindowTreeHostMus(window)->SendEventToSink(event_to_dispatch);
+    // Dispatch to the root window of the display supplying the event. This
+    // allows Ash to determine the event position in the unified desktop mode,
+    // where each physical display mirrors part of a single virtual display.
+    // This paralells the behavior of unified desktop mode in classic Ash mode.
+    DispatchEventToTarget(event_to_dispatch, display_root_window);
+  } else {
+    DispatchEventToTarget(event_to_dispatch, window);
+  }
 
   ack_handler.set_handled(event_to_dispatch->handled());
 }