Change mojo geometry structs from using type converters to StructTraits.

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"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "components/mus/gles2/gpu_state.h"
 #include "components/mus/public/interfaces/gpu.mojom.h"
 #include "components/mus/public/interfaces/quads.mojom.h"
 #include "components/mus/surfaces/display_compositor.h"
 #include "components/mus/surfaces/surfaces_state.h"
 #include "components/mus/ws/platform_display_factory.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_surface.h"
 #include "components/mus/ws/server_window_surface_manager.h"
 #include "components/mus/ws/window_coordinate_conversions.h"
-#include "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "mojo/converters/input_events/mojo_extended_key_event_data.h"
 #include "mojo/converters/surfaces/surfaces_type_converters.h"
 #include "mojo/converters/surfaces/surfaces_utils.h"
 #include "mojo/converters/transform/transform_type_converters.h"
 #include "services/shell/public/cpp/connection.h"
 #include "services/shell/public/cpp/connector.h"
 #include "third_party/skia/include/core/SkXfermode.h"
 #include "ui/base/cursor/cursor_loader.h"
 #include "ui/display/display.h"
 #include "ui/events/event.h"
 #include "ui/events/event_utils.h"
 #include "ui/platform_window/platform_ime_controller.h"
 #include "ui/platform_window/platform_window.h"
 
 #if defined(OS_WIN)
 #include "ui/platform_window/win/win_window.h"
 #elif defined(USE_X11)
 #include "ui/platform_window/x11/x11_window.h"
 #elif defined(OS_ANDROID)
 #include "ui/platform_window/android/platform_window_android.h"
 #elif defined(USE_OZONE)
 #include "ui/ozone/public/ozone_platform.h"
 #endif
 
-using mojo::Rect;
-using mojo::Size;
-
 namespace mus {
 
 namespace ws {
 namespace {
 
 // DrawWindowTree recursively visits ServerWindows, creating a SurfaceDrawQuad
 // for each that lacks one. A ServerWindow may hold a CompositorFrame that
 // references other ServerWindows in SurfaceDrawQuads. We should not create new
 // SurfaceDrawQuads for these |referenced_window_ids|. Instead,
 // cc::SurfaceAggregator will do the heavy lifting here by expanding those
@@ skipping 104 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.SetSize(init_params.display_bounds.width(),
+                                  init_params.display_bounds.height());
   // 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 114 matching lines @@
   // 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) {
   if (display::Display::HasForceDeviceScaleFactor())
     device_pixel_ratio = display::Display::GetForcedDeviceScaleFactor();
-  if (metrics_.size_in_pixels.To<gfx::Size>() == size &&
+  if (metrics_.size_in_pixels == size &&
       metrics_.device_pixel_ratio == device_pixel_ratio)
     return;
   mojom::ViewportMetrics old_metrics;
-  old_metrics.size_in_pixels = metrics_.size_in_pixels.Clone();
+  old_metrics.size_in_pixels = metrics_.size_in_pixels;
   old_metrics.device_pixel_ratio = metrics_.device_pixel_ratio;
 
-  metrics_.size_in_pixels = mojo::Size::From(size);
+  metrics_.size_in_pixels = size;
   metrics_.device_pixel_ratio = device_pixel_ratio;
 
   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->render_pass_list.push_back(std::move(render_pass));
 
@@ skipping 66 matching lines @@
 }
 
 void DefaultPlatformDisplay::OnAcceleratedWidgetAvailable(
     gfx::AcceleratedWidget widget,
     float device_pixel_ratio) {
   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_pixel_ratio);
 }
 
 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