Implement cc::SurfaceId 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>
@@ skipping 33 matching lines @@
 using mus::mojom::RenderPassIdPtr;
 using mus::mojom::RenderPassQuadState;
 using mus::mojom::RenderPassQuadStatePtr;
 using mus::mojom::ResourceFormat;
 using mus::mojom::ReturnedResource;
 using mus::mojom::ReturnedResourcePtr;
 using mus::mojom::SharedQuadState;
 using mus::mojom::SharedQuadStatePtr;
 using mus::mojom::SolidColorQuadState;
 using mus::mojom::SolidColorQuadStatePtr;
-using mus::mojom::SurfaceId;
-using mus::mojom::SurfaceIdPtr;
 using mus::mojom::SurfaceQuadState;
 using mus::mojom::SurfaceQuadStatePtr;
 using mus::mojom::TextureQuadState;
 using mus::mojom::TextureQuadStatePtr;
 using mus::mojom::TileQuadState;
 using mus::mojom::TileQuadStatePtr;
 using mus::mojom::TransferableResource;
 using mus::mojom::TransferableResourcePtr;
 using mus::mojom::YUVColorSpace;
 using mus::mojom::YUVVideoQuadState;
@@ skipping 101 matching lines @@
       if (input->surface_quad_state.is_null())
         return false;
 
       if (custom_converter) {
         return custom_converter->ConvertSurfaceDrawQuad(input, metadata, sqs,
                                                         render_pass);
       }
       cc::SurfaceDrawQuad* surface_quad =
           render_pass->CreateAndAppendDrawQuad<cc::SurfaceDrawQuad>();
       surface_quad->SetAll(
-          sqs,
-          input->rect.To<gfx::Rect>(),
-          input->opaque_rect.To<gfx::Rect>(),
-          input->visible_rect.To<gfx::Rect>(),
-          input->needs_blending,
-          input->surface_quad_state->surface.To<cc::SurfaceId>());
+          sqs, input->rect.To<gfx::Rect>(), input->opaque_rect.To<gfx::Rect>(),
+          input->visible_rect.To<gfx::Rect>(), input->needs_blending,
+          input->surface_quad_state->surface);
       break;
     }
     case mus::mojom::Material::TEXTURE_CONTENT: {
       TextureQuadStatePtr& texture_quad_state =
           input->texture_quad_state;
       if (texture_quad_state.is_null() ||
           texture_quad_state->vertex_opacity.is_null() ||
           texture_quad_state->background_color.is_null())
         return false;
       cc::TextureDrawQuad* texture_quad =
@@ skipping 53 matching lines @@
     default:
       NOTREACHED() << "Unsupported material " << input->material;
       return false;
   }
   return true;
 }
 
 }  // namespace
 
 // static
-SurfaceIdPtr TypeConverter<SurfaceIdPtr, cc::SurfaceId>::Convert(
-    const cc::SurfaceId& input) {
-  SurfaceIdPtr id(SurfaceId::New());
-  id->id_namespace = input.id_namespace();
-  id->local_id = input.local_id();
-  id->nonce = input.nonce();
-  return id;
-}
-
-// static
-cc::SurfaceId TypeConverter<cc::SurfaceId, SurfaceIdPtr>::Convert(
-    const SurfaceIdPtr& input) {
-  return cc::SurfaceId(input->id_namespace, input->local_id, input->nonce);
-}
-
-// static
 ColorPtr TypeConverter<ColorPtr, SkColor>::Convert(const SkColor& input) {
   ColorPtr color(Color::New());
   color->rgba = input;
   return color;
 }
 
 // static
 SkColor TypeConverter<SkColor, ColorPtr>::Convert(const ColorPtr& input) {
   return input->rgba;
 }
@@ skipping 65 matching lines @@
       color_state->force_anti_aliasing_off =
           color_quad->force_anti_aliasing_off;
       quad->solid_color_quad_state = std::move(color_state);
       break;
     }
     case cc::DrawQuad::SURFACE_CONTENT: {
       const cc::SurfaceDrawQuad* surface_quad =
           cc::SurfaceDrawQuad::MaterialCast(&input);
       SurfaceQuadStatePtr surface_state =
           SurfaceQuadState::New();
-      surface_state->surface = SurfaceId::From(surface_quad->surface_id);
+      surface_state->surface = surface_quad->surface_id;
       quad->surface_quad_state = std::move(surface_state);
       break;
     }
     case cc::DrawQuad::TEXTURE_CONTENT: {
       const cc::TextureDrawQuad* texture_quad =
           cc::TextureDrawQuad::MaterialCast(&input);
       TextureQuadStatePtr texture_state = TextureQuadState::New();
       texture_state->resource_id = texture_quad->resource_id();
       texture_state->premultiplied_alpha = texture_quad->premultiplied_alpha;
       texture_state->uv_top_left = PointF::From(texture_quad->uv_top_left);
@@ skipping 258 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