Adds WindowManagerManager to mus

components/mus/ws/window_tree_impl.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_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/stl_util.h"
 #include "components/mus/ws/client_connection.h"
 #include "components/mus/ws/connection_manager.h"
 #include "components/mus/ws/default_access_policy.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/focus_controller.h"
 #include "components/mus/ws/operation.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_observer.h"
 #include "components/mus/ws/window_manager_access_policy.h"
+#include "components/mus/ws/window_manager_state.h"
 #include "components/mus/ws/window_tree_host_impl.h"
 #include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/ime/ime_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
 #include "ui/platform_window/text_input_state.h"
 
 using mojo::Array;
 using mojo::Callback;
 using mojo::InterfaceRequest;
@@ skipping 37 matching lines @@
     : connection_manager_(connection_manager),
       id_(connection_manager_->GetAndAdvanceNextConnectionId()),
       next_window_id_(1),
       client_(nullptr),
       event_ack_id_(0),
       event_source_host_(nullptr),
       is_embed_root_(false),
       window_manager_internal_(nullptr) {
   if (root)
     roots_.insert(root);
-  if (root && root->GetRoot() == 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));
     is_embed_root_ = (policy_bitmask & WindowTree::kAccessPolicyEmbedRoot) != 0;
   }
 }
 
 WindowTreeImpl::~WindowTreeImpl() {
   DestroyWindows();
@@ skipping 313 matching lines @@
 
   client_->OnWindowSharedPropertyChanged(client_window_id.id, String(name),
                                          std::move(data));
 }
 
 void WindowTreeImpl::ProcessWindowHierarchyChanged(
     const ServerWindow* window,
     const ServerWindow* new_parent,
     const ServerWindow* old_parent,
     bool originated_change) {
-  if (originated_change && !IsWindowKnown(window) && new_parent &&
-      IsWindowKnown(new_parent)) {
+  const bool knows_new = new_parent && IsWindowKnown(new_parent);
+  if (originated_change && !IsWindowKnown(window) && knows_new) {
     std::vector<const ServerWindow*> unused;
     GetUnknownWindowsFrom(window, &unused);
   }
   if (originated_change || (connection_manager_->current_operation_type() ==
                             OperationType::DELETE_WINDOW) ||
       (connection_manager_->current_operation_type() == OperationType::EMBED) ||
       connection_manager_->DidConnectionMessageClient(id_)) {
     return;
   }
 
   if (!access_policy_->ShouldNotifyOnHierarchyChange(window, &new_parent,
                                                      &old_parent)) {
     return;
   }
   // Inform the client of any new windows and update the set of windows we know
   // about.
   std::vector<const ServerWindow*> to_send;
   if (!IsWindowKnown(window))
     GetUnknownWindowsFrom(window, &to_send);
+  const bool knows_old = old_parent && IsWindowKnown(old_parent);
+  if (!knows_old && !knows_new)
+    return;
+
   const ClientWindowId new_parent_client_window_id =
-      new_parent ? ClientWindowIdForWindow(new_parent) : ClientWindowId();
+      knows_new ? ClientWindowIdForWindow(new_parent) : ClientWindowId();
   const ClientWindowId old_parent_client_window_id =
-      old_parent ? ClientWindowIdForWindow(old_parent) : ClientWindowId();
+      knows_old ? ClientWindowIdForWindow(old_parent) : ClientWindowId();
   const ClientWindowId client_window_id =
       window ? ClientWindowIdForWindow(window) : ClientWindowId();
   client_->OnWindowHierarchyChanged(
       client_window_id.id, new_parent_client_window_id.id,
       old_parent_client_window_id.id, WindowsToWindowDatas(to_send));
   connection_manager_->OnConnectionMessagedClient(id_);
 }
 
 void WindowTreeImpl::ProcessWindowReorder(const ServerWindow* window,
                                           const ServerWindow* relative_window,
@@ skipping 122 matching lines @@
 }
 
 WindowTreeHostImpl* WindowTreeImpl::GetHostForWindowManager() {
   // The WindowTreeImpl for the wm has one and only one root.
   CHECK_EQ(1u, roots_.size());
 
   // Indicates this connection is for the wm.
   DCHECK(window_manager_internal_);
 
   WindowTreeHostImpl* host = GetHost(*roots_.begin());
-  CHECK(host);
-  DCHECK_EQ(this, host->GetWindowTree());
+  WindowManagerAndHost wm_and_host =
+      connection_manager_->GetWindowManagerAndHost(*roots_.begin());
+  CHECK(wm_and_host.window_tree_host);
+  CHECK(wm_and_host.window_manager_state);
+  DCHECK_EQ(this, wm_and_host.window_manager_state->tree());
   return host;
 }
 
 bool WindowTreeImpl::ShouldRouteToWindowManager(
     const ServerWindow* window) const {
   // If the client created this window, then do not route it through the WM.
   if (window->id().connection_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 WindowTreeHost, if there
   // isn't a WindowManager attached no need to route to it.
-  const WindowTreeHostImpl* host = GetHost(window);
-  if (!host || !host->GetWindowTree() ||
-      !host->GetWindowTree()->window_manager_internal_) {
+  const WindowManagerState* wms =
+      connection_manager_->GetWindowManagerAndHost(window).window_manager_state;
+  if (!wms || !wms->tree()->window_manager_internal_)
     return false;
-  }
 
   // Requests coming from the WM should not be routed through the WM again.
-  const bool is_wm = host->GetWindowTree() == this;
+  const bool is_wm = wms->tree() == this;
   return is_wm ? false : true;
 }
 
 void WindowTreeImpl::ProcessLostCapture(const ServerWindow* old_capture_window,
                                         bool originated_change) {
   if ((originated_change &&
        connection_manager_->current_operation_type() ==
            OperationType::RELEASE_CAPTURE) ||
       !IsWindowKnown(old_capture_window)) {
     return;
@@ skipping 274 matching lines @@
   client_->OnChangeCompleted(
       change_id, NewWindow(ClientWindowId(transport_window_id), properties));
 }
 
 void WindowTreeImpl::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);
-  // TODO(sky): need a way for client to provide context.
   WindowTreeHostImpl* tree_host =
       connection_manager_->GetActiveWindowTreeHost();
-  if (!tree_host || tree_host->GetWindowTree() == this ||
-      !IsValidIdForNewWindow(client_window_id)) {
+  // TODO(sky): need a way for client to provide context.
+  WindowManagerState* wms =
+      tree_host ? tree_host->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
   // window is created we'll resume processing.
   connection_manager_->GetClientConnection(this)
       ->SetIncomingMethodCallProcessingPaused(true);
 
   const uint32_t wm_change_id =
       connection_manager_->GenerateWindowManagerChangeId(this, change_id);
 
   waiting_for_top_level_window_info_.reset(
       new WaitingForTopLevelWindowInfo(client_window_id, wm_change_id));
 
-  tree_host->GetWindowTree()->window_manager_internal_->WmCreateTopLevelWindow(
+  wms->tree()->window_manager_internal_->WmCreateTopLevelWindow(
       wm_change_id, std::move(transport_properties));
 }
 
 void WindowTreeImpl::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) {
@@ skipping 106 matching lines @@
 
 void WindowTreeImpl::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 =
         connection_manager_->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.
-    WindowTreeImpl* wm_window_tree = GetHost(window)->GetWindowTree();
-    wm_window_tree->window_manager_internal_->WmSetBounds(
-        wm_change_id, wm_window_tree->ClientWindowIdForWindow(window).id,
+    WindowManagerState* wms =
+        connection_manager_->GetWindowManagerAndHost(window)
+            .window_manager_state;
+    wms->tree()->window_manager_internal_->WmSetBounds(
+        wm_change_id, wms->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, connection_manager_, OperationType::SET_WINDOW_BOUNDS);
     window->SetBounds(bounds.To<gfx::Rect>());
   }
@@ skipping 10 matching lines @@
 
 void WindowTreeImpl::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 =
         connection_manager_->GenerateWindowManagerChangeId(this, change_id);
-    WindowTreeImpl* wm_window_tree = GetHost(window)->GetWindowTree();
-    wm_window_tree->window_manager_internal_->WmSetProperty(
-        wm_change_id, wm_window_tree->ClientWindowIdForWindow(window).id, name,
+    WindowManagerState* wms =
+        connection_manager_->GetWindowManagerAndHost(window)
+            .window_manager_state;
+    wms->tree()->window_manager_internal_->WmSetProperty(
+        wm_change_id, wms->tree()->ClientWindowIdForWindow(window).id, name,
         std::move(value));
     return;
   }
   const bool success = window && access_policy_->CanSetWindowProperties(window);
   if (success) {
     Operation op(this, connection_manager_, 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 213 matching lines @@
 void WindowTreeImpl::WmRequestClose(Id transport_window_id) {
   // Only the WindowManager should be using this.
   WindowTreeHostImpl* host = GetHostForWindowManager();
   if (!host)
     return;
 
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   WindowTreeImpl* connection =
       connection_manager_->GetConnectionWithRoot(window);
-  if (connection && connection != host->GetWindowTree())
+  if (connection && connection != this) {
     connection->client_->RequestClose(
         connection->ClientWindowIdForWindow(window).id);
+  }
   // TODO(sky): think about what else case means.
 }
 
 void WindowTreeImpl::WmSetFrameDecorationValues(
     mojom::FrameDecorationValuesPtr values) {
   if (GetHostForWindowManager())
     GetHostForWindowManager()->SetFrameDecorationValues(std::move(values));
 }
 
 void WindowTreeImpl::OnWmCreatedTopLevelWindow(uint32_t change_id,
@@ skipping 33 matching lines @@
 
   for (const auto* root : roots_) {
     if (root->Contains(window))
       return true;
   }
   return false;
 }
 
 }  // namespace ws
 }  // namespace mus