Implement gfx::Transform StructTraits

components/mus/public/cpp/surfaces/surfaces_type_converters.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/surfaces/surfaces_type_converters.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
 
 #include "base/macros.h"
 #include "cc/output/compositor_frame.h"
 #include "cc/output/compositor_frame_metadata.h"
 #include "cc/output/delegated_frame_data.h"
 #include "cc/quads/debug_border_draw_quad.h"
 #include "cc/quads/draw_quad.h"
 #include "cc/quads/render_pass.h"
 #include "cc/quads/render_pass_draw_quad.h"
 #include "cc/quads/shared_quad_state.h"
 #include "cc/quads/solid_color_draw_quad.h"
 #include "cc/quads/surface_draw_quad.h"
 #include "cc/quads/texture_draw_quad.h"
 #include "cc/quads/tile_draw_quad.h"
 #include "cc/quads/yuv_video_draw_quad.h"
 #include "cc/surfaces/surface_id_allocator.h"
 #include "components/mus/public/cpp/surfaces/custom_surface_converter.h"
-#include "ui/gfx/mojo/transform_type_converters.h"
 
 using mus::mojom::Color;
 using mus::mojom::ColorPtr;
 using mus::mojom::CompositorFrame;
 using mus::mojom::CompositorFramePtr;
 using mus::mojom::CompositorFrameMetadata;
 using mus::mojom::CompositorFrameMetadataPtr;
 using mus::mojom::DebugBorderQuadState;
 using mus::mojom::DebugBorderQuadStatePtr;
 using mus::mojom::Pass;
@@ skipping 44 matching lines @@
               "REC_601 enum value must match");
 // TODO(jamesr): Add REC_709 and JPEG to the YUVColorSpace enum upstream in
 // mojo.
 
 namespace {
 
 cc::SharedQuadState* ConvertSharedQuadState(
     const mus::mojom::SharedQuadStatePtr& input,
     cc::RenderPass* render_pass) {
   cc::SharedQuadState* state = render_pass->CreateAndAppendSharedQuadState();
-  state->SetAll(input->quad_to_target_transform.To<gfx::Transform>(),
-                input->quad_layer_bounds, input->visible_quad_layer_rect,
-                input->clip_rect, input->is_clipped, input->opacity,
+  state->SetAll(input->quad_to_target_transform, input->quad_layer_bounds,
+                input->visible_quad_layer_rect, input->clip_rect,
+                input->is_clipped, input->opacity,
                 static_cast<::SkXfermode::Mode>(input->blend_mode),
                 input->sorting_context_id);
   return state;
 }
 
 bool ConvertDrawQuad(const QuadPtr& input,
                      const CompositorFrameMetadataPtr& metadata,
                      cc::SharedQuadState* sqs,
                      cc::RenderPass* render_pass,
                      CustomSurfaceConverter* custom_converter) {
@@ skipping 237 matching lines @@
       NOTREACHED() << "Unsupported material " << input.material;
   }
   return quad;
 }
 
 // static
 mus::mojom::SharedQuadStatePtr
 TypeConverter<mus::mojom::SharedQuadStatePtr, cc::SharedQuadState>::Convert(
     const cc::SharedQuadState& input) {
   mus::mojom::SharedQuadStatePtr state = SharedQuadState::New();
-  state->quad_to_target_transform =
-      Transform::From(input.quad_to_target_transform);
+  state->quad_to_target_transform = input.quad_to_target_transform;
   state->quad_layer_bounds = input.quad_layer_bounds;
   state->visible_quad_layer_rect = input.visible_quad_layer_rect;
   state->clip_rect = input.clip_rect;
   state->is_clipped = input.is_clipped;
   state->opacity = input.opacity;
   state->blend_mode = static_cast<mus::mojom::SkXfermode>(input.blend_mode);
   state->sorting_context_id = input.sorting_context_id;
   return state;
 }
 
 // static
 PassPtr TypeConverter<PassPtr, cc::RenderPass>::Convert(
     const cc::RenderPass& input) {
   PassPtr pass = Pass::New();
   pass->id = input.id;
   pass->output_rect = input.output_rect;
   pass->damage_rect = input.damage_rect;
-  pass->transform_to_root_target =
-      Transform::From(input.transform_to_root_target);
+  pass->transform_to_root_target = input.transform_to_root_target;
   pass->has_transparent_background = input.has_transparent_background;
   Array<QuadPtr> quads(input.quad_list.size());
   Array<mus::mojom::SharedQuadStatePtr> shared_quad_state(
       input.shared_quad_state_list.size());
   const cc::SharedQuadState* last_sqs = nullptr;
   cc::SharedQuadStateList::ConstIterator next_sqs_iter =
       input.shared_quad_state_list.begin();
   for (auto iter = input.quad_list.cbegin(); iter != input.quad_list.cend();
        ++iter) {
     const cc::DrawQuad& quad = **iter;
@@ skipping 16 matching lines @@
 }
 
 // static
 std::unique_ptr<cc::RenderPass> ConvertToRenderPass(
     const PassPtr& input,
     const CompositorFrameMetadataPtr& metadata,
     CustomSurfaceConverter* custom_converter) {
   std::unique_ptr<cc::RenderPass> pass = cc::RenderPass::Create(
       input->shared_quad_states.size(), input->quads.size());
   pass->SetAll(input->id, input->output_rect, input->damage_rect,
-               input->transform_to_root_target.To<gfx::Transform>(),
+               input->transform_to_root_target,
                input->has_transparent_background);
   for (size_t i = 0; i < input->shared_quad_states.size(); ++i) {
     ConvertSharedQuadState(input->shared_quad_states[i], pass.get());
   }
   cc::SharedQuadStateList::Iterator sqs_iter =
       pass->shared_quad_state_list.begin();
   for (size_t i = 0; i < input->quads.size(); ++i) {
     QuadPtr quad = std::move(input->quads[i]);
     while (quad->shared_quad_state_index > sqs_iter.index()) {
       ++sqs_iter;
@@ skipping 131 matching lines @@
 }
 
 // static
 std::unique_ptr<cc::CompositorFrame>
 TypeConverter<std::unique_ptr<cc::CompositorFrame>,
               CompositorFramePtr>::Convert(const CompositorFramePtr& input) {
   return ConvertToCompositorFrame(input, nullptr);
 }
 
 }  // namespace mojo