Change mojo geometry structs from using type converters to StructTraits.

components/mus/ws/window_tree.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/window_tree.h"
 
 #include <stddef.h>
 
 #include <utility>
 
@@ skipping 10 matching lines @@
 #include "components/mus/ws/operation.h"
 #include "components/mus/ws/platform_display.h"
 #include "components/mus/ws/server_window.h"
 #include "components/mus/ws/server_window_observer.h"
 #include "components/mus/ws/user_display_manager.h"
 #include "components/mus/ws/window_manager_state.h"
 #include "components/mus/ws/window_server.h"
 #include "components/mus/ws/window_tree_binding.h"
 #include "ui/display/display.h"
 #include "ui/events/mojo/input_events_type_converters.h"
-#include "ui/gfx/geometry/mojo/geometry_type_converters.h"
 #include "ui/platform_window/mojo/ime_type_converters.h"
 #include "ui/platform_window/text_input_state.h"
 
 using mojo::Array;
 using mojo::Callback;
 using mojo::InterfaceRequest;
-using mojo::Rect;
 using mojo::String;
 
 namespace mus {
 namespace ws {
 
 class TargetedEvent : public ServerWindowObserver {
  public:
   TargetedEvent(ServerWindow* target, const ui::Event& event)
       : target_(target), event_(ui::Event::Clone(event)) {
     target_->AddObserver(this);
@@ skipping 364 matching lines @@
   }
 }
 
 void WindowTree::ProcessWindowBoundsChanged(const ServerWindow* window,
                                             const gfx::Rect& old_bounds,
                                             const gfx::Rect& new_bounds,
                                             bool originated_change) {
   ClientWindowId client_window_id;
   if (originated_change || !IsWindowKnown(window, &client_window_id))
     return;
-  client()->OnWindowBoundsChanged(client_window_id.id, Rect::From(old_bounds),
-                                  Rect::From(new_bounds));
+  client()->OnWindowBoundsChanged(client_window_id.id, old_bounds, new_bounds);
 }
 
 void WindowTree::ProcessClientAreaChanged(
     const ServerWindow* window,
     const gfx::Insets& new_client_area,
     const std::vector<gfx::Rect>& new_additional_client_areas,
     bool originated_change) {
   ClientWindowId client_window_id;
   if (originated_change || !IsWindowKnown(window, &client_window_id))
     return;
   client()->OnClientAreaChanged(
-      client_window_id.id, mojo::Insets::From(new_client_area),
-      mojo::Array<mojo::RectPtr>::From(new_additional_client_areas));
+      client_window_id.id, new_client_area,
+      std::vector<gfx::Rect>(new_additional_client_areas));
 }
 
 void WindowTree::ProcessWillChangeWindowHierarchy(
     const ServerWindow* window,
     const ServerWindow* new_parent,
     const ServerWindow* old_parent,
     bool originated_change) {
   if (originated_change)
     return;
 
@@ skipping 410 matching lines @@
   const ServerWindow* parent = window->parent();
   // If the parent isn't known, it means the parent is not visible to us (not
   // in roots), and should not be sent over.
   if (parent && !IsWindowKnown(parent))
     parent = nullptr;
   mojom::WindowDataPtr window_data(mojom::WindowData::New());
   window_data->parent_id =
       parent ? ClientWindowIdForWindow(parent).id : ClientWindowId().id;
   window_data->window_id =
       window ? ClientWindowIdForWindow(window).id : ClientWindowId().id;
-  window_data->bounds = Rect::From(window->bounds());
+  window_data->bounds = window->bounds();
   window_data->properties =
       mojo::Map<String, Array<uint8_t>>::From(window->properties());
   window_data->visible = window->visible();
   return window_data;
 }
 
 void WindowTree::GetWindowTreeImpl(
     const ServerWindow* window,
     std::vector<const ServerWindow*>* windows) const {
   DCHECK(window);
@@ skipping 283 matching lines @@
     DVLOG(1) << "SetEventObserver event type not allowed";
     return;
   }
 
   event_observer_matcher_.reset(new EventMatcher(*matcher));
   event_observer_id_ = observer_id;
 }
 
 void WindowTree::SetWindowBounds(uint32_t change_id,
                                  Id window_id,
-                                 mojo::RectPtr bounds) {
+                                 const gfx::Rect& bounds) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   if (window && ShouldRouteToWindowManager(window)) {
     const uint32_t wm_change_id =
         window_server_->GenerateWindowManagerChangeId(this, change_id);
     // |window_id| may be a client id, use the id from the window to ensure
     // the windowmanager doesn't get an id it doesn't know about.
     WindowManagerState* wms = display_manager()
                                   ->GetWindowManagerAndDisplay(window)
                                   .window_manager_state;
     wms->tree()->window_manager_internal_->WmSetBounds(
         wm_change_id, wms->tree()->ClientWindowIdForWindow(window).id,
         std::move(bounds));
     return;
   }
 
   // Only the owner of the window can change the bounds.
   bool success = window && access_policy_->CanSetWindowBounds(window);
   if (success) {
     Operation op(this, window_server_, OperationType::SET_WINDOW_BOUNDS);
-    window->SetBounds(bounds.To<gfx::Rect>());
+    window->SetBounds(bounds);
   }
   client()->OnChangeCompleted(change_id, success);
 }
 
 void WindowTree::SetWindowVisibility(uint32_t change_id,
                                      Id transport_window_id,
                                      bool visible) {
   client()->OnChangeCompleted(
       change_id,
       SetWindowVisibility(ClientWindowId(transport_window_id), visible));
@@ skipping 101 matching lines @@
       target = targeted_event->target();
       event = targeted_event->TakeEvent();
     } while (!event_queue_.empty() && !GetDisplay(target));
     if (target)
       DispatchInputEventImpl(target, *event);
   }
 }
 
 void WindowTree::SetClientArea(
     Id transport_window_id,
-    mojo::InsetsPtr insets,
-    mojo::Array<mojo::RectPtr> transport_additional_client_areas) {
+    const gfx::Insets& insets,
+    mojo::Array<gfx::Rect> transport_additional_client_areas) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   if (!window || !access_policy_->CanSetClientArea(window))
     return;
 
   std::vector<gfx::Rect> additional_client_areas =
       transport_additional_client_areas.To<std::vector<gfx::Rect>>();
-  window->SetClientArea(insets.To<gfx::Insets>(), additional_client_areas);
+  window->SetClientArea(insets, additional_client_areas);
 }
 
-void WindowTree::SetHitTestMask(Id transport_window_id, mojo::RectPtr mask) {
+void WindowTree::SetHitTestMask(Id transport_window_id, const gfx::Rect& mask) {
   ServerWindow* window =
       GetWindowByClientId(ClientWindowId(transport_window_id));
   if (!window || !access_policy_->CanSetHitTestMask(window)) {
     DVLOG(1) << "SetHitTestMask failed";
     return;
   }
 
-  if (mask)
-    window->SetHitTestMask(mask.To<gfx::Rect>());
+  if (!mask.IsEmpty())
+    window->SetHitTestMask(mask);
   else
     window->ClearHitTestMask();
 }
 
 void WindowTree::Embed(Id transport_window_id,
                        mojom::WindowTreeClientPtr client,
                        const EmbedCallback& callback) {
   callback.Run(Embed(ClientWindowId(transport_window_id), std::move(client)));
 }
 
@@ skipping 77 matching lines @@
   Display* display = GetDisplayForWindowManager();
   if (!display)
     return;
   display->ActivateNextWindow();
 }
 
 void WindowTree::SetUnderlaySurfaceOffsetAndExtendedHitArea(
     Id window_id,
     int32_t x_offset,
     int32_t y_offset,
-    mojo::InsetsPtr hit_area) {
+    const gfx::Insets& hit_area) {
   ServerWindow* window = GetWindowByClientId(ClientWindowId(window_id));
   if (!window)
     return;
 
   window->SetUnderlayOffset(gfx::Vector2d(x_offset, y_offset));
-  window->set_extended_hit_test_region(hit_area.To<gfx::Insets>());
+  window->set_extended_hit_test_region(hit_area);
 }
 
 void WindowTree::WmResponse(uint32_t change_id, bool response) {
   // TODO(sky): think about what else case means.
   if (GetDisplayForWindowManager())
     window_server_->WindowManagerChangeCompleted(change_id, response);
 }
 
 void WindowTree::WmRequestClose(Id transport_window_id) {
   // Only the WindowManager should be using this.
@@ skipping 51 matching lines @@
 }
 
 bool WindowTree::IsWindowRootOfAnotherTreeForAccessPolicy(
     const ServerWindow* window) const {
   WindowTree* tree = window_server_->GetTreeWithRoot(window);
   return tree && tree != this;
 }
 
 }  // namespace ws
 }  // namespace mus