Promotes remaining global window manager state into 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"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "base/stl_util.h"
 #include "components/mus/public/cpp/surfaces/surfaces_type_converters.h"
 #include "components/mus/ws/default_access_policy.h"
 #include "components/mus/ws/display.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/event_matcher.h"
 #include "components/mus/ws/focus_controller.h"
-#include "components/mus/ws/global_window_manager_state.h"
 #include "components/mus/ws/operation.h"
 #include "components/mus/ws/platform_display.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_observer.h"
 #include "components/mus/ws/user_display_manager.h"
+#include "components/mus/ws/window_manager_display_root.h"
 #include "components/mus/ws/window_manager_state.h"
 #include "components/mus/ws/window_server.h"
 #include "components/mus/ws/window_tree_binding.h"
 #include "ui/display/display.h"
 #include "ui/platform_window/mojo/ime_type_converters.h"
 #include "ui/platform_window/text_input_state.h"
 
 using mojo::Array;
 using mojo::InterfaceRequest;
 using mojo::String;
@@ skipping 75 matching lines @@
 
   const bool drawn = root->parent() && root->parent()->IsDrawn();
   client()->OnEmbed(id_, WindowToWindowData(to_send.front()), std::move(tree),
                     display_id, focused_window_id.id, drawn);
 }
 
 void WindowTree::ConfigureWindowManager() {
   DCHECK(!window_manager_internal_);
   window_manager_internal_ = binding_->GetWindowManager();
   window_manager_internal_->OnConnect(id_);
-  global_window_manager_state_.reset(new GlobalWindowManagerState(this));
+  window_manager_state_.reset(new WindowManagerState(this));
 }
 
 const ServerWindow* WindowTree::GetWindow(const WindowId& id) const {
   if (id_ == id.client_id) {
     auto iter = created_window_map_.find(id);
     return iter == created_window_map_.end() ? nullptr : iter->second;
   }
   return window_server_->GetWindow(id);
 }
 
@@ skipping 17 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 WindowManagerDisplayRoot* WindowTree::GetWindowManagerDisplayRoot(
     const ServerWindow* window) const {
-  return window
-             ? display_manager()
-                   ->GetWindowManagerAndDisplay(window)
-                   .window_manager_state
-             : nullptr;
+  return window ? display_manager()->GetWindowManagerDisplayRoot(window)
+                : nullptr;
 }
 
 DisplayManager* WindowTree::display_manager() {
   return window_server_->display_manager();
 }
 
 const DisplayManager* WindowTree::display_manager() const {
   return window_server_->display_manager();
 }
 
 void WindowTree::AddRootForWindowManager(const ServerWindow* root) {
   DCHECK(window_manager_internal_);
   const ClientWindowId client_window_id(WindowIdToTransportId(root->id()));
   DCHECK_EQ(0u, client_id_to_window_id_map_.count(client_window_id));
   client_id_to_window_id_map_[client_window_id] = root->id();
   window_id_to_client_id_map_[root->id()] = client_window_id;
   roots_.insert(root);
 
   Display* display = GetDisplay(root);
   DCHECK(display);
 
   window_manager_internal_->WmNewDisplayAdded(display->ToMojomDisplay(),
                                               WindowToWindowData(root),
                                               root->parent()->IsDrawn());
 }
 
 void WindowTree::OnWindowDestroyingTreeImpl(WindowTree* tree) {
-  if (event_source_wms_ && event_source_wms_->tree() == tree)
+  if (window_manager_state_)
+    window_manager_state_->OnWillDestroyTree(tree);
+
+  if (event_source_wms_ && event_source_wms_->window_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().client_id == id_;
     if (owns_tree_root) {
       client()->OnEmbeddedAppDisconnected(
           ClientWindowIdForWindow(tree_root).id);
     }
   }
 }
 
 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 && window->IsDrawn() && wms && wms->IsActive() &&
+  WindowManagerDisplayRoot* display_root = GetWindowManagerDisplayRoot(window);
+  ServerWindow* current_capture_window =
+      display_root ? display_root->window_manager_state()->capture_window()
+                   : nullptr;
+  if (window && window->IsDrawn() && display_root &&
+      display_root->window_manager_state()->IsActive() &&
       access_policy_->CanSetCapture(window) &&
       (!current_capture_window ||
        access_policy_->CanSetCapture(current_capture_window))) {
-    return wms->SetCapture(window, id_);
+    return display_root->window_manager_state()->SetCapture(window, id_);
   }
   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();
@@ skipping 27 matching lines @@
       access_policy_->CanAddTransientWindow(window, transient_window)) {
     Operation op(this, window_server_, OperationType::ADD_TRANSIENT_WINDOW);
     return window->AddTransientWindow(transient_window);
   }
   return false;
 }
 
 bool WindowTree::SetModal(const ClientWindowId& window_id) {
   ServerWindow* window = GetWindowByClientId(window_id);
   if (window && access_policy_->CanSetModal(window)) {
-    WindowManagerState* wms = GetWindowManagerState(window);
+    WindowManagerDisplayRoot* display_root =
+        GetWindowManagerDisplayRoot(window);
     if (window->transient_parent()) {
       window->SetModal();
     } else if (user_id_ != InvalidUserId()) {
-      if (wms)
-        wms->AddSystemModalWindow(window);
+      if (display_root)
+        display_root->window_manager_state()->AddSystemModalWindow(window);
     } else {
       return false;
     }
-    if (wms)
-      wms->ReleaseCaptureBlockedByModalWindow(window);
+    if (display_root)
+      display_root->window_manager_state()->ReleaseCaptureBlockedByModalWindow(
+          window);
     return true;
   }
   return false;
 }
 
 std::vector<const ServerWindow*> WindowTree::GetWindowTree(
     const ClientWindowId& window_id) const {
   const ServerWindow* window = GetWindowByClientId(window_id);
   std::vector<const ServerWindow*> windows;
   if (window)
@@ skipping 385 matching lines @@
     return;
   ClientWindowId client_window_id, transient_client_window_id;
   if (!IsWindowKnown(window, &client_window_id) ||
       !IsWindowKnown(transient_window, &transient_client_window_id)) {
     return;
   }
   client()->OnTransientWindowRemoved(client_window_id.id,
                                      transient_client_window_id.id);
 }
 
-WindowManagerState* WindowTree::GetWindowManagerStateForWindowManager() {
-  // Indicates the client is the wm.
-  DCHECK(window_manager_internal_);
+bool WindowTree::ShouldRouteToWindowManager(const ServerWindow* window) const {
+  if (window_manager_state_)
+    return false;  // We are the window manager, don't route to ourself.
 
-  if (roots_.size() > 1) {
-    // TODO(sky): fix the > 1 case, http://crbug.com/611563.
-    NOTIMPLEMENTED();
-  }
-
-  WindowManagerState* wms = display_manager()
-                                ->GetWindowManagerAndDisplay(*roots_.begin())
-                                .window_manager_state;
-  CHECK(wms);
-  DCHECK_EQ(this, wms->tree());
-  return wms;
-}
-
-bool WindowTree::ShouldRouteToWindowManager(const ServerWindow* window) const {
   // If the client created this window, then do not route it through the WM.
   if (window->id().client_id == id_)
     return false;
 
   // If the client did not create the window, then it must be the root of the
   // client. If not, that means the client should not know about this window,
   // and so do not route the request to the WM.
   if (roots_.count(window) == 0)
     return false;
 
   // The WindowManager is attached to the root of the Display, if there isn't a
   // WindowManager attached no need to route to it.
-  const WindowManagerState* wms = display_manager()
-                                      ->GetWindowManagerAndDisplay(window)
-                                      .window_manager_state;
-  if (!wms || !wms->tree()->window_manager_internal_)
+  const WindowManagerDisplayRoot* display_root =
+      GetWindowManagerDisplayRoot(window);
+  if (!display_root)
     return false;
 
-  // Requests coming from the WM should not be routed through the WM again.
-  const bool is_wm = wms->tree() == this;
-  return is_wm ? false : true;
+  // Route to the windowmanager if the windowmanager created the window.
+  return display_root->window_manager_state()->window_tree()->id() ==
+         window->id().client_id;
 }
 
 void WindowTree::ProcessLostCapture(const ServerWindow* old_capture_window,
                                     bool originated_change) {
   if ((originated_change &&
        window_server_->current_operation_type() ==
            OperationType::RELEASE_CAPTURE) ||
       !IsWindowKnown(old_capture_window)) {
     return;
   }
@@ skipping 235 matching lines @@
 }
 
 void WindowTree::DispatchInputEventImpl(ServerWindow* target,
                                         const ui::Event& 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
   // randomly.
   // TODO(moshayedi): Find a faster way to generate ids.
   event_ack_id_ = 0x1000000 | (rand() & 0xffffff);
-  event_source_wms_ = GetWindowManagerState(target);
+  WindowManagerDisplayRoot* display_root = GetWindowManagerDisplayRoot(target);
+  DCHECK(display_root);
+  event_source_wms_ = display_root->window_manager_state();
   // Should only get events from windows attached to a host.
   DCHECK(event_source_wms_);
   bool matched_observer =
       event_observer_matcher_ && event_observer_matcher_->MatchesEvent(event);
   client()->OnWindowInputEvent(
       event_ack_id_, ClientWindowIdForWindow(target).id,
       ui::Event::Clone(event), matched_observer ? event_observer_id_ : 0);
 }
 
 void WindowTree::SendToEventObserver(const ui::Event& event) {
@@ skipping 18 matching lines @@
     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);
   // TODO(sky): need a way for client to provide context to figure out display.
   Display* display = display_manager()->displays().empty()
                          ? nullptr
                          : *(display_manager()->displays().begin());
   // TODO(sky): move checks to accesspolicy.
-  WindowManagerState* wms =
+  WindowManagerDisplayRoot* display_root =
       display && user_id_ != InvalidUserId()
-          ? display->GetWindowManagerStateForUser(user_id_)
+          ? display->GetWindowManagerDisplayRootForUser(user_id_)
           : nullptr;
-  if (!wms || wms->tree() == this || !IsValidIdForNewWindow(client_window_id)) {
+  if (!display_root ||
+      display_root->window_manager_state()->window_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
   // window is created we'll resume processing.
   binding_->SetIncomingMethodCallProcessingPaused(true);
 
   const uint32_t wm_change_id =
       window_server_->GenerateWindowManagerChangeId(this, change_id);
 
   waiting_for_top_level_window_info_.reset(
       new WaitingForTopLevelWindowInfo(client_window_id, wm_change_id));
 
-  wms->tree()->window_manager_internal_->WmCreateTopLevelWindow(
-      wm_change_id, id_, std::move(transport_properties));
+  display_root->window_manager_state()
+      ->window_tree()
+      ->window_manager_internal_->WmCreateTopLevelWindow(
+          wm_change_id, id_, std::move(transport_properties));
 }
 
 void WindowTree::DeleteWindow(uint32_t change_id, Id transport_window_id) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   bool success = false;
   bool should_close = window && (access_policy_->CanDeleteWindow(window) ||
                                  ShouldRouteToWindowManager(window));
   if (should_close) {
     WindowTree* tree =
@@ skipping 73 matching lines @@
       GetWindowTree(ClientWindowId(window_id)));
   callback.Run(WindowsToWindowDatas(windows));
 }
 
 void WindowTree::SetCapture(uint32_t change_id, Id window_id) {
   client()->OnChangeCompleted(change_id, SetCapture(ClientWindowId(window_id)));
 }
 
 void WindowTree::ReleaseCapture(uint32_t change_id, Id window_id) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
-  WindowManagerState* wms = GetWindowManagerState(window);
-  ServerWindow* current_capture_window = wms ? wms->capture_window() : nullptr;
-  bool success = window && wms && wms->IsActive() &&
+  WindowManagerDisplayRoot* display_root = GetWindowManagerDisplayRoot(window);
+  ServerWindow* current_capture_window =
+      display_root ? display_root->window_manager_state()->capture_window()
+                   : nullptr;
+  bool success = window && display_root &&
+                 display_root->window_manager_state()->IsActive() &&
                  (!current_capture_window ||
                   access_policy_->CanSetCapture(current_capture_window)) &&
                  window == current_capture_window;
   if (success) {
     Operation op(this, window_server_, OperationType::RELEASE_CAPTURE);
-    success = wms->SetCapture(nullptr, kInvalidClientId);
+    success = display_root->window_manager_state()->SetCapture(
+        nullptr, kInvalidClientId);
   }
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::SetEventObserver(mojom::EventMatcherPtr matcher,
                                   uint32_t observer_id) {
   if (matcher.is_null() || observer_id == 0) {
     // Clear any existing event observer.
     event_observer_matcher_.reset();
     event_observer_id_ = 0;
@@ skipping 29 matching lines @@
 
 void WindowTree::SetWindowBounds(uint32_t change_id,
                                  Id window_id,
                                  const gfx::Rect& bounds) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   if (window && ShouldRouteToWindowManager(window)) {
     const uint32_t wm_change_id =
         window_server_->GenerateWindowManagerChangeId(this, change_id);
     // |window_id| may be a client id, use the id from the window to ensure
     // the windowmanager doesn't get an id it doesn't know about.
-    WindowManagerState* wms = display_manager()
-                                  ->GetWindowManagerAndDisplay(window)
-                                  .window_manager_state;
-    wms->tree()->window_manager_internal_->WmSetBounds(
-        wm_change_id, wms->tree()->ClientWindowIdForWindow(window).id,
+    WindowManagerDisplayRoot* display_root =
+        GetWindowManagerDisplayRoot(window);
+    WindowTree* wm_tree = display_root->window_manager_state()->window_tree();
+    wm_tree->window_manager_internal_->WmSetBounds(
+        wm_change_id, wm_tree->ClientWindowIdForWindow(window).id,
         std::move(bounds));
     return;
   }
 
   // Only the owner of the window can change the bounds.
   bool success = window && access_policy_->CanSetWindowBounds(window);
   if (success) {
     Operation op(this, window_server_, OperationType::SET_WINDOW_BOUNDS);
     window->SetBounds(bounds);
   }
@@ skipping 10 matching lines @@
 
 void WindowTree::SetWindowProperty(uint32_t change_id,
                                    Id transport_window_id,
                                    const mojo::String& name,
                                    mojo::Array<uint8_t> value) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   if (window && ShouldRouteToWindowManager(window)) {
     const uint32_t wm_change_id =
         window_server_->GenerateWindowManagerChangeId(this, change_id);
-    WindowManagerState* wms = display_manager()
-                                  ->GetWindowManagerAndDisplay(window)
-                                  .window_manager_state;
-    wms->tree()->window_manager_internal_->WmSetProperty(
-        wm_change_id, wms->tree()->ClientWindowIdForWindow(window).id, name,
+    WindowManagerDisplayRoot* display_root =
+        GetWindowManagerDisplayRoot(window);
+    WindowTree* wm_tree = display_root->window_manager_state()->window_tree();
+    wm_tree->window_manager_internal_->WmSetProperty(
+        wm_change_id, wm_tree->ClientWindowIdForWindow(window).id, name,
         std::move(value));
     return;
   }
   const bool success = window && access_policy_->CanSetWindowProperties(window);
   if (success) {
     Operation op(this, window_server_, OperationType::SET_WINDOW_PROPERTY);
     if (value.is_null()) {
       window->SetProperty(name, nullptr);
     } else {
       std::vector<uint8_t> data = value.To<std::vector<uint8_t>>();
@@ skipping 50 matching lines @@
 
 void WindowTree::OnWindowInputEventAck(uint32_t event_id,
                                        mojom::EventResult result) {
   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;
 
   if (janky_)
-    event_source_wms_->tree()->ClientJankinessChanged(this);
+    event_source_wms_->window_tree()->ClientJankinessChanged(this);
 
   WindowManagerState* event_source_wms = event_source_wms_;
   event_source_wms_ = nullptr;
   if (event_source_wms)
     event_source_wms->OnEventAck(this, result);
 
   if (!event_queue_.empty()) {
     DCHECK(!event_ack_id_);
     ServerWindow* target = nullptr;
     std::unique_ptr<ui::Event> event;
@@ skipping 87 matching lines @@
 void WindowTree::GetCursorLocationMemory(
     const GetCursorLocationMemoryCallback& callback) {
   callback.Run(
       window_server_->display_manager()->GetUserDisplayManager(user_id_)->
       GetCursorLocationMemory());
 }
 
 void WindowTree::AddAccelerator(uint32_t id,
                                 mojom::EventMatcherPtr event_matcher,
                                 const AddAcceleratorCallback& callback) {
-  WindowManagerState* wms = GetWindowManagerStateForWindowManager();
+  DCHECK(window_manager_state_);
   const bool success =
-      wms->event_dispatcher()->AddAccelerator(id, std::move(event_matcher));
+      window_manager_state_->event_dispatcher()->AddAccelerator(
+          id, std::move(event_matcher));
   callback.Run(success);
 }
 
 void WindowTree::RemoveAccelerator(uint32_t id) {
-  WindowManagerState* wms = GetWindowManagerStateForWindowManager();
-  wms->event_dispatcher()->RemoveAccelerator(id);
+  window_manager_state_->event_dispatcher()->RemoveAccelerator(id);
 }
 
 void WindowTree::AddActivationParent(Id transport_window_id) {
   AddActivationParent(ClientWindowId(transport_window_id));
 }
 
 void WindowTree::RemoveActivationParent(Id transport_window_id) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   if (window) {
     Display* display = GetDisplay(window);
     if (display)
       display->RemoveActivationParent(window);
     else
       DVLOG(1) << "RemoveActivationParent window not associated with display";
   } else {
     DVLOG(1) << "RemoveActivationParent supplied invalid window id";
   }
 }
 
 void WindowTree::ActivateNextWindow() {
-  // TODO(sky): this needs to track active window. http://crbug.com/611563.
-  GetWindowManagerStateForWindowManager()->display()->ActivateNextWindow();
+  DCHECK(window_manager_state_);
+  if (window_server_->user_id_tracker()->active_id() != user_id_)
+    return;
+
+  ServerWindow* focused_window = window_server_->GetFocusedWindow();
+  if (focused_window) {
+    WindowManagerDisplayRoot* display_root =
+        GetWindowManagerDisplayRoot(focused_window);
+    if (display_root->window_manager_state() != window_manager_state_.get()) {
+      // We aren't active.
+      return;
+    }
+    display_root->display()->ActivateNextWindow();
+    return;
+  }
+  // Use the first display.
+  std::set<Display*> displays = window_server_->display_manager()->displays();
+  if (displays.empty())
+    return;
+
+  (*displays.begin())->ActivateNextWindow();
 }
 
 void WindowTree::SetUnderlaySurfaceOffsetAndExtendedHitArea(
     Id window_id,
     int32_t x_offset,
     int32_t y_offset,
     const gfx::Insets& hit_area) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   if (!window)
     return;
@@ skipping 11 matching lines @@
       GetWindowByClientId(ClientWindowId(transport_window_id));
   WindowTree* tree = window_server_->GetTreeWithRoot(window);
   if (tree && tree != this) {
     tree->client()->RequestClose(tree->ClientWindowIdForWindow(window).id);
   }
   // TODO(sky): think about what else case means.
 }
 
 void WindowTree::WmSetFrameDecorationValues(
     mojom::FrameDecorationValuesPtr values) {
-  DCHECK(global_window_manager_state_);
-  global_window_manager_state_->SetFrameDecorationValues(std::move(values));
+  DCHECK(window_manager_state_);
+  window_manager_state_->SetFrameDecorationValues(std::move(values));
 }
 
 void WindowTree::WmSetNonClientCursor(uint32_t window_id,
                                       mojom::Cursor cursor_id) {
-  WindowManagerState* wm_state = GetWindowManagerStateForWindowManager();
-  if (wm_state) {
-    ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
-    if (window)
-      window->SetNonClientCursor(cursor_id);
+  DCHECK(window_manager_state_);
+  ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
+  if (window) {
+    window->SetNonClientCursor(cursor_id);
+  } else {
+    DVLOG(1) << "trying to update non-client cursor of invalid window";
   }
 }
 
 void WindowTree::OnWmCreatedTopLevelWindow(uint32_t change_id,
                                            Id transport_window_id) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   if (window && window->id().client_id != id_) {
     DVLOG(1) << "OnWmCreatedTopLevelWindow supplied invalid window id";
     window_server_->WindowManagerSentBogusMessage();
@@ skipping 12 matching lines @@
 }
 
 bool WindowTree::IsWindowRootOfAnotherTreeForAccessPolicy(
     const ServerWindow* window) const {
   WindowTree* tree = window_server_->GetTreeWithRoot(window);
   return tree && tree != this;
 }
 
 }  // namespace ws
 }  // namespace mus