Add glClientWaitSync to GPU command buffer.

gpu/command_buffer/common/gles2_cmd_format.h

 // 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.
 
 // This file defines the GLES2 command buffer commands.
 
 #ifndef GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_
 #define GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_
 
 
@@ skipping 25 matching lines @@
 typedef unsigned short GLushort;
 typedef unsigned long GLulong;
 typedef float GLfloat;
 typedef float GLclampf;
 typedef double GLdouble;
 typedef double GLclampd;
 typedef void GLvoid;
 typedef khronos_intptr_t GLintptr;
 typedef khronos_ssize_t  GLsizeiptr;
 typedef struct __GLsync *GLsync;
+typedef uint64_t GLuint64;
 
 namespace gpu {
 namespace gles2 {
 
 // Command buffer is GPU_COMMAND_BUFFER_ENTRY_ALIGNMENT byte aligned.
 #pragma pack(push, GPU_COMMAND_BUFFER_ENTRY_ALIGNMENT)
 
 namespace id_namespaces {
 
 // These are used when contexts share resources.
@@ skipping 14 matching lines @@
 
 // These numbers must not change
 static_assert(kBuffers == 0, "kBuffers should equal 0");
 static_assert(kFramebuffers == 1, "kFramebuffers should equal 1");
 static_assert(kProgramsAndShaders == 2, "kProgramsAndShaders should equal 2");
 static_assert(kRenderbuffers == 3, "kRenderbuffers should equal 3");
 static_assert(kTextures == 4, "kTextures should equal 4");
 
 }  // namespace id_namespaces
 
+union GLuint64Union {

[piman, 2015/02/18 18:38:00]

Oh, actually, I missed the fact that this was a union.
Writing a member of the union and reading another one is undefined behavior in
C++.

Why does this need to be a union at all exactly? We can extract higher and lower
uints using shifts and masks, and reconstruct similarly (you can make helper
functions).

[Zhenyao Mo, 2015/02/18 19:10:37]

Thanks for catching this.  My understanding of union was apparently incorrect.

+  GLuint64Union(GLuint64 v64)
+      : param64(v64) {
+  }
+
+  GLuint64Union(uint32_t v32_0, uint32_t v32_1) {
+    param32.v0 = v32_0;
+    param32.v1 = v32_1;
+  }
+
+  GLuint64 param64;
+  struct {
+    uint32_t v0;
+    uint32_t v1;
+  } param32;
+};
+
+static_assert(sizeof(GLuint64Union) == 8, "size of GLuint64Union should be 8");
+static_assert(offsetof(GLuint64Union, param64) == 0,
+              "offset of GLuint64Union.param64 should be 0");
+static_assert(offsetof(GLuint64Union, param32.v0) == 0,
+              "offset of GLuint64Union.param32.v0 should be 0");
+static_assert(offsetof(GLuint64Union, param32.v1) == 4,
+              "offset of GLuint64Union.param32.v1 should be 4");
+
 // Used for some glGetXXX commands that return a result through a pointer. We
 // need to know if the command succeeded or not and the size of the result. If
 // the command failed its result size will 0.
 template <typename T>
 struct SizedResult {
   typedef T Type;
 
   T* GetData() {
     return static_cast<T*>(static_cast<void*>(&data));
   }
@@ skipping 265 matching lines @@
     "offset of CreateAndConsumeTextureCHROMIUMImmediate.client_id should be 8");
 
 
 #pragma pack(pop)
 
 }  // namespace cmd
 }  // namespace gles2
 }  // namespace gpu
 
 #endif  // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_H_