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 "mojo/converters/geometry/geometry_type_converters.h"
 #include "mojo/converters/input_events/input_events_type_converters.h"
 #include "services/shell/public/cpp/connector.h"
 #include "ui/events/event.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/geometry/size.h"
 
 namespace mus {
 
 Id MakeTransportId(ConnectionSpecificId connection_id,
                    ConnectionSpecificId local_id) {
@@ skipping 14 matching lines @@
   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.LocalSetViewportMetrics(mojom::ViewportMetrics(),
                                          *window_data->viewport_metrics);
   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 196 matching lines @@
   return HiWord(server_id(window)) == connection_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 connection.
   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,
+                       std::vector<gfx::Rect>(additional_client_areas));

[dcheng, 2016/05/26 22:20:40]

Why is there an explicit copy here?

[Sam McNally, 2016/05/27 03:44:47]

mojo::Array has a std::vector constructor, but it only takes rvalue references.
Thus, converting from a const std::vector& to a mojo::Array requires a copy to
get a non-const std::vector.

[dcheng, 2016/05/27 03:47:54]

Why can't it have a const std::vector<>& version too? At that point, you're
going to have to make it a copy either way, and it seems more idiomatic for that
to happen inside mojo::Array.

[Sam McNally, 2016/05/27 06:34:05]

Done. mojo::Array is getting quite strange now: move-only, but sometimes
cloneable with an explicit Clone(), convertible to and from a sometimes-copyable
vector.

 }
 
 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 connection.
   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 399 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 223 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 93 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