Added an extra sync token field for extra command buffer identification.

gpu/ipc/gpu_command_buffer_traits.cc

 // Copyright (c) 2012 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 "gpu/ipc/gpu_command_buffer_traits.h"
 
 #include "gpu/command_buffer/common/mailbox_holder.h"
 #include "gpu/command_buffer/common/sync_token.h"
 #include "gpu/command_buffer/common/value_state.h"
 
@@ skipping 41 matching lines @@
 void ParamTraits<gpu::CommandBuffer::State> ::Log(const param_type& p,
                                                   std::string* l) {
   l->append("<CommandBuffer::State>");
 }
 
 void ParamTraits<gpu::SyncToken>::Write(Message* m, const param_type& p) {
   DCHECK(!p.HasData() || p.verified_flush());
 
   WriteParam(m, p.verified_flush());
   WriteParam(m, p.namespace_id());
+  WriteParam(m, p.extra_data_field());
   WriteParam(m, p.command_buffer_id());
   WriteParam(m, p.release_count());
 }
 
 bool ParamTraits<gpu::SyncToken>::Read(const Message* m,
                                        base::PickleIterator* iter,
                                        param_type* p) {
   bool verified_flush = false;
   gpu::CommandBufferNamespace namespace_id =
       gpu::CommandBufferNamespace::INVALID;
+  uint32_t extra_data_field = 0;
   uint64_t command_buffer_id = 0;
   uint64_t release_count = 0;
 
   if (!ReadParam(m, iter, &verified_flush) ||
       !ReadParam(m, iter, &namespace_id) ||
+      !ReadParam(m, iter, &extra_data_field) ||

[piman, 2015/11/30 20:59:23]

Actually, I have a security concern: the rest of the code will assume that the
stream id stored in this field is the one that corresponds to command_buffer_id,
but we have no way to validate it here. I'm worried that we'd make
security-sensitive decisions on it when an untrusted client could craft a
SyncToken where they don't match.

My preference would actually be to not send this over IPC, and handle the
possibility that it's 0 (which is invalid) in e.g. CanWaitUnverifiedSyncToken
(if stream_id == 0, then no, we can't wait on that token).

The argument is that it's only used on the client to stash the stream_id for
same-process synchronization, but as soon as we're talking cross-process
synchronization, the stream_id shouldn't be relevant anymore.

[David Yen, 2015/11/30 22:45:06]

Since I have created this variable as a "generic store what you need into sync
token" I'm worried someone might come up with a use later in mojo or something
which they expect it to make it across process. This variable only being
available within a single process is a huge gotcha.

From the point of view of security, you're right that we do always have to
account for invalid data. I think all the data in a sync token should always be
viewed as "untrusted" though, and we already have to account for that invalid
data for all the other values. Having said that, you reminded me that the
FlushPendingStream needs to account for having an invalid stream id. I will
change the FlushPendingStream() to use find instead of operator [].

       !ReadParam(m, iter, &command_buffer_id) ||
       !ReadParam(m, iter, &release_count)) {
     return false;
   }
 
-  p->Set(namespace_id, command_buffer_id, release_count);
+  p->Set(namespace_id, extra_data_field, command_buffer_id, release_count);
   if (p->HasData()) {
     if (!verified_flush)
       return false;
     p->SetVerifyFlush();
   }
 
   return true;
 }
 
 void ParamTraits<gpu::SyncToken>::Log(const param_type& p, std::string* l) {
   *l +=
-      base::StringPrintf("[%d:%llX] %llu", static_cast<int>(p.namespace_id()),
+      base::StringPrintf("[%d:%llX:%u] %llu",
+                         static_cast<int>(p.namespace_id()),
                          static_cast<unsigned long long>(p.command_buffer_id()),
+                         p.extra_data_field(),
                          static_cast<unsigned long long>(p.release_count()));
 }
 
 void ParamTraits<gpu::Mailbox>::Write(Message* m, const param_type& p) {
   m->WriteBytes(p.name, sizeof(p.name));
 }
 
 bool ParamTraits<gpu::Mailbox> ::Read(const Message* m,
                                       base::PickleIterator* iter,
                                       param_type* p) {
@@ skipping 52 matching lines @@
   l->append("<ValueState (");
   for (int value : p.int_value)
     *l += base::StringPrintf("%i ", value);
   l->append(" int values ");
   for (float value : p.float_value)
     *l += base::StringPrintf("%f ", value);
   l->append(" float values)>");
 }
 
 }  // namespace IPC