Added 64 bit number support in the build gles2 command buffer script.

gpu/command_buffer/common/gles2_cmd_format_autogen.h

 // 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.
 
 // This file is auto-generated from
 // gpu/command_buffer/build_gles2_cmd_buffer.py
 // It's formatted by clang-format using chromium coding style:
 //    clang-format -i -style=chromium filename
 // DO NOT EDIT!
 
@@ skipping 1168 matching lines @@
   typedef GLenum Result;
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint _sync,
             GLbitfield _flags,
-            GLuint _timeout_0,
-            GLuint _timeout_1,
+            GLuint64 _timeout,
             uint32_t _result_shm_id,
             uint32_t _result_shm_offset) {
     SetHeader();
     sync = _sync;
     flags = _flags;
-    timeout_0 = _timeout_0;
-    timeout_1 = _timeout_1;
+    GLES2Util::MapUint64ToTwoUint32(static_cast<uint64_t>(_timeout), &timeout_0,
+                                    &timeout_1);
     result_shm_id = _result_shm_id;
     result_shm_offset = _result_shm_offset;
   }
 
   void* Set(void* cmd,
             GLuint _sync,
             GLbitfield _flags,
-            GLuint _timeout_0,
-            GLuint _timeout_1,
+            GLuint64 _timeout,
             uint32_t _result_shm_id,
             uint32_t _result_shm_offset) {
-    static_cast<ValueType*>(cmd)->Init(_sync, _flags, _timeout_0, _timeout_1,
-                                       _result_shm_id, _result_shm_offset);
+    static_cast<ValueType*>(cmd)
+        ->Init(_sync, _flags, _timeout, _result_shm_id, _result_shm_offset);
     return NextCmdAddress<ValueType>(cmd);
   }
 
+  GLuint64 timeout() const {
+    return static_cast<GLuint64>(
+        GLES2Util::MapTwoUint32ToUint64(timeout_0, timeout_1));
+  }
+
   gpu::CommandHeader header;
   uint32_t sync;
   uint32_t flags;
   uint32_t timeout_0;
   uint32_t timeout_1;
   uint32_t result_shm_id;
   uint32_t result_shm_offset;
 };
 
 static_assert(sizeof(ClientWaitSync) == 28,
@@ skipping 9418 matching lines @@
   static const CommandId kCmdId = kWaitSync;
   static const cmd::ArgFlags kArgFlags = cmd::kFixed;
   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
-  void Init(GLuint _sync,
-            GLbitfield _flags,
-            GLuint _timeout_0,
-            GLuint _timeout_1) {
+  void Init(GLuint _sync, GLbitfield _flags, GLuint64 _timeout) {
     SetHeader();
     sync = _sync;
     flags = _flags;
-    timeout_0 = _timeout_0;
-    timeout_1 = _timeout_1;
+    GLES2Util::MapUint64ToTwoUint32(static_cast<uint64_t>(_timeout), &timeout_0,
+                                    &timeout_1);
   }
 
-  void* Set(void* cmd,
-            GLuint _sync,
-            GLbitfield _flags,
-            GLuint _timeout_0,
-            GLuint _timeout_1) {
-    static_cast<ValueType*>(cmd)->Init(_sync, _flags, _timeout_0, _timeout_1);
+  void* Set(void* cmd, GLuint _sync, GLbitfield _flags, GLuint64 _timeout) {
+    static_cast<ValueType*>(cmd)->Init(_sync, _flags, _timeout);
     return NextCmdAddress<ValueType>(cmd);
   }
 
+  GLuint64 timeout() const {
+    return static_cast<GLuint64>(
+        GLES2Util::MapTwoUint32ToUint64(timeout_0, timeout_1));
+  }
+
   gpu::CommandHeader header;
   uint32_t sync;
   uint32_t flags;
   uint32_t timeout_0;
   uint32_t timeout_1;
 };
 
 static_assert(sizeof(WaitSync) == 20, "size of WaitSync should be 20");
 static_assert(offsetof(WaitSync, header) == 0,
               "offset of WaitSync header should be 0");
@@ skipping 2815 matching lines @@
   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(1);
 
   static uint32_t ComputeSize() {
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLuint64 _release_count) {
     SetHeader();
-    release_count = _release_count;
+    GLES2Util::MapUint64ToTwoUint32(static_cast<uint64_t>(_release_count),
+                                    &release_count_0, &release_count_1);
   }
 
   void* Set(void* cmd, GLuint64 _release_count) {
     static_cast<ValueType*>(cmd)->Init(_release_count);
     return NextCmdAddress<ValueType>(cmd);
   }
 
+  GLuint64 release_count() const {
+    return static_cast<GLuint64>(
+        GLES2Util::MapTwoUint32ToUint64(release_count_0, release_count_1));
+  }
+
   gpu::CommandHeader header;
-  uint32_t release_count;
+  uint32_t release_count_0;
+  uint32_t release_count_1;
 };
 
-static_assert(sizeof(InsertFenceSyncCHROMIUM) == 8,
-              "size of InsertFenceSyncCHROMIUM should be 8");
+static_assert(sizeof(InsertFenceSyncCHROMIUM) == 12,
+              "size of InsertFenceSyncCHROMIUM should be 12");
 static_assert(offsetof(InsertFenceSyncCHROMIUM, header) == 0,
               "offset of InsertFenceSyncCHROMIUM header should be 0");
-static_assert(offsetof(InsertFenceSyncCHROMIUM, release_count) == 4,
-              "offset of InsertFenceSyncCHROMIUM release_count should be 4");
+static_assert(offsetof(InsertFenceSyncCHROMIUM, release_count_0) == 4,
+              "offset of InsertFenceSyncCHROMIUM release_count_0 should be 4");
+static_assert(offsetof(InsertFenceSyncCHROMIUM, release_count_1) == 8,
+              "offset of InsertFenceSyncCHROMIUM release_count_1 should be 8");
 
 struct GenSyncTokenCHROMIUMImmediate {
   typedef GenSyncTokenCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kGenSyncTokenCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize(uint32_t size_in_bytes) {
     return static_cast<uint32_t>(sizeof(ValueType) +  // NOLINT
                                  RoundSizeToMultipleOfEntries(size_in_bytes));
   }
 
   void SetHeader(uint32_t size_in_bytes) {
     header.SetCmdByTotalSize<ValueType>(size_in_bytes);
   }
 
   void Init(GLuint64 _fence_sync) {
     uint32_t total_size = 0;  // WARNING: compute correct size.
     SetHeader(total_size);
-    fence_sync = _fence_sync;
+    GLES2Util::MapUint64ToTwoUint32(static_cast<uint64_t>(_fence_sync),
+                                    &fence_sync_0, &fence_sync_1);
   }
 
   void* Set(void* cmd, GLuint64 _fence_sync) {
     uint32_t total_size = 0;  // WARNING: compute correct size.
     static_cast<ValueType*>(cmd)->Init(_fence_sync);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
+  GLuint64 fence_sync() const {
+    return static_cast<GLuint64>(
+        GLES2Util::MapTwoUint32ToUint64(fence_sync_0, fence_sync_1));
+  }
+
   gpu::CommandHeader header;
-  uint32_t fence_sync;
+  uint32_t fence_sync_0;
+  uint32_t fence_sync_1;
 };
 
-static_assert(sizeof(GenSyncTokenCHROMIUMImmediate) == 8,
-              "size of GenSyncTokenCHROMIUMImmediate should be 8");
+static_assert(sizeof(GenSyncTokenCHROMIUMImmediate) == 12,
+              "size of GenSyncTokenCHROMIUMImmediate should be 12");
 static_assert(offsetof(GenSyncTokenCHROMIUMImmediate, header) == 0,
               "offset of GenSyncTokenCHROMIUMImmediate header should be 0");
-static_assert(offsetof(GenSyncTokenCHROMIUMImmediate, fence_sync) == 4,
-              "offset of GenSyncTokenCHROMIUMImmediate fence_sync should be 4");
+static_assert(
+    offsetof(GenSyncTokenCHROMIUMImmediate, fence_sync_0) == 4,
+    "offset of GenSyncTokenCHROMIUMImmediate fence_sync_0 should be 4");
+static_assert(
+    offsetof(GenSyncTokenCHROMIUMImmediate, fence_sync_1) == 8,
+    "offset of GenSyncTokenCHROMIUMImmediate fence_sync_1 should be 8");
 
 struct GenUnverifiedSyncTokenCHROMIUMImmediate {
   typedef GenUnverifiedSyncTokenCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kGenUnverifiedSyncTokenCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize(uint32_t size_in_bytes) {
     return static_cast<uint32_t>(sizeof(ValueType) +  // NOLINT
                                  RoundSizeToMultipleOfEntries(size_in_bytes));
   }
 
   void SetHeader(uint32_t size_in_bytes) {
     header.SetCmdByTotalSize<ValueType>(size_in_bytes);
   }
 
   void Init(GLuint64 _fence_sync) {
     uint32_t total_size = 0;  // WARNING: compute correct size.
     SetHeader(total_size);
-    fence_sync = _fence_sync;
+    GLES2Util::MapUint64ToTwoUint32(static_cast<uint64_t>(_fence_sync),
+                                    &fence_sync_0, &fence_sync_1);
   }
 
   void* Set(void* cmd, GLuint64 _fence_sync) {
     uint32_t total_size = 0;  // WARNING: compute correct size.
     static_cast<ValueType*>(cmd)->Init(_fence_sync);
     return NextImmediateCmdAddressTotalSize<ValueType>(cmd, total_size);
   }
 
+  GLuint64 fence_sync() const {
+    return static_cast<GLuint64>(
+        GLES2Util::MapTwoUint32ToUint64(fence_sync_0, fence_sync_1));
+  }
+
   gpu::CommandHeader header;
-  uint32_t fence_sync;
+  uint32_t fence_sync_0;
+  uint32_t fence_sync_1;
 };
 
-static_assert(sizeof(GenUnverifiedSyncTokenCHROMIUMImmediate) == 8,
-              "size of GenUnverifiedSyncTokenCHROMIUMImmediate should be 8");
+static_assert(sizeof(GenUnverifiedSyncTokenCHROMIUMImmediate) == 12,
+              "size of GenUnverifiedSyncTokenCHROMIUMImmediate should be 12");
 static_assert(
     offsetof(GenUnverifiedSyncTokenCHROMIUMImmediate, header) == 0,
     "offset of GenUnverifiedSyncTokenCHROMIUMImmediate header should be 0");
-static_assert(
-    offsetof(GenUnverifiedSyncTokenCHROMIUMImmediate, fence_sync) == 4,
-    "offset of GenUnverifiedSyncTokenCHROMIUMImmediate fence_sync should be 4");
+static_assert(offsetof(GenUnverifiedSyncTokenCHROMIUMImmediate, fence_sync_0) ==
+                  4,
+              "offset of GenUnverifiedSyncTokenCHROMIUMImmediate fence_sync_0 "
+              "should be 4");
+static_assert(offsetof(GenUnverifiedSyncTokenCHROMIUMImmediate, fence_sync_1) ==
+                  8,
+              "offset of GenUnverifiedSyncTokenCHROMIUMImmediate fence_sync_1 "
+              "should be 8");
 
 struct VerifySyncTokensCHROMIUMImmediate {
   typedef VerifySyncTokensCHROMIUMImmediate ValueType;
   static const CommandId kCmdId = kVerifySyncTokensCHROMIUMImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(3);
 
   static uint32_t ComputeSize(uint32_t size_in_bytes) {
     return static_cast<uint32_t>(sizeof(ValueType) +  // NOLINT
                                  RoundSizeToMultipleOfEntries(size_in_bytes));
@@ skipping 36 matching lines @@
     return static_cast<uint32_t>(sizeof(ValueType));  // NOLINT
   }
 
   void SetHeader() { header.SetCmd<ValueType>(); }
 
   void Init(GLint _namespace_id,
             GLuint64 _command_buffer_id,
             GLuint64 _release_count) {
     SetHeader();
     namespace_id = _namespace_id;
-    command_buffer_id = _command_buffer_id;
-    release_count = _release_count;
+    GLES2Util::MapUint64ToTwoUint32(static_cast<uint64_t>(_command_buffer_id),
+                                    &command_buffer_id_0, &command_buffer_id_1);
+    GLES2Util::MapUint64ToTwoUint32(static_cast<uint64_t>(_release_count),
+                                    &release_count_0, &release_count_1);
   }
 
   void* Set(void* cmd,
             GLint _namespace_id,
             GLuint64 _command_buffer_id,
             GLuint64 _release_count) {
     static_cast<ValueType*>(cmd)
         ->Init(_namespace_id, _command_buffer_id, _release_count);
     return NextCmdAddress<ValueType>(cmd);
   }
 
+  GLuint64 command_buffer_id() const {
+    return static_cast<GLuint64>(GLES2Util::MapTwoUint32ToUint64(
+        command_buffer_id_0, command_buffer_id_1));
+  }
+
+  GLuint64 release_count() const {
+    return static_cast<GLuint64>(
+        GLES2Util::MapTwoUint32ToUint64(release_count_0, release_count_1));
+  }
+
   gpu::CommandHeader header;
   int32_t namespace_id;
-  uint32_t command_buffer_id;
-  uint32_t release_count;
+  uint32_t command_buffer_id_0;
+  uint32_t command_buffer_id_1;
+  uint32_t release_count_0;
+  uint32_t release_count_1;
 };
 
-static_assert(sizeof(WaitSyncTokenCHROMIUM) == 16,
-              "size of WaitSyncTokenCHROMIUM should be 16");
+static_assert(sizeof(WaitSyncTokenCHROMIUM) == 24,
+              "size of WaitSyncTokenCHROMIUM should be 24");
 static_assert(offsetof(WaitSyncTokenCHROMIUM, header) == 0,
               "offset of WaitSyncTokenCHROMIUM header should be 0");
 static_assert(offsetof(WaitSyncTokenCHROMIUM, namespace_id) == 4,
               "offset of WaitSyncTokenCHROMIUM namespace_id should be 4");
-static_assert(offsetof(WaitSyncTokenCHROMIUM, command_buffer_id) == 8,
-              "offset of WaitSyncTokenCHROMIUM command_buffer_id should be 8");
-static_assert(offsetof(WaitSyncTokenCHROMIUM, release_count) == 12,
-              "offset of WaitSyncTokenCHROMIUM release_count should be 12");
+static_assert(
+    offsetof(WaitSyncTokenCHROMIUM, command_buffer_id_0) == 8,
+    "offset of WaitSyncTokenCHROMIUM command_buffer_id_0 should be 8");
+static_assert(
+    offsetof(WaitSyncTokenCHROMIUM, command_buffer_id_1) == 12,
+    "offset of WaitSyncTokenCHROMIUM command_buffer_id_1 should be 12");
+static_assert(offsetof(WaitSyncTokenCHROMIUM, release_count_0) == 16,
+              "offset of WaitSyncTokenCHROMIUM release_count_0 should be 16");
+static_assert(offsetof(WaitSyncTokenCHROMIUM, release_count_1) == 20,
+              "offset of WaitSyncTokenCHROMIUM release_count_1 should be 20");
 
 struct DrawBuffersEXTImmediate {
   typedef DrawBuffersEXTImmediate ValueType;
   static const CommandId kCmdId = kDrawBuffersEXTImmediate;
   static const cmd::ArgFlags kArgFlags = cmd::kAtLeastN;
   static const uint8 cmd_flags = CMD_FLAG_SET_TRACE_LEVEL(2);
 
   static uint32_t ComputeDataSize(GLsizei count) {
     return static_cast<uint32_t>(sizeof(GLenum) * 1 * count);  // NOLINT
   }
@@ skipping 1928 matching lines @@
 static_assert(offsetof(GetFragDataIndexEXT, program) == 4,
               "offset of GetFragDataIndexEXT program should be 4");
 static_assert(offsetof(GetFragDataIndexEXT, name_bucket_id) == 8,
               "offset of GetFragDataIndexEXT name_bucket_id should be 8");
 static_assert(offsetof(GetFragDataIndexEXT, index_shm_id) == 12,
               "offset of GetFragDataIndexEXT index_shm_id should be 12");
 static_assert(offsetof(GetFragDataIndexEXT, index_shm_offset) == 16,
               "offset of GetFragDataIndexEXT index_shm_offset should be 16");
 
 #endif  // GPU_COMMAND_BUFFER_COMMON_GLES2_CMD_FORMAT_AUTOGEN_H_