Moves EventDispatcher from Display to WindowManagerState

components/mus/ws/window_tree.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 "components/mus/ws/window_tree.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 54 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(TargetedEvent);
 };
 
 WindowTree::WindowTree(ConnectionManager* connection_manager,
                        ServerWindow* root,
                        uint32_t policy_bitmask)
     : connection_manager_(connection_manager),
       id_(connection_manager_->GetAndAdvanceNextConnectionId()),
       next_window_id_(1),
       event_ack_id_(0),
-      event_source_display_(nullptr),
       is_embed_root_(false),
       window_manager_internal_(nullptr) {
   if (root)
     roots_.insert(root);
   // TODO(sky): pass in type rather than inferring it.
   if (root && root->id().connection_id == kInvalidConnectionId) {
     access_policy_.reset(new WindowManagerAccessPolicy(id_, this));
     is_embed_root_ = true;
   } else {
     access_policy_.reset(new DefaultAccessPolicy(id_, this));
@@ skipping 65 matching lines @@
     const ClientWindowId& id) const {
   auto iter = client_id_to_window_id_map_.find(id);
   return iter == client_id_to_window_id_map_.end() ? nullptr
                                                    : GetWindow(iter->second);
 }
 
 const Display* WindowTree::GetDisplay(const ServerWindow* window) const {
   return window ? display_manager()->GetDisplayContaining(window) : nullptr;
 }
 
+const WindowManagerState* WindowTree::GetWindowManagerState(
+    const ServerWindow* window) const {
+  return window
+             ? display_manager()
+                   ->GetWindowManagerAndDisplay(window)
+                   .window_manager_state
+             : nullptr;
+}
+
 void WindowTree::OnWindowDestroyingTreeImpl(WindowTree* tree) {
+  if (event_source_wms_ && event_source_wms_->tree() == tree)
+    event_source_wms_ = nullptr;
+
   // Notify our client if |tree| was embedded in any of our views.
   for (const auto* tree_root : tree->roots_) {
     const bool owns_tree_root = tree_root->id().connection_id == id_;
     if (owns_tree_root || (is_embed_root_ && IsWindowKnown(tree_root))) {
       client()->OnEmbeddedAppDisconnected(
           ClientWindowIdForWindow(tree_root).id);
     }
   }
 }
 
-void WindowTree::OnWillDestroyDisplay(Display* display) {
-  if (event_source_display_ == display)
-    event_source_display_ = nullptr;
-}
-
 void WindowTree::NotifyChangeCompleted(
     uint32_t change_id,
     mojom::WindowManagerErrorCode error_code) {
   client()->OnChangeCompleted(
       change_id, error_code == mojom::WindowManagerErrorCode::SUCCESS);
 }
 
+bool WindowTree::SetCapture(const ClientWindowId& client_window_id) {
+  ServerWindow* window = GetWindowByClientId(client_window_id);
+  WindowManagerState* wms = GetWindowManagerState(window);
+  ServerWindow* current_capture_window = wms ? wms->capture_window() : nullptr;
+  if (window && wms && wms->IsActive() &&
+      access_policy_->CanSetCapture(window) &&
+      (!current_capture_window ||
+       access_policy_->CanSetCapture(current_capture_window)) &&
+      event_ack_id_) {
+    wms->SetCapture(window, !HasRoot(window));
+    return true;
+  }
+  return false;
+}
+
 bool WindowTree::NewWindow(
     const ClientWindowId& client_window_id,
     const std::map<std::string, std::vector<uint8_t>>& properties) {
   if (!IsValidIdForNewWindow(client_window_id))
     return false;
   const WindowId window_id = GenerateNewWindowId();
   DCHECK(!GetWindow(window_id));
   ServerWindow* window =
       connection_manager_->CreateServerWindow(window_id, properties);
   created_window_map_[window_id] = window;
@@ skipping 676 matching lines @@
 }
 
 void WindowTree::DispatchInputEventImpl(ServerWindow* target,
                                         mojom::EventPtr event) {
   DCHECK(!event_ack_id_);
   // We do not want to create a sequential id for each event, because that can
   // leak some information to the client. So instead, manufacture the id from
   // the event pointer.
   event_ack_id_ =
       0x1000000 | (reinterpret_cast<uintptr_t>(event.get()) & 0xffffff);
-  event_source_display_ = GetDisplay(target);
+  event_source_wms_ = GetWindowManagerState(target);
   // Should only get events from windows attached to a host.
-  DCHECK(event_source_display_);
+  DCHECK(event_source_wms_);
   client()->OnWindowInputEvent(
       event_ack_id_, ClientWindowIdForWindow(target).id, std::move(event));
 }
 
 void WindowTree::NewWindow(
     uint32_t change_id,
     Id transport_window_id,
     mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties) {
   std::map<std::string, std::vector<uint8_t>> properties;
   if (!transport_properties.is_null()) {
     properties =
         transport_properties.To<std::map<std::string, std::vector<uint8_t>>>();
   }
   client()->OnChangeCompleted(
       change_id, NewWindow(ClientWindowId(transport_window_id), properties));
 }
 
 void WindowTree::NewTopLevelWindow(
     uint32_t change_id,
     Id transport_window_id,
     mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties) {
   DCHECK(!waiting_for_top_level_window_info_);
   const ClientWindowId client_window_id(transport_window_id);
-  Display* display = display_manager()->GetActiveDisplay();
-  // TODO(sky): need a way for client to provide context.
+  // TODO(sky): need a way for client to provide context to figure out display.
+  // TODO(sky): get WMS for user_id for this connection.
+  Display* display = display_manager()->displays().empty()
+                         ? nullptr
+                         : *(display_manager()->displays().begin());
   WindowManagerState* wms =
       display ? display->GetFirstWindowManagerState() : nullptr;
   if (!wms || wms->tree() == this || !IsValidIdForNewWindow(client_window_id)) {
     client()->OnChangeCompleted(change_id, false);
     return;
   }
 
   // The server creates the real window. Any further messages from the client
   // may try to alter the window. Pause incoming messages so that we know we
   // can't get a message for a window before the window is created. Once the
@@ skipping 86 matching lines @@
 
 void WindowTree::GetWindowTree(
     Id window_id,
     const Callback<void(Array<mojom::WindowDataPtr>)>& callback) {
   std::vector<const ServerWindow*> windows(
       GetWindowTree(ClientWindowId(window_id)));
   callback.Run(WindowsToWindowDatas(windows));
 }
 
 void WindowTree::SetCapture(uint32_t change_id, Id window_id) {
-  ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
-  Display* display = GetDisplay(window);
-  ServerWindow* current_capture_window =
-      display ? display->GetCaptureWindow() : nullptr;
-  bool success = window && access_policy_->CanSetCapture(window) && display &&
-                 (!current_capture_window ||
-                  access_policy_->CanSetCapture(current_capture_window)) &&
-                 event_ack_id_;
-  if (success) {
-    Operation op(this, connection_manager_, OperationType::SET_CAPTURE);
-    display->SetCapture(window, !HasRoot(window));
-  }
-  client()->OnChangeCompleted(change_id, success);
+  client()->OnChangeCompleted(change_id, SetCapture(ClientWindowId(window_id)));
 }
 
 void WindowTree::ReleaseCapture(uint32_t change_id, Id window_id) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
-  Display* display = GetDisplay(window);
-  ServerWindow* current_capture_window =
-      display ? display->GetCaptureWindow() : nullptr;
-  bool success = window && display &&
+  WindowManagerState* wms = GetWindowManagerState(window);
+  ServerWindow* current_capture_window = wms ? wms->capture_window() : nullptr;
+  bool success = window && wms && wms->IsActive() &&
                  (!current_capture_window ||
                   access_policy_->CanSetCapture(current_capture_window)) &&
                  window == current_capture_window;
   if (success) {
     Operation op(this, connection_manager_, OperationType::RELEASE_CAPTURE);
-    display->SetCapture(nullptr, false);
+    wms->SetCapture(nullptr, false);
   }
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::SetWindowBounds(uint32_t change_id,
                                  Id window_id,
                                  mojo::RectPtr bounds) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   if (window && ShouldRouteToWindowManager(window)) {
     const uint32_t wm_change_id =
@@ skipping 94 matching lines @@
   }
 }
 
 void WindowTree::OnWindowInputEventAck(uint32_t event_id) {
   if (event_ack_id_ == 0 || event_id != event_ack_id_) {
     // TODO(sad): Something bad happened. Kill the client?
     NOTIMPLEMENTED() << "Wrong event acked.";
   }
   event_ack_id_ = 0;
 
-  Display* event_source_display = event_source_display_;
-  event_source_display_ = nullptr;
-  if (event_source_display)
-    event_source_display->OnEventAck(this);
+  WindowManagerState* event_source_wms = event_source_wms_;
+  event_source_wms_ = nullptr;
+  if (event_source_wms)
+    event_source_wms->OnEventAck(this);
 
   if (!event_queue_.empty()) {
     DCHECK(!event_ack_id_);
     ServerWindow* target = nullptr;
     mojom::EventPtr event;
     do {
       scoped_ptr<TargetedEvent> targeted_event =
           std::move(event_queue_.front());
       event_queue_.pop();
       target = targeted_event->target();
@@ skipping 77 matching lines @@
     return;
   }
   window_manager_internal_client_binding_.reset(
       new mojo::AssociatedBinding<mojom::WindowManagerClient>(
           this, std::move(internal)));
 }
 
 void WindowTree::AddAccelerator(uint32_t id,
                                 mojom::EventMatcherPtr event_matcher,
                                 const AddAcceleratorCallback& callback) {
-  Display* host = GetDisplayForWindowManager();
+  WindowManagerState* wms = GetWindowManagerStateForWindowManager();
   const bool success =
-      host &&
-      host->event_dispatcher()->AddAccelerator(id, std::move(event_matcher));
+      wms->event_dispatcher()->AddAccelerator(id, std::move(event_matcher));
   callback.Run(success);
 }
 
 void WindowTree::RemoveAccelerator(uint32_t id) {
-  Display* host = GetDisplayForWindowManager();
-  if (!host)
-    return;
-  host->event_dispatcher()->RemoveAccelerator(id);
+  WindowManagerState* wms = GetWindowManagerStateForWindowManager();
+  wms->event_dispatcher()->RemoveAccelerator(id);
 }
 
 void WindowTree::AddActivationParent(Id transport_window_id) {
   Display* host = GetDisplayForWindowManager();
   if (!host)
     return;
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   if (window)
     host->AddActivationParent(window);
@@ skipping 93 matching lines @@
 
   for (const auto* root : roots_) {
     if (root->Contains(window))
       return true;
   }
   return false;
 }
 
 }  // namespace ws
 }  // namespace mus