Makes WindowTreeHostMus supply properties directly to window creation

ui/aura/mus/window_tree_client.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 "ui/aura/mus/window_tree_client.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
@@ skipping 517 matching lines @@
   tree_->SetWindowBounds(change_id, window->server_id(), new_bounds);
 }
 
 void WindowTreeClient::OnWindowMusCreated(WindowMus* window) {
   if (window->server_id() != kInvalidServerId)
     return;
 
   window->set_server_id(MakeTransportId(client_id_, next_window_id_++));
   RegisterWindowMus(window);
 
-  const bool create_top_level = !window_manager_delegate_ && IsRoot(window);
+  DCHECK(window_manager_delegate_ || !IsRoot(window));
 
   std::unordered_map<std::string, std::vector<uint8_t>> transport_properties;
   std::set<const void*> property_keys =
       window->GetWindow()->GetAllPropertKeys();
   PropertyConverter* property_converter = delegate_->GetPropertyConverter();
   for (const void* key : property_keys) {
     std::string transport_name;
     std::unique_ptr<std::vector<uint8_t>> transport_value;
     if (!property_converter->ConvertPropertyForTransport(
             window->GetWindow(), key, &transport_name, &transport_value)) {
       continue;
     }
     if (!transport_value) {
       transport_properties[transport_name] = std::vector<uint8_t>();
     } else {
       transport_properties[transport_name] = std::move(*transport_value);
     }
   }
 
-  const uint32_t change_id =
-      ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
-          window, create_top_level ? ChangeType::NEW_TOP_LEVEL_WINDOW
-                                   : ChangeType::NEW_WINDOW));
-  if (create_top_level) {
-    tree_->NewTopLevelWindow(change_id, window->server_id(),
-                             transport_properties);
-  } else {
-    tree_->NewWindow(change_id, window->server_id(),
-                     std::move(transport_properties));
-  }
+  const uint32_t change_id = ScheduleInFlightChange(
+      base::MakeUnique<CrashInFlightChange>(window, ChangeType::NEW_WINDOW));
+  tree_->NewWindow(change_id, window->server_id(),
+                   std::move(transport_properties));
 }
 
 void WindowTreeClient::OnWindowMusDestroyed(WindowMus* window, Origin origin) {
   if (focus_synchronizer_->focused_window() == window)
     focus_synchronizer_->OnFocusedWindowDestroyed();
 
   // TODO: decide how to deal with windows not owned by this client.
   if (origin == Origin::CLIENT &&
       (WasCreatedByThisClient(window) || IsRoot(window))) {
     const uint32_t change_id =
@@ skipping 947 matching lines @@
   base::Optional<gfx::Rect> out_rect = base::nullopt;
   if (mask_rect) {
     out_rect = gfx::ConvertRectToPixel(ScaleFactorForDisplay(window),
                                        mask_rect.value());
   }
 
   tree_->SetHitTestMask(WindowMus::Get(window_tree_host->window())->server_id(),
                         out_rect);
 }
 
-std::unique_ptr<WindowPortMus> WindowTreeClient::CreateWindowPortForTopLevel() {
+std::unique_ptr<WindowPortMus> WindowTreeClient::CreateWindowPortForTopLevel(
+    const std::map<std::string, std::vector<uint8_t>>* properties) {
   std::unique_ptr<WindowPortMus> window_port =
       base::MakeUnique<WindowPortMus>(this, WindowMusType::TOP_LEVEL);
   roots_.insert(window_port.get());
+
+  window_port->set_server_id(MakeTransportId(client_id_, next_window_id_++));
+  RegisterWindowMus(window_port.get());
+
+  std::unordered_map<std::string, std::vector<uint8_t>> transport_properties;
+  if (properties) {
+    for (const auto& property_pair : *properties)
+      transport_properties[property_pair.first] = property_pair.second;
+  }
+
+  const uint32_t change_id =
+      ScheduleInFlightChange(base::MakeUnique<CrashInFlightChange>(
+          window_port.get(), ChangeType::NEW_TOP_LEVEL_WINDOW));
+  tree_->NewTopLevelWindow(change_id, window_port->server_id(),
+                           transport_properties);
   return window_port;
 }
 
 void WindowTreeClient::OnWindowTreeHostCreated(
     WindowTreeHostMus* window_tree_host) {
   // All WindowTreeHosts are destroyed before this, so we don't need to unset
   // the DragDropClient.
   client::SetDragDropClient(window_tree_host->window(),
                             drag_drop_controller_.get());
 }
@@ skipping 56 matching lines @@
   return ScheduleInFlightChange(base::MakeUnique<InFlightCaptureChange>(
       this, capture_synchronizer_.get(), window));
 }
 
 uint32_t WindowTreeClient::CreateChangeIdForFocus(WindowMus* window) {
   return ScheduleInFlightChange(base::MakeUnique<InFlightFocusChange>(
       this, focus_synchronizer_.get(), window));
 }
 
 }  // namespace aura