Change mojo geometry structs from using type converters to StructTraits.

media/mojo/common/media_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 "media/mojo/common/media_type_converters.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include "base/memory/ptr_util.h"
 #include "base/numerics/safe_conversions.h"
 #include "media/base/audio_buffer.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/buffering_state.h"
 #include "media/base/cdm_config.h"
 #include "media/base/cdm_key_information.h"
 #include "media/base/decode_status.h"
 #include "media/base/decoder_buffer.h"
 #include "media/base/decrypt_config.h"
 #include "media/base/decryptor.h"
 #include "media/base/demuxer_stream.h"
 #include "media/base/encryption_scheme.h"
 #include "media/base/media_keys.h"
 #include "media/base/video_decoder_config.h"
 #include "media/base/video_frame.h"
 #include "media/mojo/common/mojo_shared_buffer_video_frame.h"
 #include "media/mojo/interfaces/demuxer_stream.mojom.h"
 #include "mojo/public/cpp/system/buffer.h"
-#include "ui/gfx/geometry/mojo/geometry_type_converters.h"
 
 namespace mojo {
 
 #define ASSERT_ENUM_EQ(media_enum, media_prefix, mojo_prefix, value)        \
   static_assert(media::media_prefix##value ==                               \
                     static_cast<media::media_enum>(                         \
                         media::mojom::media_enum::mojo_prefix##value),      \
                 "Mismatched enum: " #media_prefix #value " != " #media_enum \
                 "::" #mojo_prefix #value)
 
@@ skipping 504 matching lines @@
 TypeConverter<media::mojom::VideoDecoderConfigPtr, media::VideoDecoderConfig>::
     Convert(const media::VideoDecoderConfig& input) {
   media::mojom::VideoDecoderConfigPtr config(
       media::mojom::VideoDecoderConfig::New());
   config->codec = static_cast<media::mojom::VideoCodec>(input.codec());
   config->profile =
       static_cast<media::mojom::VideoCodecProfile>(input.profile());
   config->format = static_cast<media::mojom::VideoFormat>(input.format());
   config->color_space =
       static_cast<media::mojom::ColorSpace>(input.color_space());
-  config->coded_size = Size::From(input.coded_size());
-  config->visible_rect = Rect::From(input.visible_rect());
-  config->natural_size = Size::From(input.natural_size());
+  config->coded_size = input.coded_size();
+  config->visible_rect = input.visible_rect();
+  config->natural_size = input.natural_size();
   if (!input.extra_data().empty()) {
     config->extra_data = mojo::Array<uint8_t>::From(input.extra_data());
   }
   config->encryption_scheme =
       media::mojom::EncryptionScheme::From(input.encryption_scheme());
   return config;
 }
 
 // static
 media::VideoDecoderConfig
 TypeConverter<media::VideoDecoderConfig, media::mojom::VideoDecoderConfigPtr>::
     Convert(const media::mojom::VideoDecoderConfigPtr& input) {
   media::VideoDecoderConfig config;
-  config.Initialize(
-      static_cast<media::VideoCodec>(input->codec),
-      static_cast<media::VideoCodecProfile>(input->profile),
-      static_cast<media::VideoPixelFormat>(input->format),
-      static_cast<media::ColorSpace>(input->color_space),
-      input->coded_size.To<gfx::Size>(), input->visible_rect.To<gfx::Rect>(),
-      input->natural_size.To<gfx::Size>(), input->extra_data.storage(),
-      input->encryption_scheme.To<media::EncryptionScheme>());
+  config.Initialize(static_cast<media::VideoCodec>(input->codec),
+                    static_cast<media::VideoCodecProfile>(input->profile),
+                    static_cast<media::VideoPixelFormat>(input->format),
+                    static_cast<media::ColorSpace>(input->color_space),
+                    input->coded_size, input->visible_rect, input->natural_size,
+                    input->extra_data.storage(),
+                    input->encryption_scheme.To<media::EncryptionScheme>());
   return config;
 }
 
 // static
 media::mojom::CdmKeyInformationPtr TypeConverter<
     media::mojom::CdmKeyInformationPtr,
     media::CdmKeyInformation>::Convert(const media::CdmKeyInformation& input) {
   media::mojom::CdmKeyInformationPtr info(
       media::mojom::CdmKeyInformation::New());
   std::vector<uint8_t> key_id_copy(input.key_id);
@@ skipping 100 matching lines @@
            input->storage_type());
   media::MojoSharedBufferVideoFrame* input_frame =
       static_cast<media::MojoSharedBufferVideoFrame*>(input.get());
   mojo::ScopedSharedBufferHandle duplicated_handle;
   const MojoResult result =
       DuplicateBuffer(input_frame->Handle(), nullptr, &duplicated_handle);
   CHECK_EQ(MOJO_RESULT_OK, result);
   CHECK(duplicated_handle.is_valid());
 
   frame->format = static_cast<media::mojom::VideoFormat>(input->format());
-  frame->coded_size = Size::From(input->coded_size());
-  frame->visible_rect = Rect::From(input->visible_rect());
-  frame->natural_size = Size::From(input->natural_size());
+  frame->coded_size = input->coded_size();
+  frame->visible_rect = input->visible_rect();
+  frame->natural_size = input->natural_size();
   frame->timestamp_usec = input->timestamp().InMicroseconds();
   frame->frame_data = std::move(duplicated_handle);
   frame->frame_data_size = input_frame->MappedSize();
   frame->y_stride = input_frame->stride(media::VideoFrame::kYPlane);
   frame->u_stride = input_frame->stride(media::VideoFrame::kUPlane);
   frame->v_stride = input_frame->stride(media::VideoFrame::kVPlane);
   frame->y_offset = input_frame->PlaneOffset(media::VideoFrame::kYPlane);
   frame->u_offset = input_frame->PlaneOffset(media::VideoFrame::kUPlane);
   frame->v_offset = input_frame->PlaneOffset(media::VideoFrame::kVPlane);
   return frame;
 }
 
 // static
 scoped_refptr<media::VideoFrame>
 TypeConverter<scoped_refptr<media::VideoFrame>, media::mojom::VideoFramePtr>::
     Convert(const media::mojom::VideoFramePtr& input) {
   if (input->end_of_stream)
     return media::VideoFrame::CreateEOSFrame();
 
   return media::MojoSharedBufferVideoFrame::Create(
-      static_cast<media::VideoPixelFormat>(input->format),
-      input->coded_size.To<gfx::Size>(), input->visible_rect.To<gfx::Rect>(),
-      input->natural_size.To<gfx::Size>(), std::move(input->frame_data),
+      static_cast<media::VideoPixelFormat>(input->format), input->coded_size,
+      input->visible_rect, input->natural_size, std::move(input->frame_data),
       base::saturated_cast<size_t>(input->frame_data_size),
       base::saturated_cast<size_t>(input->y_offset),
       base::saturated_cast<size_t>(input->u_offset),
       base::saturated_cast<size_t>(input->v_offset), input->y_stride,
       input->u_stride, input->v_stride,
       base::TimeDelta::FromMicroseconds(input->timestamp_usec));
 }
 
 }  // namespace mojo