Changes how window manager obtains WindowTree from mus

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>
 
@@ skipping 100 matching lines @@
     IsWindowKnown(focused_window, &focused_window_id);
 
   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_);
 }
 
 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 26 matching lines @@
 
 const WindowManagerState* WindowTree::GetWindowManagerState(
     const ServerWindow* window) const {
   return window
              ? display_manager()
                    ->GetWindowManagerAndDisplay(window)
                    .window_manager_state
              : nullptr;
 }
 
+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)
     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);
@@ skipping 199 matching lines @@
   roots_.insert(window);
   Display* display = GetDisplay(window);
   int64_t display_id =
       display ? display->id() : display::Display::kInvalidDisplayID;
   const bool drawn = window->parent() && window->parent()->IsDrawn();
   client()->OnTopLevelCreated(client_change_id, WindowToWindowData(window),
                               display_id, drawn);
 }
 
 void WindowTree::AddActivationParent(const ClientWindowId& window_id) {
-  Display* host = GetDisplayForWindowManager();
-  if (!host)
-    return;
   ServerWindow* window = GetWindowByClientId(window_id);
-  if (window)
-    host->AddActivationParent(window);
+  if (window) {
+    Display* display = GetDisplay(window);
+    if (display)
+      display->AddActivationParent(window);
+    else
+      DVLOG(1) << "AddActivationParent window not associated with display";
+  } else {
+    DVLOG(1) << "AddActivationParent supplied invalid window id";
+  }
 }
 
 void WindowTree::OnChangeCompleted(uint32_t change_id, bool success) {
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::OnAccelerator(uint32_t accelerator_id,
                                const ui::Event& event) {
   DCHECK(window_manager_internal_);
   // TODO(moshayedi): crbug.com/617167. Don't clone even once we map
@@ skipping 253 matching lines @@
 }
 
 DisplayManager* WindowTree::display_manager() {
   return window_server_->display_manager();
 }
 
 const DisplayManager* WindowTree::display_manager() const {
   return window_server_->display_manager();
 }
 
-Display* WindowTree::GetDisplayForWindowManager() {
-  return GetWindowManagerStateForWindowManager()->display();
-}
-
 WindowManagerState* WindowTree::GetWindowManagerStateForWindowManager() {
-  // The WindowTree for the wm has one and only one root.
-  CHECK_EQ(1u, roots_.size());
-
   // Indicates the client is the wm.
   DCHECK(window_manager_internal_);
 
+  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.
@@ skipping 712 matching lines @@
 void WindowTree::RemoveAccelerator(uint32_t id) {
   WindowManagerState* wms = GetWindowManagerStateForWindowManager();
   wms->event_dispatcher()->RemoveAccelerator(id);
 }
 
 void WindowTree::AddActivationParent(Id transport_window_id) {
   AddActivationParent(ClientWindowId(transport_window_id));
 }
 
 void WindowTree::RemoveActivationParent(Id transport_window_id) {
-  Display* host = GetDisplayForWindowManager();
-  if (!host)
-    return;
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
-  if (window)
-    host->RemoveActivationParent(window);
+  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() {
-  Display* display = GetDisplayForWindowManager();
-  if (!display)
-    return;
-  display->ActivateNextWindow();
+  // TODO(sky): this needs to track active window. http://crbug.com/611563.
+  GetWindowManagerStateForWindowManager()->display()->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;
 
   window->SetUnderlayOffset(gfx::Vector2d(x_offset, y_offset));
   window->set_extended_hit_test_region(hit_area);
 }
 
 void WindowTree::WmResponse(uint32_t change_id, bool response) {
-  // TODO(sky): think about what else case means.
-  if (GetDisplayForWindowManager())
-    window_server_->WindowManagerChangeCompleted(change_id, response);
+  window_server_->WindowManagerChangeCompleted(change_id, response);
 }
 
 void WindowTree::WmRequestClose(Id transport_window_id) {
-  // Only the WindowManager should be using this.
-  Display* host = GetDisplayForWindowManager();
-  if (!host)
-    return;
-
   ServerWindow* window =
       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) {
   WindowManagerState* wm_state = GetWindowManagerStateForWindowManager();
   if (wm_state)
     wm_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);
   }
 }
 
 void WindowTree::OnWmCreatedTopLevelWindow(uint32_t change_id,
                                            Id transport_window_id) {
-  if (GetDisplayForWindowManager()) {
-    ServerWindow* window =
-        GetWindowByClientId(ClientWindowId(transport_window_id));
-    if (window && window->id().client_id != id_) {
-      window_server_->WindowManagerSentBogusMessage();
-      window = nullptr;
-    }
-    window_server_->WindowManagerCreatedTopLevelWindow(this, change_id, window);
+  ServerWindow* window =
+      GetWindowByClientId(ClientWindowId(transport_window_id));
+  if (window && window->id().client_id != id_) {
+    DVLOG(1) << "OnWmCreatedTopLevelWindow supplied invalid window id";
+    window_server_->WindowManagerSentBogusMessage();
+    window = nullptr;
   }
-  // TODO(sky): think about what else case means.
+  window_server_->WindowManagerCreatedTopLevelWindow(this, change_id, window);
 }
 
 bool WindowTree::HasRootForAccessPolicy(const ServerWindow* window) const {
   return HasRoot(window);
 }
 
 bool WindowTree::IsWindowKnownForAccessPolicy(
     const ServerWindow* window) const {
   return IsWindowKnown(window);
 }
 
 bool WindowTree::IsWindowRootOfAnotherTreeForAccessPolicy(
     const ServerWindow* window) const {
   WindowTree* tree = window_server_->GetTreeWithRoot(window);
   return tree && tree != this;
 }
 
 }  // namespace ws
 }  // namespace mus