Adds remainder of support for multiple roots to WS

components/mus/public/cpp/lib/window_tree_client_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/public/cpp/lib/window_tree_client_impl.h"
 
 #include <stddef.h>
 #include <utility>
 
 #include "base/bind.h"
@@ skipping 112 matching lines @@
   if (request.is_pending())
     binding_.Bind(std::move(request));
 }
 
 WindowTreeClientImpl::~WindowTreeClientImpl() {
   in_destructor_ = true;
 
   std::vector<Window*> non_owned;
   while (!windows_.empty()) {
     IdToWindowMap::iterator it = windows_.begin();
-    if (OwnsWindow(it->second->id())) {
+    if (OwnsWindow(it->second)) {
       it->second->Destroy();
     } else {
       non_owned.push_back(it->second);
       windows_.erase(it);
     }
   }
 
   // Delete the non-owned windows last. In the typical case these are roots. The
   // exception is the window manager and embed roots, which may know about
   // other random windows that it doesn't own.
@@ skipping 50 matching lines @@
 
 void WindowTreeClientImpl::Reorder(Window* window,
                                    Id relative_window_id,
                                    mojom::OrderDirection direction) {
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
       make_scoped_ptr(new CrashInFlightChange(window, ChangeType::REORDER)));
   tree_->ReorderWindow(change_id, window->id(), relative_window_id, direction);
 }
 
-bool WindowTreeClientImpl::OwnsWindow(Id id) const {
-  return HiWord(id) == connection_id_;
+bool WindowTreeClientImpl::OwnsWindow(Window* window) const {
+  // Windows created via CreateTopLevelWindow() are not owned by us, but have
+  // our connection id.
+  return HiWord(window->id()) == connection_id_ && roots_.count(window) == 0;
 }
 
 void WindowTreeClientImpl::SetBounds(Window* window,
                                      const gfx::Rect& old_bounds,
                                      const gfx::Rect& bounds) {
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
       make_scoped_ptr(new InFlightBoundsChange(window, old_bounds)));
   tree_->SetWindowBounds(change_id, window->id(), mojo::Rect::From(bounds));
 }
@@ skipping 160 matching lines @@
 bool WindowTreeClientImpl::ApplyServerChangeToExistingInFlightChange(
     const InFlightChange& change) {
   InFlightChange* existing_change = GetOldestInFlightChangeMatching(change);
   if (!existing_change)
     return false;
 
   existing_change->SetRevertValueFrom(change);
   return true;
 }
 
+Window* WindowTreeClientImpl::NewWindowImpl(
+    NewWindowType type,
+    const Window::SharedProperties* properties) {
+  DCHECK(tree_);
+  Window* window =
+      new Window(this, MakeTransportId(connection_id_, next_window_id_++));
+  if (properties)
+    window->properties_ = *properties;
+  AddWindow(window);
+
+  const uint32_t change_id = ScheduleInFlightChange(make_scoped_ptr(
+      new CrashInFlightChange(window, type == NewWindowType::CHILD
+                                          ? ChangeType::NEW_WINDOW
+                                          : ChangeType::NEW_TOP_LEVEL_WINDOW)));
+  mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties;
+  if (properties) {
+    transport_properties =
+        mojo::Map<mojo::String, mojo::Array<uint8_t>>::From(*properties);
+  }
+  if (type == NewWindowType::CHILD) {
+    tree_->NewWindow(change_id, window->id(), std::move(transport_properties));
+  } else {
+    roots_.insert(window);
+    tree_->NewTopLevelWindow(change_id, window->id(),
+                             std::move(transport_properties));
+  }
+  return window;
+}
+
 void WindowTreeClientImpl::OnEmbedImpl(mojom::WindowTree* window_tree,
                                        ConnectionSpecificId connection_id,
                                        mojom::WindowDataPtr root_data,
                                        Id focused_window_id,
                                        uint32_t access_policy) {
   tree_ = window_tree;
   connection_id_ = connection_id;
   is_embed_root_ =
       (access_policy & mojom::WindowTree::ACCESS_POLICY_EMBED_ROOT) != 0;
 
@@ skipping 26 matching lines @@
   IdToWindowMap::const_iterator it = windows_.find(id);
   return it != windows_.end() ? it->second : NULL;
 }
 
 Window* WindowTreeClientImpl::GetFocusedWindow() {
   return focused_window_;
 }
 
 Window* WindowTreeClientImpl::NewWindow(
     const Window::SharedProperties* properties) {
-  DCHECK(tree_);
-  Window* window =
-      new Window(this, MakeTransportId(connection_id_, next_window_id_++));
-  if (properties)
-    window->properties_ = *properties;
-  AddWindow(window);
+  return NewWindowImpl(NewWindowType::CHILD, properties);
+}
 
-  const uint32_t change_id = ScheduleInFlightChange(
-      make_scoped_ptr(new CrashInFlightChange(window, ChangeType::NEW_WINDOW)));
-  mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties;
-  if (properties) {
-    transport_properties =
-        mojo::Map<mojo::String, mojo::Array<uint8_t>>::From(*properties);
-  }
-  tree_->NewWindow(change_id, window->id(), std::move(transport_properties));
-  return window;
+Window* WindowTreeClientImpl::NewTopLevelWindow(
+    const Window::SharedProperties* properties) {
+  return NewWindowImpl(NewWindowType::TOP_LEVEL, properties);
 }
 
 bool WindowTreeClientImpl::IsEmbedRoot() {
   return is_embed_root_;
 }
 
 ConnectionSpecificId WindowTreeClientImpl::GetConnectionId() {
   return connection_id_;
 }
 
@@ skipping 301 matching lines @@
     result = window_manager_delegate_->OnWmSetProperty(window, name, &data);
     if (result) {
       // If the resulting bounds differ return false. Returning false ensures
       // the client applies the bounds we set below.
       window->SetSharedPropertyInternal(name, data.get());
     }
   }
   window_manager_internal_client_->WmResponse(change_id, result);
 }
 
+void WindowTreeClientImpl::WmCreateTopLevelWindow(
+    uint32_t change_id,
+    mojo::Map<mojo::String, mojo::Array<uint8_t>> transport_properties) {
+  std::map<std::string, std::vector<uint8_t>> properties =
+      transport_properties.To<std::map<std::string, std::vector<uint8_t>>>();
+  Window* window =
+      window_manager_delegate_->OnWmCreateTopLevelWindow(&properties);
+  window_manager_internal_client_->OnWmCreatedTopLevelWindow(change_id,
+                                                             window->id());
+}
+
 }  // namespace mus