mus: Remove ViewportMetrics from mojom.

components/mus/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 "components/mus/ws/platform_display.h"
 
 #include "base/numerics/safe_conversions.h"
 #include "build/build_config.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/copy_output_request.h"
@@ skipping 157 matching lines @@
     const PlatformDisplayInitParams& init_params)
     : gpu_state_(init_params.gpu_state),
       surfaces_state_(init_params.surfaces_state),
       delegate_(nullptr),
       draw_timer_(false, false),
       frame_pending_(false),
 #if !defined(OS_ANDROID)
       cursor_loader_(ui::CursorLoader::Create()),
 #endif
       weak_factory_(this) {
-  metrics_.size_in_pixels = mojo::Size::New();
-  metrics_.size_in_pixels->width = init_params.display_bounds.width();
-  metrics_.size_in_pixels->height = init_params.display_bounds.height();
+  metrics_.size_in_pixels = init_params.display_bounds.size();
   // TODO(rjkroege): Preserve the display_id when Ozone platform can use it.
 }
 
 void DefaultPlatformDisplay::Init(PlatformDisplayDelegate* delegate) {
   delegate_ = delegate;
 
-  gfx::Rect bounds(metrics_.size_in_pixels.To<gfx::Size>());
+  gfx::Rect bounds(metrics_.size_in_pixels);
 #if defined(OS_WIN)
   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, bounds);
 #else
@@ skipping 52 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(cursor_id);
   cursor_loader_->SetPlatformCursor(&cursor);
   platform_window_->SetCursor(cursor.platform());
 #endif
 }
 
-const mojom::ViewportMetrics& DefaultPlatformDisplay::GetViewportMetrics() {
-  return metrics_;
+float DefaultPlatformDisplay::GetDeviceScaleFactor() {
+  return metrics_.device_scale_factor;
 }
 
 mojom::Rotation DefaultPlatformDisplay::GetRotation() {
   // TODO(sky): implement me.
   return mojom::Rotation::VALUE_0;
 }
 
 void DefaultPlatformDisplay::UpdateTextInputState(
     const ui::TextInputState& state) {
   ui::PlatformImeController* ime = platform_window_->GetPlatformImeController();
@@ skipping 37 matching lines @@
   if (draw_timer_.IsRunning() || frame_pending_)
     return;
 
   // TODO(rjkroege): Use vblank to kick off Draw.
   draw_timer_.Start(
       FROM_HERE, base::TimeDelta(),
       base::Bind(&DefaultPlatformDisplay::Draw, weak_factory_.GetWeakPtr()));
 }
 
 void DefaultPlatformDisplay::UpdateMetrics(const gfx::Size& size,
-                                           float device_pixel_ratio) {
+                                           float device_scale_factor) {
   if (display::Display::HasForceDeviceScaleFactor())
-    device_pixel_ratio = display::Display::GetForcedDeviceScaleFactor();
-  if (metrics_.size_in_pixels.To<gfx::Size>() == size &&
-      metrics_.device_pixel_ratio == device_pixel_ratio)
+    device_scale_factor = display::Display::GetForcedDeviceScaleFactor();
+  if (metrics_.size_in_pixels == size &&
+      metrics_.device_scale_factor == device_scale_factor)
     return;
-  mojom::ViewportMetrics old_metrics;
-  old_metrics.size_in_pixels = metrics_.size_in_pixels.Clone();
-  old_metrics.device_pixel_ratio = metrics_.device_pixel_ratio;
 
-  metrics_.size_in_pixels = mojo::Size::From(size);
-  metrics_.device_pixel_ratio = device_pixel_ratio;
-
+  ViewportMetrics old_metrics = metrics_;
+  metrics_.size_in_pixels = size;
+  metrics_.device_scale_factor = device_scale_factor;
   delegate_->OnViewportMetricsChanged(old_metrics, metrics_);
 }
 
 std::unique_ptr<cc::CompositorFrame>
 DefaultPlatformDisplay::GenerateCompositorFrame() {
   std::unique_ptr<cc::RenderPass> render_pass = cc::RenderPass::Create();
   render_pass->damage_rect = dirty_rect_;
-  render_pass->output_rect = gfx::Rect(metrics_.size_in_pixels.To<gfx::Size>());
+  render_pass->output_rect = gfx::Rect(metrics_.size_in_pixels);
 
   std::set<WindowId> referenced_window_ids;
   DrawWindowTree(render_pass.get(), delegate_->GetRootWindow(), gfx::Vector2d(),
                  1.0f, &referenced_window_ids);
 
   std::unique_ptr<cc::DelegatedFrameData> frame_data(
       new cc::DelegatedFrameData);
-  frame_data->device_scale_factor = metrics_.device_pixel_ratio;
+  frame_data->device_scale_factor = metrics_.device_scale_factor;
   frame_data->render_pass_list.push_back(std::move(render_pass));
 
   std::unique_ptr<cc::CompositorFrame> frame(new cc::CompositorFrame);
   frame->delegated_frame_data = std::move(frame_data);
   return frame;
 }
 
 void DefaultPlatformDisplay::OnBoundsChanged(const gfx::Rect& new_bounds) {
-  UpdateMetrics(new_bounds.size(), metrics_.device_pixel_ratio);
+  UpdateMetrics(new_bounds.size(), metrics_.device_scale_factor);
 }
 
 void DefaultPlatformDisplay::OnDamageRect(const gfx::Rect& damaged_region) {
   dirty_rect_.Union(damaged_region);
   WantToDraw();
 }
 
 void DefaultPlatformDisplay::DispatchEvent(ui::Event* event) {
   if (event->IsScrollEvent()) {
     // TODO(moshayedi): crbug.com/602859. Dispatch scroll events as
@@ skipping 43 matching lines @@
 
 void DefaultPlatformDisplay::OnWindowStateChanged(
     ui::PlatformWindowState new_state) {}
 
 void DefaultPlatformDisplay::OnLostCapture() {
   delegate_->OnNativeCaptureLost();
 }
 
 void DefaultPlatformDisplay::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget,
-    float device_pixel_ratio) {
+    float device_scale_factor) {
   if (widget != gfx::kNullAcceleratedWidget) {
     display_compositor_.reset(
         new DisplayCompositor(base::ThreadTaskRunnerHandle::Get(), widget,
                               gpu_state_, surfaces_state_));
   }
-  UpdateMetrics(metrics_.size_in_pixels.To<gfx::Size>(), device_pixel_ratio);
+  UpdateMetrics(metrics_.size_in_pixels, device_scale_factor);
 }
 
 void DefaultPlatformDisplay::OnAcceleratedWidgetDestroyed() {
   NOTREACHED();
 }
 
 void DefaultPlatformDisplay::OnActivationChanged(bool active) {}
 
 void DefaultPlatformDisplay::RequestCopyOfOutput(
     std::unique_ptr<cc::CopyOutputRequest> output_request) {
   if (display_compositor_)
     display_compositor_->RequestCopyOfOutput(std::move(output_request));
 }
 
 }  // namespace ws
 
 }  // namespace mus