Lines Matching defs:cmd

16   cmds::ActiveTexture& cmd = *GetBufferAs<cmds::ActiveTexture>();
17   void* next_cmd = cmd.Set(
18       &cmd,
21             cmd.header.command);
22   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
23   EXPECT_EQ(static_cast<GLenum>(11), cmd.texture);
25       next_cmd, sizeof(cmd));
29   cmds::AttachShader& cmd = *GetBufferAs<cmds::AttachShader>();
30   void* next_cmd = cmd.Set(
31       &cmd,
35             cmd.header.command);
36   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
37   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
38   EXPECT_EQ(static_cast<GLuint>(12), cmd.shader);
40       next_cmd, sizeof(cmd));
44   cmds::BindAttribLocation& cmd = *GetBufferAs<cmds::BindAttribLocation>();
45   void* next_cmd = cmd.Set(
46       &cmd,
53             cmd.header.command);
54   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
55   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
56   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
57   EXPECT_EQ(static_cast<uint32>(13), cmd.name_shm_id);
58   EXPECT_EQ(static_cast<uint32>(14), cmd.name_shm_offset);
59   EXPECT_EQ(static_cast<uint32>(15), cmd.data_size);
61       next_cmd, sizeof(cmd));
66   cmds::BindAttribLocationImmediate& cmd =
69   void* next_cmd = cmd.Set(
70       &cmd,
76             cmd.header.command);
77   EXPECT_EQ(sizeof(cmd) +
79             cmd.header.size * 4u);
81             reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
83   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
84   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
85   EXPECT_EQ(static_cast<uint32>(strlen(test_str)), cmd.data_size);
86   EXPECT_EQ(0, memcmp(test_str, ImmediateDataAddress(&cmd), strlen(test_str)));
89       sizeof(cmd) + RoundSizeToMultipleOfEntries(strlen(test_str)),
90       sizeof(cmd) + strlen(test_str));
94   cmds::BindAttribLocationBucket& cmd =
96   void* next_cmd = cmd.Set(
97       &cmd,
102             cmd.header.command);
103   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
104   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
105   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
106   EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
108       next_cmd, sizeof(cmd));
112   cmds::BindBuffer& cmd = *GetBufferAs<cmds::BindBuffer>();
113   void* next_cmd = cmd.Set(
114       &cmd,
118             cmd.header.command);
119   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
120   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
121   EXPECT_EQ(static_cast<GLuint>(12), cmd.buffer);
123       next_cmd, sizeof(cmd));
127   cmds::BindFramebuffer& cmd = *GetBufferAs<cmds::BindFramebuffer>();
128   void* next_cmd = cmd.Set(
129       &cmd,
133             cmd.header.command);
134   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
135   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
136   EXPECT_EQ(static_cast<GLuint>(12), cmd.framebuffer);
138       next_cmd, sizeof(cmd));
142   cmds::BindRenderbuffer& cmd = *GetBufferAs<cmds::BindRenderbuffer>();
143   void* next_cmd = cmd.Set(
144       &cmd,
148             cmd.header.command);
149   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
150   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
151   EXPECT_EQ(static_cast<GLuint>(12), cmd.renderbuffer);
153       next_cmd, sizeof(cmd));
157   cmds::BindTexture& cmd = *GetBufferAs<cmds::BindTexture>();
158   void* next_cmd = cmd.Set(
159       &cmd,
163             cmd.header.command);
164   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
165   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
166   EXPECT_EQ(static_cast<GLuint>(12), cmd.texture);
168       next_cmd, sizeof(cmd));
172   cmds::BlendColor& cmd = *GetBufferAs<cmds::BlendColor>();
173   void* next_cmd = cmd.Set(
174       &cmd,
180             cmd.header.command);
181   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
182   EXPECT_EQ(static_cast<GLclampf>(11), cmd.red);
183   EXPECT_EQ(static_cast<GLclampf>(12), cmd.green);
184   EXPECT_EQ(static_cast<GLclampf>(13), cmd.blue);
185   EXPECT_EQ(static_cast<GLclampf>(14), cmd.alpha);
187       next_cmd, sizeof(cmd));
191   cmds::BlendEquation& cmd = *GetBufferAs<cmds::BlendEquation>();
192   void* next_cmd = cmd.Set(
193       &cmd,
196             cmd.header.command);
197   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
198   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
200       next_cmd, sizeof(cmd));
204   cmds::BlendEquationSeparate& cmd =
206   void* next_cmd = cmd.Set(
207       &cmd,
211             cmd.header.command);
212   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
213   EXPECT_EQ(static_cast<GLenum>(11), cmd.modeRGB);
214   EXPECT_EQ(static_cast<GLenum>(12), cmd.modeAlpha);
216       next_cmd, sizeof(cmd));
220   cmds::BlendFunc& cmd = *GetBufferAs<cmds::BlendFunc>();
221   void* next_cmd = cmd.Set(
222       &cmd,
226             cmd.header.command);
227   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
228   EXPECT_EQ(static_cast<GLenum>(11), cmd.sfactor);
229   EXPECT_EQ(static_cast<GLenum>(12), cmd.dfactor);
231       next_cmd, sizeof(cmd));
235   cmds::BlendFuncSeparate& cmd = *GetBufferAs<cmds::BlendFuncSeparate>();
236   void* next_cmd = cmd.Set(
237       &cmd,
243             cmd.header.command);
244   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
245   EXPECT_EQ(static_cast<GLenum>(11), cmd.srcRGB);
246   EXPECT_EQ(static_cast<GLenum>(12), cmd.dstRGB);
247   EXPECT_EQ(static_cast<GLenum>(13), cmd.srcAlpha);
248   EXPECT_EQ(static_cast<GLenum>(14), cmd.dstAlpha);
250       next_cmd, sizeof(cmd));
254   cmds::BufferData& cmd = *GetBufferAs<cmds::BufferData>();
255   void* next_cmd = cmd.Set(
256       &cmd,
263             cmd.header.command);
264   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
265   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
266   EXPECT_EQ(static_cast<GLsizeiptr>(12), cmd.size);
267   EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_id);
268   EXPECT_EQ(static_cast<uint32>(14), cmd.data_shm_offset);
269   EXPECT_EQ(static_cast<GLenum>(15), cmd.usage);
271       next_cmd, sizeof(cmd));
276   cmds::BufferSubData& cmd = *GetBufferAs<cmds::BufferSubData>();
277   void* next_cmd = cmd.Set(
278       &cmd,
285             cmd.header.command);
286   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
287   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
288   EXPECT_EQ(static_cast<GLintptr>(12), cmd.offset);
289   EXPECT_EQ(static_cast<GLsizeiptr>(13), cmd.size);
290   EXPECT_EQ(static_cast<uint32>(14), cmd.data_shm_id);
291   EXPECT_EQ(static_cast<uint32>(15), cmd.data_shm_offset);
293       next_cmd, sizeof(cmd));
298   cmds::CheckFramebufferStatus& cmd =
300   void* next_cmd = cmd.Set(
301       &cmd,
306             cmd.header.command);
307   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
308   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
309   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
310   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
312       next_cmd, sizeof(cmd));
316   cmds::Clear& cmd = *GetBufferAs<cmds::Clear>();
317   void* next_cmd = cmd.Set(
318       &cmd,
321             cmd.header.command);
322   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
323   EXPECT_EQ(static_cast<GLbitfield>(11), cmd.mask);
325       next_cmd, sizeof(cmd));
329   cmds::ClearColor& cmd = *GetBufferAs<cmds::ClearColor>();
330   void* next_cmd = cmd.Set(
331       &cmd,
337             cmd.header.command);
338   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
339   EXPECT_EQ(static_cast<GLclampf>(11), cmd.red);
340   EXPECT_EQ(static_cast<GLclampf>(12), cmd.green);
341   EXPECT_EQ(static_cast<GLclampf>(13), cmd.blue);
342   EXPECT_EQ(static_cast<GLclampf>(14), cmd.alpha);
344       next_cmd, sizeof(cmd));
348   cmds::ClearDepthf& cmd = *GetBufferAs<cmds::ClearDepthf>();
349   void* next_cmd = cmd.Set(
350       &cmd,
353             cmd.header.command);
354   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
355   EXPECT_EQ(static_cast<GLclampf>(11), cmd.depth);
357       next_cmd, sizeof(cmd));
361   cmds::ClearStencil& cmd = *GetBufferAs<cmds::ClearStencil>();
362   void* next_cmd = cmd.Set(
363       &cmd,
366             cmd.header.command);
367   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
368   EXPECT_EQ(static_cast<GLint>(11), cmd.s);
370       next_cmd, sizeof(cmd));
374   cmds::ColorMask& cmd = *GetBufferAs<cmds::ColorMask>();
375   void* next_cmd = cmd.Set(
376       &cmd,
382             cmd.header.command);
383   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
384   EXPECT_EQ(static_cast<GLboolean>(11), cmd.red);
385   EXPECT_EQ(static_cast<GLboolean>(12), cmd.green);
386   EXPECT_EQ(static_cast<GLboolean>(13), cmd.blue);
387   EXPECT_EQ(static_cast<GLboolean>(14), cmd.alpha);
389       next_cmd, sizeof(cmd));
393   cmds::CompileShader& cmd = *GetBufferAs<cmds::CompileShader>();
394   void* next_cmd = cmd.Set(
395       &cmd,
398             cmd.header.command);
399   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
400   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
402       next_cmd, sizeof(cmd));
406   cmds::CompressedTexImage2D& cmd = *GetBufferAs<cmds::CompressedTexImage2D>();
407   void* next_cmd = cmd.Set(
408       &cmd,
419             cmd.header.command);
420   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
421   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
422   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
423   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
424   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
425   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
426   EXPECT_EQ(static_cast<GLint>(16), cmd.border);
427   EXPECT_EQ(static_cast<GLsizei>(17), cmd.imageSize);
428   EXPECT_EQ(static_cast<uint32>(18), cmd.data_shm_id);
429   EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_offset);
431       next_cmd, sizeof(cmd));
436   cmds::CompressedTexImage2DBucket& cmd =
438   void* next_cmd = cmd.Set(
439       &cmd,
448             cmd.header.command);
449   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
450   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
451   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
452   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
453   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
454   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
455   EXPECT_EQ(static_cast<GLint>(16), cmd.border);
456   EXPECT_EQ(static_cast<GLuint>(17), cmd.bucket_id);
458       next_cmd, sizeof(cmd));
462   cmds::CompressedTexSubImage2D& cmd =
464   void* next_cmd = cmd.Set(
465       &cmd,
477             cmd.header.command);
478   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
479   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
480   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
481   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
482   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
483   EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
484   EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
485   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
486   EXPECT_EQ(static_cast<GLsizei>(18), cmd.imageSize);
487   EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_id);
488   EXPECT_EQ(static_cast<uint32>(20), cmd.data_shm_offset);
490       next_cmd, sizeof(cmd));
495   cmds::CompressedTexSubImage2DBucket& cmd =
497   void* next_cmd = cmd.Set(
498       &cmd,
508             cmd.header.command);
509   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
510   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
511   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
512   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
513   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
514   EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
515   EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
516   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
517   EXPECT_EQ(static_cast<GLuint>(18), cmd.bucket_id);
519       next_cmd, sizeof(cmd));
523   cmds::CopyTexImage2D& cmd = *GetBufferAs<cmds::CopyTexImage2D>();
524   void* next_cmd = cmd.Set(
525       &cmd,
535             cmd.header.command);
536   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
537   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
538   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
539   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
540   EXPECT_EQ(static_cast<GLint>(14), cmd.x);
541   EXPECT_EQ(static_cast<GLint>(15), cmd.y);
542   EXPECT_EQ(static_cast<GLsizei>(16), cmd.width);
543   EXPECT_EQ(static_cast<GLsizei>(17), cmd.height);
544   EXPECT_EQ(static_cast<GLint>(18), cmd.border);
546       next_cmd, sizeof(cmd));
550   cmds::CopyTexSubImage2D& cmd = *GetBufferAs<cmds::CopyTexSubImage2D>();
551   void* next_cmd = cmd.Set(
552       &cmd,
562             cmd.header.command);
563   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
564   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
565   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
566   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
567   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
568   EXPECT_EQ(static_cast<GLint>(15), cmd.x);
569   EXPECT_EQ(static_cast<GLint>(16), cmd.y);
570   EXPECT_EQ(static_cast<GLsizei>(17), cmd.width);
571   EXPECT_EQ(static_cast<GLsizei>(18), cmd.height);
573       next_cmd, sizeof(cmd));
577   cmds::CreateProgram& cmd = *GetBufferAs<cmds::CreateProgram>();
578   void* next_cmd = cmd.Set(
579       &cmd,
582             cmd.header.command);
583   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
584   EXPECT_EQ(static_cast<uint32>(11), cmd.client_id);
586       next_cmd, sizeof(cmd));
590   cmds::CreateShader& cmd = *GetBufferAs<cmds::CreateShader>();
591   void* next_cmd = cmd.Set(
592       &cmd,
596             cmd.header.command);
597   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
598   EXPECT_EQ(static_cast<GLenum>(11), cmd.type);
599   EXPECT_EQ(static_cast<uint32>(12), cmd.client_id);
601       next_cmd, sizeof(cmd));
605   cmds::CullFace& cmd = *GetBufferAs<cmds::CullFace>();
606   void* next_cmd = cmd.Set(
607       &cmd,
610             cmd.header.command);
611   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
612   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
614       next_cmd, sizeof(cmd));
618   cmds::DeleteBuffers& cmd = *GetBufferAs<cmds::DeleteBuffers>();
619   void* next_cmd = cmd.Set(
620       &cmd,
625             cmd.header.command);
626   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
627   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
628   EXPECT_EQ(static_cast<uint32>(12), cmd.buffers_shm_id);
629   EXPECT_EQ(static_cast<uint32>(13), cmd.buffers_shm_offset);
631       next_cmd, sizeof(cmd));
636   cmds::DeleteBuffersImmediate& cmd =
638   void* next_cmd = cmd.Set(
639       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
641             cmd.header.command);
642   EXPECT_EQ(sizeof(cmd) +
643             RoundSizeToMultipleOfEntries(cmd.n * 4u),
644             cmd.header.size * 4u);
645   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
647       next_cmd, sizeof(cmd) +
653   cmds::DeleteFramebuffers& cmd = *GetBufferAs<cmds::DeleteFramebuffers>();
654   void* next_cmd = cmd.Set(
655       &cmd,
660             cmd.header.command);
661   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
662   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
663   EXPECT_EQ(static_cast<uint32>(12), cmd.framebuffers_shm_id);
664   EXPECT_EQ(static_cast<uint32>(13), cmd.framebuffers_shm_offset);
666       next_cmd, sizeof(cmd));
671   cmds::DeleteFramebuffersImmediate& cmd =
673   void* next_cmd = cmd.Set(
674       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
676             cmd.header.command);
677   EXPECT_EQ(sizeof(cmd) +
678             RoundSizeToMultipleOfEntries(cmd.n * 4u),
679             cmd.header.size * 4u);
680   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
682       next_cmd, sizeof(cmd) +
688   cmds::DeleteProgram& cmd = *GetBufferAs<cmds::DeleteProgram>();
689   void* next_cmd = cmd.Set(
690       &cmd,
693             cmd.header.command);
694   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
695   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
697       next_cmd, sizeof(cmd));
701   cmds::DeleteRenderbuffers& cmd = *GetBufferAs<cmds::DeleteRenderbuffers>();
702   void* next_cmd = cmd.Set(
703       &cmd,
708             cmd.header.command);
709   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
710   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
711   EXPECT_EQ(static_cast<uint32>(12), cmd.renderbuffers_shm_id);
712   EXPECT_EQ(static_cast<uint32>(13), cmd.renderbuffers_shm_offset);
714       next_cmd, sizeof(cmd));
719   cmds::DeleteRenderbuffersImmediate& cmd =
721   void* next_cmd = cmd.Set(
722       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
724             cmd.header.command);
725   EXPECT_EQ(sizeof(cmd) +
726             RoundSizeToMultipleOfEntries(cmd.n * 4u),
727             cmd.header.size * 4u);
728   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
730       next_cmd, sizeof(cmd) +
736   cmds::DeleteShader& cmd = *GetBufferAs<cmds::DeleteShader>();
737   void* next_cmd = cmd.Set(
738       &cmd,
741             cmd.header.command);
742   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
743   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
745       next_cmd, sizeof(cmd));
749   cmds::DeleteTextures& cmd = *GetBufferAs<cmds::DeleteTextures>();
750   void* next_cmd = cmd.Set(
751       &cmd,
756             cmd.header.command);
757   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
758   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
759   EXPECT_EQ(static_cast<uint32>(12), cmd.textures_shm_id);
760   EXPECT_EQ(static_cast<uint32>(13), cmd.textures_shm_offset);
762       next_cmd, sizeof(cmd));
767   cmds::DeleteTexturesImmediate& cmd =
769   void* next_cmd = cmd.Set(
770       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
772             cmd.header.command);
773   EXPECT_EQ(sizeof(cmd) +
774             RoundSizeToMultipleOfEntries(cmd.n * 4u),
775             cmd.header.size * 4u);
776   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
778       next_cmd, sizeof(cmd) +
784   cmds::DepthFunc& cmd = *GetBufferAs<cmds::DepthFunc>();
785   void* next_cmd = cmd.Set(
786       &cmd,
789             cmd.header.command);
790   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
791   EXPECT_EQ(static_cast<GLenum>(11), cmd.func);
793       next_cmd, sizeof(cmd));
797   cmds::DepthMask& cmd = *GetBufferAs<cmds::DepthMask>();
798   void* next_cmd = cmd.Set(
799       &cmd,
802             cmd.header.command);
803   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
804   EXPECT_EQ(static_cast<GLboolean>(11), cmd.flag);
806       next_cmd, sizeof(cmd));
810   cmds::DepthRangef& cmd = *GetBufferAs<cmds::DepthRangef>();
811   void* next_cmd = cmd.Set(
812       &cmd,
816             cmd.header.command);
817   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
818   EXPECT_EQ(static_cast<GLclampf>(11), cmd.zNear);
819   EXPECT_EQ(static_cast<GLclampf>(12), cmd.zFar);
821       next_cmd, sizeof(cmd));
825   cmds::DetachShader& cmd = *GetBufferAs<cmds::DetachShader>();
826   void* next_cmd = cmd.Set(
827       &cmd,
831             cmd.header.command);
832   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
833   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
834   EXPECT_EQ(static_cast<GLuint>(12), cmd.shader);
836       next_cmd, sizeof(cmd));
840   cmds::Disable& cmd = *GetBufferAs<cmds::Disable>();
841   void* next_cmd = cmd.Set(
842       &cmd,
845             cmd.header.command);
846   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
847   EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
849       next_cmd, sizeof(cmd));
853   cmds::DisableVertexAttribArray& cmd =
855   void* next_cmd = cmd.Set(
856       &cmd,
859             cmd.header.command);
860   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
861   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
863       next_cmd, sizeof(cmd));
867   cmds::DrawArrays& cmd = *GetBufferAs<cmds::DrawArrays>();
868   void* next_cmd = cmd.Set(
869       &cmd,
874             cmd.header.command);
875   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
876   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
877   EXPECT_EQ(static_cast<GLint>(12), cmd.first);
878   EXPECT_EQ(static_cast<GLsizei>(13), cmd.count);
880       next_cmd, sizeof(cmd));
884   cmds::DrawElements& cmd = *GetBufferAs<cmds::DrawElements>();
885   void* next_cmd = cmd.Set(
886       &cmd,
892             cmd.header.command);
893   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
894   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
895   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
896   EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
897   EXPECT_EQ(static_cast<GLuint>(14), cmd.index_offset);
899       next_cmd, sizeof(cmd));
903   cmds::Enable& cmd = *GetBufferAs<cmds::Enable>();
904   void* next_cmd = cmd.Set(
905       &cmd,
908             cmd.header.command);
909   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
910   EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
912       next_cmd, sizeof(cmd));
916   cmds::EnableVertexAttribArray& cmd =
918   void* next_cmd = cmd.Set(
919       &cmd,
922             cmd.header.command);
923   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
924   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
926       next_cmd, sizeof(cmd));
930   cmds::Finish& cmd = *GetBufferAs<cmds::Finish>();
931   void* next_cmd = cmd.Set(
932       &cmd);
934             cmd.header.command);
935   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
937       next_cmd, sizeof(cmd));
941   cmds::Flush& cmd = *GetBufferAs<cmds::Flush>();
942   void* next_cmd = cmd.Set(
943       &cmd);
945             cmd.header.command);
946   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
948       next_cmd, sizeof(cmd));
952   cmds::FramebufferRenderbuffer& cmd =
954   void* next_cmd = cmd.Set(
955       &cmd,
961             cmd.header.command);
962   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
963   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
964   EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
965   EXPECT_EQ(static_cast<GLenum>(13), cmd.renderbuffertarget);
966   EXPECT_EQ(static_cast<GLuint>(14), cmd.renderbuffer);
968       next_cmd, sizeof(cmd));
972   cmds::FramebufferTexture2D& cmd = *GetBufferAs<cmds::FramebufferTexture2D>();
973   void* next_cmd = cmd.Set(
974       &cmd,
981             cmd.header.command);
982   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
983   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
984   EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
985   EXPECT_EQ(static_cast<GLenum>(13), cmd.textarget);
986   EXPECT_EQ(static_cast<GLuint>(14), cmd.texture);
987   EXPECT_EQ(static_cast<GLint>(15), cmd.level);
989       next_cmd, sizeof(cmd));
993   cmds::FrontFace& cmd = *GetBufferAs<cmds::FrontFace>();
994   void* next_cmd = cmd.Set(
995       &cmd,
998             cmd.header.command);
999   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1000   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
1002       next_cmd, sizeof(cmd));
1006   cmds::GenBuffers& cmd = *GetBufferAs<cmds::GenBuffers>();
1007   void* next_cmd = cmd.Set(
1008       &cmd,
1013             cmd.header.command);
1014   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1015   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
1016   EXPECT_EQ(static_cast<uint32>(12), cmd.buffers_shm_id);
1017   EXPECT_EQ(static_cast<uint32>(13), cmd.buffers_shm_offset);
1019       next_cmd, sizeof(cmd));
1024   cmds::GenBuffersImmediate& cmd = *GetBufferAs<cmds::GenBuffersImmediate>();
1025   void* next_cmd = cmd.Set(
1026       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
1028             cmd.header.command);
1029   EXPECT_EQ(sizeof(cmd) +
1030             RoundSizeToMultipleOfEntries(cmd.n * 4u),
1031             cmd.header.size * 4u);
1032   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
1034       next_cmd, sizeof(cmd) +
1040   cmds::GenerateMipmap& cmd = *GetBufferAs<cmds::GenerateMipmap>();
1041   void* next_cmd = cmd.Set(
1042       &cmd,
1045             cmd.header.command);
1046   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1047   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1049       next_cmd, sizeof(cmd));
1053   cmds::GenFramebuffers& cmd = *GetBufferAs<cmds::GenFramebuffers>();
1054   void* next_cmd = cmd.Set(
1055       &cmd,
1060             cmd.header.command);
1061   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1062   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
1063   EXPECT_EQ(static_cast<uint32>(12), cmd.framebuffers_shm_id);
1064   EXPECT_EQ(static_cast<uint32>(13), cmd.framebuffers_shm_offset);
1066       next_cmd, sizeof(cmd));
1071   cmds::GenFramebuffersImmediate& cmd =
1073   void* next_cmd = cmd.Set(
1074       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
1076             cmd.header.command);
1077   EXPECT_EQ(sizeof(cmd) +
1078             RoundSizeToMultipleOfEntries(cmd.n * 4u),
1079             cmd.header.size * 4u);
1080   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
1082       next_cmd, sizeof(cmd) +
1088   cmds::GenRenderbuffers& cmd = *GetBufferAs<cmds::GenRenderbuffers>();
1089   void* next_cmd = cmd.Set(
1090       &cmd,
1095             cmd.header.command);
1096   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1097   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
1098   EXPECT_EQ(static_cast<uint32>(12), cmd.renderbuffers_shm_id);
1099   EXPECT_EQ(static_cast<uint32>(13), cmd.renderbuffers_shm_offset);
1101       next_cmd, sizeof(cmd));
1106   cmds::GenRenderbuffersImmediate& cmd =
1108   void* next_cmd = cmd.Set(
1109       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
1111             cmd.header.command);
1112   EXPECT_EQ(sizeof(cmd) +
1113             RoundSizeToMultipleOfEntries(cmd.n * 4u),
1114             cmd.header.size * 4u);
1115   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
1117       next_cmd, sizeof(cmd) +
1123   cmds::GenTextures& cmd = *GetBufferAs<cmds::GenTextures>();
1124   void* next_cmd = cmd.Set(
1125       &cmd,
1130             cmd.header.command);
1131   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1132   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
1133   EXPECT_EQ(static_cast<uint32>(12), cmd.textures_shm_id);
1134   EXPECT_EQ(static_cast<uint32>(13), cmd.textures_shm_offset);
1136       next_cmd, sizeof(cmd));
1141   cmds::GenTexturesImmediate& cmd = *GetBufferAs<cmds::GenTexturesImmediate>();
1142   void* next_cmd = cmd.Set(
1143       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
1145             cmd.header.command);
1146   EXPECT_EQ(sizeof(cmd) +
1147             RoundSizeToMultipleOfEntries(cmd.n * 4u),
1148             cmd.header.size * 4u);
1149   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
1151       next_cmd, sizeof(cmd) +
1157   cmds::GetActiveAttrib& cmd = *GetBufferAs<cmds::GetActiveAttrib>();
1158   void* next_cmd = cmd.Set(
1159       &cmd,
1166             cmd.header.command);
1167   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1168   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1169   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
1170   EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
1171   EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_id);
1172   EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_offset);
1174       next_cmd, sizeof(cmd));
1178   cmds::GetActiveUniform& cmd = *GetBufferAs<cmds::GetActiveUniform>();
1179   void* next_cmd = cmd.Set(
1180       &cmd,
1187             cmd.header.command);
1188   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1189   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1190   EXPECT_EQ(static_cast<GLuint>(12), cmd.index);
1191   EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
1192   EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_id);
1193   EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_offset);
1195       next_cmd, sizeof(cmd));
1199   cmds::GetAttachedShaders& cmd = *GetBufferAs<cmds::GetAttachedShaders>();
1200   void* next_cmd = cmd.Set(
1201       &cmd,
1207             cmd.header.command);
1208   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1209   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1210   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1211   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1212   EXPECT_EQ(static_cast<uint32>(14), cmd.result_size);
1214       next_cmd, sizeof(cmd));
1221   cmds::GetBooleanv& cmd = *GetBufferAs<cmds::GetBooleanv>();
1222   void* next_cmd = cmd.Set(
1223       &cmd,
1228             cmd.header.command);
1229   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1230   EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
1231   EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
1232   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
1234       next_cmd, sizeof(cmd));
1238   cmds::GetBufferParameteriv& cmd = *GetBufferAs<cmds::GetBufferParameteriv>();
1239   void* next_cmd = cmd.Set(
1240       &cmd,
1246             cmd.header.command);
1247   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1248   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1249   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1250   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1251   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1253       next_cmd, sizeof(cmd));
1257   cmds::GetError& cmd = *GetBufferAs<cmds::GetError>();
1258   void* next_cmd = cmd.Set(
1259       &cmd,
1263             cmd.header.command);
1264   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1265   EXPECT_EQ(static_cast<uint32>(11), cmd.result_shm_id);
1266   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_offset);
1268       next_cmd, sizeof(cmd));
1272   cmds::GetFloatv& cmd = *GetBufferAs<cmds::GetFloatv>();
1273   void* next_cmd = cmd.Set(
1274       &cmd,
1279             cmd.header.command);
1280   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1281   EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
1282   EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
1283   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
1285       next_cmd, sizeof(cmd));
1289   cmds::GetFramebufferAttachmentParameteriv& cmd =
1291   void* next_cmd = cmd.Set(
1292       &cmd,
1300             cmd.header.command);
1301   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1302   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1303   EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
1304   EXPECT_EQ(static_cast<GLenum>(13), cmd.pname);
1305   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_id);
1306   EXPECT_EQ(static_cast<uint32>(15), cmd.params_shm_offset);
1308       next_cmd, sizeof(cmd));
1312   cmds::GetIntegerv& cmd = *GetBufferAs<cmds::GetIntegerv>();
1313   void* next_cmd = cmd.Set(
1314       &cmd,
1319             cmd.header.command);
1320   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1321   EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
1322   EXPECT_EQ(static_cast<uint32>(12), cmd.params_shm_id);
1323   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_offset);
1325       next_cmd, sizeof(cmd));
1329   cmds::GetProgramiv& cmd = *GetBufferAs<cmds::GetProgramiv>();
1330   void* next_cmd = cmd.Set(
1331       &cmd,
1337             cmd.header.command);
1338   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1339   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1340   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1341   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1342   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1344       next_cmd, sizeof(cmd));
1348   cmds::GetProgramInfoLog& cmd = *GetBufferAs<cmds::GetProgramInfoLog>();
1349   void* next_cmd = cmd.Set(
1350       &cmd,
1354             cmd.header.command);
1355   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1356   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1357   EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
1359       next_cmd, sizeof(cmd));
1363   cmds::GetRenderbufferParameteriv& cmd =
1365   void* next_cmd = cmd.Set(
1366       &cmd,
1372             cmd.header.command);
1373   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1374   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1375   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1376   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1377   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1379       next_cmd, sizeof(cmd));
1383   cmds::GetShaderiv& cmd = *GetBufferAs<cmds::GetShaderiv>();
1384   void* next_cmd = cmd.Set(
1385       &cmd,
1391             cmd.header.command);
1392   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1393   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1394   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1395   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1396   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1398       next_cmd, sizeof(cmd));
1402   cmds::GetShaderInfoLog& cmd = *GetBufferAs<cmds::GetShaderInfoLog>();
1403   void* next_cmd = cmd.Set(
1404       &cmd,
1408             cmd.header.command);
1409   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1410   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1411   EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
1413       next_cmd, sizeof(cmd));
1417   cmds::GetShaderPrecisionFormat& cmd =
1419   void* next_cmd = cmd.Set(
1420       &cmd,
1426             cmd.header.command);
1427   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1428   EXPECT_EQ(static_cast<GLenum>(11), cmd.shadertype);
1429   EXPECT_EQ(static_cast<GLenum>(12), cmd.precisiontype);
1430   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_id);
1431   EXPECT_EQ(static_cast<uint32>(14), cmd.result_shm_offset);
1433       next_cmd, sizeof(cmd));
1437   cmds::GetShaderSource& cmd = *GetBufferAs<cmds::GetShaderSource>();
1438   void* next_cmd = cmd.Set(
1439       &cmd,
1443             cmd.header.command);
1444   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1445   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1446   EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
1448       next_cmd, sizeof(cmd));
1452   cmds::GetString& cmd = *GetBufferAs<cmds::GetString>();
1453   void* next_cmd = cmd.Set(
1454       &cmd,
1458             cmd.header.command);
1459   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1460   EXPECT_EQ(static_cast<GLenum>(11), cmd.name);
1461   EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
1463       next_cmd, sizeof(cmd));
1467   cmds::GetTexParameterfv& cmd = *GetBufferAs<cmds::GetTexParameterfv>();
1468   void* next_cmd = cmd.Set(
1469       &cmd,
1475             cmd.header.command);
1476   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1477   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1478   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1479   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1480   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1482       next_cmd, sizeof(cmd));
1486   cmds::GetTexParameteriv& cmd = *GetBufferAs<cmds::GetTexParameteriv>();
1487   void* next_cmd = cmd.Set(
1488       &cmd,
1494             cmd.header.command);
1495   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1496   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1497   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1498   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1499   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1501       next_cmd, sizeof(cmd));
1505   cmds::GetUniformfv& cmd = *GetBufferAs<cmds::GetUniformfv>();
1506   void* next_cmd = cmd.Set(
1507       &cmd,
1513             cmd.header.command);
1514   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1515   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1516   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
1517   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1518   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1520       next_cmd, sizeof(cmd));
1524   cmds::GetUniformiv& cmd = *GetBufferAs<cmds::GetUniformiv>();
1525   void* next_cmd = cmd.Set(
1526       &cmd,
1532             cmd.header.command);
1533   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1534   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1535   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
1536   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1537   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1539       next_cmd, sizeof(cmd));
1546   cmds::GetVertexAttribfv& cmd = *GetBufferAs<cmds::GetVertexAttribfv>();
1547   void* next_cmd = cmd.Set(
1548       &cmd,
1554             cmd.header.command);
1555   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1556   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
1557   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1558   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1559   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1561       next_cmd, sizeof(cmd));
1565   cmds::GetVertexAttribiv& cmd = *GetBufferAs<cmds::GetVertexAttribiv>();
1566   void* next_cmd = cmd.Set(
1567       &cmd,
1573             cmd.header.command);
1574   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1575   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
1576   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1577   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
1578   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
1580       next_cmd, sizeof(cmd));
1584   cmds::GetVertexAttribPointerv& cmd =
1586   void* next_cmd = cmd.Set(
1587       &cmd,
1593             cmd.header.command);
1594   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1595   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
1596   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
1597   EXPECT_EQ(static_cast<uint32>(13), cmd.pointer_shm_id);
1598   EXPECT_EQ(static_cast<uint32>(14), cmd.pointer_shm_offset);
1600       next_cmd, sizeof(cmd));
1604   cmds::Hint& cmd = *GetBufferAs<cmds::Hint>();
1605   void* next_cmd = cmd.Set(
1606       &cmd,
1610             cmd.header.command);
1611   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1612   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1613   EXPECT_EQ(static_cast<GLenum>(12), cmd.mode);
1615       next_cmd, sizeof(cmd));
1619   cmds::IsBuffer& cmd = *GetBufferAs<cmds::IsBuffer>();
1620   void* next_cmd = cmd.Set(
1621       &cmd,
1626             cmd.header.command);
1627   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1628   EXPECT_EQ(static_cast<GLuint>(11), cmd.buffer);
1629   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1630   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1632       next_cmd, sizeof(cmd));
1636   cmds::IsEnabled& cmd = *GetBufferAs<cmds::IsEnabled>();
1637   void* next_cmd = cmd.Set(
1638       &cmd,
1643             cmd.header.command);
1644   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1645   EXPECT_EQ(static_cast<GLenum>(11), cmd.cap);
1646   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1647   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1649       next_cmd, sizeof(cmd));
1653   cmds::IsFramebuffer& cmd = *GetBufferAs<cmds::IsFramebuffer>();
1654   void* next_cmd = cmd.Set(
1655       &cmd,
1660             cmd.header.command);
1661   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1662   EXPECT_EQ(static_cast<GLuint>(11), cmd.framebuffer);
1663   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1664   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1666       next_cmd, sizeof(cmd));
1670   cmds::IsProgram& cmd = *GetBufferAs<cmds::IsProgram>();
1671   void* next_cmd = cmd.Set(
1672       &cmd,
1677             cmd.header.command);
1678   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1679   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1680   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1681   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1683       next_cmd, sizeof(cmd));
1687   cmds::IsRenderbuffer& cmd = *GetBufferAs<cmds::IsRenderbuffer>();
1688   void* next_cmd = cmd.Set(
1689       &cmd,
1694             cmd.header.command);
1695   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1696   EXPECT_EQ(static_cast<GLuint>(11), cmd.renderbuffer);
1697   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1698   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1700       next_cmd, sizeof(cmd));
1704   cmds::IsShader& cmd = *GetBufferAs<cmds::IsShader>();
1705   void* next_cmd = cmd.Set(
1706       &cmd,
1711             cmd.header.command);
1712   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1713   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1714   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1715   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1717       next_cmd, sizeof(cmd));
1721   cmds::IsTexture& cmd = *GetBufferAs<cmds::IsTexture>();
1722   void* next_cmd = cmd.Set(
1723       &cmd,
1728             cmd.header.command);
1729   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1730   EXPECT_EQ(static_cast<GLuint>(11), cmd.texture);
1731   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
1732   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
1734       next_cmd, sizeof(cmd));
1738   cmds::LineWidth& cmd = *GetBufferAs<cmds::LineWidth>();
1739   void* next_cmd = cmd.Set(
1740       &cmd,
1743             cmd.header.command);
1744   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1745   EXPECT_EQ(static_cast<GLfloat>(11), cmd.width);
1747       next_cmd, sizeof(cmd));
1751   cmds::LinkProgram& cmd = *GetBufferAs<cmds::LinkProgram>();
1752   void* next_cmd = cmd.Set(
1753       &cmd,
1756             cmd.header.command);
1757   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1758   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
1760       next_cmd, sizeof(cmd));
1764   cmds::PixelStorei& cmd = *GetBufferAs<cmds::PixelStorei>();
1765   void* next_cmd = cmd.Set(
1766       &cmd,
1770             cmd.header.command);
1771   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1772   EXPECT_EQ(static_cast<GLenum>(11), cmd.pname);
1773   EXPECT_EQ(static_cast<GLint>(12), cmd.param);
1775       next_cmd, sizeof(cmd));
1779   cmds::PolygonOffset& cmd = *GetBufferAs<cmds::PolygonOffset>();
1780   void* next_cmd = cmd.Set(
1781       &cmd,
1785             cmd.header.command);
1786   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1787   EXPECT_EQ(static_cast<GLfloat>(11), cmd.factor);
1788   EXPECT_EQ(static_cast<GLfloat>(12), cmd.units);
1790       next_cmd, sizeof(cmd));
1794   cmds::ReadPixels& cmd = *GetBufferAs<cmds::ReadPixels>();
1795   void* next_cmd = cmd.Set(
1796       &cmd,
1809             cmd.header.command);
1810   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1811   EXPECT_EQ(static_cast<GLint>(11), cmd.x);
1812   EXPECT_EQ(static_cast<GLint>(12), cmd.y);
1813   EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
1814   EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
1815   EXPECT_EQ(static_cast<GLenum>(15), cmd.format);
1816   EXPECT_EQ(static_cast<GLenum>(16), cmd.type);
1817   EXPECT_EQ(static_cast<uint32>(17), cmd.pixels_shm_id);
1818   EXPECT_EQ(static_cast<uint32>(18), cmd.pixels_shm_offset);
1819   EXPECT_EQ(static_cast<uint32>(19), cmd.result_shm_id);
1820   EXPECT_EQ(static_cast<uint32>(20), cmd.result_shm_offset);
1821   EXPECT_EQ(static_cast<GLboolean>(21), cmd.async);
1823       next_cmd, sizeof(cmd));
1827   cmds::ReleaseShaderCompiler& cmd =
1829   void* next_cmd = cmd.Set(
1830       &cmd);
1832             cmd.header.command);
1833   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1835       next_cmd, sizeof(cmd));
1839   cmds::RenderbufferStorage& cmd = *GetBufferAs<cmds::RenderbufferStorage>();
1840   void* next_cmd = cmd.Set(
1841       &cmd,
1847             cmd.header.command);
1848   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1849   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
1850   EXPECT_EQ(static_cast<GLenum>(12), cmd.internalformat);
1851   EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
1852   EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
1854       next_cmd, sizeof(cmd));
1858   cmds::SampleCoverage& cmd = *GetBufferAs<cmds::SampleCoverage>();
1859   void* next_cmd = cmd.Set(
1860       &cmd,
1864             cmd.header.command);
1865   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1866   EXPECT_EQ(static_cast<GLclampf>(11), cmd.value);
1867   EXPECT_EQ(static_cast<GLboolean>(12), cmd.invert);
1869       next_cmd, sizeof(cmd));
1873   cmds::Scissor& cmd = *GetBufferAs<cmds::Scissor>();
1874   void* next_cmd = cmd.Set(
1875       &cmd,
1881             cmd.header.command);
1882   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1883   EXPECT_EQ(static_cast<GLint>(11), cmd.x);
1884   EXPECT_EQ(static_cast<GLint>(12), cmd.y);
1885   EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
1886   EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
1888       next_cmd, sizeof(cmd));
1892   cmds::ShaderBinary& cmd = *GetBufferAs<cmds::ShaderBinary>();
1893   void* next_cmd = cmd.Set(
1894       &cmd,
1903             cmd.header.command);
1904   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1905   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
1906   EXPECT_EQ(static_cast<uint32>(12), cmd.shaders_shm_id);
1907   EXPECT_EQ(static_cast<uint32>(13), cmd.shaders_shm_offset);
1908   EXPECT_EQ(static_cast<GLenum>(14), cmd.binaryformat);
1909   EXPECT_EQ(static_cast<uint32>(15), cmd.binary_shm_id);
1910   EXPECT_EQ(static_cast<uint32>(16), cmd.binary_shm_offset);
1911   EXPECT_EQ(static_cast<GLsizei>(17), cmd.length);
1913       next_cmd, sizeof(cmd));
1917   cmds::ShaderSource& cmd = *GetBufferAs<cmds::ShaderSource>();
1918   void* next_cmd = cmd.Set(
1919       &cmd,
1925             cmd.header.command);
1926   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1927   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1928   EXPECT_EQ(static_cast<uint32>(12), cmd.data_shm_id);
1929   EXPECT_EQ(static_cast<uint32>(13), cmd.data_shm_offset);
1930   EXPECT_EQ(static_cast<uint32>(14), cmd.data_size);
1932       next_cmd, sizeof(cmd));
1937   cmds::ShaderSourceBucket& cmd = *GetBufferAs<cmds::ShaderSourceBucket>();
1938   void* next_cmd = cmd.Set(
1939       &cmd,
1943             cmd.header.command);
1944   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1945   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
1946   EXPECT_EQ(static_cast<uint32>(12), cmd.data_bucket_id);
1948       next_cmd, sizeof(cmd));
1952   cmds::StencilFunc& cmd = *GetBufferAs<cmds::StencilFunc>();
1953   void* next_cmd = cmd.Set(
1954       &cmd,
1959             cmd.header.command);
1960   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1961   EXPECT_EQ(static_cast<GLenum>(11), cmd.func);
1962   EXPECT_EQ(static_cast<GLint>(12), cmd.ref);
1963   EXPECT_EQ(static_cast<GLuint>(13), cmd.mask);
1965       next_cmd, sizeof(cmd));
1969   cmds::StencilFuncSeparate& cmd = *GetBufferAs<cmds::StencilFuncSeparate>();
1970   void* next_cmd = cmd.Set(
1971       &cmd,
1977             cmd.header.command);
1978   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1979   EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
1980   EXPECT_EQ(static_cast<GLenum>(12), cmd.func);
1981   EXPECT_EQ(static_cast<GLint>(13), cmd.ref);
1982   EXPECT_EQ(static_cast<GLuint>(14), cmd.mask);
1984       next_cmd, sizeof(cmd));
1988   cmds::StencilMask& cmd = *GetBufferAs<cmds::StencilMask>();
1989   void* next_cmd = cmd.Set(
1990       &cmd,
1993             cmd.header.command);
1994   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
1995   EXPECT_EQ(static_cast<GLuint>(11), cmd.mask);
1997       next_cmd, sizeof(cmd));
2001   cmds::StencilMaskSeparate& cmd = *GetBufferAs<cmds::StencilMaskSeparate>();
2002   void* next_cmd = cmd.Set(
2003       &cmd,
2007             cmd.header.command);
2008   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2009   EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
2010   EXPECT_EQ(static_cast<GLuint>(12), cmd.mask);
2012       next_cmd, sizeof(cmd));
2016   cmds::StencilOp& cmd = *GetBufferAs<cmds::StencilOp>();
2017   void* next_cmd = cmd.Set(
2018       &cmd,
2023             cmd.header.command);
2024   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2025   EXPECT_EQ(static_cast<GLenum>(11), cmd.fail);
2026   EXPECT_EQ(static_cast<GLenum>(12), cmd.zfail);
2027   EXPECT_EQ(static_cast<GLenum>(13), cmd.zpass);
2029       next_cmd, sizeof(cmd));
2033   cmds::StencilOpSeparate& cmd = *GetBufferAs<cmds::StencilOpSeparate>();
2034   void* next_cmd = cmd.Set(
2035       &cmd,
2041             cmd.header.command);
2042   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2043   EXPECT_EQ(static_cast<GLenum>(11), cmd.face);
2044   EXPECT_EQ(static_cast<GLenum>(12), cmd.fail);
2045   EXPECT_EQ(static_cast<GLenum>(13), cmd.zfail);
2046   EXPECT_EQ(static_cast<GLenum>(14), cmd.zpass);
2048       next_cmd, sizeof(cmd));
2052   cmds::TexImage2D& cmd = *GetBufferAs<cmds::TexImage2D>();
2053   void* next_cmd = cmd.Set(
2054       &cmd,
2066             cmd.header.command);
2067   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2068   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2069   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
2070   EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
2071   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
2072   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
2073   EXPECT_EQ(static_cast<GLint>(16), cmd.border);
2074   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
2075   EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
2076   EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
2077   EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
2079       next_cmd, sizeof(cmd));
2084   cmds::TexParameterf& cmd = *GetBufferAs<cmds::TexParameterf>();
2085   void* next_cmd = cmd.Set(
2086       &cmd,
2091             cmd.header.command);
2092   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2093   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2094   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
2095   EXPECT_EQ(static_cast<GLfloat>(13), cmd.param);
2097       next_cmd, sizeof(cmd));
2101   cmds::TexParameterfv& cmd = *GetBufferAs<cmds::TexParameterfv>();
2102   void* next_cmd = cmd.Set(
2103       &cmd,
2109             cmd.header.command);
2110   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2111   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2112   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
2113   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
2114   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
2116       next_cmd, sizeof(cmd));
2124   cmds::TexParameterfvImmediate& cmd =
2126   void* next_cmd = cmd.Set(
2127       &cmd,
2132             cmd.header.command);
2133   EXPECT_EQ(sizeof(cmd) +
2135             cmd.header.size * 4u);
2136   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2137   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
2139       next_cmd, sizeof(cmd) +
2145   cmds::TexParameteri& cmd = *GetBufferAs<cmds::TexParameteri>();
2146   void* next_cmd = cmd.Set(
2147       &cmd,
2152             cmd.header.command);
2153   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2154   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2155   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
2156   EXPECT_EQ(static_cast<GLint>(13), cmd.param);
2158       next_cmd, sizeof(cmd));
2162   cmds::TexParameteriv& cmd = *GetBufferAs<cmds::TexParameteriv>();
2163   void* next_cmd = cmd.Set(
2164       &cmd,
2170             cmd.header.command);
2171   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2172   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2173   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
2174   EXPECT_EQ(static_cast<uint32>(13), cmd.params_shm_id);
2175   EXPECT_EQ(static_cast<uint32>(14), cmd.params_shm_offset);
2177       next_cmd, sizeof(cmd));
2185   cmds::TexParameterivImmediate& cmd =
2187   void* next_cmd = cmd.Set(
2188       &cmd,
2193             cmd.header.command);
2194   EXPECT_EQ(sizeof(cmd) +
2196             cmd.header.size * 4u);
2197   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2198   EXPECT_EQ(static_cast<GLenum>(12), cmd.pname);
2200       next_cmd, sizeof(cmd) +
2206   cmds::TexSubImage2D& cmd = *GetBufferAs<cmds::TexSubImage2D>();
2207   void* next_cmd = cmd.Set(
2208       &cmd,
2221             cmd.header.command);
2222   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2223   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
2224   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
2225   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
2226   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
2227   EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
2228   EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
2229   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
2230   EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
2231   EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
2232   EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
2233   EXPECT_EQ(static_cast<GLboolean>(21), cmd.internal);
2235       next_cmd, sizeof(cmd));
2240   cmds::Uniform1f& cmd = *GetBufferAs<cmds::Uniform1f>();
2241   void* next_cmd = cmd.Set(
2242       &cmd,
2246             cmd.header.command);
2247   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2248   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2249   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2251       next_cmd, sizeof(cmd));
2255   cmds::Uniform1fv& cmd = *GetBufferAs<cmds::Uniform1fv>();
2256   void* next_cmd = cmd.Set(
2257       &cmd,
2263             cmd.header.command);
2264   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2265   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2266   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2267   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2268   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2270       next_cmd, sizeof(cmd));
2279   cmds::Uniform1fvImmediate& cmd = *GetBufferAs<cmds::Uniform1fvImmediate>();
2282       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 1;
2283   void* next_cmd = cmd.Set(
2284       &cmd,
2289             cmd.header.command);
2290   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2291   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2292   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2294       next_cmd, sizeof(cmd) +
2300   cmds::Uniform1i& cmd = *GetBufferAs<cmds::Uniform1i>();
2301   void* next_cmd = cmd.Set(
2302       &cmd,
2306             cmd.header.command);
2307   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2308   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2309   EXPECT_EQ(static_cast<GLint>(12), cmd.x);
2311       next_cmd, sizeof(cmd));
2315   cmds::Uniform1iv& cmd = *GetBufferAs<cmds::Uniform1iv>();
2316   void* next_cmd = cmd.Set(
2317       &cmd,
2323             cmd.header.command);
2324   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2325   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2326   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2327   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2328   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2330       next_cmd, sizeof(cmd));
2339   cmds::Uniform1ivImmediate& cmd = *GetBufferAs<cmds::Uniform1ivImmediate>();
2342       sizeof(cmd) + kNumElements * sizeof(GLint) * 1;
2343   void* next_cmd = cmd.Set(
2344       &cmd,
2349             cmd.header.command);
2350   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2351   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2352   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2354       next_cmd, sizeof(cmd) +
2360   cmds::Uniform2f& cmd = *GetBufferAs<cmds::Uniform2f>();
2361   void* next_cmd = cmd.Set(
2362       &cmd,
2367             cmd.header.command);
2368   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2369   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2370   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2371   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
2373       next_cmd, sizeof(cmd));
2377   cmds::Uniform2fv& cmd = *GetBufferAs<cmds::Uniform2fv>();
2378   void* next_cmd = cmd.Set(
2379       &cmd,
2385             cmd.header.command);
2386   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2387   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2388   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2389   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2390   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2392       next_cmd, sizeof(cmd));
2403   cmds::Uniform2fvImmediate& cmd = *GetBufferAs<cmds::Uniform2fvImmediate>();
2406       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 2;
2407   void* next_cmd = cmd.Set(
2408       &cmd,
2413             cmd.header.command);
2414   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2415   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2416   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2418       next_cmd, sizeof(cmd) +
2424   cmds::Uniform2i& cmd = *GetBufferAs<cmds::Uniform2i>();
2425   void* next_cmd = cmd.Set(
2426       &cmd,
2431             cmd.header.command);
2432   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2433   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2434   EXPECT_EQ(static_cast<GLint>(12), cmd.x);
2435   EXPECT_EQ(static_cast<GLint>(13), cmd.y);
2437       next_cmd, sizeof(cmd));
2441   cmds::Uniform2iv& cmd = *GetBufferAs<cmds::Uniform2iv>();
2442   void* next_cmd = cmd.Set(
2443       &cmd,
2449             cmd.header.command);
2450   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2451   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2452   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2453   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2454   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2456       next_cmd, sizeof(cmd));
2467   cmds::Uniform2ivImmediate& cmd = *GetBufferAs<cmds::Uniform2ivImmediate>();
2470       sizeof(cmd) + kNumElements * sizeof(GLint) * 2;
2471   void* next_cmd = cmd.Set(
2472       &cmd,
2477             cmd.header.command);
2478   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2479   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2480   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2482       next_cmd, sizeof(cmd) +
2488   cmds::Uniform3f& cmd = *GetBufferAs<cmds::Uniform3f>();
2489   void* next_cmd = cmd.Set(
2490       &cmd,
2496             cmd.header.command);
2497   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2498   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2499   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2500   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
2501   EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
2503       next_cmd, sizeof(cmd));
2507   cmds::Uniform3fv& cmd = *GetBufferAs<cmds::Uniform3fv>();
2508   void* next_cmd = cmd.Set(
2509       &cmd,
2515             cmd.header.command);
2516   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2517   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2518   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2519   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2520   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2522       next_cmd, sizeof(cmd));
2535   cmds::Uniform3fvImmediate& cmd = *GetBufferAs<cmds::Uniform3fvImmediate>();
2538       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 3;
2539   void* next_cmd = cmd.Set(
2540       &cmd,
2545             cmd.header.command);
2546   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2547   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2548   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2550       next_cmd, sizeof(cmd) +
2556   cmds::Uniform3i& cmd = *GetBufferAs<cmds::Uniform3i>();
2557   void* next_cmd = cmd.Set(
2558       &cmd,
2564             cmd.header.command);
2565   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2566   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2567   EXPECT_EQ(static_cast<GLint>(12), cmd.x);
2568   EXPECT_EQ(static_cast<GLint>(13), cmd.y);
2569   EXPECT_EQ(static_cast<GLint>(14), cmd.z);
2571       next_cmd, sizeof(cmd));
2575   cmds::Uniform3iv& cmd = *GetBufferAs<cmds::Uniform3iv>();
2576   void* next_cmd = cmd.Set(
2577       &cmd,
2583             cmd.header.command);
2584   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2585   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2586   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2587   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2588   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2590       next_cmd, sizeof(cmd));
2603   cmds::Uniform3ivImmediate& cmd = *GetBufferAs<cmds::Uniform3ivImmediate>();
2606       sizeof(cmd) + kNumElements * sizeof(GLint) * 3;
2607   void* next_cmd = cmd.Set(
2608       &cmd,
2613             cmd.header.command);
2614   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2615   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2616   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2618       next_cmd, sizeof(cmd) +
2624   cmds::Uniform4f& cmd = *GetBufferAs<cmds::Uniform4f>();
2625   void* next_cmd = cmd.Set(
2626       &cmd,
2633             cmd.header.command);
2634   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2635   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2636   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
2637   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
2638   EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
2639   EXPECT_EQ(static_cast<GLfloat>(15), cmd.w);
2641       next_cmd, sizeof(cmd));
2645   cmds::Uniform4fv& cmd = *GetBufferAs<cmds::Uniform4fv>();
2646   void* next_cmd = cmd.Set(
2647       &cmd,
2653             cmd.header.command);
2654   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2655   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2656   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2657   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2658   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2660       next_cmd, sizeof(cmd));
2675   cmds::Uniform4fvImmediate& cmd = *GetBufferAs<cmds::Uniform4fvImmediate>();
2678       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4;
2679   void* next_cmd = cmd.Set(
2680       &cmd,
2685             cmd.header.command);
2686   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2687   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2688   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2690       next_cmd, sizeof(cmd) +
2696   cmds::Uniform4i& cmd = *GetBufferAs<cmds::Uniform4i>();
2697   void* next_cmd = cmd.Set(
2698       &cmd,
2705             cmd.header.command);
2706   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2707   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2708   EXPECT_EQ(static_cast<GLint>(12), cmd.x);
2709   EXPECT_EQ(static_cast<GLint>(13), cmd.y);
2710   EXPECT_EQ(static_cast<GLint>(14), cmd.z);
2711   EXPECT_EQ(static_cast<GLint>(15), cmd.w);
2713       next_cmd, sizeof(cmd));
2717   cmds::Uniform4iv& cmd = *GetBufferAs<cmds::Uniform4iv>();
2718   void* next_cmd = cmd.Set(
2719       &cmd,
2725             cmd.header.command);
2726   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2727   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2728   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2729   EXPECT_EQ(static_cast<uint32>(13), cmd.v_shm_id);
2730   EXPECT_EQ(static_cast<uint32>(14), cmd.v_shm_offset);
2732       next_cmd, sizeof(cmd));
2747   cmds::Uniform4ivImmediate& cmd = *GetBufferAs<cmds::Uniform4ivImmediate>();
2750       sizeof(cmd) + kNumElements * sizeof(GLint) * 4;
2751   void* next_cmd = cmd.Set(
2752       &cmd,
2757             cmd.header.command);
2758   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2759   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2760   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2762       next_cmd, sizeof(cmd) +
2768   cmds::UniformMatrix2fv& cmd = *GetBufferAs<cmds::UniformMatrix2fv>();
2769   void* next_cmd = cmd.Set(
2770       &cmd,
2777             cmd.header.command);
2778   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2779   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2780   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2781   EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
2782   EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
2783   EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
2785       next_cmd, sizeof(cmd));
2800   cmds::UniformMatrix2fvImmediate& cmd =
2804       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 4;
2805   void* next_cmd = cmd.Set(
2806       &cmd,
2812             cmd.header.command);
2813   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2814   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2815   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2816   EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
2818       next_cmd, sizeof(cmd) +
2824   cmds::UniformMatrix3fv& cmd = *GetBufferAs<cmds::UniformMatrix3fv>();
2825   void* next_cmd = cmd.Set(
2826       &cmd,
2833             cmd.header.command);
2834   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2835   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2836   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2837   EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
2838   EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
2839   EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
2841       next_cmd, sizeof(cmd));
2866   cmds::UniformMatrix3fvImmediate& cmd =
2870       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 9;
2871   void* next_cmd = cmd.Set(
2872       &cmd,
2878             cmd.header.command);
2879   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2880   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2881   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2882   EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
2884       next_cmd, sizeof(cmd) +
2890   cmds::UniformMatrix4fv& cmd = *GetBufferAs<cmds::UniformMatrix4fv>();
2891   void* next_cmd = cmd.Set(
2892       &cmd,
2899             cmd.header.command);
2900   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2901   EXPECT_EQ(static_cast<GLint>(11), cmd.location);
2902   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
2903   EXPECT_EQ(static_cast<GLboolean>(13), cmd.transpose);
2904   EXPECT_EQ(static_cast<uint32>(14), cmd.value_shm_id);
2905   EXPECT_EQ(static_cast<uint32>(15), cmd.value_shm_offset);
2907       next_cmd, sizeof(cmd));
2946   cmds::UniformMatrix4fvImmediate& cmd =
2950       sizeof(cmd) + kNumElements * sizeof(GLfloat) * 16;
2951   void* next_cmd = cmd.Set(
2952       &cmd,
2958             cmd.header.command);
2959   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
2960   EXPECT_EQ(static_cast<GLint>(1), cmd.location);
2961   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
2962   EXPECT_EQ(static_cast<GLboolean>(3), cmd.transpose);
2964       next_cmd, sizeof(cmd) +
2970   cmds::UseProgram& cmd = *GetBufferAs<cmds::UseProgram>();
2971   void* next_cmd = cmd.Set(
2972       &cmd,
2975             cmd.header.command);
2976   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2977   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
2979       next_cmd, sizeof(cmd));
2983   cmds::ValidateProgram& cmd = *GetBufferAs<cmds::ValidateProgram>();
2984   void* next_cmd = cmd.Set(
2985       &cmd,
2988             cmd.header.command);
2989   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
2990   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
2992       next_cmd, sizeof(cmd));
2996   cmds::VertexAttrib1f& cmd = *GetBufferAs<cmds::VertexAttrib1f>();
2997   void* next_cmd = cmd.Set(
2998       &cmd,
3002             cmd.header.command);
3003   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3004   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3005   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
3007       next_cmd, sizeof(cmd));
3011   cmds::VertexAttrib1fv& cmd = *GetBufferAs<cmds::VertexAttrib1fv>();
3012   void* next_cmd = cmd.Set(
3013       &cmd,
3018             cmd.header.command);
3019   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3020   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3021   EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
3022   EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
3024       next_cmd, sizeof(cmd));
3032   cmds::VertexAttrib1fvImmediate& cmd =
3034   void* next_cmd = cmd.Set(
3035       &cmd,
3039             cmd.header.command);
3040   EXPECT_EQ(sizeof(cmd) +
3042             cmd.header.size * 4u);
3043   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3045       next_cmd, sizeof(cmd) +
3051   cmds::VertexAttrib2f& cmd = *GetBufferAs<cmds::VertexAttrib2f>();
3052   void* next_cmd = cmd.Set(
3053       &cmd,
3058             cmd.header.command);
3059   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3060   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3061   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
3062   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
3064       next_cmd, sizeof(cmd));
3068   cmds::VertexAttrib2fv& cmd = *GetBufferAs<cmds::VertexAttrib2fv>();
3069   void* next_cmd = cmd.Set(
3070       &cmd,
3075             cmd.header.command);
3076   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3077   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3078   EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
3079   EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
3081       next_cmd, sizeof(cmd));
3090   cmds::VertexAttrib2fvImmediate& cmd =
3092   void* next_cmd = cmd.Set(
3093       &cmd,
3097             cmd.header.command);
3098   EXPECT_EQ(sizeof(cmd) +
3100             cmd.header.size * 4u);
3101   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3103       next_cmd, sizeof(cmd) +
3109   cmds::VertexAttrib3f& cmd = *GetBufferAs<cmds::VertexAttrib3f>();
3110   void* next_cmd = cmd.Set(
3111       &cmd,
3117             cmd.header.command);
3118   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3119   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3120   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
3121   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
3122   EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
3124       next_cmd, sizeof(cmd));
3128   cmds::VertexAttrib3fv& cmd = *GetBufferAs<cmds::VertexAttrib3fv>();
3129   void* next_cmd = cmd.Set(
3130       &cmd,
3135             cmd.header.command);
3136   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3137   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3138   EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
3139   EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
3141       next_cmd, sizeof(cmd));
3151   cmds::VertexAttrib3fvImmediate& cmd =
3153   void* next_cmd = cmd.Set(
3154       &cmd,
3158             cmd.header.command);
3159   EXPECT_EQ(sizeof(cmd) +
3161             cmd.header.size * 4u);
3162   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3164       next_cmd, sizeof(cmd) +
3170   cmds::VertexAttrib4f& cmd = *GetBufferAs<cmds::VertexAttrib4f>();
3171   void* next_cmd = cmd.Set(
3172       &cmd,
3179             cmd.header.command);
3180   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3181   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3182   EXPECT_EQ(static_cast<GLfloat>(12), cmd.x);
3183   EXPECT_EQ(static_cast<GLfloat>(13), cmd.y);
3184   EXPECT_EQ(static_cast<GLfloat>(14), cmd.z);
3185   EXPECT_EQ(static_cast<GLfloat>(15), cmd.w);
3187       next_cmd, sizeof(cmd));
3191   cmds::VertexAttrib4fv& cmd = *GetBufferAs<cmds::VertexAttrib4fv>();
3192   void* next_cmd = cmd.Set(
3193       &cmd,
3198             cmd.header.command);
3199   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3200   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3201   EXPECT_EQ(static_cast<uint32>(12), cmd.values_shm_id);
3202   EXPECT_EQ(static_cast<uint32>(13), cmd.values_shm_offset);
3204       next_cmd, sizeof(cmd));
3215   cmds::VertexAttrib4fvImmediate& cmd =
3217   void* next_cmd = cmd.Set(
3218       &cmd,
3222             cmd.header.command);
3223   EXPECT_EQ(sizeof(cmd) +
3225             cmd.header.size * 4u);
3226   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3228       next_cmd, sizeof(cmd) +
3234   cmds::VertexAttribPointer& cmd = *GetBufferAs<cmds::VertexAttribPointer>();
3235   void* next_cmd = cmd.Set(
3236       &cmd,
3244             cmd.header.command);
3245   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3246   EXPECT_EQ(static_cast<GLuint>(11), cmd.indx);
3247   EXPECT_EQ(static_cast<GLint>(12), cmd.size);
3248   EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
3249   EXPECT_EQ(static_cast<GLboolean>(14), cmd.normalized);
3250   EXPECT_EQ(static_cast<GLsizei>(15), cmd.stride);
3251   EXPECT_EQ(static_cast<GLuint>(16), cmd.offset);
3253       next_cmd, sizeof(cmd));
3257   cmds::Viewport& cmd = *GetBufferAs<cmds::Viewport>();
3258   void* next_cmd = cmd.Set(
3259       &cmd,
3265             cmd.header.command);
3266   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3267   EXPECT_EQ(static_cast<GLint>(11), cmd.x);
3268   EXPECT_EQ(static_cast<GLint>(12), cmd.y);
3269   EXPECT_EQ(static_cast<GLsizei>(13), cmd.width);
3270   EXPECT_EQ(static_cast<GLsizei>(14), cmd.height);
3272       next_cmd, sizeof(cmd));
3276   cmds::BlitFramebufferEXT& cmd = *GetBufferAs<cmds::BlitFramebufferEXT>();
3277   void* next_cmd = cmd.Set(
3278       &cmd,
3290             cmd.header.command);
3291   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3292   EXPECT_EQ(static_cast<GLint>(11), cmd.srcX0);
3293   EXPECT_EQ(static_cast<GLint>(12), cmd.srcY0);
3294   EXPECT_EQ(static_cast<GLint>(13), cmd.srcX1);
3295   EXPECT_EQ(static_cast<GLint>(14), cmd.srcY1);
3296   EXPECT_EQ(static_cast<GLint>(15), cmd.dstX0);
3297   EXPECT_EQ(static_cast<GLint>(16), cmd.dstY0);
3298   EXPECT_EQ(static_cast<GLint>(17), cmd.dstX1);
3299   EXPECT_EQ(static_cast<GLint>(18), cmd.dstY1);
3300   EXPECT_EQ(static_cast<GLbitfield>(19), cmd.mask);
3301   EXPECT_EQ(static_cast<GLenum>(20), cmd.filter);
3303       next_cmd, sizeof(cmd));
3307   cmds::RenderbufferStorageMultisampleEXT& cmd =
3309   void* next_cmd = cmd.Set(
3310       &cmd,
3318             cmd.header.command);
3319   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3320   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3321   EXPECT_EQ(static_cast<GLsizei>(12), cmd.samples);
3322   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalformat);
3323   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
3324   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
3326       next_cmd, sizeof(cmd));
3330   cmds::FramebufferTexture2DMultisampleEXT& cmd =
3332   void* next_cmd = cmd.Set(
3333       &cmd,
3342             cmd.header.command);
3343   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3344   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3345   EXPECT_EQ(static_cast<GLenum>(12), cmd.attachment);
3346   EXPECT_EQ(static_cast<GLenum>(13), cmd.textarget);
3347   EXPECT_EQ(static_cast<GLuint>(14), cmd.texture);
3348   EXPECT_EQ(static_cast<GLint>(15), cmd.level);
3349   EXPECT_EQ(static_cast<GLsizei>(16), cmd.samples);
3351       next_cmd, sizeof(cmd));
3355   cmds::TexStorage2DEXT& cmd = *GetBufferAs<cmds::TexStorage2DEXT>();
3356   void* next_cmd = cmd.Set(
3357       &cmd,
3364             cmd.header.command);
3365   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3366   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3367   EXPECT_EQ(static_cast<GLsizei>(12), cmd.levels);
3368   EXPECT_EQ(static_cast<GLenum>(13), cmd.internalFormat);
3369   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
3370   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
3372       next_cmd, sizeof(cmd));
3376   cmds::GenQueriesEXT& cmd = *GetBufferAs<cmds::GenQueriesEXT>();
3377   void* next_cmd = cmd.Set(
3378       &cmd,
3383             cmd.header.command);
3384   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3385   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
3386   EXPECT_EQ(static_cast<uint32>(12), cmd.queries_shm_id);
3387   EXPECT_EQ(static_cast<uint32>(13), cmd.queries_shm_offset);
3389       next_cmd, sizeof(cmd));
3394   cmds::GenQueriesEXTImmediate& cmd =
3396   void* next_cmd = cmd.Set(
3397       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
3399             cmd.header.command);
3400   EXPECT_EQ(sizeof(cmd) +
3401             RoundSizeToMultipleOfEntries(cmd.n * 4u),
3402             cmd.header.size * 4u);
3403   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
3405       next_cmd, sizeof(cmd) +
3411   cmds::DeleteQueriesEXT& cmd = *GetBufferAs<cmds::DeleteQueriesEXT>();
3412   void* next_cmd = cmd.Set(
3413       &cmd,
3418             cmd.header.command);
3419   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3420   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
3421   EXPECT_EQ(static_cast<uint32>(12), cmd.queries_shm_id);
3422   EXPECT_EQ(static_cast<uint32>(13), cmd.queries_shm_offset);
3424       next_cmd, sizeof(cmd));
3429   cmds::DeleteQueriesEXTImmediate& cmd =
3431   void* next_cmd = cmd.Set(
3432       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
3434             cmd.header.command);
3435   EXPECT_EQ(sizeof(cmd) +
3436             RoundSizeToMultipleOfEntries(cmd.n * 4u),
3437             cmd.header.size * 4u);
3438   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
3440       next_cmd, sizeof(cmd) +
3446   cmds::BeginQueryEXT& cmd = *GetBufferAs<cmds::BeginQueryEXT>();
3447   void* next_cmd = cmd.Set(
3448       &cmd,
3454             cmd.header.command);
3455   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3456   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3457   EXPECT_EQ(static_cast<GLuint>(12), cmd.id);
3458   EXPECT_EQ(static_cast<uint32>(13), cmd.sync_data_shm_id);
3459   EXPECT_EQ(static_cast<uint32>(14), cmd.sync_data_shm_offset);
3461       next_cmd, sizeof(cmd));
3465   cmds::EndQueryEXT& cmd = *GetBufferAs<cmds::EndQueryEXT>();
3466   void* next_cmd = cmd.Set(
3467       &cmd,
3471             cmd.header.command);
3472   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3473   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3474   EXPECT_EQ(static_cast<GLuint>(12), cmd.submit_count);
3476       next_cmd, sizeof(cmd));
3480   cmds::InsertEventMarkerEXT& cmd = *GetBufferAs<cmds::InsertEventMarkerEXT>();
3481   void* next_cmd = cmd.Set(
3482       &cmd,
3485             cmd.header.command);
3486   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3487   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
3489       next_cmd, sizeof(cmd));
3493   cmds::PushGroupMarkerEXT& cmd = *GetBufferAs<cmds::PushGroupMarkerEXT>();
3494   void* next_cmd = cmd.Set(
3495       &cmd,
3498             cmd.header.command);
3499   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3500   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
3502       next_cmd, sizeof(cmd));
3506   cmds::PopGroupMarkerEXT& cmd = *GetBufferAs<cmds::PopGroupMarkerEXT>();
3507   void* next_cmd = cmd.Set(
3508       &cmd);
3510             cmd.header.command);
3511   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3513       next_cmd, sizeof(cmd));
3517   cmds::GenVertexArraysOES& cmd = *GetBufferAs<cmds::GenVertexArraysOES>();
3518   void* next_cmd = cmd.Set(
3519       &cmd,
3524             cmd.header.command);
3525   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3526   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
3527   EXPECT_EQ(static_cast<uint32>(12), cmd.arrays_shm_id);
3528   EXPECT_EQ(static_cast<uint32>(13), cmd.arrays_shm_offset);
3530       next_cmd, sizeof(cmd));
3535   cmds::GenVertexArraysOESImmediate& cmd =
3537   void* next_cmd = cmd.Set(
3538       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
3540             cmd.header.command);
3541   EXPECT_EQ(sizeof(cmd) +
3542             RoundSizeToMultipleOfEntries(cmd.n * 4u),
3543             cmd.header.size * 4u);
3544   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
3546       next_cmd, sizeof(cmd) +
3552   cmds::DeleteVertexArraysOES& cmd =
3554   void* next_cmd = cmd.Set(
3555       &cmd,
3560             cmd.header.command);
3561   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3562   EXPECT_EQ(static_cast<GLsizei>(11), cmd.n);
3563   EXPECT_EQ(static_cast<uint32>(12), cmd.arrays_shm_id);
3564   EXPECT_EQ(static_cast<uint32>(13), cmd.arrays_shm_offset);
3566       next_cmd, sizeof(cmd));
3571   cmds::DeleteVertexArraysOESImmediate& cmd =
3573   void* next_cmd = cmd.Set(
3574       &cmd, static_cast<GLsizei>(arraysize(ids)), ids);
3576             cmd.header.command);
3577   EXPECT_EQ(sizeof(cmd) +
3578             RoundSizeToMultipleOfEntries(cmd.n * 4u),
3579             cmd.header.size * 4u);
3580   EXPECT_EQ(static_cast<GLsizei>(arraysize(ids)), cmd.n);
3582       next_cmd, sizeof(cmd) +
3588   cmds::IsVertexArrayOES& cmd = *GetBufferAs<cmds::IsVertexArrayOES>();
3589   void* next_cmd = cmd.Set(
3590       &cmd,
3595             cmd.header.command);
3596   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3597   EXPECT_EQ(static_cast<GLuint>(11), cmd.array);
3598   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
3599   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
3601       next_cmd, sizeof(cmd));
3605   cmds::BindVertexArrayOES& cmd = *GetBufferAs<cmds::BindVertexArrayOES>();
3606   void* next_cmd = cmd.Set(
3607       &cmd,
3610             cmd.header.command);
3611   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3612   EXPECT_EQ(static_cast<GLuint>(11), cmd.array);
3614       next_cmd, sizeof(cmd));
3618   cmds::SwapBuffers& cmd = *GetBufferAs<cmds::SwapBuffers>();
3619   void* next_cmd = cmd.Set(
3620       &cmd);
3622             cmd.header.command);
3623   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3625       next_cmd, sizeof(cmd));
3629   cmds::GetMaxValueInBufferCHROMIUM& cmd =
3631   void* next_cmd = cmd.Set(
3632       &cmd,
3640             cmd.header.command);
3641   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3642   EXPECT_EQ(static_cast<GLuint>(11), cmd.buffer_id);
3643   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
3644   EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
3645   EXPECT_EQ(static_cast<GLuint>(14), cmd.offset);
3646   EXPECT_EQ(static_cast<uint32>(15), cmd.result_shm_id);
3647   EXPECT_EQ(static_cast<uint32>(16), cmd.result_shm_offset);
3649       next_cmd, sizeof(cmd));
3653   cmds::GenSharedIdsCHROMIUM& cmd = *GetBufferAs<cmds::GenSharedIdsCHROMIUM>();
3654   void* next_cmd = cmd.Set(
3655       &cmd,
3662             cmd.header.command);
3663   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3664   EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
3665   EXPECT_EQ(static_cast<GLuint>(12), cmd.id_offset);
3666   EXPECT_EQ(static_cast<GLsizei>(13), cmd.n);
3667   EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_id);
3668   EXPECT_EQ(static_cast<uint32>(15), cmd.ids_shm_offset);
3670       next_cmd, sizeof(cmd));
3674   cmds::DeleteSharedIdsCHROMIUM& cmd =
3676   void* next_cmd = cmd.Set(
3677       &cmd,
3683             cmd.header.command);
3684   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3685   EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
3686   EXPECT_EQ(static_cast<GLsizei>(12), cmd.n);
3687   EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_id);
3688   EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_offset);
3690       next_cmd, sizeof(cmd));
3694   cmds::RegisterSharedIdsCHROMIUM& cmd =
3696   void* next_cmd = cmd.Set(
3697       &cmd,
3703             cmd.header.command);
3704   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3705   EXPECT_EQ(static_cast<GLuint>(11), cmd.namespace_id);
3706   EXPECT_EQ(static_cast<GLsizei>(12), cmd.n);
3707   EXPECT_EQ(static_cast<uint32>(13), cmd.ids_shm_id);
3708   EXPECT_EQ(static_cast<uint32>(14), cmd.ids_shm_offset);
3710       next_cmd, sizeof(cmd));
3714   cmds::EnableFeatureCHROMIUM& cmd =
3716   void* next_cmd = cmd.Set(
3717       &cmd,
3722             cmd.header.command);
3723   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3724   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
3725   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
3726   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
3728       next_cmd, sizeof(cmd));
3732   cmds::ResizeCHROMIUM& cmd = *GetBufferAs<cmds::ResizeCHROMIUM>();
3733   void* next_cmd = cmd.Set(
3734       &cmd,
3739             cmd.header.command);
3740   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3741   EXPECT_EQ(static_cast<GLuint>(11), cmd.width);
3742   EXPECT_EQ(static_cast<GLuint>(12), cmd.height);
3743   EXPECT_EQ(static_cast<GLfloat>(13), cmd.scale_factor);
3745       next_cmd, sizeof(cmd));
3749   cmds::GetRequestableExtensionsCHROMIUM& cmd =
3751   void* next_cmd = cmd.Set(
3752       &cmd,
3756             cmd.header.command);
3757   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3758   EXPECT_EQ(static_cast<uint32>(11), cmd.bucket_id);
3760       next_cmd, sizeof(cmd));
3764   cmds::RequestExtensionCHROMIUM& cmd =
3766   void* next_cmd = cmd.Set(
3767       &cmd,
3770             cmd.header.command);
3771   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3772   EXPECT_EQ(static_cast<uint32>(11), cmd.bucket_id);
3774       next_cmd, sizeof(cmd));
3778   cmds::GetMultipleIntegervCHROMIUM& cmd =
3780   void* next_cmd = cmd.Set(
3781       &cmd,
3789             cmd.header.command);
3790   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3791   EXPECT_EQ(static_cast<uint32>(11), cmd.pnames_shm_id);
3792   EXPECT_EQ(static_cast<uint32>(12), cmd.pnames_shm_offset);
3793   EXPECT_EQ(static_cast<GLuint>(13), cmd.count);
3794   EXPECT_EQ(static_cast<uint32>(14), cmd.results_shm_id);
3795   EXPECT_EQ(static_cast<uint32>(15), cmd.results_shm_offset);
3796   EXPECT_EQ(static_cast<GLsizeiptr>(16), cmd.size);
3798       next_cmd, sizeof(cmd));
3802   cmds::GetProgramInfoCHROMIUM& cmd =
3804   void* next_cmd = cmd.Set(
3805       &cmd,
3809             cmd.header.command);
3810   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3811   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
3812   EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
3814       next_cmd, sizeof(cmd));
3818   cmds::CreateStreamTextureCHROMIUM& cmd =
3820   void* next_cmd = cmd.Set(
3821       &cmd,
3826             cmd.header.command);
3827   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3828   EXPECT_EQ(static_cast<GLuint>(11), cmd.client_id);
3829   EXPECT_EQ(static_cast<uint32>(12), cmd.result_shm_id);
3830   EXPECT_EQ(static_cast<uint32>(13), cmd.result_shm_offset);
3832       next_cmd, sizeof(cmd));
3836   cmds::DestroyStreamTextureCHROMIUM& cmd =
3838   void* next_cmd = cmd.Set(
3839       &cmd,
3842             cmd.header.command);
3843   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3844   EXPECT_EQ(static_cast<GLuint>(11), cmd.texture);
3846       next_cmd, sizeof(cmd));
3850   cmds::GetTranslatedShaderSourceANGLE& cmd =
3852   void* next_cmd = cmd.Set(
3853       &cmd,
3857             cmd.header.command);
3858   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3859   EXPECT_EQ(static_cast<GLuint>(11), cmd.shader);
3860   EXPECT_EQ(static_cast<uint32>(12), cmd.bucket_id);
3862       next_cmd, sizeof(cmd));
3866   cmds::PostSubBufferCHROMIUM& cmd =
3868   void* next_cmd = cmd.Set(
3869       &cmd,
3875             cmd.header.command);
3876   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3877   EXPECT_EQ(static_cast<GLint>(11), cmd.x);
3878   EXPECT_EQ(static_cast<GLint>(12), cmd.y);
3879   EXPECT_EQ(static_cast<GLint>(13), cmd.width);
3880   EXPECT_EQ(static_cast<GLint>(14), cmd.height);
3882       next_cmd, sizeof(cmd));
3886   cmds::TexImageIOSurface2DCHROMIUM& cmd =
3888   void* next_cmd = cmd.Set(
3889       &cmd,
3896             cmd.header.command);
3897   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3898   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3899   EXPECT_EQ(static_cast<GLsizei>(12), cmd.width);
3900   EXPECT_EQ(static_cast<GLsizei>(13), cmd.height);
3901   EXPECT_EQ(static_cast<GLuint>(14), cmd.ioSurfaceId);
3902   EXPECT_EQ(static_cast<GLuint>(15), cmd.plane);
3904       next_cmd, sizeof(cmd));
3908   cmds::CopyTextureCHROMIUM& cmd = *GetBufferAs<cmds::CopyTextureCHROMIUM>();
3909   void* next_cmd = cmd.Set(
3910       &cmd,
3918             cmd.header.command);
3919   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3920   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
3921   EXPECT_EQ(static_cast<GLenum>(12), cmd.source_id);
3922   EXPECT_EQ(static_cast<GLenum>(13), cmd.dest_id);
3923   EXPECT_EQ(static_cast<GLint>(14), cmd.level);
3924   EXPECT_EQ(static_cast<GLint>(15), cmd.internalformat);
3925   EXPECT_EQ(static_cast<GLenum>(16), cmd.dest_type);
3927       next_cmd, sizeof(cmd));
3931   cmds::DrawArraysInstancedANGLE& cmd =
3933   void* next_cmd = cmd.Set(
3934       &cmd,
3940             cmd.header.command);
3941   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3942   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
3943   EXPECT_EQ(static_cast<GLint>(12), cmd.first);
3944   EXPECT_EQ(static_cast<GLsizei>(13), cmd.count);
3945   EXPECT_EQ(static_cast<GLsizei>(14), cmd.primcount);
3947       next_cmd, sizeof(cmd));
3951   cmds::DrawElementsInstancedANGLE& cmd =
3953   void* next_cmd = cmd.Set(
3954       &cmd,
3961             cmd.header.command);
3962   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3963   EXPECT_EQ(static_cast<GLenum>(11), cmd.mode);
3964   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
3965   EXPECT_EQ(static_cast<GLenum>(13), cmd.type);
3966   EXPECT_EQ(static_cast<GLuint>(14), cmd.index_offset);
3967   EXPECT_EQ(static_cast<GLsizei>(15), cmd.primcount);
3969       next_cmd, sizeof(cmd));
3973   cmds::VertexAttribDivisorANGLE& cmd =
3975   void* next_cmd = cmd.Set(
3976       &cmd,
3980             cmd.header.command);
3981   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3982   EXPECT_EQ(static_cast<GLuint>(11), cmd.index);
3983   EXPECT_EQ(static_cast<GLuint>(12), cmd.divisor);
3985       next_cmd, sizeof(cmd));
3989   cmds::GenMailboxCHROMIUM& cmd = *GetBufferAs<cmds::GenMailboxCHROMIUM>();
3990   void* next_cmd = cmd.Set(
3991       &cmd,
3994             cmd.header.command);
3995   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
3996   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
3998       next_cmd, sizeof(cmd));
4002   cmds::ProduceTextureCHROMIUM& cmd =
4004   void* next_cmd = cmd.Set(
4005       &cmd,
4010             cmd.header.command);
4011   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4012   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4013   EXPECT_EQ(static_cast<uint32>(12), cmd.mailbox_shm_id);
4014   EXPECT_EQ(static_cast<uint32>(13), cmd.mailbox_shm_offset);
4016       next_cmd, sizeof(cmd));
4087   cmds::ProduceTextureCHROMIUMImmediate& cmd =
4089   void* next_cmd = cmd.Set(
4090       &cmd,
4094             cmd.header.command);
4095   EXPECT_EQ(sizeof(cmd) +
4097             cmd.header.size * 4u);
4098   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4100       next_cmd, sizeof(cmd) +
4106   cmds::ConsumeTextureCHROMIUM& cmd =
4108   void* next_cmd = cmd.Set(
4109       &cmd,
4114             cmd.header.command);
4115   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4116   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4117   EXPECT_EQ(static_cast<uint32>(12), cmd.mailbox_shm_id);
4118   EXPECT_EQ(static_cast<uint32>(13), cmd.mailbox_shm_offset);
4120       next_cmd, sizeof(cmd));
4191   cmds::ConsumeTextureCHROMIUMImmediate& cmd =
4193   void* next_cmd = cmd.Set(
4194       &cmd,
4198             cmd.header.command);
4199   EXPECT_EQ(sizeof(cmd) +
4201             cmd.header.size * 4u);
4202   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4204       next_cmd, sizeof(cmd) +
4210   cmds::BindUniformLocationCHROMIUM& cmd =
4212   void* next_cmd = cmd.Set(
4213       &cmd,
4220             cmd.header.command);
4221   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4222   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
4223   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
4224   EXPECT_EQ(static_cast<uint32>(13), cmd.name_shm_id);
4225   EXPECT_EQ(static_cast<uint32>(14), cmd.name_shm_offset);
4226   EXPECT_EQ(static_cast<uint32>(15), cmd.data_size);
4228       next_cmd, sizeof(cmd));
4233   cmds::BindUniformLocationCHROMIUMImmediate& cmd =
4236   void* next_cmd = cmd.Set(
4237       &cmd,
4244             cmd.header.command);
4245   EXPECT_EQ(sizeof(cmd) +
4247             cmd.header.size * 4u);
4249             reinterpret_cast<char*>(&cmd) + sizeof(cmd) +
4251   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
4252   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
4253   EXPECT_EQ(static_cast<uint32>(strlen(test_str)), cmd.data_size);
4254   EXPECT_EQ(0, memcmp(test_str, ImmediateDataAddress(&cmd), strlen(test_str)));
4257       sizeof(cmd) + RoundSizeToMultipleOfEntries(strlen(test_str)),
4258       sizeof(cmd) + strlen(test_str));
4262   cmds::BindUniformLocationCHROMIUMBucket& cmd =
4264   void* next_cmd = cmd.Set(
4265       &cmd,
4271             cmd.header.command);
4272   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4273   EXPECT_EQ(static_cast<GLuint>(11), cmd.program);
4274   EXPECT_EQ(static_cast<GLint>(12), cmd.location);
4275   EXPECT_EQ(static_cast<uint32>(13), cmd.name_bucket_id);
4277       next_cmd, sizeof(cmd));
4281   cmds::BindTexImage2DCHROMIUM& cmd =
4283   void* next_cmd = cmd.Set(
4284       &cmd,
4288             cmd.header.command);
4289   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4290   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4291   EXPECT_EQ(static_cast<GLint>(12), cmd.imageId);
4293       next_cmd, sizeof(cmd));
4297   cmds::ReleaseTexImage2DCHROMIUM& cmd =
4299   void* next_cmd = cmd.Set(
4300       &cmd,
4304             cmd.header.command);
4305   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4306   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4307   EXPECT_EQ(static_cast<GLint>(12), cmd.imageId);
4309       next_cmd, sizeof(cmd));
4313   cmds::TraceBeginCHROMIUM& cmd = *GetBufferAs<cmds::TraceBeginCHROMIUM>();
4314   void* next_cmd = cmd.Set(
4315       &cmd,
4318             cmd.header.command);
4319   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4320   EXPECT_EQ(static_cast<GLuint>(11), cmd.bucket_id);
4322       next_cmd, sizeof(cmd));
4326   cmds::TraceEndCHROMIUM& cmd = *GetBufferAs<cmds::TraceEndCHROMIUM>();
4327   void* next_cmd = cmd.Set(
4328       &cmd);
4330             cmd.header.command);
4331   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4333       next_cmd, sizeof(cmd));
4337   cmds::AsyncTexSubImage2DCHROMIUM& cmd =
4339   void* next_cmd = cmd.Set(
4340       &cmd,
4352             cmd.header.command);
4353   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4354   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4355   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
4356   EXPECT_EQ(static_cast<GLint>(13), cmd.xoffset);
4357   EXPECT_EQ(static_cast<GLint>(14), cmd.yoffset);
4358   EXPECT_EQ(static_cast<GLsizei>(15), cmd.width);
4359   EXPECT_EQ(static_cast<GLsizei>(16), cmd.height);
4360   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
4361   EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
4362   EXPECT_EQ(static_cast<uint32>(19), cmd.data_shm_id);
4363   EXPECT_EQ(static_cast<uint32>(20), cmd.data_shm_offset);
4365       next_cmd, sizeof(cmd));
4369   cmds::AsyncTexImage2DCHROMIUM& cmd =
4371   void* next_cmd = cmd.Set(
4372       &cmd,
4384             cmd.header.command);
4385   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4386   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4387   EXPECT_EQ(static_cast<GLint>(12), cmd.level);
4388   EXPECT_EQ(static_cast<GLint>(13), cmd.internalformat);
4389   EXPECT_EQ(static_cast<GLsizei>(14), cmd.width);
4390   EXPECT_EQ(static_cast<GLsizei>(15), cmd.height);
4391   EXPECT_EQ(static_cast<GLint>(16), cmd.border);
4392   EXPECT_EQ(static_cast<GLenum>(17), cmd.format);
4393   EXPECT_EQ(static_cast<GLenum>(18), cmd.type);
4394   EXPECT_EQ(static_cast<uint32>(19), cmd.pixels_shm_id);
4395   EXPECT_EQ(static_cast<uint32>(20), cmd.pixels_shm_offset);
4397       next_cmd, sizeof(cmd));
4401   cmds::WaitAsyncTexImage2DCHROMIUM& cmd =
4403   void* next_cmd = cmd.Set(
4404       &cmd,
4407             cmd.header.command);
4408   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4409   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4411       next_cmd, sizeof(cmd));
4415   cmds::DiscardFramebufferEXT& cmd =
4417   void* next_cmd = cmd.Set(
4418       &cmd,
4424             cmd.header.command);
4425   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4426   EXPECT_EQ(static_cast<GLenum>(11), cmd.target);
4427   EXPECT_EQ(static_cast<GLsizei>(12), cmd.count);
4428   EXPECT_EQ(static_cast<uint32>(13), cmd.attachments_shm_id);
4429   EXPECT_EQ(static_cast<uint32>(14), cmd.attachments_shm_offset);
4431       next_cmd, sizeof(cmd));
4440   cmds::DiscardFramebufferEXTImmediate& cmd =
4444       sizeof(cmd) + kNumElements * sizeof(GLenum) * 1;
4445   void* next_cmd = cmd.Set(
4446       &cmd,
4451             cmd.header.command);
4452   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
4453   EXPECT_EQ(static_cast<GLenum>(1), cmd.target);
4454   EXPECT_EQ(static_cast<GLsizei>(2), cmd.count);
4456       next_cmd, sizeof(cmd) +
4462   cmds::LoseContextCHROMIUM& cmd = *GetBufferAs<cmds::LoseContextCHROMIUM>();
4463   void* next_cmd = cmd.Set(
4464       &cmd,
4468             cmd.header.command);
4469   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4470   EXPECT_EQ(static_cast<GLenum>(11), cmd.current);
4471   EXPECT_EQ(static_cast<GLenum>(12), cmd.other);
4473       next_cmd, sizeof(cmd));
4478   cmds::WaitSyncPointCHROMIUM& cmd =
4480   void* next_cmd = cmd.Set(
4481       &cmd,
4484             cmd.header.command);
4485   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4486   EXPECT_EQ(static_cast<GLuint>(11), cmd.sync_point);
4488       next_cmd, sizeof(cmd));
4492   cmds::DrawBuffersEXT& cmd = *GetBufferAs<cmds::DrawBuffersEXT>();
4493   void* next_cmd = cmd.Set(
4494       &cmd,
4499             cmd.header.command);
4500   EXPECT_EQ(sizeof(cmd), cmd.header.size * 4u);
4501   EXPECT_EQ(static_cast<GLsizei>(11), cmd.count);
4502   EXPECT_EQ(static_cast<uint32>(12), cmd.bufs_shm_id);
4503   EXPECT_EQ(static_cast<uint32>(13), cmd.bufs_shm_offset);
4505       next_cmd, sizeof(cmd));
4513   cmds::DrawBuffersEXTImmediate& cmd =
4517       sizeof(cmd) + kNumElements * sizeof(GLenum) * 1;
4518   void* next_cmd = cmd.Set(
4519       &cmd,
4523             cmd.header.command);
4524   EXPECT_EQ(kExpectedCmdSize, cmd.header.size * 4u);
4525   EXPECT_EQ(static_cast<GLsizei>(1), cmd.count);
4527       next_cmd, sizeof(cmd) +