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;
 
+  // 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);
+  platform_window_->SetBounds(bounds);
   platform_window_->Show();
+
+  delegate_->OnViewportMetricsChanged(ViewportMetrics(), metrics_);

[rjkroege, 2016/09/21 13:23:47]

this is required? And if it is, why do you show the window first? The order
seems strange.

[kylechar, 2016/09/21 16:31:13]

Yes/no. First, yes it's required because OnViewportMetricsChanged handles two
things. It handles creating the root window and updating viewport metrics.
Second, no it shouldn't be required because it shouldn't work that way.

I've split it into two methods to make it clearer. I'm also creating the root
window before showing the platform window now.

 }
 
 int64_t DefaultPlatformDisplay::GetId() const {
   return id_;
 }
 
 DefaultPlatformDisplay::~DefaultPlatformDisplay() {
   // Don't notify the delegate from the destructor.
   delegate_ = nullptr;
 
@@ skipping 78 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