mus: Changes SetDisplayRoot() to create actual display

services/ui/ws/window_tree.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 "services/ui/ws/window_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
 #include "base/bind.h"
 #include "base/macros.h"
 #include "base/memory/ptr_util.h"
 #include "mojo/public/cpp/bindings/map.h"
 #include "services/ui/ws/cursor_location_manager.h"
 #include "services/ui/ws/default_access_policy.h"
 #include "services/ui/ws/display.h"
 #include "services/ui/ws/display_manager.h"
 #include "services/ui/ws/event_matcher.h"
 #include "services/ui/ws/focus_controller.h"
 #include "services/ui/ws/operation.h"
 #include "services/ui/ws/platform_display.h"
 #include "services/ui/ws/server_window.h"
 #include "services/ui/ws/server_window_compositor_frame_sink_manager.h"
 #include "services/ui/ws/server_window_observer.h"
 #include "services/ui/ws/user_display_manager.h"
 #include "services/ui/ws/window_manager_display_root.h"
 #include "services/ui/ws/window_manager_state.h"
 #include "services/ui/ws/window_server.h"
+#include "services/ui/ws/window_server_delegate.h"
 #include "services/ui/ws/window_tree_binding.h"
 #include "ui/display/display.h"
+#include "ui/display/display_list.h"
+#include "ui/display/screen_base.h"
 #include "ui/display/types/display_constants.h"
 #include "ui/platform_window/mojo/ime_type_converters.h"
 #include "ui/platform_window/text_input_state.h"
 
 using mojo::InterfaceRequest;
 
 using EventProperties = std::unordered_map<std::string, std::vector<uint8_t>>;
 
 namespace ui {
 namespace ws {
@@ skipping 214 matching lines @@
 void WindowTree::OnWmMoveDragImageAck() {
   if (drag_move_state_->has_queued_drag_window_move) {
     gfx::Point queued_location = drag_move_state_->queued_cursor_location;
     drag_move_state_.reset();
     OnDragMoved(queued_location);
   } else {
     drag_move_state_.reset();
   }
 }
 
-bool WindowTree::ProcessSetDisplayRoot(int64_t display_id,
-                                       const ClientWindowId& client_window_id) {
+ServerWindow* WindowTree::ProcessSetDisplayRoot(
+    const display::Display& display_to_create,
+    const mojom::WmViewportMetrics& transport_viewport_metrics,
+    bool is_primary_display,
+    const ClientWindowId& client_window_id) {
   DCHECK(window_manager_state_);  // Only called for window manager.
+  DVLOG(3) << "SetDisplayRoot client=" << id_
+           << " global window_id=" << client_window_id.id;
   Display* display =
-      window_server_->display_manager()->GetDisplayById(display_id);
-  if (!display) {
-    DVLOG(1) << "SetDisplayRoot called with unknown display " << display_id;
-    return false;
+      window_server_->display_manager()->GetDisplayById(display_to_create.id());
+  if (display) {
+    DVLOG(1) << "SetDisplayRoot called with existing display "
+             << display_to_create.id();
+    return nullptr;
   }
 
   if (automatically_create_display_roots_) {
     DVLOG(1) << "SetDisplayRoot is only applicable when "
              << "automatically_create_display_roots is false";
-    return false;
+    return nullptr;
   }
 
   ServerWindow* window = GetWindowByClientId(client_window_id);
   // The window must not have a parent.
   if (!window || window->parent()) {
     DVLOG(1) << "SetDisplayRoot called with invalid window id "
              << client_window_id.id;
-    return false;
+    return nullptr;
   }
 
+  if (base::ContainsValue(roots_, window)) {
+    DVLOG(1) << "SetDisplayRoot called with existing root";
+    return nullptr;
+  }
+
+  const display::DisplayList::Type display_type =
+      is_primary_display ? display::DisplayList::Type::PRIMARY
+                         : display::DisplayList::Type::NOT_PRIMARY;
+  window_server_->delegate()->GetScreen()->display_list().AddDisplay(
+      display_to_create, display_type);
+  display::ViewportMetrics viewport_metrics;
+  viewport_metrics.bounds_in_pixels =
+      transport_viewport_metrics.bounds_in_pixels;
+  viewport_metrics.device_scale_factor =
+      transport_viewport_metrics.device_scale_factor;
+  viewport_metrics.ui_scale_factor = transport_viewport_metrics.ui_scale_factor;
+  window_server_->display_manager()->AddDisplayForWindowManager(
+      display_to_create, viewport_metrics);
+
+  // OnDisplayAdded() should trigger creation of the Display.
+  display =
+      window_server_->display_manager()->GetDisplayById(display_to_create.id());
+  DCHECK(display);
   WindowManagerDisplayRoot* display_root =
       display->GetWindowManagerDisplayRootForUser(
           window_manager_state_->user_id());
   DCHECK(display_root);
-  if (!display_root->root()->children().empty()) {
-    DVLOG(1) << "SetDisplayRoot called more than once";
-    return false;
-  }
-
-  if (base::ContainsValue(roots_, window)) {
-    DVLOG(1) << "SetDisplayRoot called with existing root";
-    return false;
-  }
+  DCHECK(display_root->root()->children().empty());
 
   // NOTE: this doesn't resize the window in anyway. We assume the client takes
   // care of any modifications it needs to do.
   roots_.insert(window);
   Operation op(this, window_server_, OperationType::ADD_WINDOW);
   display_root->root()->Add(window);
-  return true;
+  return window;
 }
 
 bool WindowTree::SetCapture(const ClientWindowId& client_window_id) {
   ServerWindow* window = GetWindowByClientId(client_window_id);
   WindowManagerDisplayRoot* display_root = GetWindowManagerDisplayRoot(window);
   ServerWindow* current_capture_window =
       display_root ? display_root->window_manager_state()->capture_window()
                    : nullptr;
   if (window && window->IsDrawn() && display_root &&
       display_root->window_manager_state()->IsActive() &&
@@ skipping 20 matching lines @@
     return false;
   }
   Operation op(this, window_server_, OperationType::RELEASE_CAPTURE);
   return display_root->window_manager_state()->SetCapture(nullptr,
                                                           kInvalidClientId);
 }
 
 bool WindowTree::NewWindow(
     const ClientWindowId& client_window_id,
     const std::map<std::string, std::vector<uint8_t>>& properties) {
-  if (!IsValidIdForNewWindow(client_window_id))
+  DVLOG(3) << "new window client=" << id_
+           << " window_id=" << client_window_id.id;
+  if (!IsValidIdForNewWindow(client_window_id)) {
+    DVLOG(1) << "new window failed, id is not valid for client";
     return false;
+  }
   const WindowId window_id = GenerateNewWindowId();
   DCHECK(!GetWindow(window_id));
   ServerWindow* window =
       window_server_->CreateServerWindow(window_id, properties);
   created_window_map_[window_id] = window;
   client_id_to_window_id_map_[client_window_id] = window_id;
   window_id_to_client_id_map_[window_id] = client_window_id;
   return true;
 }
 
@@ skipping 128 matching lines @@
   const ServerWindow* window = GetWindowByClientId(window_id);
   std::vector<const ServerWindow*> windows;
   if (window)
     GetWindowTreeImpl(window, &windows);
   return windows;
 }
 
 bool WindowTree::SetWindowVisibility(const ClientWindowId& window_id,
                                      bool visible) {
   ServerWindow* window = GetWindowByClientId(window_id);
-  if (!window || !access_policy_->CanChangeWindowVisibility(window))
+  DVLOG(3) << "SetWindowVisibility client=" << id_
+           << " client window_id= " << window_id.id << " global window_id="
+           << (window ? WindowIdToTransportId(window->id()) : 0);
+  if (!window) {
+    DVLOG(1) << "SetWindowVisibility failure, no window";
     return false;
+  }
+  if (!access_policy_->CanChangeWindowVisibility(window)) {
+    DVLOG(1) << "SetWindowVisibility failure, access policy denied change";
+    return false;
+  }
   if (window->visible() == visible)
     return true;
   Operation op(this, window_server_, OperationType::SET_WINDOW_VISIBILITY);
   window->SetVisible(visible);
   return true;
 }
 
 bool WindowTree::SetWindowOpacity(const ClientWindowId& window_id,
                                   float opacity) {
   ServerWindow* window = GetWindowByClientId(window_id);
@@ skipping 1586 matching lines @@
     DVLOG(1) << "SetExtendedHitArea supplied unknown window";
     return;
   }
   if (window->id().client_id != id_) {
     DVLOG(1) << "SetExtendedHitArea supplied window that client does not own";
     return;
   }
   window->set_extended_hit_test_region(hit_area);
 }
 
-void WindowTree::SetDisplayRoot(int64_t display_id,
-                                Id window_id,
-                                const SetDisplayRootCallback& callback) {
-  callback.Run(ProcessSetDisplayRoot(display_id, ClientWindowId(window_id)));
+void WindowTree::SetDisplayRoot(
+    const display::Display& display,
+    const mojom::WmViewportMetricsPtr viewport_metrics,
+    bool is_primary_display,
+    Id window_id,
+    const SetDisplayRootCallback& callback) {
+  ServerWindow* display_root =
+      ProcessSetDisplayRoot(display, *(viewport_metrics.get()),
+                            is_primary_display, ClientWindowId(window_id));
+  if (!display_root) {
+    base::Optional<cc::FrameSinkId> frame_sink_id;
+    callback.Run(frame_sink_id);

[kylechar, 2017/04/19 18:06:08]

Maybe named |empty_frame_sink_id| or just
callback.Run(base::Optional<cc::FrameSinkId>()) just so it's immediately obvious
what is happening here.

[sky, 2017/04/19 19:30:03]

Done.

+    return;
+  }
+  display_root->parent()->SetVisible(true);
+  callback.Run(display_root->frame_sink_id());
 }
 
 void WindowTree::WmResponse(uint32_t change_id, bool response) {
   if (window_server_->in_move_loop() &&
       window_server_->GetCurrentMoveLoopChangeId() == change_id) {
     ServerWindow* window = window_server_->GetCurrentMoveLoopWindow();
 
     if (window->id().client_id != id_) {
       window_server_->WindowManagerSentBogusMessage();
       window = nullptr;
@@ skipping 229 matching lines @@
   client()->OnCompleteDrop(client_window_id.id, event_flags, cursor_offset,
                            effect_bitmask, callback);
 }
 
 void WindowTree::PerformOnDragDropDone() {
   client()->OnDragDropDone();
 }
 
 }  // namespace ws
 }  // namespace ui