Makes sure bounds and visibilty are updated correctly for new displays

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 357 matching lines @@
     int64_t display_id) {
   std::unique_ptr<WindowPortMus> window_port =
       CreateWindowPortMus(window_data, window_mus_type);
   roots_.insert(window_port.get());
   std::unique_ptr<WindowTreeHostMus> window_tree_host =
       base::MakeUnique<WindowTreeHostMus>(std::move(window_port), this,
                                           display_id);
   if (!window_data.is_null()) {
     SetLocalPropertiesFromServerProperties(
         WindowMus::Get(window_tree_host->window()), window_data);
+    if (window_data->visible) {
+      SetWindowVisibleFromServer(WindowMus::Get(window_tree_host->window()),
+                                 window_data->visible);
+      SetWindowBoundsFromServer(WindowMus::Get(window_tree_host->window()),
+                                window_data->bounds);

[sadrul, 2016/11/29 23:29:28]

Should this set bounds regardless of visibility?

[sky, 2016/11/29 23:35:00]

Good catch! done.

+    }
   }
   return window_tree_host;
 }
 
 WindowMus* WindowTreeClient::NewWindowFromWindowData(
     WindowMus* parent,
     const ui::mojom::WindowDataPtr& window_data) {
   // This function is only called for windows coming from other clients.
   std::unique_ptr<WindowPortMus> window_port_mus(
       CreateWindowPortMus(window_data, WindowMusType::OTHER));
@@ skipping 75 matching lines @@
   DCHECK(roots_.empty());
   std::unique_ptr<WindowTreeHostMus> window_tree_host =
       CreateWindowTreeHost(WindowMusType::EMBED, root_data, display_id);
 
   focus_synchronizer_->SetFocusFromServer(
       GetWindowByServerId(focused_window_id));
 
   delegate_->OnEmbed(std::move(window_tree_host));
 }
 
-WindowTreeHost* WindowTreeClient::WmNewDisplayAddedImpl(
+WindowTreeHostMus* WindowTreeClient::WmNewDisplayAddedImpl(
     const display::Display& display,
     ui::mojom::WindowDataPtr root_data,
     bool parent_drawn) {
   DCHECK(window_manager_delegate_);
 
   std::unique_ptr<WindowTreeHostMus> window_tree_host =
       CreateWindowTreeHost(WindowMusType::DISPLAY, root_data, display.id());
 
-  WindowTreeHost* window_tree_host_ptr = window_tree_host.get();
+  WindowTreeHostMus* window_tree_host_ptr = window_tree_host.get();
   window_manager_delegate_->OnWmNewDisplay(std::move(window_tree_host),
                                            display);
   return window_tree_host_ptr;
 }
 
 std::unique_ptr<EventResultCallback>
 WindowTreeClient::CreateEventResultCallback(int32_t event_id) {
   return base::MakeUnique<EventResultCallback>(
       base::Bind(&ui::mojom::WindowTree::OnWindowInputEventAck,
                  base::Unretained(tree_), event_id));
@@ skipping 1090 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