Promotes remaining global window manager state into 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>
@@ skipping 52 matching lines @@
   ui::Event* last_event_target_not_found() {
     return last_event_target_not_found_.get();
   }
 
   uint32_t GetAndClearLastAccelerator() {
     uint32_t return_value = last_accelerator_;
     last_accelerator_ = 0;
     return return_value;
   }
 
+  void set_root(ServerWindow* root) { root_ = root; }
+
   // Returns the last dispatched event, or null if there are no more.
   std::unique_ptr<DispatchedEventDetails>
   GetAndAdvanceDispatchedEventDetails() {
     if (dispatched_event_queue_.empty())
       return nullptr;
 
     std::unique_ptr<DispatchedEventDetails> details =
         std::move(dispatched_event_queue_.front());
     dispatched_event_queue_.pop();
     return details;
@@ skipping 15 matching lines @@
 
  private:
   // EventDispatcherDelegate:
   void OnAccelerator(uint32_t accelerator, const ui::Event& event) override {
     EXPECT_EQ(0u, last_accelerator_);
     last_accelerator_ = accelerator;
   }
   ServerWindow* GetFocusedWindowForEventDispatcher() override {
     return focused_window_;
   }
-  void SetNativeCapture() override {}
+  void SetNativeCapture(ServerWindow* window) override {}
   void ReleaseNativeCapture() override {
     if (delegate_)
       delegate_->ReleaseCapture();
   }
   void OnServerWindowCaptureLost(ServerWindow* window) override {
     lost_capture_window_ = window;
   }
   void OnMouseCursorLocationChanged(const gfx::Point& point) override {}
   void DispatchInputEventToWindow(ServerWindow* target,
                                   ClientSpecificId client_id,
                                   const ui::Event& event,
                                   Accelerator* accelerator) override {
     std::unique_ptr<DispatchedEventDetails> details(new DispatchedEventDetails);
     details->window = target;
     details->client_id = client_id;
     details->event = ui::Event::Clone(event);
     details->accelerator = accelerator;
     dispatched_event_queue_.push(std::move(details));
   }
-  void OnEventTargetNotFound(const ui::Event& event) override {
-    last_event_target_not_found_ = ui::Event::Clone(event);
-  }
   ClientSpecificId GetEventTargetClientId(const ServerWindow* window,
                                           bool in_nonclient_area) override {
     return in_nonclient_area ? kNonclientAreaId : kClientAreaId;
   }
+  ServerWindow* GetRootWindowContaining(const gfx::Point& location) override {
+    return root_;
+  }
+  void OnEventTargetNotFound(const ui::Event& event) override {
+    last_event_target_not_found_ = ui::Event::Clone(event);
+  }
 
   Delegate* delegate_;
   ServerWindow* focused_window_;
   ServerWindow* lost_capture_window_;
   uint32_t last_accelerator_;
   std::queue<std::unique_ptr<DispatchedEventDetails>> dispatched_event_queue_;
+  ServerWindow* root_ = nullptr;
   std::unique_ptr<ui::Event> last_event_target_not_found_;
 
   DISALLOW_COPY_AND_ASSIGN(TestEventDispatcherDelegate);
 };
 
 // Used by RunMouseEventTests(). Can identify up to two generated events. The
 // first ServerWindow and two points identify the first event, the second
 // ServerWindow and points identify the second event. If only one event is
 // generated set the second window to null.
 struct MouseEventTest {
@@ skipping 154 matching lines @@
   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);
 
   test_event_dispatcher_delegate_.reset(new TestEventDispatcherDelegate(this));
   event_dispatcher_.reset(
       new EventDispatcher(test_event_dispatcher_delegate_.get()));
-  event_dispatcher_->set_root(root_window_.get());
+  test_event_dispatcher_delegate_->set_root(root_window_.get());
 }
 
 TEST_F(EventDispatcherTest, ProcessEvent) {
   std::unique_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(
@@ skipping 1273 matching lines @@
   // The delegate can decide if it really wants to forward the event or not.
   EXPECT_EQ(child.get(),
             test_event_dispatcher_delegate()->lost_capture_window());
   EXPECT_EQ(child.get(), event_dispatcher()->capture_window());
   EXPECT_EQ(kClientAreaId, event_dispatcher()->capture_window_client_id());
 }
 
 }  // namespace test
 }  // namespace ws
 }  // namespace mus