Changes top level window creation to include window state in callback

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 18 matching lines @@
 
 Id MakeTransportId(ConnectionSpecificId connection_id,
                    ConnectionSpecificId local_id) {
   return (connection_id << 16) | local_id;
 }
 
 // Helper called to construct a local window object from transport data.
 Window* AddWindowToConnection(WindowTreeClientImpl* client,
                               Window* parent,
                               const mojom::WindowDataPtr& window_data) {
-  // We don't use the cto that takes a WindowTreeConnection here, since it will
-  // call back to the service and attempt to create a new window.
+  // We don't use the ctor that takes a WindowTreeConnection here, since it
+  // will call back to the service and attempt to create a new window.
   Window* window = WindowPrivate::LocalCreate();
   WindowPrivate private_window(window);
   private_window.set_connection(client);
   private_window.set_id(window_data->window_id);
   private_window.set_visible(window_data->visible);
   private_window.set_drawn(window_data->drawn);
   private_window.LocalSetViewportMetrics(mojom::ViewportMetrics(),
                                          *window_data->viewport_metrics);
   private_window.set_properties(
       window_data->properties
@@ skipping 465 matching lines @@
 
 void WindowTreeClientImpl::OnUnembed(Id window_id) {
   Window* window = GetWindowById(window_id);
   if (!window)
     return;
 
   delegate_->OnUnembed(window);
   WindowPrivate(window).LocalDestroy();
 }
 
+void WindowTreeClientImpl::OnTopLevelCreated(uint32_t change_id,
+                                             mojom::WindowDataPtr data) {
+  // The server ack'd the top level window we created and supplied the state
+  // of the window at the time the server created it. For properties we do not
+  // have changes in flight for we can update them immediately. For properties
+  // with changes in flight we set the revert value from the server.
+
+  scoped_ptr<InFlightChange> change(std::move(in_flight_map_[change_id]));
+  in_flight_map_.erase(change_id);
+  DCHECK(change);
+
+  Window* window = change->window();
+  WindowPrivate window_private(window);
+
+  // Drawn state and ViewportMetrics always come from the server (they can't
+  // be modified locally).
+  window_private.set_drawn(data->drawn);
+  window_private.LocalSetViewportMetrics(mojom::ViewportMetrics(),
+                                         *data->viewport_metrics);
+
+  // The default visibilty is false, we only need update visibility if it
+  // differs from that.
+  if (data->visible) {
+    InFlightVisibleChange visible_change(window, data->visible);
+    InFlightChange* current_change =
+        GetOldestInFlightChangeMatching(visible_change);
+    if (current_change)
+      current_change->SetRevertValueFrom(visible_change);
+    else
+      window_private.LocalSetVisible(true);
+  }
+
+  const gfx::Rect bounds(data->bounds.To<gfx::Rect>());
+  {
+    InFlightBoundsChange bounds_change(window, bounds);
+    InFlightChange* current_change =
+        GetOldestInFlightChangeMatching(bounds_change);
+    if (current_change)
+      current_change->SetRevertValueFrom(bounds_change);
+    else if (window->bounds() != bounds)
+      window_private.LocalSetBounds(window->bounds(), bounds);
+  }
+
+  // There is currently no API to bulk set properties, so we iterate over each
+  // property individually.
+  Window::SharedProperties properties =
+      data->properties.To<std::map<std::string, std::vector<uint8_t>>>();
+  for (const auto& pair : properties) {
+    InFlightPropertyChange property_change(
+        window, pair.first, mojo::Array<uint8_t>::From(pair.second));
+    InFlightChange* current_change =
+        GetOldestInFlightChangeMatching(property_change);
+    if (current_change)
+      current_change->SetRevertValueFrom(property_change);
+    else
+      window_private.LocalSetSharedProperty(pair.first, &(pair.second));
+  }
+
+  // Top level windows should not have a parent.
+  DCHECK_EQ(0u, data->parent_id);
+}
+
 void WindowTreeClientImpl::OnWindowBoundsChanged(Id window_id,
                                                  mojo::RectPtr old_bounds,
                                                  mojo::RectPtr new_bounds) {
   Window* window = GetWindowById(window_id);
   if (!window)
     return;
 
   InFlightBoundsChange new_change(window, new_bounds.To<gfx::Rect>());
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
@@ skipping 256 matching lines @@
     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