Start to decouple display::Display from ws::PlatformDisplay.

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/memory/ptr_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "services/service_manager/public/interfaces/connector.mojom.h"
 #include "services/ui/common/types.h"
+#include "services/ui/display/viewport_metrics.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"
+#include "ui/display/screen.h"
 
 namespace ui {
 namespace ws {
 
 Display::Display(WindowServer* window_server)
     : window_server_(window_server), last_cursor_(mojom::Cursor::CURSOR_NULL) {
   window_server_->window_manager_window_tree_factory_set()->AddObserver(this);
   window_server_->user_id_tracker()->AddObserver(this);
 }
 
@@ skipping 13 matching lines @@
       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(const PlatformDisplayInitParams& init_params,
+void Display::Init(const display::ViewportMetrics& metrics,
                    std::unique_ptr<DisplayBinding> binding) {
   binding_ = std::move(binding);
   display_manager()->AddDisplay(this);
 
-  CreateRootWindow(init_params.metrics.pixel_size);
-  PlatformDisplayInitParams params_copy = init_params;
-  params_copy.root_window = root_.get();
+  CreateRootWindow(metrics.bounds_in_pixels.size());
 
-  platform_display_ = PlatformDisplay::Create(params_copy);
+  platform_display_ = PlatformDisplay::Create(root_.get(), metrics);
   platform_display_->Init(this);
 }
 
 int64_t Display::GetId() const {
-  return platform_display_->GetId();
+  // TODO(tonikitoo): Implement a different ID for external window mode.
+  return display_.id();
+}
+
+void Display::SetDisplay(const display::Display& display) {
+  display_ = display;
+}
+
+const display::Display& Display::GetDisplay() {
+  return display_;
 }
 
 DisplayManager* Display::display_manager() {
   return window_server_->display_manager();
 }
 
 const DisplayManager* Display::display_manager() const {
   return window_server_->display_manager();
 }
 
-display::Display Display::ToDisplay() const {
-  display::Display display(GetId());
-
-  const display::ViewportMetrics& metrics =
-      platform_display_->GetViewportMetrics();
-
-  display.set_bounds(metrics.bounds);
-  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 {
   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)
@@ skipping 99 matching lines @@
     // 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();
     window_tree->window_manager_state()->AddWindowManagerDisplayRoot(
         std::move(display_root_ptr));
   } else {
     CreateWindowManagerDisplayRootsFromFactories();
   }
-  display_manager()->OnDisplayUpdate(this);
+  display_manager()->OnDisplayUpdate(display_);
 }
 
 void Display::CreateWindowManagerDisplayRootsFromFactories() {
   std::vector<WindowManagerWindowTreeFactory*> factories =
       window_server_->window_manager_window_tree_factory_set()->GetFactories();
   for (WindowManagerWindowTreeFactory* factory : factories) {
     if (factory->window_tree())
       CreateWindowManagerDisplayRootFromFactory(factory);
   }
 }
@@ skipping 23 matching lines @@
       display_manager()->GetAndAdvanceNextRootId(),
       ServerWindow::Properties()));
   root_->set_event_targeting_policy(
       mojom::EventTargetingPolicy::DESCENDANTS_ONLY);
   root_->SetBounds(gfx::Rect(size), allocator_.GenerateId());
   root_->SetVisible(true);
   focus_controller_ = base::MakeUnique<FocusController>(this, root_.get());
   focus_controller_->AddObserver(this);
 }
 
-display::Display Display::GetDisplay() {
-  return ToDisplay();
-}
-
 ServerWindow* Display::GetRootWindow() {
   return root_.get();
 }
 
 void Display::OnAcceleratedWidgetAvailable() {
   display_manager()->OnDisplayAcceleratedWidgetAvailable(this);
   InitWindowManagerDisplayRoots();
 }
 
 bool Display::IsInHighContrastMode() {
@@ skipping 11 matching lines @@
 }
 
 void Display::OnNativeCaptureLost() {
   WindowManagerDisplayRoot* display_root = GetActiveWindowManagerDisplayRoot();
   if (display_root)
     display_root->window_manager_state()->SetCapture(nullptr, kInvalidClientId);
 }
 
 void Display::OnViewportMetricsChanged(
     const display::ViewportMetrics& metrics) {
-  if (root_->bounds().size() == metrics.pixel_size)
+  if (root_->bounds().size() == metrics.bounds_in_pixels.size())
     return;
 
-  gfx::Rect new_bounds(metrics.pixel_size);
+  gfx::Rect new_bounds(metrics.bounds_in_pixels.size());
   root_->SetBounds(new_bounds, allocator_.GenerateId());
   for (auto& pair : window_manager_display_root_map_)
     pair.second->root()->SetBounds(new_bounds, allocator_.GenerateId());
 }
 
 ServerWindow* Display::GetActiveRootWindow() {
   WindowManagerDisplayRoot* display_root = GetActiveWindowManagerDisplayRoot();
   if (display_root)
     return display_root->root();
   return nullptr;
@@ skipping 77 matching lines @@
 }
 
 void Display::OnWindowManagerWindowTreeFactoryReady(
     WindowManagerWindowTreeFactory* factory) {
   if (!binding_)
     CreateWindowManagerDisplayRootFromFactory(factory);
 }
 
 }  // namespace ws
 }  // namespace ui