Handle modified displays in mustash.

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 128 matching lines @@
   // that chrome would use, not custom image cursors. For that, we should
   // delegate to the window manager to load images from resource packs.
   //
   // We probably also need to deal with different DPIs.
   ui::Cursor cursor(static_cast<int32_t>(cursor_id));
   cursor_loader_->SetPlatformCursor(&cursor);
   platform_window_->SetCursor(cursor.platform());
 #endif
 }
 
-float DefaultPlatformDisplay::GetDeviceScaleFactor() {
-  return metrics_.device_scale_factor;
-}
-
-display::Display::Rotation DefaultPlatformDisplay::GetRotation() {
-  // TODO(sky): implement me.
-  return display::Display::ROTATE_0;
-}
-
 void DefaultPlatformDisplay::UpdateTextInputState(
     const ui::TextInputState& state) {
   ui::PlatformImeController* ime = platform_window_->GetPlatformImeController();
   if (ime)
     ime->UpdateTextInputState(state);
 }
 
 void DefaultPlatformDisplay::SetImeVisibility(bool visible) {
   ui::PlatformImeController* ime = platform_window_->GetPlatformImeController();
   if (ime)
@@ skipping 10 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) {
-  // 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 == bounds && metrics_.pixel_size == pixel_size &&
-      metrics_.device_scale_factor == device_scale_factor)
-    return;
+bool DefaultPlatformDisplay::UpdateViewportMetrics(
+    const display::ViewportMetrics& metrics) {
+  if (metrics_ == metrics)
+    return false;
 
-  ViewportMetrics old_metrics = metrics_;
-  metrics_.bounds = bounds;
-  metrics_.pixel_size = pixel_size;
-  metrics_.device_scale_factor = device_scale_factor;
-  delegate_->OnViewportMetricsChanged(old_metrics, metrics_);
+  gfx::Rect bounds = platform_window_->GetBounds();
+  if (bounds.size() != metrics.pixel_size) {
+    bounds.set_size(metrics.pixel_size);
+    platform_window_->SetBounds(bounds);
+  }
+
+  metrics_ = metrics;
+  return true;
+}
+
+const display::ViewportMetrics& DefaultPlatformDisplay::GetViewportMetrics()
+    const {
+  return 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) {
-  // 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);
+  // We only care if the window size has changed.
+  if (new_bounds.size() == metrics_.pixel_size)
+    return;
+
+  // TODO(kylechar): Maybe do something here. For CrOS we don't need to support
+  // PlatformWindow initiated resizes. For other platforms we need to do
+  // something but that isn't fully flushed out.
 }
 
 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 68 matching lines @@
 }
 
 ServerWindow* DefaultPlatformDisplay::GetRootWindow() {
   return delegate_->GetRootWindow();
 }
 
 bool DefaultPlatformDisplay::IsInHighContrastMode() {
   return delegate_ ? delegate_->IsInHighContrastMode() : false;
 }
 
-const ViewportMetrics& DefaultPlatformDisplay::GetViewportMetrics() {
-  return metrics_;
-}
-
 }  // namespace ws
 
 }  // namespace ui