Fix ws::Display initialization order.

services/ui/ws/display.cc

 // Copyright 2015 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/display.h"
 
 #include <set>
 #include <utility>
 #include <vector>
 
-#include "base/debug/debugger.h"
 #include "base/strings/utf_string_conversions.h"
 #include "mojo/common/common_type_converters.h"
 #include "services/service_manager/public/interfaces/connector.mojom.h"
 #include "services/ui/common/types.h"
 #include "services/ui/public/interfaces/cursor.mojom.h"
 #include "services/ui/ws/display_binding.h"
 #include "services/ui/ws/display_manager.h"
 #include "services/ui/ws/focus_controller.h"
 #include "services/ui/ws/platform_display.h"
 #include "services/ui/ws/platform_display_init_params.h"
 #include "services/ui/ws/user_activity_monitor.h"
 #include "services/ui/ws/window_manager_display_root.h"
 #include "services/ui/ws/window_manager_state.h"
 #include "services/ui/ws/window_manager_window_tree_factory.h"
 #include "services/ui/ws/window_server.h"
 #include "services/ui/ws/window_server_delegate.h"
 #include "services/ui/ws/window_tree.h"
 #include "services/ui/ws/window_tree_binding.h"
 #include "ui/base/cursor/cursor.h"
 
 namespace ui {
 namespace ws {
 
-Display::Display(WindowServer* window_server,
-                 const PlatformDisplayInitParams& platform_display_init_params)
+Display::Display(WindowServer* window_server)
     : window_server_(window_server), last_cursor_(mojom::Cursor::CURSOR_NULL) {
-  CreateRootWindow(platform_display_init_params.metrics.pixel_size);
-
-  // Pass the display root ServerWindow to PlatformDisplay.
-  PlatformDisplayInitParams param_copy = platform_display_init_params;
-  param_copy.root_window = root_.get();
-  platform_display_.reset(PlatformDisplay::Create(param_copy));
-  platform_display_->Init(this);
-
   window_server_->window_manager_window_tree_factory_set()->AddObserver(this);
   window_server_->user_id_tracker()->AddObserver(this);
 }
 
 Display::~Display() {
   window_server_->user_id_tracker()->RemoveObserver(this);
 
   window_server_->window_manager_window_tree_factory_set()->RemoveObserver(
       this);
 
   if (!focus_controller_) {
     focus_controller_->RemoveObserver(this);
     focus_controller_.reset();
   }
 
   if (!binding_) {
     for (auto& pair : window_manager_display_root_map_)
       pair.second->window_manager_state()->OnDisplayDestroying(this);
   } else if (!window_manager_display_root_map_.empty()) {
     // If there is a |binding_| then the tree was created specifically for this
     // display (which corresponds to a WindowTreeHost).
     window_server_->DestroyTree(window_manager_display_root_map_.begin()
                                     ->second->window_manager_state()
                                     ->window_tree());
   }
 }
 
-void Display::Init(std::unique_ptr<DisplayBinding> binding) {
-  init_called_ = true;
+void Display::Init(const PlatformDisplayInitParams& init_params,
+                   std::unique_ptr<DisplayBinding> binding) {
   binding_ = std::move(binding);
   display_manager()->AddDisplay(this);
-  InitWindowManagerDisplayRootsIfNecessary();
+
+  CreateRootWindow(init_params.metrics.pixel_size);
+  PlatformDisplayInitParams params_copy = init_params;
+  params_copy.root_window = root_.get();
+
+  platform_display_ = PlatformDisplay::Create(params_copy);
+  platform_display_->Init(this);
 }
 
 int64_t Display::GetId() const {
   return platform_display_->GetId();
 }
 
 DisplayManager* Display::display_manager() {
   return window_server_->display_manager();
 }
 
@@ skipping 11 matching lines @@
   display.set_work_area(metrics.work_area);
   display.set_device_scale_factor(metrics.device_scale_factor);
   display.set_rotation(metrics.rotation);
   display.set_touch_support(
       display::Display::TouchSupport::TOUCH_SUPPORT_UNKNOWN);
 
   return display;
 }
 
 gfx::Size Display::GetSize() const {
-  return platform_display_->GetBounds().size();
+  DCHECK(root_);
+  return root_->bounds().size();
 }
 
 ServerWindow* Display::GetRootWithId(const WindowId& id) {
   if (id == root_->id())
     return root_.get();
   for (auto& pair : window_manager_display_root_map_) {
     if (pair.second->root()->id() == id)
       return pair.second->root();
   }
   return nullptr;
@@ skipping 80 matching lines @@
 }
 
 void Display::SetSize(const gfx::Size& size) {
   platform_display_->SetViewportSize(size);
 }
 
 void Display::SetTitle(const mojo::String& title) {
   platform_display_->SetTitle(title.To<base::string16>());
 }
 
-void Display::InitWindowManagerDisplayRootsIfNecessary() {
-  if (!init_called_ || !root_)
-    return;
-
-  display_manager()->OnDisplayAcceleratedWidgetAvailable(this);
+void Display::InitWindowManagerDisplayRoots() {
   if (binding_) {
     std::unique_ptr<WindowManagerDisplayRoot> display_root_ptr(
         new WindowManagerDisplayRoot(this));
     WindowManagerDisplayRoot* display_root = display_root_ptr.get();
     // For this case we never create additional displays roots, so any
     // id works.
     window_manager_display_root_map_[service_manager::mojom::kRootUserID] =
         display_root_ptr.get();
     WindowTree* window_tree = binding_->CreateWindowTree(display_root->root());
     display_root->window_manager_state_ = window_tree->window_manager_state();
@@ skipping 35 matching lines @@
 void Display::CreateRootWindow(const gfx::Size& size) {
   DCHECK(!root_);
 
   root_.reset(window_server_->CreateServerWindow(
       display_manager()->GetAndAdvanceNextRootId(),
       ServerWindow::Properties()));
   root_->SetBounds(gfx::Rect(size));
   root_->SetVisible(true);
   focus_controller_ = base::MakeUnique<FocusController>(this, root_.get());
   focus_controller_->AddObserver(this);
-  InitWindowManagerDisplayRootsIfNecessary();
 }
 
 ServerWindow* Display::GetRootWindow() {
   return root_.get();
 }
 
+void Display::OnAcceleratedWidgetAvailable() {
+  display_manager()->OnDisplayAcceleratedWidgetAvailable(this);
+  InitWindowManagerDisplayRoots();
+}
+
 bool Display::IsInHighContrastMode() {
   return window_server_->IsActiveUserInHighContrastMode();
 }
 
 void Display::OnEvent(const ui::Event& event) {
   WindowManagerDisplayRoot* display_root = GetActiveWindowManagerDisplayRoot();
   if (display_root)
     display_root->window_manager_state()->ProcessEvent(event);
   window_server_
       ->GetUserActivityMonitorForUser(
@@ skipping 96 matching lines @@
 }
 
 void Display::OnWindowManagerWindowTreeFactoryReady(
     WindowManagerWindowTreeFactory* factory) {
   if (!binding_)
     CreateWindowManagerDisplayRootFromFactory(factory);
 }
 
 }  // namespace ws
 }  // namespace ui