Change mojo geometry structs from using type converters to StructTraits.

components/mus/ws/display.cc

 // Copyright 2015 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/display.h"
 
 #include <set>
 #include <vector>
 
 #include "base/debug/debugger.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/mus/common/types.h"
 #include "components/mus/ws/display_binding.h"
 #include "components/mus/ws/display_manager.h"
 #include "components/mus/ws/focus_controller.h"
 #include "components/mus/ws/platform_display.h"
 #include "components/mus/ws/platform_display_init_params.h"
 #include "components/mus/ws/window_manager_factory_service.h"
 #include "components/mus/ws/window_manager_state.h"
 #include "components/mus/ws/window_server.h"
 #include "components/mus/ws/window_server_delegate.h"
 #include "components/mus/ws/window_tree.h"
 #include "components/mus/ws/window_tree_binding.h"
 #include "mojo/common/common_type_converters.h"
-#include "mojo/converters/geometry/geometry_type_converters.h"
 #include "services/shell/public/interfaces/connector.mojom.h"
 #include "ui/base/cursor/cursor.h"
 
 namespace mus {
 namespace ws {
 
 Display::Display(WindowServer* window_server,
                  const PlatformDisplayInitParams& platform_display_init_params)
     : id_(window_server->display_manager()->GetAndAdvanceNextDisplayId()),
       window_server_(window_server),
@@ skipping 40 matching lines @@
 }
 
 const DisplayManager* Display::display_manager() const {
   return window_server_->display_manager();
 }
 
 mojom::DisplayPtr Display::ToMojomDisplay() const {
   mojom::DisplayPtr display_ptr = mojom::Display::New();
   display_ptr = mojom::Display::New();
   display_ptr->id = id_;
-  display_ptr->bounds = mojo::Rect::New();
   // TODO(sky): Display should know it's origin.
-  display_ptr->bounds->x = 0;
-  display_ptr->bounds->y = 0;
-  display_ptr->bounds->width = root_->bounds().size().width();
-  display_ptr->bounds->height = root_->bounds().size().height();
+  display_ptr->bounds.SetRect(0, 0, root_->bounds().size().width(),
+                              root_->bounds().size().height());
   // TODO(sky): window manager needs an API to set the work area.
-  display_ptr->work_area = display_ptr->bounds.Clone();
+  display_ptr->work_area = display_ptr->bounds;
   display_ptr->device_pixel_ratio =
       platform_display_->GetViewportMetrics().device_pixel_ratio;
   display_ptr->rotation = platform_display_->GetRotation();
   // TODO(sky): make this real.
   display_ptr->is_primary = true;
   // TODO(sky): make this real.
   display_ptr->touch_support = mojom::TouchSupport::UNKNOWN;
   display_ptr->frame_decoration_values = mojom::FrameDecorationValues::New();
-  display_ptr->frame_decoration_values->normal_client_area_insets =
-      mojo::Insets::New();
-  display_ptr->frame_decoration_values->maximized_client_area_insets =
-      mojo::Insets::New();
   return display_ptr;
 }
 
 void Display::SchedulePaint(const ServerWindow* window,
                             const gfx::Rect& bounds) {
   DCHECK(root_->Contains(window));
   platform_display_->SchedulePaint(window, bounds);
 }
 
 void Display::ScheduleSurfaceDestruction(ServerWindow* window) {
@@ skipping 99 matching lines @@
     pair.second->OnWillDestroyTree(tree);
 }
 
 void Display::UpdateNativeCursor(int32_t cursor_id) {
   if (cursor_id != last_cursor_) {
     platform_display_->SetCursorById(cursor_id);
     last_cursor_ = cursor_id;
   }
 }
 
-void Display::SetSize(mojo::SizePtr size) {
-  platform_display_->SetViewportSize(size.To<gfx::Size>());
+void Display::SetSize(const gfx::Size& size) {
+  platform_display_->SetViewportSize(size);
 }
 
 void Display::SetTitle(const mojo::String& title) {
   platform_display_->SetTitle(title.To<base::string16>());
 }
 
 void Display::InitWindowManagersIfNecessary() {
   if (!init_called_ || !root_)
     return;
 
@@ skipping 55 matching lines @@
   display_manager()->DestroyDisplay(this);
 }
 
 void Display::OnViewportMetricsChanged(
     const mojom::ViewportMetrics& old_metrics,
     const mojom::ViewportMetrics& new_metrics) {
   if (!root_) {
     root_.reset(window_server_->CreateServerWindow(
         display_manager()->GetAndAdvanceNextRootId(),
         ServerWindow::Properties()));
-    root_->SetBounds(gfx::Rect(new_metrics.size_in_pixels.To<gfx::Size>()));
+    root_->SetBounds(gfx::Rect(new_metrics.size_in_pixels));
     root_->SetVisible(true);
     focus_controller_.reset(new FocusController(this, root_.get()));
     focus_controller_->AddObserver(this);
     InitWindowManagersIfNecessary();
   } else {
-    root_->SetBounds(gfx::Rect(new_metrics.size_in_pixels.To<gfx::Size>()));
+    root_->SetBounds(gfx::Rect(new_metrics.size_in_pixels));
     const gfx::Rect wm_bounds(root_->bounds().size());
     for (auto& pair : window_manager_state_map_)
       pair.second->root()->SetBounds(wm_bounds);
   }
   // TODO(sky): if bounds changed, then need to update
   // Display/WindowManagerState appropriately (e.g. notify observers).
   window_server_->ProcessViewportMetricsChanged(this, old_metrics, new_metrics);
 }
 
 void Display::OnCompositorFrameDrawn() {
@@ skipping 141 matching lines @@
   DCHECK_EQ(0u, window_manager_state_map_.count(id));
 }
 
 void Display::OnWindowManagerFactorySet(WindowManagerFactoryService* service) {
   if (!binding_)
     CreateWindowManagerStateFromService(service);
 }
 
 }  // namespace ws
 }  // namespace mus