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

ui/aura/mus/window_tree_client_unittest.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 "ui/aura/mus/window_tree_client.h"
 
 #include <stdint.h>
 
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "mojo/public/cpp/bindings/map.h"
 #include "services/ui/public/cpp/property_type_converters.h"
 #include "services/ui/public/interfaces/window_manager.mojom.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/capture_client.h"
 #include "ui/aura/client/capture_client_observer.h"
 #include "ui/aura/client/default_capture_client.h"
 #include "ui/aura/client/focus_client.h"
 #include "ui/aura/client/transient_window_client.h"
 #include "ui/aura/mus/capture_synchronizer.h"
+#include "ui/aura/mus/mus_types.h"
 #include "ui/aura/mus/property_converter.h"
 #include "ui/aura/mus/window_mus.h"
 #include "ui/aura/mus/window_tree_client_delegate.h"
 #include "ui/aura/mus/window_tree_client_observer.h"
 #include "ui/aura/mus/window_tree_host_mus.h"
 #include "ui/aura/test/aura_mus_test_base.h"
 #include "ui/aura/test/mus/test_window_tree.h"
 #include "ui/aura/test/mus/window_tree_client_private.h"
 #include "ui/aura/test/test_window_delegate.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/aura/window_tree_host_observer.h"
 #include "ui/base/class_property.h"
 #include "ui/compositor/compositor.h"
 #include "ui/display/display.h"
 #include "ui/display/display_switches.h"
 #include "ui/display/screen.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
+#include "ui/events/test/test_event_handler.h"
 #include "ui/gfx/geometry/dip_util.h"
 #include "ui/gfx/geometry/rect.h"
 
 namespace aura {
 
 namespace {
 
 DEFINE_UI_CLASS_PROPERTY_KEY(uint8_t, kTestPropertyKey1, 0);
 DEFINE_UI_CLASS_PROPERTY_KEY(uint16_t, kTestPropertyKey2, 0);
 DEFINE_UI_CLASS_PROPERTY_KEY(bool, kTestPropertyKey3, false);
@@ skipping 460 matching lines @@
 
  private:
   TestWindowTree* test_window_tree_;
   bool was_acked_ = false;
   bool got_move_ = false;
   gfx::Point last_event_location_;
 
   DISALLOW_COPY_AND_ASSIGN(InputEventBasicTestWindowDelegate);
 };
 
+class InputEventBasicTestEventHandler : public ui::test::TestEventHandler {
+ public:
+  static uint32_t constexpr kEventId = 1;
+
+  explicit InputEventBasicTestEventHandler(TestWindowTree* test_window_tree)
+      : test_window_tree_(test_window_tree) {}
+  ~InputEventBasicTestEventHandler() override {}
+
+  bool got_move() const { return got_move_; }
+  bool was_acked() const { return was_acked_; }
+  const gfx::Point& last_event_location() const { return last_event_location_; }
+
+  // ui::test::TestEventHandler overrides.
+  void OnMouseEvent(ui::MouseEvent* event) override {
+    was_acked_ = test_window_tree_->WasEventAcked(kEventId);
+    if (event->type() == ui::ET_MOUSE_MOVED)
+      got_move_ = true;
+    last_event_location_ = event->location();
+    event->SetHandled();
+  }
+
+ private:
+  TestWindowTree* test_window_tree_;
+  bool was_acked_ = false;
+  bool got_move_ = false;
+  gfx::Point last_event_location_;
+
+  DISALLOW_COPY_AND_ASSIGN(InputEventBasicTestEventHandler);
+};
+
 }  // namespace
 
 TEST_F(WindowTreeClientClientTest, InputEventBasic) {
   InputEventBasicTestWindowDelegate window_delegate(window_tree());
   WindowTreeHostMus window_tree_host(window_tree_client_impl());
   Window* top_level = window_tree_host.window();
   const gfx::Rect bounds(0, 0, 100, 100);
   window_tree_host.SetBoundsInPixels(bounds);
   window_tree_host.InitHost();
   window_tree_host.Show();
@@ skipping 16 matching lines @@
   EXPECT_TRUE(window_tree()->WasEventAcked(
       InputEventBasicTestWindowDelegate::kEventId));
   EXPECT_EQ(ui::mojom::EventResult::HANDLED,
             window_tree()->GetEventResult(
                 InputEventBasicTestWindowDelegate::kEventId));
   EXPECT_TRUE(window_delegate.got_move());
   EXPECT_FALSE(window_delegate.was_acked());
   EXPECT_EQ(event_location_in_child, window_delegate.last_event_location());
 }
 
+TEST_F(WindowTreeClientClientTest, InputEventNoWindow) {
+  WindowTreeHostMus window_tree_host(window_tree_client_impl());
+  Window* top_level = window_tree_host.window();
+  InputEventBasicTestEventHandler event_handler(window_tree());
+  top_level->AddPreTargetHandler(&event_handler);
+  const gfx::Rect bounds(0, 0, 100, 100);
+  window_tree_host.SetBoundsInPixels(bounds);
+  window_tree_host.InitHost();
+  window_tree_host.Show();
+  EXPECT_EQ(bounds, top_level->bounds());
+  EXPECT_EQ(bounds, window_tree_host.GetBoundsInPixels());
+  InputEventBasicTestWindowDelegate window_delegate(window_tree());
+  Window child(&window_delegate);
+  child.Init(ui::LAYER_NOT_DRAWN);
+  top_level->AddChild(&child);
+  child.SetBounds(gfx::Rect(10, 10, 100, 100));
+  child.Show();
+  EXPECT_FALSE(event_handler.got_move());
+  EXPECT_FALSE(event_handler.was_acked());
+  EXPECT_FALSE(window_delegate.got_move());
+  EXPECT_FALSE(window_delegate.was_acked());
+  const gfx::Point event_location_in_child(20, 30);
+  std::unique_ptr<ui::Event> ui_event(new ui::MouseEvent(
+      ui::ET_MOUSE_MOVED, event_location_in_child, gfx::Point(2, 3),
+      ui::EventTimeForNow(), ui::EF_NONE, 0));
+  window_tree_client()->OnWindowInputEvent(
+      InputEventBasicTestWindowDelegate::kEventId, kInvalidServerId,
+      window_tree_host.display_id(), ui::Event::Clone(*ui_event.get()), 0);
+  // WindowTreeClient::OnWindowInputEvent cannot find a target window with
+  // kInvalidServerId but should use the display_id to find the window_tree_host
+  // for event dispatching and dispatch the event to |top_level|.
+  EXPECT_TRUE(window_tree()->WasEventAcked(
+      InputEventBasicTestWindowDelegate::kEventId));
+  EXPECT_EQ(ui::mojom::EventResult::HANDLED,
+            window_tree()->GetEventResult(
+                InputEventBasicTestWindowDelegate::kEventId));
+  EXPECT_TRUE(event_handler.got_move());
+  EXPECT_FALSE(event_handler.was_acked());
+  EXPECT_EQ(gfx::Point(2, 3), event_handler.last_event_location());
+  EXPECT_FALSE(window_delegate.got_move());
+  EXPECT_FALSE(window_delegate.was_acked());
+  EXPECT_EQ(gfx::Point(), window_delegate.last_event_location());
+}
+
 class WindowTreeClientPointerObserverTest : public WindowTreeClientClientTest {
  public:
   WindowTreeClientPointerObserverTest() {}
   ~WindowTreeClientPointerObserverTest() override {}
 
   void DeleteLastEventObserved() { last_event_observed_.reset(); }
   const ui::PointerEvent* last_event_observed() const {
     return last_event_observed_.get();
   }
 
@@ skipping 1046 matching lines @@
   // Delegate received the event in Dips.
   const ui::PointerEvent* last_event = last_event_observed();
   ASSERT_TRUE(last_event);
   EXPECT_EQ(gfx::ConvertPointToDIP(2.0f, location_pixels),
             last_event->location());
   EXPECT_EQ(gfx::ConvertPointToDIP(2.0f, root_location_pixels),
             last_event->root_location());
 }
 
 }  // namespace aura