Moves EventDispatcher from Display to WindowManagerState

components/mus/ws/event_dispatcher_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 "components/mus/ws/event_dispatcher.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <queue>
 
 #include "base/macros.h"
 #include "components/mus/public/cpp/event_matcher.h"
 #include "components/mus/ws/event_dispatcher_delegate.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_surface_manager_test_api.h"
 #include "components/mus/ws/test_server_window_delegate.h"
+#include "components/mus/ws/test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "ui/events/event.h"
 
 namespace mus {
 namespace ws {
+namespace test {
 namespace {
 
 // Identifies a generated event.
 struct DispatchedEventDetails {
   DispatchedEventDetails() : window(nullptr), in_nonclient_area(false) {}
 
   ServerWindow* window;
   bool in_nonclient_area;
   scoped_ptr<ui::Event> event;
 };
@@ skipping 162 matching lines @@
  private:
   scoped_ptr<TestServerWindowDelegate> window_delegate_;
   scoped_ptr<ServerWindow> root_window_;
   scoped_ptr<TestEventDispatcherDelegate> test_event_dispatcher_delegate_;
   scoped_ptr<EventDispatcher> event_dispatcher_;
 
   DISALLOW_COPY_AND_ASSIGN(EventDispatcherTest);
 };
 
 bool EventDispatcherTest::AreAnyPointersDown() const {
-  return event_dispatcher_->AreAnyPointersDown();
+  return EventDispatcherTestApi(event_dispatcher_.get()).AreAnyPointersDown();
 }
 
 void EventDispatcherTest::ClearSetup() {
   window_delegate_.reset();
   root_window_.reset();
   test_event_dispatcher_delegate_.reset();
   event_dispatcher_.reset();
 }
 
 ServerWindow* EventDispatcherTest::CreateChildWindow(const WindowId& id) {
   ServerWindow* child = new ServerWindow(window_delegate_.get(), id);
   root_window_->Add(child);
   child->SetVisible(true);
   EnableHitTest(child);
   return child;
 }
 
 bool EventDispatcherTest::IsMouseButtonDown() const {
-  return event_dispatcher_->mouse_button_down_;
+  return EventDispatcherTestApi(event_dispatcher_.get()).is_mouse_button_down();
 }
 
 bool EventDispatcherTest::IsWindowPointerTarget(ServerWindow* window) const {
-  return event_dispatcher_->IsObservingWindow(window);
+  return EventDispatcherTestApi(event_dispatcher_.get())
+      .IsObservingWindow(window);
 }
 
 int EventDispatcherTest::NumberPointerTargetsForWindow(
     ServerWindow* window) const {
-  int count = 0;
-  for (const auto& pair : event_dispatcher_->pointer_targets_)
-    if (pair.second.window == window)
-      count++;
-  return count;
+  return EventDispatcherTestApi(event_dispatcher_.get())
+      .NumberPointerTargetsForWindow(window);
 }
 
 void EventDispatcherTest::SetUp() {
   testing::Test::SetUp();
 
   window_delegate_.reset(new TestServerWindowDelegate());
   root_window_.reset(new ServerWindow(window_delegate_.get(), WindowId(1, 2)));
   window_delegate_->set_root_window(root_window_.get());
   root_window_->SetVisible(true);
 
@@ skipping 833 matching lines @@
     ASSERT_TRUE(details->event);
     ASSERT_TRUE(details->event->IsPointerEvent());
 
     ui::PointerEvent* dispatched_event = details->event->AsPointerEvent();
     EXPECT_EQ(gfx::Point(25, 20), dispatched_event->root_location());
     EXPECT_EQ(gfx::Point(15, 10), dispatched_event->location());
     EXPECT_EQ(touch_id, dispatched_event->pointer_id());
   }
 }
 
+TEST_F(EventDispatcherTest, ResetClearsPointerDown) {
+  scoped_ptr<ServerWindow> child(CreateChildWindow(WindowId(1, 3)));
+
+  root_window()->SetBounds(gfx::Rect(0, 0, 100, 100));
+  child->SetBounds(gfx::Rect(10, 10, 20, 20));
+
+  // Send event that is over child.
+  const ui::PointerEvent ui_event(ui::MouseEvent(
+      ui::ET_MOUSE_PRESSED, gfx::Point(20, 25), gfx::Point(20, 25),
+      base::TimeDelta(), ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
+  event_dispatcher()->ProcessEvent(ui_event);
+
+  scoped_ptr<DispatchedEventDetails> details =
+      test_event_dispatcher_delegate()->GetAndAdvanceDispatchedEventDetails();
+  ASSERT_TRUE(details);
+  ASSERT_EQ(child.get(), details->window);
+
+  EXPECT_TRUE(AreAnyPointersDown());
+
+  event_dispatcher()->Reset();
+  EXPECT_FALSE(test_event_dispatcher_delegate()->has_queued_events());
+  EXPECT_FALSE(AreAnyPointersDown());
+}
+
+TEST_F(EventDispatcherTest, ResetClearsCapture) {
+  ServerWindow* root = root_window();
+  root->SetBounds(gfx::Rect(0, 0, 100, 100));
+
+  root->SetClientArea(gfx::Insets(5, 5, 5, 5), std::vector<gfx::Rect>());
+  EventDispatcher* dispatcher = event_dispatcher();
+  dispatcher->SetCaptureWindow(root, true);
+
+  event_dispatcher()->Reset();
+  EXPECT_FALSE(test_event_dispatcher_delegate()->has_queued_events());
+  EXPECT_EQ(nullptr, event_dispatcher()->capture_window());
+}
+
+}  // namespace test
 }  // namespace ws
 }  // namespace mus