Modified old wait sync point functions to also accept new sync tokens.

mojo/converters/surfaces/surfaces_type_converters.cc

Index: mojo/converters/surfaces/surfaces_type_converters.cc
diff --git a/mojo/converters/surfaces/surfaces_type_converters.cc b/mojo/converters/surfaces/surfaces_type_converters.cc
index 5f2f25db8d12f4ec3efcd2aba407f847f52876bd..43af20d29bb79d131ba77932d2d3359437be2077 100644
--- a/mojo/converters/surfaces/surfaces_type_converters.cc
+++ b/mojo/converters/surfaces/surfaces_type_converters.cc
@@ -527,12 +527,37 @@ gpu::Mailbox TypeConverter<gpu::Mailbox, MailboxPtr>::Convert(
 }
 
 // static
+SyncTokenPtr TypeConverter<SyncTokenPtr, gpu::SyncToken>::Convert(
+    const gpu::SyncToken& input) {
+  SyncTokenPtr sync_token(SyncToken::New());
+  sync_token->verified_flush = input.verified_flush();
+  sync_token->namespace_id =
+      static_cast<CommandBufferNamespace>(input.namespace_id());
+  sync_token->command_buffer_id = input.command_buffer_id();
+  sync_token->release_count = input.release_count();
+  return sync_token.Pass();
+}
+
+// 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, input.command_buffer_id,
+                            input.release_count);
+  if (input.verified_flush)
+    sync_token.SetVerifyFlush();

[piman, 2015/10/29 00:08:20]

Actually, thinking about this.... if untrusted, the client can definitely lie
about verified_flush. But the system is designed to handle that.

If the SyncToken gets converted, that means we're about to send it over Mojo
IPC. When that's the case, we should expect it to be verified, before sending,
otherwise the synchronization will not work reliably anyway. So my suggestion is
instead to DCHECK(input.verified_flush()) on l.533, and when we get here simply
always sync_token.SetVerifyFlush() (and remove verified_flush from the mojom).
Checking on the sender side rather than the receiving side is better because
it's closer to the source that failed to verify the token (hopefully in a
related stack trace).

(The same argument applies to chrome IPC, and we could add a DCHECK in
ParamTraits<gpu::SyncToken>::Write).

[David Yen, 2015/10/29 17:08:08]

Is it possible to have an empty sync token too which would be unverified? For
example, a mailbox holder which has no sync token associated with it

[piman, 2015/10/29 23:22:15]

That's fair, but so the check should be DCHECK(input.verified_flush() ||
!input.HasData()).

[David Yen, 2015/10/29 23:27:38]

Done.

+
+  return sync_token;
+}
+
+// static
 MailboxHolderPtr TypeConverter<MailboxHolderPtr, gpu::MailboxHolder>::Convert(
     const gpu::MailboxHolder& input) {
   MailboxHolderPtr holder(MailboxHolder::New());
   holder->mailbox = Mailbox::From<gpu::Mailbox>(input.mailbox);
+  holder->sync_token = input.sync_token;
   holder->texture_target = input.texture_target;
-  holder->sync_point = input.sync_point;
   return holder.Pass();
 }
 
@@ -541,8 +566,8 @@ gpu::MailboxHolder TypeConverter<gpu::MailboxHolder, MailboxHolderPtr>::Convert(
     const MailboxHolderPtr& input) {
   gpu::MailboxHolder holder;
   holder.mailbox = input->mailbox.To<gpu::Mailbox>();
+  holder.sync_token = input->sync_token;
   holder.texture_target = input->texture_target;
-  holder.sync_point = input->sync_point;
   return holder;
 }
 
@@ -603,7 +628,7 @@ TypeConverter<ReturnedResourcePtr, cc::ReturnedResource>::Convert(
     const cc::ReturnedResource& input) {
   ReturnedResourcePtr returned = ReturnedResource::New();
   returned->id = input.id;
-  returned->sync_point = input.sync_point;
+  returned->sync_token = input.sync_token;
   returned->count = input.count;
   returned->lost = input.lost;
   return returned.Pass();
@@ -615,7 +640,7 @@ TypeConverter<cc::ReturnedResource, ReturnedResourcePtr>::Convert(
     const ReturnedResourcePtr& input) {
   cc::ReturnedResource returned;
   returned.id = input->id;
-  returned.sync_point = input->sync_point;
+  returned.sync_token = input->sync_token;
   returned.count = input->count;
   returned.lost = input->lost;
   return returned;