Change OnWindowInputEvent to use display_id to find the host and update event root_location in WS.

ui/aura/mus/window_tree_client.cc

 // Copyright 2014 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 "ui/aura/mus/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 1118 matching lines @@
 
 void WindowTreeClient::OnWindowInputEvent(uint32_t event_id,
                                           Id window_id,
                                           int64_t display_id,
                                           std::unique_ptr<ui::Event> event,
                                           bool matches_pointer_watcher) {
   DCHECK(event);
 
   WindowMus* window = GetWindowByServerId(window_id);  // May be null.
 
-  if (event->IsKeyEvent()) {
-    DCHECK(!matches_pointer_watcher);  // PointerWatcher isn't for key events.
-    if (!window || !window->GetWindow()->GetHost()) {
-      tree_->OnWindowInputEventAck(event_id, ui::mojom::EventResult::UNHANDLED);
-      return;
-    }
-    InputMethodMus* input_method = GetWindowTreeHostMus(window)->input_method();
-    input_method->DispatchKeyEvent(event->AsKeyEvent(),
-                                   CreateEventResultCallback(event_id));
-    return;
-  }
-
   if (matches_pointer_watcher && has_pointer_watcher_) {
     DCHECK(event->IsPointerEvent());
     std::unique_ptr<ui::Event> event_in_dip(ui::Event::Clone(*event));
     ConvertEventLocationToDip(display_id, event_in_dip->AsLocatedEvent());
     delegate_->OnPointerEventObserved(*event_in_dip->AsPointerEvent(),
                                       window ? window->GetWindow() : nullptr);
   }
 
-  // TODO: use |display_id| to find host and send there.
+  WindowTreeHostMus* host = nullptr;
   if (!window || !window->GetWindow()->GetHost()) {
-    tree_->OnWindowInputEventAck(event_id, ui::mojom::EventResult::UNHANDLED);
+    // If |window| has already been deleted by the time OnWindowInputEvent is
+    // called, we fall back to use the |display_id| to find the window_tree_host
+    // for event dispatching.
+    host = GetWindowTreeHostMusWithDisplayId(display_id);
+    if (!host) {
+      tree_->OnWindowInputEventAck(event_id, ui::mojom::EventResult::UNHANDLED);
+      return;
+    }
+    window = WindowMus::Get(host->window());
+  } else {
+    host = GetWindowTreeHostMus(window);

[sky, 2017/02/14 23:31:14]

I don't think you're guaranteed the window has a host. For example, if between
the dispatch and this function being called the window was removed then the host
will be null. Can we always lookup the host?

[riajiang, 2017/02/15 19:35:05]

Oh makes sense. I changed it to always lookup the host with display_id and use
the root window if window was removed before this?

+  }
+  DCHECK(host);
+
+  if (event->IsKeyEvent()) {
+    DCHECK(!matches_pointer_watcher);  // PointerWatcher isn't for key events.
+    InputMethodMus* input_method = host->input_method();
+    input_method->DispatchKeyEvent(event->AsKeyEvent(),
+                                   CreateEventResultCallback(event_id));
     return;
   }
 
-  WindowTreeHostMus* host = GetWindowTreeHostMus(window);
-  DCHECK(host);
-
   // The location of the event is relative to |window|. As the event is handed
   // to WindowTreeHost we need it to be relative to WindowTreeHost.
   if (event->IsLocatedEvent()) {
     gfx::Point host_location = event->AsLocatedEvent()->location();
     aura::Window::ConvertPointToTarget(window->GetWindow(), host->window(),
                                        &host_location);
     event->AsLocatedEvent()->set_location(host_location);
   }
 
   EventAckHandler ack_handler(CreateEventResultCallback(event_id));
@@ skipping 162 matching lines @@
 }
 
 void WindowTreeClient::WmNewDisplayAdded(const display::Display& display,
                                          ui::mojom::WindowDataPtr root_data,
                                          bool parent_drawn) {
   WmNewDisplayAddedImpl(display, std::move(root_data), parent_drawn);
 }
 
 void WindowTreeClient::WmDisplayRemoved(int64_t display_id) {
   DCHECK(window_manager_delegate_);
-  for (WindowMus* root : roots_) {
-    DCHECK(root->GetWindow()->GetHost());
-    WindowTreeHostMus* window_tree_host =
-        static_cast<WindowTreeHostMus*>(root->GetWindow()->GetHost());
-    if (window_tree_host->display_id() == display_id) {
-      window_manager_delegate_->OnWmDisplayRemoved(window_tree_host);
-      return;
-    }
+  WindowTreeHostMus* host = GetWindowTreeHostMusWithDisplayId(display_id);
+  if (host) {
+    window_manager_delegate_->OnWmDisplayRemoved(host);
+    return;
   }
 }
 
 void WindowTreeClient::WmDisplayModified(const display::Display& display) {
   DCHECK(window_manager_delegate_);
   // TODO(sky): this should likely route to WindowTreeHost.
   window_manager_delegate_->OnWmDisplayModified(display);
 }
 
 void WindowTreeClient::WmSetBounds(uint32_t change_id,
@@ skipping 476 matching lines @@
 uint32_t WindowTreeClient::CreateChangeIdForCapture(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
       this, capture_synchronizer_.get(), window));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForFocus(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightFocusChange>(
       this, focus_synchronizer_.get(), window));
 }
 
+WindowTreeHostMus* WindowTreeClient::GetWindowTreeHostMusWithDisplayId(
+    int64_t display_id) {
+  for (WindowMus* root : roots_) {
+    DCHECK(root->GetWindow()->GetHost());
+    WindowTreeHostMus* window_tree_host =
+        static_cast<WindowTreeHostMus*>(root->GetWindow()->GetHost());
+    if (window_tree_host->display_id() == display_id)
+      return window_tree_host;
+  }
+  return nullptr;
+}
+
 }  // namespace aura