components/mus/public/interfaces View => Window

mojo/converters/surfaces/surfaces_type_converters.h

Index: mojo/converters/surfaces/surfaces_type_converters.h
diff --git a/mojo/converters/surfaces/surfaces_type_converters.h b/mojo/converters/surfaces/surfaces_type_converters.h
index 081ad12b8cc838ab38b6d7935bc7552ad6fbad44..4bcb0db2b5d5248419e6e3c8bb75033ef7c5521c 100644
--- a/mojo/converters/surfaces/surfaces_type_converters.h
+++ b/mojo/converters/surfaces/surfaces_type_converters.h
@@ -32,157 +32,176 @@ class CustomSurfaceConverter;
 
 // Types from surface_id.mojom
 template <>
-struct MOJO_SURFACES_EXPORT TypeConverter<SurfaceIdPtr, cc::SurfaceId> {
-  static SurfaceIdPtr Convert(const cc::SurfaceId& input);
+struct MOJO_SURFACES_EXPORT
+    TypeConverter<mus::mojom::SurfaceIdPtr, cc::SurfaceId> {
+  static mus::mojom::SurfaceIdPtr Convert(const cc::SurfaceId& input);
 };
 template <>
-struct MOJO_SURFACES_EXPORT TypeConverter<cc::SurfaceId, SurfaceIdPtr> {
-  static cc::SurfaceId Convert(const SurfaceIdPtr& input);
+struct MOJO_SURFACES_EXPORT
+    TypeConverter<cc::SurfaceId, mus::mojom::SurfaceIdPtr> {
+  static cc::SurfaceId Convert(const mus::mojom::SurfaceIdPtr& input);
 };
 
 // Types from quads.mojom
 template <>
-struct MOJO_SURFACES_EXPORT TypeConverter<ColorPtr, SkColor> {
-  static ColorPtr Convert(const SkColor& input);
+struct MOJO_SURFACES_EXPORT TypeConverter<mus::mojom::ColorPtr, SkColor> {
+  static mus::mojom::ColorPtr Convert(const SkColor& input);
 };
 template <>
-struct MOJO_SURFACES_EXPORT TypeConverter<SkColor, ColorPtr> {
-  static SkColor Convert(const ColorPtr& input);
+struct MOJO_SURFACES_EXPORT TypeConverter<SkColor, mus::mojom::ColorPtr> {
+  static SkColor Convert(const mus::mojom::ColorPtr& input);
 };
 
 template <>
-struct MOJO_SURFACES_EXPORT TypeConverter<RenderPassIdPtr, cc::RenderPassId> {
-  static RenderPassIdPtr Convert(const cc::RenderPassId& input);
+struct MOJO_SURFACES_EXPORT
+    TypeConverter<mus::mojom::RenderPassIdPtr, cc::RenderPassId> {
+  static mus::mojom::RenderPassIdPtr Convert(const cc::RenderPassId& input);
 };
 
 template <>
-struct MOJO_SURFACES_EXPORT TypeConverter<cc::RenderPassId, RenderPassIdPtr> {
-  static cc::RenderPassId Convert(const RenderPassIdPtr& input);
+struct MOJO_SURFACES_EXPORT
+    TypeConverter<cc::RenderPassId, mus::mojom::RenderPassIdPtr> {
+  static cc::RenderPassId Convert(const mus::mojom::RenderPassIdPtr& input);
 };
 
 template <>
-struct MOJO_SURFACES_EXPORT TypeConverter<QuadPtr, cc::DrawQuad> {
-  static QuadPtr Convert(const cc::DrawQuad& input);
+struct MOJO_SURFACES_EXPORT TypeConverter<mus::mojom::QuadPtr, cc::DrawQuad> {
+  static mus::mojom::QuadPtr Convert(const cc::DrawQuad& input);
 };
 
 template <>
 struct MOJO_SURFACES_EXPORT
-TypeConverter<SharedQuadStatePtr, cc::SharedQuadState> {
-  static SharedQuadStatePtr Convert(const cc::SharedQuadState& input);
+    TypeConverter<mus::mojom::SharedQuadStatePtr, cc::SharedQuadState> {
+  static mus::mojom::SharedQuadStatePtr Convert(
+      const cc::SharedQuadState& input);
 };
 
 scoped_ptr<cc::RenderPass> ConvertToRenderPass(
-    const mojo::PassPtr& input,
-    const mojo::CompositorFrameMetadataPtr& metadata,
+    const mus::mojom::PassPtr& input,
+    const mus::mojom::CompositorFrameMetadataPtr& metadata,
     CustomSurfaceConverter* custom_converter);
 
 template <>
-struct MOJO_SURFACES_EXPORT TypeConverter<PassPtr, cc::RenderPass> {
-  static PassPtr Convert(const cc::RenderPass& input);
+struct MOJO_SURFACES_EXPORT TypeConverter<mus::mojom::PassPtr, cc::RenderPass> {
+  static mus::mojom::PassPtr Convert(const cc::RenderPass& input);
 };
 
 template <>
-struct MOJO_SURFACES_EXPORT TypeConverter<scoped_ptr<cc::RenderPass>, PassPtr> {
-  static scoped_ptr<cc::RenderPass> Convert(const PassPtr& input);
+struct MOJO_SURFACES_EXPORT
+    TypeConverter<scoped_ptr<cc::RenderPass>, mus::mojom::PassPtr> {
+  static scoped_ptr<cc::RenderPass> Convert(const mus::mojom::PassPtr& input);
 };
 
 // Types from compositor_frame.mojom
 template <>
-struct MOJO_SURFACES_EXPORT TypeConverter<MailboxPtr, gpu::Mailbox> {
-  static MailboxPtr Convert(const gpu::Mailbox& input);
+struct MOJO_SURFACES_EXPORT
+    TypeConverter<mus::mojom::MailboxPtr, gpu::Mailbox> {
+  static mus::mojom::MailboxPtr Convert(const gpu::Mailbox& input);
 };
 template <>
-struct MOJO_SURFACES_EXPORT TypeConverter<gpu::Mailbox, MailboxPtr> {
-  static gpu::Mailbox Convert(const MailboxPtr& input);
+struct MOJO_SURFACES_EXPORT
+    TypeConverter<gpu::Mailbox, mus::mojom::MailboxPtr> {
+  static gpu::Mailbox Convert(const mus::mojom::MailboxPtr& input);
 };
 
 template <>
 struct MOJO_SURFACES_EXPORT
-TypeConverter<MailboxHolderPtr, gpu::MailboxHolder> {
-  static MailboxHolderPtr Convert(const gpu::MailboxHolder& input);
+    TypeConverter<mus::mojom::MailboxHolderPtr, gpu::MailboxHolder> {
+  static mus::mojom::MailboxHolderPtr Convert(const gpu::MailboxHolder& input);
 };
 template <>
 struct MOJO_SURFACES_EXPORT
-TypeConverter<gpu::MailboxHolder, MailboxHolderPtr> {
-  static gpu::MailboxHolder Convert(const MailboxHolderPtr& input);
+    TypeConverter<gpu::MailboxHolder, mus::mojom::MailboxHolderPtr> {
+  static gpu::MailboxHolder Convert(const mus::mojom::MailboxHolderPtr& input);
 };
 
 template <>
-struct MOJO_SURFACES_EXPORT
-TypeConverter<TransferableResourcePtr, cc::TransferableResource> {
-  static TransferableResourcePtr Convert(const cc::TransferableResource& input);
+struct MOJO_SURFACES_EXPORT TypeConverter<mus::mojom::TransferableResourcePtr,
+                                          cc::TransferableResource> {
+  static mus::mojom::TransferableResourcePtr Convert(
+      const cc::TransferableResource& input);
 };
 template <>
-struct MOJO_SURFACES_EXPORT
-TypeConverter<cc::TransferableResource, TransferableResourcePtr> {
-  static cc::TransferableResource Convert(const TransferableResourcePtr& input);
+struct MOJO_SURFACES_EXPORT TypeConverter<cc::TransferableResource,
+                                          mus::mojom::TransferableResourcePtr> {
+  static cc::TransferableResource Convert(
+      const mus::mojom::TransferableResourcePtr& input);
 };
 
 template <>
 struct MOJO_SURFACES_EXPORT
-TypeConverter<Array<TransferableResourcePtr>, cc::TransferableResourceArray> {
-  static Array<TransferableResourcePtr> Convert(
+    TypeConverter<Array<mus::mojom::TransferableResourcePtr>,
+                  cc::TransferableResourceArray> {
+  static Array<mus::mojom::TransferableResourcePtr> Convert(
       const cc::TransferableResourceArray& input);
 };
 template <>
 struct MOJO_SURFACES_EXPORT
-TypeConverter<cc::TransferableResourceArray, Array<TransferableResourcePtr> > {
+    TypeConverter<cc::TransferableResourceArray,
+                  Array<mus::mojom::TransferableResourcePtr>> {
   static cc::TransferableResourceArray Convert(
-      const Array<TransferableResourcePtr>& input);
+      const Array<mus::mojom::TransferableResourcePtr>& input);
 };
 
 template <>
 struct MOJO_SURFACES_EXPORT
-TypeConverter<ReturnedResourcePtr, cc::ReturnedResource> {
-  static ReturnedResourcePtr Convert(const cc::ReturnedResource& input);
+    TypeConverter<mus::mojom::ReturnedResourcePtr, cc::ReturnedResource> {
+  static mus::mojom::ReturnedResourcePtr Convert(
+      const cc::ReturnedResource& input);
 };
 template <>
 struct MOJO_SURFACES_EXPORT
-TypeConverter<cc::ReturnedResource, ReturnedResourcePtr> {
-  static cc::ReturnedResource Convert(const ReturnedResourcePtr& input);
+    TypeConverter<cc::ReturnedResource, mus::mojom::ReturnedResourcePtr> {
+  static cc::ReturnedResource Convert(
+      const mus::mojom::ReturnedResourcePtr& input);
 };
 
 template <>
 struct MOJO_SURFACES_EXPORT
-TypeConverter<Array<ReturnedResourcePtr>, cc::ReturnedResourceArray> {
-  static Array<ReturnedResourcePtr> Convert(
+    TypeConverter<Array<mus::mojom::ReturnedResourcePtr>,
+                  cc::ReturnedResourceArray> {
+  static Array<mus::mojom::ReturnedResourcePtr> Convert(
       const cc::ReturnedResourceArray& input);
 };
 template <>
 struct MOJO_SURFACES_EXPORT
-    TypeConverter<cc::ReturnedResourceArray, Array<ReturnedResourcePtr>> {
+    TypeConverter<cc::ReturnedResourceArray,
+                  Array<mus::mojom::ReturnedResourcePtr>> {
   static cc::ReturnedResourceArray Convert(
-      const Array<ReturnedResourcePtr>& input);
+      const Array<mus::mojom::ReturnedResourcePtr>& input);
 };
 
 template <>
 struct MOJO_SURFACES_EXPORT
-    TypeConverter<CompositorFrameMetadataPtr, cc::CompositorFrameMetadata> {
-  static CompositorFrameMetadataPtr Convert(
+    TypeConverter<mus::mojom::CompositorFrameMetadataPtr,
+                  cc::CompositorFrameMetadata> {
+  static mus::mojom::CompositorFrameMetadataPtr Convert(
       const cc::CompositorFrameMetadata& input);
 };
 template <>
 struct MOJO_SURFACES_EXPORT
-    TypeConverter<cc::CompositorFrameMetadata, CompositorFrameMetadataPtr> {
+    TypeConverter<cc::CompositorFrameMetadata,
+                  mus::mojom::CompositorFrameMetadataPtr> {
   static cc::CompositorFrameMetadata Convert(
-      const CompositorFrameMetadataPtr& input);
+      const mus::mojom::CompositorFrameMetadataPtr& input);
 };
 
 scoped_ptr<cc::CompositorFrame> ConvertToCompositorFrame(
-    const mojo::CompositorFramePtr& input,
+    const mus::mojom::CompositorFramePtr& input,
     CustomSurfaceConverter* custom_converter);
 
 template <>
 struct MOJO_SURFACES_EXPORT
-TypeConverter<CompositorFramePtr, cc::CompositorFrame> {
-  static CompositorFramePtr Convert(const cc::CompositorFrame& input);
+    TypeConverter<mus::mojom::CompositorFramePtr, cc::CompositorFrame> {
+  static mus::mojom::CompositorFramePtr Convert(
+      const cc::CompositorFrame& input);
 };
 
 template <>
-struct MOJO_SURFACES_EXPORT
-TypeConverter<scoped_ptr<cc::CompositorFrame>, CompositorFramePtr> {
+struct MOJO_SURFACES_EXPORT TypeConverter<scoped_ptr<cc::CompositorFrame>,
+                                          mus::mojom::CompositorFramePtr> {
   static scoped_ptr<cc::CompositorFrame> Convert(
-      const CompositorFramePtr& input);
+      const mus::mojom::CompositorFramePtr& input);
 };
 
 }  // namespace mojo