Add extra_data_field_ in gpu::SyncToken converter and remove two array converters

mojo/converters/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 "mojo/converters/surfaces/surfaces_type_converters.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 524 matching lines @@
 }
 
 // static
 SyncTokenPtr TypeConverter<SyncTokenPtr, gpu::SyncToken>::Convert(
     const gpu::SyncToken& input) {
   DCHECK(!input.HasData() || input.verified_flush());
   SyncTokenPtr sync_token(SyncToken::New());
   sync_token->verified_flush = input.verified_flush();
   sync_token->namespace_id =
       static_cast<CommandBufferNamespace>(input.namespace_id());
+  sync_token->extra_data_field = input.extra_data_field();
   sync_token->command_buffer_id = input.command_buffer_id();
   sync_token->release_count = input.release_count();
   return sync_token;
 }
 
 // static
 gpu::SyncToken TypeConverter<gpu::SyncToken, SyncTokenPtr>::Convert(
     const SyncTokenPtr& input) {
   const gpu::CommandBufferNamespace namespace_id =
       static_cast<gpu::CommandBufferNamespace>(input->namespace_id);
-  gpu::SyncToken sync_token(namespace_id, 0,
+  gpu::SyncToken sync_token(namespace_id, input->extra_data_field,
                             input->command_buffer_id, input->release_count);
   if (input->verified_flush)
     sync_token.SetVerifyFlush();
 
   return sync_token;
 }
 
 // static
 MailboxHolderPtr TypeConverter<MailboxHolderPtr, gpu::MailboxHolder>::Convert(
     const gpu::MailboxHolder& input) {
@@ skipping 36 matching lines @@
   transferable.id = input->id;
   transferable.format = static_cast<cc::ResourceFormat>(input->format);
   transferable.filter = input->filter;
   transferable.size = input->size.To<gfx::Size>();
   transferable.mailbox_holder = input->mailbox_holder.To<gpu::MailboxHolder>();
   transferable.is_software = input->is_software;
   return transferable;
 }
 
 // static
-Array<TransferableResourcePtr> TypeConverter<
-    Array<TransferableResourcePtr>,
-    cc::TransferableResourceArray>::Convert(const cc::TransferableResourceArray&
-                                                input) {
-  Array<TransferableResourcePtr> resources(input.size());
-  for (size_t i = 0; i < input.size(); ++i) {
-    resources[i] = TransferableResource::From(input[i]);
-  }
-  return resources;
-}
-
-// static
-cc::TransferableResourceArray
-TypeConverter<cc::TransferableResourceArray, Array<TransferableResourcePtr> >::
-    Convert(const Array<TransferableResourcePtr>& input) {
-  cc::TransferableResourceArray resources(input.size());
-  for (size_t i = 0; i < input.size(); ++i) {
-    resources[i] = input[i].To<cc::TransferableResource>();
-  }
-  return resources;
-}
-
-// static
 ReturnedResourcePtr
 TypeConverter<ReturnedResourcePtr, cc::ReturnedResource>::Convert(
     const cc::ReturnedResource& input) {
   ReturnedResourcePtr returned = ReturnedResource::New();
   returned->id = input.id;
   returned->sync_token = SyncToken::From<gpu::SyncToken>(input.sync_token);
   returned->count = input.count;
   returned->lost = input.lost;
   return returned;
 }
 
 // static
 cc::ReturnedResource
 TypeConverter<cc::ReturnedResource, ReturnedResourcePtr>::Convert(
     const ReturnedResourcePtr& input) {
   cc::ReturnedResource returned;
   returned.id = input->id;
   returned.sync_token = input->sync_token.To<gpu::SyncToken>();
   returned.count = input->count;
   returned.lost = input->lost;
   return returned;
 }
 
 // static
-Array<ReturnedResourcePtr>
-TypeConverter<Array<ReturnedResourcePtr>, cc::ReturnedResourceArray>::Convert(
-    const cc::ReturnedResourceArray& input) {
-  Array<ReturnedResourcePtr> resources(input.size());
-  for (size_t i = 0; i < input.size(); ++i) {
-    resources[i] = ReturnedResource::From(input[i]);
-  }
-  return resources;
-}
-
-// static
-cc::ReturnedResourceArray
-TypeConverter<cc::ReturnedResourceArray, Array<ReturnedResourcePtr>>::Convert(
-    const Array<ReturnedResourcePtr>& input) {
-  cc::ReturnedResourceArray resources(input.size());
-  for (size_t i = 0; i < input.size(); ++i) {
-    resources[i] = input[i].To<cc::ReturnedResource>();
-  }
-  return resources;
-}
-
-// static
 CompositorFrameMetadataPtr
 TypeConverter<CompositorFrameMetadataPtr, cc::CompositorFrameMetadata>::Convert(
     const cc::CompositorFrameMetadata& input) {
   CompositorFrameMetadataPtr metadata = CompositorFrameMetadata::New();
   metadata->device_scale_factor = input.device_scale_factor;
   return metadata;
 }
 
 // static
 cc::CompositorFrameMetadata
@@ skipping 46 matching lines @@
 }
 
 // static
 scoped_ptr<cc::CompositorFrame>
 TypeConverter<scoped_ptr<cc::CompositorFrame>, CompositorFramePtr>::Convert(
     const CompositorFramePtr& input) {
   return ConvertToCompositorFrame(input, nullptr);
 }
 
 }  // namespace mojo