Pass device scale factor from display to ws.

services/ui/ws/platform_display.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/platform_display.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "build/build_config.h"
 #include "cc/ipc/quads.mojom.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 41 matching lines @@
 
   return new DefaultPlatformDisplay(init_params);
 }
 
 DefaultPlatformDisplay::DefaultPlatformDisplay(
     const PlatformDisplayInitParams& init_params)
     : id_(init_params.display_id),
 #if !defined(OS_ANDROID)
       cursor_loader_(ui::CursorLoader::Create()),
 #endif
-      frame_generator_(new FrameGenerator(this, init_params.surfaces_state)) {
-  metrics_.bounds = init_params.display_bounds;
+      frame_generator_(new FrameGenerator(this, init_params.surfaces_state)),
+      metrics_(init_params.metrics) {
 }
 
 void DefaultPlatformDisplay::Init(PlatformDisplayDelegate* delegate) {
   delegate_ = delegate;
 
+  DCHECK(!metrics_.pixel_size.IsEmpty());
+
+  // TODO(kylechar): The origin here isn't right if any displays have
+  // scale_factor other than 1.0 but will prevent windows from being stacked.
+  gfx::Rect bounds(metrics_.bounds.origin(), metrics_.pixel_size);
 #if defined(OS_WIN)
-  platform_window_.reset(new ui::WinWindow(this, metrics_.bounds));
+  platform_window_.reset(new ui::WinWindow(this, bounds));
 #elif defined(USE_X11)
   platform_window_.reset(new ui::X11Window(this));
 #elif defined(OS_ANDROID)
   platform_window_.reset(new ui::PlatformWindowAndroid(this));
 #elif defined(USE_OZONE)
-  platform_window_ = ui::OzonePlatform::GetInstance()->CreatePlatformWindow(
-      this, metrics_.bounds);
+  platform_window_ =
+      ui::OzonePlatform::GetInstance()->CreatePlatformWindow(this, bounds);
 #else
   NOTREACHED() << "Unsupported platform";
 #endif
-  platform_window_->SetBounds(metrics_.bounds);
+  delegate_->CreateRootWindow(metrics_.bounds.size());
+
+  platform_window_->SetBounds(bounds);
   platform_window_->Show();
 }
 
 int64_t DefaultPlatformDisplay::GetId() const {
   return id_;
 }
 
 DefaultPlatformDisplay::~DefaultPlatformDisplay() {
   // Don't notify the delegate from the destructor.
   delegate_ = nullptr;
@@ skipping 79 matching lines @@
 bool DefaultPlatformDisplay::IsPrimaryDisplay() const {
   return display::PlatformScreen::GetInstance()->GetPrimaryDisplayId() == id_;
 }
 
 void DefaultPlatformDisplay::OnGpuChannelEstablished(
     scoped_refptr<gpu::GpuChannelHost> channel) {
   frame_generator_->OnGpuChannelEstablished(channel);
 }
 
 void DefaultPlatformDisplay::UpdateMetrics(const gfx::Rect& bounds,
+                                           const gfx::Size& pixel_size,
                                            float device_scale_factor) {
-  if (display::Display::HasForceDeviceScaleFactor())
-    device_scale_factor = display::Display::GetForcedDeviceScaleFactor();
-
   // We don't care about the origin of the platform window, as that may not be
   // related to the origin of the display in our screen space.
-  if (metrics_.bounds.size() == bounds.size() &&
+  if (metrics_.bounds == bounds && metrics_.pixel_size == pixel_size &&
       metrics_.device_scale_factor == device_scale_factor)
     return;
 
-  // TODO(kylechar): If the window size is updated then we may need to update
-  // the origin for any other windows.
   ViewportMetrics old_metrics = metrics_;
-  metrics_.bounds.set_size(bounds.size());
+  metrics_.bounds = bounds;
+  metrics_.pixel_size = pixel_size;
   metrics_.device_scale_factor = device_scale_factor;
   delegate_->OnViewportMetricsChanged(old_metrics, metrics_);
 }
 
 void DefaultPlatformDisplay::UpdateEventRootLocation(ui::LocatedEvent* event) {
   gfx::Point location = event->location();
   location.Offset(metrics_.bounds.x(), metrics_.bounds.y());
   event->set_root_location(location);
 }
 
 void DefaultPlatformDisplay::OnBoundsChanged(const gfx::Rect& new_bounds) {
-  UpdateMetrics(new_bounds, metrics_.device_scale_factor);
+  // TODO(kylechar): We're updating the bounds assuming that the device scale
+  // factor is 1 here. The correct thing to do is let PlatformSreen know the
+  // display size has changed and let it update the display.
+  gfx::Size pixel_size = new_bounds.size();
+  gfx::Rect bounds = gfx::Rect(metrics_.bounds.origin(), pixel_size);
+  UpdateMetrics(bounds, pixel_size, metrics_.device_scale_factor);
 }
 
 void DefaultPlatformDisplay::OnDamageRect(const gfx::Rect& damaged_region) {
   frame_generator_->RequestRedraw(damaged_region);
 }
 
 void DefaultPlatformDisplay::DispatchEvent(ui::Event* event) {
   if (event->IsLocatedEvent())
     UpdateEventRootLocation(event->AsLocatedEvent());
 
@@ skipping 47 matching lines @@
     ui::PlatformWindowState new_state) {}
 
 void DefaultPlatformDisplay::OnLostCapture() {
   delegate_->OnNativeCaptureLost();
 }
 
 void DefaultPlatformDisplay::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget,
     float device_scale_factor) {
   frame_generator_->OnAcceleratedWidgetAvailable(widget);
-  UpdateMetrics(metrics_.bounds, device_scale_factor);
 }
 
 void DefaultPlatformDisplay::OnAcceleratedWidgetDestroyed() {
   NOTREACHED();
 }
 
 void DefaultPlatformDisplay::OnActivationChanged(bool active) {}
 
 void DefaultPlatformDisplay::RequestCopyOfOutput(
     std::unique_ptr<cc::CopyOutputRequest> output_request) {
@@ skipping 13 matching lines @@
   return delegate_ ? delegate_->IsInHighContrastMode() : false;
 }
 
 const ViewportMetrics& DefaultPlatformDisplay::GetViewportMetrics() {
   return metrics_;
 }
 
 }  // namespace ws
 
 }  // namespace ui