Add PlatformScreenDelegate and start implementation.

services/ui/service.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/service.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 63 matching lines @@
 };
 
 struct Service::UserState {
   std::unique_ptr<ws::AccessibilityManager> accessibility;
   std::unique_ptr<ws::WindowTreeHostFactory> window_tree_host_factory;
 };
 
 Service::Service()
     : test_config_(false),
       platform_screen_(display::PlatformScreen::Create()),
-      ime_registrar_(&ime_server_),
-      weak_ptr_factory_(this) {}
+      ime_registrar_(&ime_server_) {}
 
 Service::~Service() {
   // Destroy |window_server_| first, since it depends on |event_source_|.
   // WindowServer (or more correctly its Displays) may have state that needs to
   // be destroyed before GpuState as well.
   window_server_.reset();
 }
 
 void Service::InitializeResources(shell::Connector* connector) {
   if (ui::ResourceBundle::HasSharedInstance())
@@ skipping 30 matching lines @@
     return it->second.get();
   user_id_to_user_state_[user_id] = base::WrapUnique(new UserState);
   return user_id_to_user_state_[user_id].get();
 }
 
 void Service::AddUserIfNecessary(const shell::Identity& remote_identity) {
   window_server_->user_id_tracker()->AddUserId(remote_identity.user_id());
 }
 
 void Service::OnStart(const shell::Identity& identity) {
-  platform_display_init_params_.surfaces_state = new SurfacesState;
-
   base::PlatformThread::SetName("mus");
   tracing_.Initialize(connector(), identity.name());
   TRACE_EVENT0("mus", "Service::Initialize started");
 
   test_config_ = base::CommandLine::ForCurrentProcess()->HasSwitch(
       switches::kUseTestConfig);
 #if defined(USE_X11)
   XInitThreads();
   if (test_config_)
     ui::test::SetUseOverrideRedirectWindowByDefault(true);
@@ skipping 29 matching lines @@
 #endif
 
   // This needs to happen after DeviceDataManager has been constructed. That
   // happens either during OzonePlatform or PlatformEventSource initialization,
   // so keep this line below both of those.
   input_device_server_.RegisterAsObserver();
 
   gpu_proxy_.reset(new GpuServiceProxy());
 
   // Gpu must be running before the PlatformScreen can be initialized.
-  platform_screen_->Init();
-  window_server_.reset(
-      new ws::WindowServer(this, platform_display_init_params_.surfaces_state));
+  window_server_.reset(new ws::WindowServer(this));
 
   // DeviceDataManager must be initialized before TouchController. On non-Linux
   // platforms there is no DeviceDataManager so don't create touch controller.
   if (ui::DeviceDataManager::HasInstance())
     touch_controller_.reset(
         new ws::TouchController(window_server_->display_manager()));
 }
 
 bool Service::OnConnect(const shell::Identity& remote_identity,
                         shell::InterfaceRegistry* registry) {
@@ skipping 37 matching lines @@
 void Service::OnNoMoreDisplays() {
   // We may get here from the destructor, in which case there is no messageloop.
   if (base::MessageLoop::current())
     base::MessageLoop::current()->QuitWhenIdle();
 }
 
 bool Service::IsTestConfig() const {
   return test_config_;
 }
 
+void Service::UpdateTouchTransforms() {
+  if (touch_controller_)
+    touch_controller_->UpdateTouchTransforms();
+}
+
 void Service::CreateDefaultDisplays() {
-  // An asynchronous callback will create the Displays once the physical
-  // displays are ready.
-  platform_screen_->ConfigurePhysicalDisplay(base::Bind(
-      &Service::OnCreatedPhysicalDisplay, weak_ptr_factory_.GetWeakPtr()));
+  // The display manager will create Displays once hardware or virtual displays
+  // are ready.
+  platform_screen_->Init(window_server_->display_manager());
 }
 
 void Service::Create(const shell::Identity& remote_identity,
                      mojom::AccessibilityManagerRequest request) {
   UserState* user_state = GetUserState(remote_identity);
   if (!user_state->accessibility) {
     const ws::UserId& user_id = remote_identity.user_id();
     user_state->accessibility.reset(
         new ws::AccessibilityManager(window_server_.get(), user_id));
   }
@@ skipping 71 matching lines @@
   AddUserIfNecessary(remote_identity);
   new ws::WindowTreeFactory(window_server_.get(), remote_identity.user_id(),
                             remote_identity.name(), std::move(request));
 }
 
 void Service::Create(const shell::Identity& remote_identity,
                      mojom::WindowTreeHostFactoryRequest request) {
   UserState* user_state = GetUserState(remote_identity);
   if (!user_state->window_tree_host_factory) {
     user_state->window_tree_host_factory.reset(new ws::WindowTreeHostFactory(
-        window_server_.get(), remote_identity.user_id(),
-        platform_display_init_params_));
+        window_server_.get(), remote_identity.user_id()));
   }
   user_state->window_tree_host_factory->AddBinding(std::move(request));
 }
 
 void Service::Create(const shell::Identity& remote_identity,
                      mojom::WindowServerTestRequest request) {
   if (!test_config_)
     return;
   new ws::WindowServerTestImpl(window_server_.get(), std::move(request));
 }
 
-void Service::OnCreatedPhysicalDisplay(int64_t id, const gfx::Rect& bounds) {
-  platform_display_init_params_.display_bounds = bounds;
-  platform_display_init_params_.display_id = id;
-  platform_display_init_params_.platform_screen = platform_screen_.get();
-
-  // Display manages its own lifetime.
-  ws::Display* host_impl =
-      new ws::Display(window_server_.get(), platform_display_init_params_);
-  host_impl->Init(nullptr);
-
-  if (touch_controller_)
-    touch_controller_->UpdateTouchTransforms();
-}
 
 }  // namespace ui