WIP: simplified display management in ash

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 48 matching lines @@
 #if defined(HiWord)
 #undef HiWord
 #endif
 #if defined(LoWord)
 #undef LoWord
 #endif
 
 namespace aura {
 namespace {
 
+// This serves to document the places that rely on bounds changes to the
+// root window being ignored.
+constexpr bool kRootWindowBoundsChangesAreIgnored = true;
+
 Id MakeTransportId(ClientSpecificId client_id, ClientSpecificId local_id) {
   return (client_id << 16) | local_id;
 }
 
 inline uint16_t HiWord(uint32_t id) {
   return static_cast<uint16_t>((id >> 16) & 0xFFFF);
 }
 
 struct WindowPortPropertyDataMus : public ui::PropertyData {
   std::string transport_name;
@@ skipping 491 matching lines @@
   std::unique_ptr<WindowTreeHostMus> window_tree_host =
       CreateWindowTreeHost(WindowMusType::EMBED, *root_data, display_id,
                            frame_sink_id, local_surface_id);
 
   focus_synchronizer_->SetFocusFromServer(
       GetWindowByServerId(focused_window_id));
 
   delegate_->OnEmbed(std::move(window_tree_host));
 }
 
+void WindowTreeClient::OnSetDisplayRootDone(
+    Id window_id,
+    const base::Optional<cc::FrameSinkId>& frame_sink_id) {
+  // The only way SetDisplayRoot() should fail is if we've done something wrong.
+  CHECK(frame_sink_id);
+
+  WindowMus* window = GetWindowByServerId(window_id);
+  if (!window)
+    return;  // Display was already deleted.
+
+  window->SetFrameSinkIdFromServer(*frame_sink_id);
+}
+
 WindowTreeHostMus* WindowTreeClient::WmNewDisplayAddedImpl(
     const display::Display& display,
     ui::mojom::WindowDataPtr root_data,
     bool parent_drawn,
     const cc::FrameSinkId& frame_sink_id,
     const base::Optional<cc::LocalSurfaceId>& local_surface_id) {
   DCHECK(window_manager_delegate_);
 
   got_initial_displays_ = true;
 
   window_manager_delegate_->OnWmWillCreateDisplay(display);
 
-  std::unique_ptr<WindowTreeHostMus> window_tree_host =
-      CreateWindowTreeHost(WindowMusType::DISPLAY, *root_data, display.id(),
-                           frame_sink_id, local_surface_id);
+  std::unique_ptr<WindowTreeHostMus> window_tree_host = CreateWindowTreeHost(
+      WindowMusType::DISPLAY_AUTOMATICALLY_CREATED, *root_data, display.id(),
+      frame_sink_id, local_surface_id);
 
   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>(
@@ skipping 81 matching lines @@
       continue;
     }
     transport_properties[transport_name] =
         transport_value ? std::move(*transport_value) : std::vector<uint8_t>();
   }
 
   const uint32_t change_id = ScheduleInFlightChange(
       base::MakeUnique<CrashInFlightChange>(window, ChangeType::NEW_WINDOW));
   tree_->NewWindow(change_id, window->server_id(),
                    std::move(transport_properties));
+  if (window->window_mus_type() == WindowMusType::DISPLAY_MANUALLY_CREATED) {
+    WindowTreeHostMus* window_tree_host = GetWindowTreeHostMus(window);
+    ui::mojom::WmViewportMetricsPtr viewport_metrics =
+        window_tree_host->ReleaseInitialMetrics();
+    DCHECK(viewport_metrics);
+    display::Display display;
+    std::unique_ptr<display::Display> initial_display =
+        window_tree_host->ReleaseInitialDisplay();
+    if (initial_display) {
+      display = *initial_display;
+    } else {
+      const bool has_display =
+          display::Screen::GetScreen()->GetDisplayWithDisplayId(
+              window_tree_host->display_id(), &display);
+      DCHECK(has_display);
+    }
+    // As |window| is a root, changes to its bounds are ignored (it's assumed
+    // bounds changes are routed through OnWindowTreeHostBoundsWillChange()).
+    // But the display is created with an initial bounds, and we need to push
+    // that to the server.
+    DCHECK(kRootWindowBoundsChangesAreIgnored);
+    ScheduleInFlightBoundsChange(
+        window, gfx::Rect(),
+        gfx::Rect(viewport_metrics->bounds_in_pixels.size()));
+
+    // TODO: file bug on this, need to map to primary.
+    const bool is_primary_display = true;
+    // Tests may not config |window_manager_internal_client_|.
+    if (window_manager_internal_client_) {
+      window_manager_internal_client_->SetDisplayRoot(
+          display, std::move(viewport_metrics), is_primary_display,
+          window->server_id(),
+          base::Bind(&WindowTreeClient::OnSetDisplayRootDone,
+                     base::Unretained(this), window->server_id()));
+    }
+  }
 }
 
 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 23 matching lines @@
 
   roots_.erase(window);
 }
 
 void WindowTreeClient::OnWindowMusBoundsChanged(WindowMus* window,
                                                 const gfx::Rect& old_bounds,
                                                 const gfx::Rect& new_bounds) {
   // Changes to bounds of root windows are routed through
   // OnWindowTreeHostBoundsWillChange(). Any bounds that happen here are a side
   // effect of those and can be ignored.
-  if (IsRoot(window))
+  if (IsRoot(window)) {
+    DCHECK(kRootWindowBoundsChangesAreIgnored);
     return;
+  }
 
   float device_scale_factor = ScaleFactorForDisplay(window->GetWindow());
   ScheduleInFlightBoundsChange(
       window, gfx::ConvertRectToPixel(device_scale_factor, old_bounds),
       gfx::ConvertRectToPixel(device_scale_factor, new_bounds));
 }
 
 void WindowTreeClient::OnWindowMusAddChild(WindowMus* parent,
                                            WindowMus* child) {
   // TODO: add checks to ensure this can work.
@@ skipping 657 matching lines @@
   WindowMus* window = GetWindowByServerId(window_id);
   if (!window || !IsRoot(window))
     return;
 
   // Since the window is the root window, we send close request to the entire
   // WindowTreeHost.
   GetWindowTreeHostMus(window->GetWindow())->OnCloseRequest();
 }
 
 bool WindowTreeClient::WaitForInitialDisplays() {
+  LOG(WARNING) << "WaitForInitialDisplays got=" << got_initial_displays_;
   if (got_initial_displays_)
     return true;
 
   bool valid_wait = true;
   // TODO(sky): having to block here is not ideal. http://crbug.com/594852.
   while (!got_initial_displays_ && valid_wait)
     valid_wait = binding_.WaitForIncomingMethodCall();
+  LOG(WARNING) << "wait done, valid=" << valid_wait;
   return valid_wait;
 }
 
+WindowTreeHostMusInitParams WindowTreeClient::CreateInitParamsForNewDisplay() {
+  WindowTreeHostMusInitParams init_params;
+  init_params.window_port = base::MakeUnique<WindowPortMus>(
+      this, WindowMusType::DISPLAY_MANUALLY_CREATED);
+  roots_.insert(init_params.window_port.get());
+  init_params.window_tree_client = this;
+  return init_params;
+}
+
 void WindowTreeClient::OnConnect(ClientSpecificId client_id) {
+  LOG(WARNING) << "OnConnect";
   client_id_ = client_id;
+  got_initial_displays_ = true;
   if (window_manager_delegate_)
     window_manager_delegate_->OnWmConnected();
 }
 
 void WindowTreeClient::WmNewDisplayAdded(
     const display::Display& display,
     ui::mojom::WindowDataPtr root_data,
     bool parent_drawn,
     const cc::FrameSinkId& frame_sink_id,
     const base::Optional<cc::LocalSurfaceId>& local_surface_id) {
@@ skipping 530 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