Change mojo geometry structs from using type converters to StructTraits.

components/mus/public/cpp/lib/window_tree_client_impl.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/public/cpp/lib/window_tree_client_impl.h"
 
 #include <stddef.h>
 
 #include <string>
 #include <utility>
 #include <vector>
 
 #include "base/bind.h"
 #include "base/memory/ptr_util.h"
 #include "components/mus/common/util.h"
 #include "components/mus/public/cpp/input_event_handler.h"
 #include "components/mus/public/cpp/lib/in_flight_change.h"
 #include "components/mus/public/cpp/lib/window_private.h"
 #include "components/mus/public/cpp/window_manager_delegate.h"
 #include "components/mus/public/cpp/window_observer.h"
 #include "components/mus/public/cpp/window_tracker.h"
 #include "components/mus/public/cpp/window_tree_connection.h"
 #include "components/mus/public/cpp/window_tree_connection_observer.h"
 #include "components/mus/public/cpp/window_tree_delegate.h"
 #include "services/shell/public/cpp/connector.h"
 #include "ui/events/event.h"
 #include "ui/events/mojo/input_events_type_converters.h"
 #include "ui/gfx/geometry/insets.h"
-#include "ui/gfx/geometry/mojo/geometry_type_converters.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace mus {
 
 Id MakeTransportId(ClientSpecificId client_id, ClientSpecificId local_id) {
   return (client_id << 16) | local_id;
 }
 
 Id server_id(Window* window) {
   return WindowPrivate(window).server_id();
 }
 
 // Helper called to construct a local window object from transport data.
 Window* AddWindowToClient(WindowTreeClientImpl* client,
                           Window* parent,
                           const mojom::WindowDataPtr& window_data) {
   // We don't use the ctor that takes a WindowTreeConnection here, since it
   // will call back to the service and attempt to create a new window.
   Window* window = WindowPrivate::LocalCreate();
   WindowPrivate private_window(window);
   private_window.set_connection(client);
   private_window.set_server_id(window_data->window_id);
   private_window.set_visible(window_data->visible);
   private_window.set_properties(
       window_data->properties
           .To<std::map<std::string, std::vector<uint8_t>>>());
   client->AddWindow(window);
-  private_window.LocalSetBounds(gfx::Rect(),
-                                window_data->bounds.To<gfx::Rect>());
+  private_window.LocalSetBounds(gfx::Rect(), window_data->bounds);
   if (parent)
     WindowPrivate(parent).LocalAddChild(window);
   return window;
 }
 
 Window* BuildWindowTree(WindowTreeClientImpl* client,
                         const mojo::Array<mojom::WindowDataPtr>& windows,
                         Window* initial_parent) {
   std::vector<Window*> parents;
   Window* root = NULL;
@@ skipping 186 matching lines @@
   return HiWord(server_id(window)) == client_id_ &&
          roots_.count(window) == 0;
 }
 
 void WindowTreeClientImpl::SetBounds(Window* window,
                                      const gfx::Rect& old_bounds,
                                      const gfx::Rect& bounds) {
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
       base::WrapUnique(new InFlightBoundsChange(window, old_bounds)));
-  tree_->SetWindowBounds(change_id, server_id(window),
-                         mojo::Rect::From(bounds));
+  tree_->SetWindowBounds(change_id, server_id(window), bounds);
 }
 
 void WindowTreeClientImpl::SetCapture(Window* window) {
   // In order for us to get here we had to have exposed a window, which implies
   // we got a client.
   DCHECK(tree_);
   if (capture_window_ == window)
     return;
   const uint32_t change_id = ScheduleInFlightChange(
       base::WrapUnique(new InFlightCaptureChange(this, capture_window_)));
@@ skipping 11 matching lines @@
       base::WrapUnique(new InFlightCaptureChange(this, window)));
   tree_->ReleaseCapture(change_id, server_id(window));
   LocalSetCapture(nullptr);
 }
 
 void WindowTreeClientImpl::SetClientArea(
     Id window_id,
     const gfx::Insets& client_area,
     const std::vector<gfx::Rect>& additional_client_areas) {
   DCHECK(tree_);
-  tree_->SetClientArea(
-      window_id, mojo::Insets::From(client_area),
-      mojo::Array<mojo::RectPtr>::From(additional_client_areas));
+  tree_->SetClientArea(window_id, client_area, additional_client_areas);
 }
 
 void WindowTreeClientImpl::SetHitTestMask(Id window_id, const gfx::Rect& mask) {
   DCHECK(tree_);
-  tree_->SetHitTestMask(window_id, mojo::Rect::From(mask));
+  tree_->SetHitTestMask(window_id, mask);
 }
 
 void WindowTreeClientImpl::ClearHitTestMask(Id window_id) {
   DCHECK(tree_);
-  tree_->SetHitTestMask(window_id, nullptr);
+  tree_->SetHitTestMask(window_id, {});
 }
 
 void WindowTreeClientImpl::SetFocus(Window* window) {
   // In order for us to get here we had to have exposed a window, which implies
   // we got a client.
   DCHECK(tree_);
   const uint32_t change_id = ScheduleInFlightChange(
       base::WrapUnique(new InFlightFocusChange(this, focused_window_)));
   tree_->SetFocus(change_id, window ? server_id(window) : 0);
   LocalSetFocus(window);
@@ skipping 414 matching lines @@
   if (data->visible) {
     InFlightVisibleChange visible_change(window, data->visible);
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(visible_change);
     if (current_change)
       current_change->SetRevertValueFrom(visible_change);
     else
       window_private.LocalSetVisible(true);
   }
 
-  const gfx::Rect bounds(data->bounds.To<gfx::Rect>());
+  const gfx::Rect bounds(data->bounds);
   {
     InFlightBoundsChange bounds_change(window, bounds);
     InFlightChange* current_change =
         GetOldestInFlightChangeMatching(bounds_change);
     if (current_change)
       current_change->SetRevertValueFrom(bounds_change);
     else if (window->bounds() != bounds)
       window_private.LocalSetBounds(window->bounds(), bounds);
   }
 
@@ skipping 10 matching lines @@
       current_change->SetRevertValueFrom(property_change);
     else
       window_private.LocalSetSharedProperty(pair.first, &(pair.second));
   }
 
   // Top level windows should not have a parent.
   DCHECK_EQ(0u, data->parent_id);
 }
 
 void WindowTreeClientImpl::OnWindowBoundsChanged(Id window_id,
-                                                 mojo::RectPtr old_bounds,
-                                                 mojo::RectPtr new_bounds) {
+                                                 const gfx::Rect& old_bounds,
+                                                 const gfx::Rect& new_bounds) {
   Window* window = GetWindowByServerId(window_id);
   if (!window)
     return;
 
-  InFlightBoundsChange new_change(window, new_bounds.To<gfx::Rect>());
+  InFlightBoundsChange new_change(window, new_bounds);
   if (ApplyServerChangeToExistingInFlightChange(new_change))
     return;
 
-  WindowPrivate(window)
-      .LocalSetBounds(old_bounds.To<gfx::Rect>(), new_bounds.To<gfx::Rect>());
+  WindowPrivate(window).LocalSetBounds(old_bounds, new_bounds);
 }
 
 void WindowTreeClientImpl::OnClientAreaChanged(
     uint32_t window_id,
-    mojo::InsetsPtr new_client_area,
-    mojo::Array<mojo::RectPtr> new_additional_client_areas) {
+    const gfx::Insets& new_client_area,
+    mojo::Array<gfx::Rect> new_additional_client_areas) {
   Window* window = GetWindowByServerId(window_id);
   if (window) {
     WindowPrivate(window).LocalSetClientArea(
-        new_client_area.To<gfx::Insets>(),
+        new_client_area,
         new_additional_client_areas.To<std::vector<gfx::Rect>>());
   }
 }
 
 void WindowTreeClientImpl::OnTransientWindowAdded(
     uint32_t window_id,
     uint32_t transient_window_id) {
   Window* window = GetWindowByServerId(window_id);
   Window* transient_window = GetWindowByServerId(transient_window_id);
   // window or transient_window or both may be null if a local delete occurs
@@ skipping 199 matching lines @@
   Window* window = GetWindowByServerId(window_id);
   if (!window || !IsRoot(window))
     return;
 
   FOR_EACH_OBSERVER(WindowObserver, *WindowPrivate(window).observers(),
                     OnRequestClose(window));
 }
 
 void WindowTreeClientImpl::WmSetBounds(uint32_t change_id,
                                        Id window_id,
-                                       mojo::RectPtr transit_bounds) {
+                                       const gfx::Rect& transit_bounds) {
   Window* window = GetWindowByServerId(window_id);
   bool result = false;
   if (window) {
     DCHECK(window_manager_delegate_);
-    gfx::Rect bounds = transit_bounds.To<gfx::Rect>();
+    gfx::Rect bounds = transit_bounds;
     result = window_manager_delegate_->OnWmSetBounds(window, &bounds);
     if (result) {
       // If the resulting bounds differ return false. Returning false ensures
       // the client applies the bounds we set below.
-      result = bounds == transit_bounds.To<gfx::Rect>();
+      result = bounds == transit_bounds;
       window->SetBounds(bounds);
     }
   }
   if (window_manager_internal_client_)
     window_manager_internal_client_->WmResponse(change_id, result);
 }
 
 void WindowTreeClientImpl::WmSetProperty(uint32_t change_id,
                                          Id window_id,
                                          const mojo::String& name,
@@ skipping 92 matching lines @@
   if (window_manager_internal_client_)
     window_manager_internal_client_->ActivateNextWindow();
 }
 
 void WindowTreeClientImpl::SetUnderlaySurfaceOffsetAndExtendedHitArea(
     Window* window,
     const gfx::Vector2d& offset,
     const gfx::Insets& hit_area) {
   if (window_manager_internal_client_) {
     window_manager_internal_client_->SetUnderlaySurfaceOffsetAndExtendedHitArea(
-        server_id(window), offset.x(), offset.y(),
-        mojo::Insets::From(hit_area));
+        server_id(window), offset.x(), offset.y(), hit_area);
   }
 }
 
 }  // namespace mus