Make command buffer commands and immediate data volatile

gpu/command_buffer/service/gles2_cmd_decoder.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 
 #include <limits.h>
 #include <stddef.h>
 #include <stdint.h>
 #include <stdio.h>
@@ skipping 524 matching lines @@
 
 GLES2Decoder::~GLES2Decoder() {
 }
 
 void GLES2Decoder::BeginDecoding() {}
 
 void GLES2Decoder::EndDecoding() {}
 
 error::Error GLES2Decoder::DoCommand(unsigned int command,
                                      unsigned int arg_count,
-                                     const void* cmd_data) {
+                                     const volatile void* cmd_data) {
   return DoCommands(1, cmd_data, arg_count + 1, 0);
 }
 
 // This class implements GLES2Decoder so we don't have to expose all the GLES2
 // cmd stuff to outside this class.
 class GLES2DecoderImpl : public GLES2Decoder, public ErrorStateClient {
  public:
   explicit GLES2DecoderImpl(ContextGroup* group);
   ~GLES2DecoderImpl() override;
 
   error::Error DoCommands(unsigned int num_commands,
-                          const void* buffer,
+                          const volatile void* buffer,
                           int num_entries,
                           int* entries_processed) override;
 
   template <bool DebugImpl>
   error::Error DoCommandsImpl(unsigned int num_commands,
-                              const void* buffer,
+                              const volatile void* buffer,
                               int num_entries,
                               int* entries_processed);
 
   // Overridden from AsyncAPIInterface.
   const char* GetCommandName(unsigned int command_id) const override;
 
   // Overridden from GLES2Decoder.
   bool Initialize(const scoped_refptr<gl::GLSurface>& surface,
                   const scoped_refptr<gl::GLContext>& context,
                   bool offscreen,
@@ skipping 154 matching lines @@
     kBindBufferRange
   };
 
   // Initialize or re-initialize the shader translator.
   bool InitializeShaderTranslator();
 
   void UpdateCapabilities();
 
   // Helpers for the glGen and glDelete functions.
   bool GenTexturesHelper(GLsizei n, const GLuint* client_ids);
-  void DeleteTexturesHelper(GLsizei n, const GLuint* client_ids);
+  void DeleteTexturesHelper(GLsizei n, const volatile GLuint* client_ids);
   bool GenBuffersHelper(GLsizei n, const GLuint* client_ids);
-  void DeleteBuffersHelper(GLsizei n, const GLuint* client_ids);
+  void DeleteBuffersHelper(GLsizei n, const volatile GLuint* client_ids);
   bool GenFramebuffersHelper(GLsizei n, const GLuint* client_ids);
-  void DeleteFramebuffersHelper(GLsizei n, const GLuint* client_ids);
+  void DeleteFramebuffersHelper(GLsizei n, const volatile GLuint* client_ids);
   bool GenRenderbuffersHelper(GLsizei n, const GLuint* client_ids);
-  void DeleteRenderbuffersHelper(GLsizei n, const GLuint* client_ids);
+  void DeleteRenderbuffersHelper(GLsizei n, const volatile GLuint* client_ids);
   bool GenQueriesEXTHelper(GLsizei n, const GLuint* client_ids);
-  void DeleteQueriesEXTHelper(GLsizei n, const GLuint* client_ids);
+  void DeleteQueriesEXTHelper(GLsizei n, const volatile GLuint* client_ids);
   bool GenVertexArraysOESHelper(GLsizei n, const GLuint* client_ids);
-  void DeleteVertexArraysOESHelper(GLsizei n, const GLuint* client_ids);
+  void DeleteVertexArraysOESHelper(GLsizei n,
+                                   const volatile GLuint* client_ids);
   bool GenPathsCHROMIUMHelper(GLuint first_client_id, GLsizei range);
   bool DeletePathsCHROMIUMHelper(GLuint first_client_id, GLsizei range);
   bool GenSamplersHelper(GLsizei n, const GLuint* client_ids);
-  void DeleteSamplersHelper(GLsizei n, const GLuint* client_ids);
+  void DeleteSamplersHelper(GLsizei n, const volatile GLuint* client_ids);
   bool GenTransformFeedbacksHelper(GLsizei n, const GLuint* client_ids);
-  void DeleteTransformFeedbacksHelper(GLsizei n, const GLuint* client_ids);
+  void DeleteTransformFeedbacksHelper(GLsizei n,
+                                      const volatile GLuint* client_ids);
   void DeleteSyncHelper(GLuint sync);
 
   // Workarounds
   void OnFboChanged() const;
   void OnUseFramebuffer() const;
 
   error::ContextLostReason GetContextLostReasonFromResetStatus(
       GLenum reset_status) const;
 
   // TODO(gman): Cache these pointers?
@@ skipping 281 matching lines @@
                          GLsizei height);
 
   // Wrapper for TexStorage3D.
   void DoTexStorage3D(GLenum target,
                       GLsizei levels,
                       GLenum internal_format,
                       GLsizei width,
                       GLsizei height,
                       GLsizei depth);
 
-  void DoProduceTextureCHROMIUM(GLenum target, const GLbyte* key);
-  void DoProduceTextureDirectCHROMIUM(GLuint texture, GLenum target,
-      const GLbyte* key);
+  void DoProduceTextureCHROMIUM(GLenum target, const volatile GLbyte* key);
+  void DoProduceTextureDirectCHROMIUM(GLuint texture,
+                                      GLenum target,
+                                      const volatile GLbyte* key);
   void ProduceTextureRef(const char* func_name,
                          bool clear,
                          TextureRef* texture_ref,
                          GLenum target,
-                         const GLbyte* data);
+                         const volatile GLbyte* data);
 
   void EnsureTextureForClientId(GLenum target, GLuint client_id);
-  void DoConsumeTextureCHROMIUM(GLenum target, const GLbyte* key);
+  void DoConsumeTextureCHROMIUM(GLenum target, const volatile GLbyte* key);
   void DoCreateAndConsumeTextureINTERNAL(GLenum target,
                                          GLuint client_id,
-                                         const GLbyte* key);
+                                         const volatile GLbyte* key);
   void DoApplyScreenSpaceAntialiasingCHROMIUM();
 
   void DoBindTexImage2DCHROMIUM(
       GLenum target,
       GLint image_id);
   void DoReleaseTexImage2DCHROMIUM(
       GLenum target,
       GLint image_id);
 
   void DoTraceEndCHROMIUM(void);
 
-  void DoDrawBuffersEXT(GLsizei count, const GLenum* bufs);
+  void DoDrawBuffersEXT(GLsizei count, const volatile GLenum* bufs);
 
   void DoLoseContextCHROMIUM(GLenum current, GLenum other);
 
   void DoFlushDriverCachesCHROMIUM(void);
 
-  void DoMatrixLoadfCHROMIUM(GLenum matrix_mode, const GLfloat* matrix);
+  void DoMatrixLoadfCHROMIUM(GLenum matrix_mode,
+                             const volatile GLfloat* matrix);
   void DoMatrixLoadIdentityCHROMIUM(GLenum matrix_mode);
   void DoScheduleCALayerInUseQueryCHROMIUM(GLsizei count,
-                                           const GLuint* textures);
+                                           const volatile GLuint* textures);
 
   // Creates a Program for the given program.
   Program* CreateProgram(GLuint client_id, GLuint service_id) {
     return program_manager()->CreateProgram(client_id, service_id);
   }
 
   // Gets the program info for the given program. Returns NULL if none exists.
   Program* GetProgram(GLuint client_id) {
     return program_manager()->GetProgram(client_id);
   }
@@ skipping 382 matching lines @@
 
   // Wrapper for glBufferSubData.
   void DoBufferSubData(
     GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid * data);
 
   // Wrapper for glCheckFramebufferStatus
   GLenum DoCheckFramebufferStatus(GLenum target);
 
   // Wrapper for glClear*()
   error::Error DoClear(GLbitfield mask);
-  void DoClearBufferiv(
-      GLenum buffer, GLint drawbuffer, const GLint* value);
-  void DoClearBufferuiv(
-      GLenum buffer, GLint drawbuffer, const GLuint* value);
-  void DoClearBufferfv(
-      GLenum buffer, GLint drawbuffer, const GLfloat* value);
+  void DoClearBufferiv(GLenum buffer,
+                       GLint drawbuffer,
+                       const volatile GLint* value);
+  void DoClearBufferuiv(GLenum buffer,
+                        GLint drawbuffer,
+                        const volatile GLuint* value);
+  void DoClearBufferfv(GLenum buffer,
+                       GLint drawbuffer,
+                       const volatile GLfloat* value);
   void DoClearBufferfi(
       GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil);
 
   // Wrappers for various state.
   void DoDepthRangef(GLclampf znear, GLclampf zfar);
   void DoSampleCoverage(GLclampf value, GLboolean invert);
 
   // Wrapper for glCompileShader.
   void DoCompileShader(GLuint shader);
 
   // Wrapper for glDetachShader
   void DoDetachShader(GLuint client_program_id, GLint client_shader_id);
 
   // Wrapper for glDisable
   void DoDisable(GLenum cap);
 
   // Wrapper for glDisableVertexAttribArray.
   void DoDisableVertexAttribArray(GLuint index);
 
   // Wrapper for glDiscardFramebufferEXT, since we need to track undefined
   // attachments.
-  void DoDiscardFramebufferEXT(
-      GLenum target, GLsizei count, const GLenum* attachments);
+  void DoDiscardFramebufferEXT(GLenum target,
+                               GLsizei count,
+                               const volatile GLenum* attachments);
 
-  void DoInvalidateFramebuffer(
-      GLenum target, GLsizei count, const GLenum* attachments);
-  void DoInvalidateSubFramebuffer(
-      GLenum target, GLsizei count, const GLenum* attachments,
-      GLint x, GLint y, GLsizei width, GLsizei height);
+  void DoInvalidateFramebuffer(GLenum target,
+                               GLsizei count,
+                               const volatile GLenum* attachments);
+  void DoInvalidateSubFramebuffer(GLenum target,
+                                  GLsizei count,
+                                  const volatile GLenum* attachments,
+                                  GLint x,
+                                  GLint y,
+                                  GLsizei width,
+                                  GLsizei height);
 
   // Helper for DoDiscardFramebufferEXT, DoInvalidate{Sub}Framebuffer.
-  void InvalidateFramebufferImpl(
-      GLenum target, GLsizei count, const GLenum* attachments,
-      GLint x, GLint y, GLsizei width, GLsizei height,
-      const char* function_name, FramebufferOperation op);
+  void InvalidateFramebufferImpl(GLenum target,
+                                 GLsizei count,
+                                 const volatile GLenum* attachments,
+                                 GLint x,
+                                 GLint y,
+                                 GLsizei width,
+                                 GLsizei height,
+                                 const char* function_name,
+                                 FramebufferOperation op);
 
   // Wrapper for glEnable
   void DoEnable(GLenum cap);
 
   // Wrapper for glEnableVertexAttribArray.
   void DoEnableVertexAttribArray(GLuint index);
 
   // Wrapper for glFinish.
   void DoFinish();
 
@@ skipping 155 matching lines @@
   // buffers under memory pressure
   bool VerifyMultisampleRenderbufferIntegrity(
       GLuint renderbuffer, GLenum format);
 
   // Wrapper for glReleaseShaderCompiler.
   void DoReleaseShaderCompiler() { }
 
   // Wrappers for glSamplerParameter functions.
   void DoSamplerParameterf(GLuint client_id, GLenum pname, GLfloat param);
   void DoSamplerParameteri(GLuint client_id, GLenum pname, GLint param);
-  void DoSamplerParameterfv(
-      GLuint client_id, GLenum pname, const GLfloat* params);
-  void DoSamplerParameteriv(
-      GLuint client_id, GLenum pname, const GLint* params);
+  void DoSamplerParameterfv(GLuint client_id,
+                            GLenum pname,
+                            const volatile GLfloat* params);
+  void DoSamplerParameteriv(GLuint client_id,
+                            GLenum pname,
+                            const volatile GLint* params);
 
   // Wrappers for glTexParameter functions.
   void DoTexParameterf(GLenum target, GLenum pname, GLfloat param);
   void DoTexParameteri(GLenum target, GLenum pname, GLint param);
-  void DoTexParameterfv(GLenum target, GLenum pname, const GLfloat* params);
-  void DoTexParameteriv(GLenum target, GLenum pname, const GLint* params);
+  void DoTexParameterfv(GLenum target,
+                        GLenum pname,
+                        const volatile GLfloat* params);
+  void DoTexParameteriv(GLenum target,
+                        GLenum pname,
+                        const volatile GLint* params);
 
   // Wrappers for glUniform1i and glUniform1iv as according to the GLES2
   // spec only these 2 functions can be used to set sampler uniforms.
   void DoUniform1i(GLint fake_location, GLint v0);
-  void DoUniform1iv(GLint fake_location, GLsizei count, const GLint* value);
-  void DoUniform2iv(GLint fake_location, GLsizei count, const GLint* value);
-  void DoUniform3iv(GLint fake_location, GLsizei count, const GLint* value);
-  void DoUniform4iv(GLint fake_location, GLsizei count, const GLint* value);
+  void DoUniform1iv(GLint fake_location,
+                    GLsizei count,
+                    const volatile GLint* value);
+  void DoUniform2iv(GLint fake_location,
+                    GLsizei count,
+                    const volatile GLint* value);
+  void DoUniform3iv(GLint fake_location,
+                    GLsizei count,
+                    const volatile GLint* value);
+  void DoUniform4iv(GLint fake_location,
+                    GLsizei count,
+                    const volatile GLint* value);
 
   void DoUniform1ui(GLint fake_location, GLuint v0);
-  void DoUniform1uiv(GLint fake_location, GLsizei count, const GLuint* value);
-  void DoUniform2uiv(GLint fake_location, GLsizei count, const GLuint* value);
-  void DoUniform3uiv(GLint fake_location, GLsizei count, const GLuint* value);
-  void DoUniform4uiv(GLint fake_location, GLsizei count, const GLuint* value);
+  void DoUniform1uiv(GLint fake_location,
+                     GLsizei count,
+                     const volatile GLuint* value);
+  void DoUniform2uiv(GLint fake_location,
+                     GLsizei count,
+                     const volatile GLuint* value);
+  void DoUniform3uiv(GLint fake_location,
+                     GLsizei count,
+                     const volatile GLuint* value);
+  void DoUniform4uiv(GLint fake_location,
+                     GLsizei count,
+                     const volatile GLuint* value);
 
   // Wrappers for glUniformfv because some drivers don't correctly accept
   // bool uniforms.
-  void DoUniform1fv(GLint fake_location, GLsizei count, const GLfloat* value);
-  void DoUniform2fv(GLint fake_location, GLsizei count, const GLfloat* value);
-  void DoUniform3fv(GLint fake_location, GLsizei count, const GLfloat* value);
-  void DoUniform4fv(GLint fake_location, GLsizei count, const GLfloat* value);
+  void DoUniform1fv(GLint fake_location,
+                    GLsizei count,
+                    const volatile GLfloat* value);
+  void DoUniform2fv(GLint fake_location,
+                    GLsizei count,
+                    const volatile GLfloat* value);
+  void DoUniform3fv(GLint fake_location,
+                    GLsizei count,
+                    const volatile GLfloat* value);
+  void DoUniform4fv(GLint fake_location,
+                    GLsizei count,
+                    const volatile GLfloat* value);
 
-  void DoUniformMatrix2fv(
-      GLint fake_location, GLsizei count, GLboolean transpose,
-      const GLfloat* value);
-  void DoUniformMatrix3fv(
-      GLint fake_location, GLsizei count, GLboolean transpose,
-      const GLfloat* value);
-  void DoUniformMatrix4fv(
-      GLint fake_location, GLsizei count, GLboolean transpose,
-      const GLfloat* value);
+  void DoUniformMatrix2fv(GLint fake_location,
+                          GLsizei count,
+                          GLboolean transpose,
+                          const volatile GLfloat* value);
+  void DoUniformMatrix3fv(GLint fake_location,
+                          GLsizei count,
+                          GLboolean transpose,
+                          const volatile GLfloat* value);
+  void DoUniformMatrix4fv(GLint fake_location,
+                          GLsizei count,
+                          GLboolean transpose,
+                          const volatile GLfloat* value);
   void DoUniformMatrix4fvStreamTextureMatrixCHROMIUM(
       GLint fake_location,
       GLboolean transpose,
-      const GLfloat* default_value);
-  void DoUniformMatrix2x3fv(
-      GLint fake_location, GLsizei count, GLboolean transpose,
-      const GLfloat* value);
-  void DoUniformMatrix2x4fv(
-      GLint fake_location, GLsizei count, GLboolean transpose,
-      const GLfloat* value);
-  void DoUniformMatrix3x2fv(
-      GLint fake_location, GLsizei count, GLboolean transpose,
-      const GLfloat* value);
-  void DoUniformMatrix3x4fv(
-      GLint fake_location, GLsizei count, GLboolean transpose,
-      const GLfloat* value);
-  void DoUniformMatrix4x2fv(
-      GLint fake_location, GLsizei count, GLboolean transpose,
-      const GLfloat* value);
-  void DoUniformMatrix4x3fv(
-      GLint fake_location, GLsizei count, GLboolean transpose,
-      const GLfloat* value);
+      const volatile GLfloat* default_value);
+  void DoUniformMatrix2x3fv(GLint fake_location,
+                            GLsizei count,
+                            GLboolean transpose,
+                            const volatile GLfloat* value);
+  void DoUniformMatrix2x4fv(GLint fake_location,
+                            GLsizei count,
+                            GLboolean transpose,
+                            const volatile GLfloat* value);
+  void DoUniformMatrix3x2fv(GLint fake_location,
+                            GLsizei count,
+                            GLboolean transpose,
+                            const volatile GLfloat* value);
+  void DoUniformMatrix3x4fv(GLint fake_location,
+                            GLsizei count,
+                            GLboolean transpose,
+                            const volatile GLfloat* value);
+  void DoUniformMatrix4x2fv(GLint fake_location,
+                            GLsizei count,
+                            GLboolean transpose,
+                            const volatile GLfloat* value);
+  void DoUniformMatrix4x3fv(GLint fake_location,
+                            GLsizei count,
+                            GLboolean transpose,
+                            const volatile GLfloat* value);
 
   template <typename T>
   bool SetVertexAttribValue(
     const char* function_name, GLuint index, const T* value);
 
   // Wrappers for glVertexAttrib??
   void DoVertexAttrib1f(GLuint index, GLfloat v0);
   void DoVertexAttrib2f(GLuint index, GLfloat v0, GLfloat v1);
   void DoVertexAttrib3f(GLuint index, GLfloat v0, GLfloat v1, GLfloat v2);
   void DoVertexAttrib4f(
       GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3);
-  void DoVertexAttrib1fv(GLuint index, const GLfloat* v);
-  void DoVertexAttrib2fv(GLuint index, const GLfloat* v);
-  void DoVertexAttrib3fv(GLuint index, const GLfloat* v);
-  void DoVertexAttrib4fv(GLuint index, const GLfloat* v);
+  void DoVertexAttrib1fv(GLuint index, const volatile GLfloat* v);
+  void DoVertexAttrib2fv(GLuint index, const volatile GLfloat* v);
+  void DoVertexAttrib3fv(GLuint index, const volatile GLfloat* v);
+  void DoVertexAttrib4fv(GLuint index, const volatile GLfloat* v);
   void DoVertexAttribI4i(GLuint index, GLint v0, GLint v1, GLint v2, GLint v3);
-  void DoVertexAttribI4iv(GLuint index, const GLint* v);
+  void DoVertexAttribI4iv(GLuint index, const volatile GLint* v);
   void DoVertexAttribI4ui(
       GLuint index, GLuint v0, GLuint v1, GLuint v2, GLuint v3);
-  void DoVertexAttribI4uiv(GLuint index, const GLuint* v);
+  void DoVertexAttribI4uiv(GLuint index, const volatile GLuint* v);
 
   // Wrapper for glViewport
   void DoViewport(GLint x, GLint y, GLsizei width, GLsizei height);
 
   // Wrapper for glUseProgram
   void DoUseProgram(GLuint program);
 
   // Wrapper for glValidateProgram.
   void DoValidateProgram(GLuint program_client_id);
 
@@ skipping 268 matching lines @@
   void ClearScheduleCALayerState();
 
   // Helper method to call glClear workaround.
   void ClearFramebufferForWorkaround(GLbitfield mask);
 
   bool InitializeCopyTexImageBlitter(const char* function_name);
   bool InitializeCopyTextureCHROMIUM(const char* function_name);
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
 #define GLES2_CMD_OP(name) \
-  Error Handle##name(uint32_t immediate_data_size, const void* data);
+  Error Handle##name(uint32_t immediate_data_size, const volatile void* data);
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 
   // The GL context this decoder renders to on behalf of the client.
   scoped_refptr<gl::GLSurface> surface_;
   scoped_refptr<gl::GLContext> context_;
 
   // The ContextGroup for this decoder uses to track resources.
@@ skipping 201 matching lines @@
   // get rescheduled.
   std::vector<std::unique_ptr<gl::GLFence>> deschedule_until_finished_fences_;
 
   // Used to validate multisample renderbuffers if needed
   GLuint validation_texture_;
   GLuint validation_fbo_multisample_;
   GLuint validation_fbo_;
 
   typedef gpu::gles2::GLES2Decoder::Error (GLES2DecoderImpl::*CmdHandler)(
       uint32_t immediate_data_size,
-      const void* data);
+      const volatile void* data);
 
   // A struct to hold info about each command.
   struct CommandInfo {
     CmdHandler cmd_handler;
     uint8_t arg_flags;   // How to handle the arguments for this command
     uint8_t cmd_flags;   // How to handle this command
     uint16_t arg_count;  // How many arguments are expected for this command.
   };
 
   // A table of CommandInfo for all the commands.
@@ skipping 1559 matching lines @@
                                                  GLsizei range) {
   GLuint last_client_id;
   if (!SafeAddUint32(first_client_id, range - 1, &last_client_id))
     return false;
 
   path_manager()->RemovePaths(first_client_id, last_client_id);
   return true;
 }
 
 void GLES2DecoderImpl::DeleteBuffersHelper(GLsizei n,
-                                           const GLuint* client_ids) {
+                                           const volatile GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint client_id = client_ids[ii];
     Buffer* buffer = GetBuffer(client_id);
     if (buffer && !buffer->IsDeleted()) {
       buffer->RemoveMappedRange();
       state_.RemoveBoundBuffer(buffer);
       transform_feedback_manager_->RemoveBoundBuffer(buffer);
       RemoveBuffer(client_id);
     }
   }
 }
 
-void GLES2DecoderImpl::DeleteFramebuffersHelper(GLsizei n,
-                                                const GLuint* client_ids) {
+void GLES2DecoderImpl::DeleteFramebuffersHelper(
+    GLsizei n,
+    const volatile GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      features().chromium_framebuffer_multisample;
 
   for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint client_id = client_ids[ii];
     Framebuffer* framebuffer = GetFramebuffer(client_id);
     if (framebuffer && !framebuffer->IsDeleted()) {
       if (framebuffer == framebuffer_state_.bound_draw_framebuffer.get()) {
         GLenum target = supports_separate_framebuffer_binds ?
             GL_DRAW_FRAMEBUFFER_EXT : GL_FRAMEBUFFER;
@@ skipping 11 matching lines @@
         GLenum target = supports_separate_framebuffer_binds ?
             GL_READ_FRAMEBUFFER_EXT : GL_FRAMEBUFFER;
         glBindFramebufferEXT(target, GetBackbufferServiceId());
       }
       OnFboChanged();
       RemoveFramebuffer(client_id);
     }
   }
 }
 
-void GLES2DecoderImpl::DeleteRenderbuffersHelper(GLsizei n,
-                                                 const GLuint* client_ids) {
+void GLES2DecoderImpl::DeleteRenderbuffersHelper(
+    GLsizei n,
+    const volatile GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      features().chromium_framebuffer_multisample;
   for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint client_id = client_ids[ii];
     Renderbuffer* renderbuffer = GetRenderbuffer(client_id);
     if (renderbuffer && !renderbuffer->IsDeleted()) {
       if (state_.bound_renderbuffer.get() == renderbuffer) {
         state_.bound_renderbuffer = NULL;
       }
       // Unbind from current framebuffers.
@@ skipping 12 matching lines @@
               ->UnbindRenderbuffer(GL_FRAMEBUFFER, renderbuffer);
         }
       }
       framebuffer_state_.clear_state_dirty = true;
       RemoveRenderbuffer(client_id);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteTexturesHelper(GLsizei n,
-                                            const GLuint* client_ids) {
+                                            const volatile GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      features().chromium_framebuffer_multisample;
   for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint client_id = client_ids[ii];
     TextureRef* texture_ref = GetTexture(client_id);
     if (texture_ref) {
       Texture* texture = texture_ref->texture();
       if (texture->IsAttachedToFramebuffer()) {
         framebuffer_state_.clear_state_dirty = true;
       }
@@ skipping 15 matching lines @@
           framebuffer_state_.bound_draw_framebuffer
               ->UnbindTexture(GL_FRAMEBUFFER, texture_ref);
         }
       }
       RemoveTexture(client_id);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteSamplersHelper(GLsizei n,
-                                            const GLuint* client_ids) {
+                                            const volatile GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint client_id = client_ids[ii];
     Sampler* sampler = GetSampler(client_id);
     if (sampler && !sampler->IsDeleted()) {
       // Unbind from current sampler units.
       state_.UnbindSampler(sampler);
 
       RemoveSampler(client_id);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteTransformFeedbacksHelper(
     GLsizei n,
-    const GLuint* client_ids) {
+    const volatile GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint client_id = client_ids[ii];
     TransformFeedback* transform_feedback = GetTransformFeedback(client_id);
     if (transform_feedback) {
       if (transform_feedback->active()) {
         LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glDeleteTransformFeedbacks",
                            "Deleting transform feedback is active");
         return;
       }
       if (state_.bound_transform_feedback.get() == transform_feedback) {
@@ skipping 893 matching lines @@
   if (offscreen_resolved_color_texture_.get())
     offscreen_resolved_color_texture_->Destroy();
   offscreen_resolved_color_texture_.reset();
   offscreen_resolved_frame_buffer_.reset();
 
   return true;
 }
 
 error::Error GLES2DecoderImpl::HandleResizeCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::ResizeCHROMIUM& c =
-      *static_cast<const gles2::cmds::ResizeCHROMIUM*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::ResizeCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::ResizeCHROMIUM*>(cmd_data);
   if (!offscreen_target_frame_buffer_.get() && surface_->DeferDraws())
     return error::kDeferCommandUntilLater;
 
   GLuint width = static_cast<GLuint>(c.width);
   GLuint height = static_cast<GLuint>(c.height);
   GLfloat scale_factor = c.scale_factor;
   GLboolean has_alpha = c.alpha;
   TRACE_EVENT2("gpu", "glResizeChromium", "width", width, "height", height);
 
   width = std::max(1U, width);
@@ skipping 41 matching lines @@
 }
 
 // Decode multiple commands, and call the corresponding GL functions.
 // NOTE: 'buffer' is a pointer to the command buffer. As such, it could be
 // changed by a (malicious) client at any time, so if validation has to happen,
 // it should operate on a copy of them.
 // NOTE: This is duplicating code from AsyncAPIInterface::DoCommands() in the
 // interest of performance in this critical execution loop.
 template <bool DebugImpl>
 error::Error GLES2DecoderImpl::DoCommandsImpl(unsigned int num_commands,
-                                              const void* buffer,
+                                              const volatile void* buffer,
                                               int num_entries,
                                               int* entries_processed) {
   commands_to_process_ = num_commands;
   error::Error result = error::kNoError;
-  const CommandBufferEntry* cmd_data =
-      static_cast<const CommandBufferEntry*>(buffer);
+  const volatile CommandBufferEntry* cmd_data =
+      static_cast<const volatile CommandBufferEntry*>(buffer);
   int process_pos = 0;
   unsigned int command = 0;
 
   while (process_pos < num_entries && result == error::kNoError &&
          commands_to_process_--) {
     const unsigned int size = cmd_data->value_header.size;
     command = cmd_data->value_header.command;
 
     if (size == 0) {
       result = error::kInvalidSize;
@@ skipping 68 matching lines @@
 
   if (error::IsError(result)) {
     LOG(ERROR) << "Error: " << result << " for Command "
                << GetCommandName(command);
   }
 
   return result;
 }
 
 error::Error GLES2DecoderImpl::DoCommands(unsigned int num_commands,
-                                          const void* buffer,
+                                          const volatile void* buffer,
                                           int num_entries,
                                           int* entries_processed) {
   if (gpu_debug_commands_) {
     return DoCommandsImpl<true>(
         num_commands, buffer, num_entries, entries_processed);
   } else {
     return DoCommandsImpl<false>(
         num_commands, buffer, num_entries, entries_processed);
   }
 }
@@ skipping 599 matching lines @@
     if (index != 0 || gl_version_info().BehavesLikeGLES()) {
       glDisableVertexAttribArray(index);
     }
   } else {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glDisableVertexAttribArray", "index out of range");
   }
 }
 
-void GLES2DecoderImpl::InvalidateFramebufferImpl(GLenum target,
-                                                 GLsizei count,
-                                                 const GLenum* attachments,
-                                                 GLint x,
-                                                 GLint y,
-                                                 GLsizei width,
-                                                 GLsizei height,
-                                                 const char* function_name,
-                                                 FramebufferOperation op) {
+void GLES2DecoderImpl::InvalidateFramebufferImpl(
+    GLenum target,
+    GLsizei count,
+    const volatile GLenum* attachments,
+    GLint x,
+    GLint y,
+    GLsizei width,
+    GLsizei height,
+    const char* function_name,
+    FramebufferOperation op) {
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(GL_FRAMEBUFFER);
 
   // Because of performance issues, no-op if the format of the attachment is
   // DEPTH_STENCIL and only one part is intended to be invalidated.
   bool has_depth_stencil_format = framebuffer &&
       framebuffer->HasDepthStencilFormatAttachment();
   bool invalidate_depth = false;
   bool invalidate_stencil = false;
   std::unique_ptr<GLenum[]> validated_attachments(new GLenum[count]);
   GLsizei validated_count = 0;
@@ skipping 134 matching lines @@
           backbuffer_needs_clear_bits_ |= GL_STENCIL_BUFFER_BIT;
           break;
         default:
           NOTREACHED();
           break;
       }
     }
   }
 }
 
-void GLES2DecoderImpl::DoDiscardFramebufferEXT(GLenum target,
-                                               GLsizei count,
-                                               const GLenum* attachments) {
+void GLES2DecoderImpl::DoDiscardFramebufferEXT(
+    GLenum target,
+    GLsizei count,
+    const volatile GLenum* attachments) {
   if (workarounds().disable_discard_framebuffer)
     return;
 
   const GLsizei kWidthNotUsed = 1;
   const GLsizei kHeightNotUsed = 1;
   InvalidateFramebufferImpl(
       target, count, attachments, 0, 0, kWidthNotUsed, kHeightNotUsed,
       "glDiscardFramebufferEXT", kFramebufferDiscard);
 }
 
 void GLES2DecoderImpl::DoInvalidateFramebuffer(
-    GLenum target, GLsizei count, const GLenum* attachments) {
+    GLenum target,
+    GLsizei count,
+    const volatile GLenum* attachments) {
   const GLsizei kWidthNotUsed = 1;
   const GLsizei kHeightNotUsed = 1;
   InvalidateFramebufferImpl(
       target, count, attachments, 0, 0, kWidthNotUsed, kHeightNotUsed,
       "glInvalidateFramebuffer", kFramebufferInvalidate);
 }
 
 void GLES2DecoderImpl::DoInvalidateSubFramebuffer(
-    GLenum target, GLsizei count, const GLenum* attachments,
-    GLint x, GLint y, GLsizei width, GLsizei height) {
+    GLenum target,
+    GLsizei count,
+    const volatile GLenum* attachments,
+    GLint x,
+    GLint y,
+    GLsizei width,
+    GLsizei height) {
   InvalidateFramebufferImpl(
       target, count, attachments, x, y, width, height,
       "glInvalidateSubFramebuffer", kFramebufferInvalidateSub);
 }
 
 void GLES2DecoderImpl::DoEnableVertexAttribArray(GLuint index) {
   if (state_.vertex_attrib_manager->Enable(index, true)) {
     glEnableVertexAttribArray(index);
   } else {
     LOCAL_SET_GL_ERROR(
@@ skipping 788 matching lines @@
   // glBindAttribLocation call with original name is useless.
   // So instead, we should simply cache the binding, and then call
   // Program::ExecuteBindAttribLocationCalls() right before link.
   program->SetAttribLocationBinding(name, static_cast<GLint>(index));
   // TODO(zmo): Get rid of the following glBindAttribLocation call.
   glBindAttribLocation(program->service_id(), index, name.c_str());
 }
 
 error::Error GLES2DecoderImpl::HandleBindAttribLocationBucket(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::BindAttribLocationBucket& c =
-      *static_cast<const gles2::cmds::BindAttribLocationBucket*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::BindAttribLocationBucket& c =
+      *static_cast<const volatile gles2::cmds::BindAttribLocationBucket*>(
+          cmd_data);
   GLuint program = static_cast<GLuint>(c.program);
   GLuint index = static_cast<GLuint>(c.index);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
@@ skipping 21 matching lines @@
   Program* program = GetProgramInfoNotShader(program_id, kFunctionName);
   if (!program) {
     return error::kNoError;
   }
   program->SetProgramOutputLocationBinding(name, colorName);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindFragDataLocationEXTBucket(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!features().ext_blend_func_extended) {
     return error::kUnknownCommand;
   }
-  const gles2::cmds::BindFragDataLocationEXTBucket& c =
-      *static_cast<const gles2::cmds::BindFragDataLocationEXTBucket*>(cmd_data);
+  const volatile gles2::cmds::BindFragDataLocationEXTBucket& c =
+      *static_cast<const volatile gles2::cmds::BindFragDataLocationEXTBucket*>(
+          cmd_data);
   GLuint program = static_cast<GLuint>(c.program);
   GLuint colorNumber = static_cast<GLuint>(c.colorNumber);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
@@ skipping 27 matching lines @@
   Program* program = GetProgramInfoNotShader(program_id, kFunctionName);
   if (!program) {
     return error::kNoError;
   }
   program->SetProgramOutputLocationIndexedBinding(name, colorName, index);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBindFragDataLocationIndexedEXTBucket(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!features().ext_blend_func_extended) {
     return error::kUnknownCommand;
   }
-  const gles2::cmds::BindFragDataLocationIndexedEXTBucket& c =
-      *static_cast<const gles2::cmds::BindFragDataLocationIndexedEXTBucket*>(
+  const volatile gles2::cmds::BindFragDataLocationIndexedEXTBucket& c =
+      *static_cast<
+          const volatile gles2::cmds::BindFragDataLocationIndexedEXTBucket*>(
           cmd_data);
   GLuint program = static_cast<GLuint>(c.program);
   GLuint colorNumber = static_cast<GLuint>(c.colorNumber);
   GLuint index = static_cast<GLuint>(c.index);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
@@ skipping 34 matching lines @@
   }
   if (!program->SetUniformLocationBinding(name, location)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glBindUniformLocationCHROMIUM", "location out of range");
   }
 }
 
 error::Error GLES2DecoderImpl::HandleBindUniformLocationCHROMIUMBucket(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::BindUniformLocationCHROMIUMBucket& c =
-      *static_cast<const gles2::cmds::BindUniformLocationCHROMIUMBucket*>(
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::BindUniformLocationCHROMIUMBucket& c =
+      *static_cast<
+          const volatile gles2::cmds::BindUniformLocationCHROMIUMBucket*>(
           cmd_data);
   GLuint program = static_cast<GLuint>(c.program);
   GLint location = static_cast<GLint>(c.location);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   DoBindUniformLocationCHROMIUM(program, location, name_str);
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDeleteShader(uint32_t immediate_data_size,
-                                                  const void* cmd_data) {
-  const gles2::cmds::DeleteShader& c =
-      *static_cast<const gles2::cmds::DeleteShader*>(cmd_data);
+error::Error GLES2DecoderImpl::HandleDeleteShader(
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::DeleteShader& c =
+      *static_cast<const volatile gles2::cmds::DeleteShader*>(cmd_data);
   GLuint client_id = c.shader;
   if (client_id) {
     Shader* shader = GetShader(client_id);
     if (shader) {
       if (!shader->IsDeleted()) {
         shader_manager()->Delete(shader);
       }
     } else {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glDeleteShader", "unknown shader");
     }
   }
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDeleteProgram(uint32_t immediate_data_size,
-                                                   const void* cmd_data) {
-  const gles2::cmds::DeleteProgram& c =
-      *static_cast<const gles2::cmds::DeleteProgram*>(cmd_data);
+error::Error GLES2DecoderImpl::HandleDeleteProgram(
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::DeleteProgram& c =
+      *static_cast<const volatile gles2::cmds::DeleteProgram*>(cmd_data);
   GLuint client_id = c.program;
   if (client_id) {
     Program* program = GetProgram(client_id);
     if (program) {
       if (!program->IsDeleted()) {
         program_manager()->MarkAsDeleted(shader_manager(), program);
       }
     } else {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glDeleteProgram", "unknown program");
@@ skipping 22 matching lines @@
         LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
             "can't be called on integer buffers");
         return error::kNoError;
       }
     }
     glClear(mask);
   }
   return error::kNoError;
 }
 
-void GLES2DecoderImpl::DoClearBufferiv(
-    GLenum buffer, GLint drawbuffer, const GLint* value) {
+void GLES2DecoderImpl::DoClearBufferiv(GLenum buffer,
+                                       GLint drawbuffer,
+                                       const volatile GLint* value) {
   const char* func_name = "glClearBufferiv";
   if (!CheckBoundDrawFramebufferValid(func_name))
     return;
   ApplyDirtyState();
 
   if (buffer == GL_COLOR) {
     if (drawbuffer < 0 ||
         drawbuffer >= static_cast<GLint>(group_->max_draw_buffers())) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "invalid drawBuffer");
       return;
     }
     GLenum internal_format =
         GetBoundColorDrawBufferInternalFormat(drawbuffer);
     if (!GLES2Util::IsSignedIntegerFormat(internal_format)) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
           "can only be called on signed integer buffers");
       return;
     }
   } else {
     DCHECK(buffer == GL_STENCIL);
     if (drawbuffer != 0) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "invalid drawBuffer");
       return;
     }
     if (!BoundFramebufferHasStencilAttachment()) {
       return;
     }
   }
   MarkDrawBufferAsCleared(buffer, drawbuffer);
-  glClearBufferiv(buffer, drawbuffer, value);
+  glClearBufferiv(buffer, drawbuffer, const_cast<const GLint*>(value));
 }
 
-void GLES2DecoderImpl::DoClearBufferuiv(
-    GLenum buffer, GLint drawbuffer, const GLuint* value) {
+void GLES2DecoderImpl::DoClearBufferuiv(GLenum buffer,
+                                        GLint drawbuffer,
+                                        const volatile GLuint* value) {
   const char* func_name = "glClearBufferuiv";
   if (!CheckBoundDrawFramebufferValid(func_name))
     return;
   ApplyDirtyState();
 
   if (drawbuffer < 0 ||
       drawbuffer >= static_cast<GLint>(group_->max_draw_buffers())) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "invalid drawBuffer");
     return;
   }
   GLenum internal_format =
       GetBoundColorDrawBufferInternalFormat(drawbuffer);
   if (!GLES2Util::IsUnsignedIntegerFormat(internal_format)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
         "can only be called on unsigned integer buffers");
     return;
   }
   MarkDrawBufferAsCleared(buffer, drawbuffer);
-  glClearBufferuiv(buffer, drawbuffer, value);
+  glClearBufferuiv(buffer, drawbuffer, const_cast<const GLuint*>(value));
 }
 
-void GLES2DecoderImpl::DoClearBufferfv(
-    GLenum buffer, GLint drawbuffer, const GLfloat* value) {
+void GLES2DecoderImpl::DoClearBufferfv(GLenum buffer,
+                                       GLint drawbuffer,
+                                       const volatile GLfloat* value) {
   const char* func_name = "glClearBufferfv";
   if (!CheckBoundDrawFramebufferValid(func_name))
     return;
   ApplyDirtyState();
 
   if (buffer == GL_COLOR) {
     if (drawbuffer < 0 ||
         drawbuffer >= static_cast<GLint>(group_->max_draw_buffers())) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "invalid drawBuffer");
       return;
     }
     GLenum internal_format =
         GetBoundColorDrawBufferInternalFormat(drawbuffer);
     if (GLES2Util::IsIntegerFormat(internal_format)) {
       LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, func_name,
           "can only be called on float buffers");
       return;
     }
   } else {
     DCHECK(buffer == GL_DEPTH);
     if (drawbuffer != 0) {
       LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name, "invalid drawBuffer");
       return;
     }
     if (!BoundFramebufferHasDepthAttachment()) {
       return;
     }
   }
   MarkDrawBufferAsCleared(buffer, drawbuffer);
-  glClearBufferfv(buffer, drawbuffer, value);
+  glClearBufferfv(buffer, drawbuffer, const_cast<const GLfloat*>(value));
 }
 
 void GLES2DecoderImpl::DoClearBufferfi(
     GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) {
   const char* func_name = "glClearBufferfi";
   if (!CheckBoundDrawFramebufferValid(func_name))
     return;
   ApplyDirtyState();
 
   if (drawbuffer != 0) {
@@ skipping 954 matching lines @@
   Sampler* sampler = GetSampler(client_id);
   if (!sampler) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glSamplerParameteri", "unknown sampler");
     return;
   }
   sampler_manager()->SetParameteri(
       "glSamplerParameteri", GetErrorState(), sampler, pname, param);
 }
 
-void GLES2DecoderImpl::DoSamplerParameterfv(
-    GLuint client_id, GLenum pname, const GLfloat* params) {
+void GLES2DecoderImpl::DoSamplerParameterfv(GLuint client_id,
+                                            GLenum pname,
+                                            const volatile GLfloat* params) {
   DCHECK(params);
   Sampler* sampler = GetSampler(client_id);
   if (!sampler) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glSamplerParameterfv", "unknown sampler");
     return;
   }
   sampler_manager()->SetParameterf(
       "glSamplerParameterfv", GetErrorState(), sampler, pname, params[0]);
 }
 
-void GLES2DecoderImpl::DoSamplerParameteriv(
-    GLuint client_id, GLenum pname, const GLint* params) {
+void GLES2DecoderImpl::DoSamplerParameteriv(GLuint client_id,
+                                            GLenum pname,
+                                            const volatile GLint* params) {
   DCHECK(params);
   Sampler* sampler = GetSampler(client_id);
   if (!sampler) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glSamplerParameteriv", "unknown sampler");
     return;
   }
   sampler_manager()->SetParameteri(
       "glSamplerParameteriv", GetErrorState(), sampler, pname, params[0]);
 }
@@ skipping 17 matching lines @@
       &state_, target);
   if (!texture) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexParameteri", "unknown texture");
     return;
   }
 
   texture_manager()->SetParameteri(
       "glTexParameteri", GetErrorState(), texture, pname, param);
 }
 
-void GLES2DecoderImpl::DoTexParameterfv(
-    GLenum target, GLenum pname, const GLfloat* params) {
+void GLES2DecoderImpl::DoTexParameterfv(GLenum target,
+                                        GLenum pname,
+                                        const volatile GLfloat* params) {
   TextureRef* texture = texture_manager()->GetTextureInfoForTarget(
       &state_, target);
   if (!texture) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glTexParameterfv", "unknown texture");
     return;
   }
 
   texture_manager()->SetParameterf(
       "glTexParameterfv", GetErrorState(), texture, pname, *params);
 }
 
-void GLES2DecoderImpl::DoTexParameteriv(
-  GLenum target, GLenum pname, const GLint* params) {
+void GLES2DecoderImpl::DoTexParameteriv(GLenum target,
+                                        GLenum pname,
+                                        const volatile GLint* params) {
   TextureRef* texture = texture_manager()->GetTextureInfoForTarget(
       &state_, target);
   if (!texture) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glTexParameteriv", "unknown texture");
     return;
   }
 
   texture_manager()->SetParameteri(
       "glTexParameteriv", GetErrorState(), texture, pname, *params);
@@ skipping 166 matching lines @@
       state_.texture_units.size(), fake_location, 1, &v0)) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glUniform1i", "texture unit out of range");
     return;
   }
   glUniform1i(real_location, v0);
 }
 
 void GLES2DecoderImpl::DoUniform1iv(GLint fake_location,
                                     GLsizei count,
-                                    const GLint* values) {
+                                    const volatile GLint* values) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform1iv",
                                    Program::kUniform1i,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
   auto values_copy = base::MakeUnique<GLint[]>(count);
   GLint* safe_values = values_copy.get();
   std::copy(values, values + count, safe_values);
   if (type == GL_SAMPLER_2D || type == GL_SAMPLER_2D_RECT_ARB ||
       type == GL_SAMPLER_CUBE || type == GL_SAMPLER_EXTERNAL_OES) {
     if (!state_.current_program->SetSamplers(
             state_.texture_units.size(), fake_location, count, safe_values)) {
       LOCAL_SET_GL_ERROR(
           GL_INVALID_VALUE, "glUniform1iv", "texture unit out of range");
       return;
     }
   }
   glUniform1iv(real_location, count, safe_values);
 }
 
-void GLES2DecoderImpl::DoUniform1uiv(
-    GLint fake_location, GLsizei count, const GLuint *value) {
+void GLES2DecoderImpl::DoUniform1uiv(GLint fake_location,
+                                     GLsizei count,
+                                     const volatile GLuint* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform1uiv",
                                    Program::kUniform1ui,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniform1uiv(real_location, count, value);
+  glUniform1uiv(real_location, count, const_cast<const GLuint*>(value));
 }
 
-void GLES2DecoderImpl::DoUniform1fv(
-    GLint fake_location, GLsizei count, const GLfloat* value) {
+void GLES2DecoderImpl::DoUniform1fv(GLint fake_location,
+                                    GLsizei count,
+                                    const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform1fv",
                                    Program::kUniform1f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
   if (type == GL_BOOL) {
     std::unique_ptr<GLint[]> temp(new GLint[count]);
     for (GLsizei ii = 0; ii < count; ++ii) {
       temp[ii] = static_cast<GLint>(value[ii] != 0.0f);
     }
     glUniform1iv(real_location, count, temp.get());
   } else {
-    glUniform1fv(real_location, count, value);
+    glUniform1fv(real_location, count, const_cast<const GLfloat*>(value));
   }
 }
 
-void GLES2DecoderImpl::DoUniform2fv(
-    GLint fake_location, GLsizei count, const GLfloat* value) {
+void GLES2DecoderImpl::DoUniform2fv(GLint fake_location,
+                                    GLsizei count,
+                                    const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform2fv",
                                    Program::kUniform2f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
   if (type == GL_BOOL_VEC2) {
     GLsizei num_values = count * 2;
     std::unique_ptr<GLint[]> temp(new GLint[num_values]);
     for (GLsizei ii = 0; ii < num_values; ++ii) {
       temp[ii] = static_cast<GLint>(value[ii] != 0.0f);
     }
     glUniform2iv(real_location, count, temp.get());
   } else {
-    glUniform2fv(real_location, count, value);
+    glUniform2fv(real_location, count, const_cast<const GLfloat*>(value));
   }
 }
 
-void GLES2DecoderImpl::DoUniform3fv(
-    GLint fake_location, GLsizei count, const GLfloat* value) {
+void GLES2DecoderImpl::DoUniform3fv(GLint fake_location,
+                                    GLsizei count,
+                                    const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform3fv",
                                    Program::kUniform3f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
   if (type == GL_BOOL_VEC3) {
     GLsizei num_values = count * 3;
     std::unique_ptr<GLint[]> temp(new GLint[num_values]);
     for (GLsizei ii = 0; ii < num_values; ++ii) {
       temp[ii] = static_cast<GLint>(value[ii] != 0.0f);
     }
     glUniform3iv(real_location, count, temp.get());
   } else {
-    glUniform3fv(real_location, count, value);
+    glUniform3fv(real_location, count, const_cast<const GLfloat*>(value));
   }
 }
 
-void GLES2DecoderImpl::DoUniform4fv(
-    GLint fake_location, GLsizei count, const GLfloat* value) {
+void GLES2DecoderImpl::DoUniform4fv(GLint fake_location,
+                                    GLsizei count,
+                                    const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform4fv",
                                    Program::kUniform4f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
   if (type == GL_BOOL_VEC4) {
     GLsizei num_values = count * 4;
     std::unique_ptr<GLint[]> temp(new GLint[num_values]);
     for (GLsizei ii = 0; ii < num_values; ++ii) {
       temp[ii] = static_cast<GLint>(value[ii] != 0.0f);
     }
     glUniform4iv(real_location, count, temp.get());
   } else {
-    glUniform4fv(real_location, count, value);
+    glUniform4fv(real_location, count, const_cast<const GLfloat*>(value));
   }
 }
 
-void GLES2DecoderImpl::DoUniform2iv(
-    GLint fake_location, GLsizei count, const GLint* value) {
+void GLES2DecoderImpl::DoUniform2iv(GLint fake_location,
+                                    GLsizei count,
+                                    const volatile GLint* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform2iv",
                                    Program::kUniform2i,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniform2iv(real_location, count, value);
+  glUniform2iv(real_location, count, const_cast<const GLint*>(value));
 }
 
-void GLES2DecoderImpl::DoUniform2uiv(
-    GLint fake_location, GLsizei count, const GLuint* value) {
+void GLES2DecoderImpl::DoUniform2uiv(GLint fake_location,
+                                     GLsizei count,
+                                     const volatile GLuint* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform2uiv",
                                    Program::kUniform2ui,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniform2uiv(real_location, count, value);
+  glUniform2uiv(real_location, count, const_cast<const GLuint*>(value));
 }
 
-void GLES2DecoderImpl::DoUniform3iv(
-    GLint fake_location, GLsizei count, const GLint* value) {
+void GLES2DecoderImpl::DoUniform3iv(GLint fake_location,
+                                    GLsizei count,
+                                    const volatile GLint* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform3iv",
                                    Program::kUniform3i,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniform3iv(real_location, count, value);
+  glUniform3iv(real_location, count, const_cast<const GLint*>(value));
 }
 
-void GLES2DecoderImpl::DoUniform3uiv(
-    GLint fake_location, GLsizei count, const GLuint* value) {
+void GLES2DecoderImpl::DoUniform3uiv(GLint fake_location,
+                                     GLsizei count,
+                                     const volatile GLuint* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform3uiv",
                                    Program::kUniform3ui,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniform3uiv(real_location, count, value);
+  glUniform3uiv(real_location, count, const_cast<const GLuint*>(value));
 }
 
-void GLES2DecoderImpl::DoUniform4iv(
-    GLint fake_location, GLsizei count, const GLint* value) {
+void GLES2DecoderImpl::DoUniform4iv(GLint fake_location,
+                                    GLsizei count,
+                                    const volatile GLint* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform4iv",
                                    Program::kUniform4i,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniform4iv(real_location, count, value);
+  glUniform4iv(real_location, count, const_cast<const GLint*>(value));
 }
 
-void GLES2DecoderImpl::DoUniform4uiv(
-    GLint fake_location, GLsizei count, const GLuint* value) {
+void GLES2DecoderImpl::DoUniform4uiv(GLint fake_location,
+                                     GLsizei count,
+                                     const volatile GLuint* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniform4uiv",
                                    Program::kUniform4ui,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniform4uiv(real_location, count, value);
+  glUniform4uiv(real_location, count, const_cast<const GLuint*>(value));
 }
 
-void GLES2DecoderImpl::DoUniformMatrix2fv(
-    GLint fake_location, GLsizei count, GLboolean transpose,
-    const GLfloat* value) {
+void GLES2DecoderImpl::DoUniformMatrix2fv(GLint fake_location,
+                                          GLsizei count,
+                                          GLboolean transpose,
+                                          const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (transpose && !unsafe_es3_apis_enabled()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glUniformMatrix2fv", "transpose not FALSE");
     return;
   }
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniformMatrix2fv",
                                    Program::kUniformMatrix2f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniformMatrix2fv(real_location, count, transpose, value);
+  glUniformMatrix2fv(real_location, count, transpose,
+                     const_cast<const GLfloat*>(value));
 }
 
-void GLES2DecoderImpl::DoUniformMatrix3fv(
-    GLint fake_location, GLsizei count, GLboolean transpose,
-    const GLfloat* value) {
+void GLES2DecoderImpl::DoUniformMatrix3fv(GLint fake_location,
+                                          GLsizei count,
+                                          GLboolean transpose,
+                                          const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (transpose && !unsafe_es3_apis_enabled()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glUniformMatrix3fv", "transpose not FALSE");
     return;
   }
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniformMatrix3fv",
                                    Program::kUniformMatrix3f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniformMatrix3fv(real_location, count, transpose, value);
+  glUniformMatrix3fv(real_location, count, transpose,
+                     const_cast<const GLfloat*>(value));
 }
 
-void GLES2DecoderImpl::DoUniformMatrix4fv(
-    GLint fake_location, GLsizei count, GLboolean transpose,
-    const GLfloat* value) {
+void GLES2DecoderImpl::DoUniformMatrix4fv(GLint fake_location,
+                                          GLsizei count,
+                                          GLboolean transpose,
+                                          const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (transpose && !unsafe_es3_apis_enabled()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE, "glUniformMatrix4fv", "transpose not FALSE");
     return;
   }
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniformMatrix4fv",
                                    Program::kUniformMatrix4f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniformMatrix4fv(real_location, count, transpose, value);
+  glUniformMatrix4fv(real_location, count, transpose,
+                     const_cast<const GLfloat*>(value));
 }
 
 void GLES2DecoderImpl::DoUniformMatrix4fvStreamTextureMatrixCHROMIUM(
     GLint fake_location,
     GLboolean transpose,
-    const GLfloat* transform) {
+    const volatile GLfloat* transform) {
   float gl_matrix[16];
 
   // This refers to the bound external texture on the active unit.
   TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
   if (TextureRef* texture_ref = unit.bound_texture_external_oes.get()) {
     if (GLStreamTextureImage* image =
             texture_ref->texture()->GetLevelStreamTextureImage(
                 GL_TEXTURE_EXTERNAL_OES, 0)) {
       gfx::Transform st_transform(gfx::Transform::kSkipInitialization);
       gfx::Transform pre_transform(gfx::Transform::kSkipInitialization);
       image->GetTextureMatrix(gl_matrix);
       st_transform.matrix().setColMajorf(gl_matrix);
-      pre_transform.matrix().setColMajorf(transform);
+      // const_cast is safe, because setColMajorf only does a memcpy.
+      // TODO(piman): can we remove this assumption without having to introduce
+      // an extra copy?

[no sievers, 2016/09/02 21:17:34]

Hmm.. maybe we shouldn't use gfx::Transform then and just an internal helper
that takes a volatile pointer. (Would be ridiculous to qualify with volatile in
random other external classes.)

[piman, 2016/09/02 23:11:06]

Yes, agreed it would be ridiculous...
gfx::Transform (SkMatrix44) is convenient though, because of the matrix multiply
(with fast paths if one or the other is identity, or just a scale+translate,
which is likely), so I'm not sure it's worth duplicating the logic.
Maybe without introducing volatile, a helper that directly exposes the float
array (and resets the type mask), so that we can just copy into it. I'll think
about options.

+      pre_transform.matrix().setColMajorf(
+          const_cast<const GLfloat*>(transform));
       gfx::Transform(pre_transform, st_transform)
           .matrix()
           .asColMajorf(gl_matrix);
     } else {
       // Missing stream texture. Treat matrix as identity.
-      memcpy(gl_matrix, transform, sizeof(gl_matrix));
+      std::copy(transform, transform + arraysize(gl_matrix), gl_matrix);

[no sievers, 2016/09/02 21:17:34]

This array is small, but was wondering about std::copy() specialization and
volatile ptrs:

http://stackoverflow.com/questions/36098055/stdis-trivially-copyable-why-are-...

" The problem with this is that a volatile qualified type may need to be copied
in a specific way (by copying using only atomic operations on multithreaded
platforms, for example) in order to avoid the “memory tearing” that may occur
with a byte-by-byte copy."

So if we were doing this a lot, maybe better to cast the volatile away.

[piman, 2016/09/02 23:11:06]

I went a bit back and forth on this. The const_cast is a theoretical problem,
especially since the compiler will inline the copy (fixed size), but looking at
the generated code, it is both safe and a lot better, and since this could be in
the fast path, I went back to const_cast + memcpy.

     }
   } else {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
                        "DoUniformMatrix4vStreamTextureMatrix",
                        "no texture bound");
     return;
   }
 
   GLenum type = 0;
   GLint real_location = -1;
   GLsizei count = 1;
   if (!PrepForSetUniformByLocation(fake_location, "glUniformMatrix4fv",
                                    Program::kUniformMatrix4f, &real_location,
                                    &type, &count)) {
     return;
   }
 
   glUniformMatrix4fv(real_location, count, transpose, gl_matrix);
 }
 
-void GLES2DecoderImpl::DoUniformMatrix2x3fv(
-    GLint fake_location, GLsizei count, GLboolean transpose,
-    const GLfloat* value) {
+void GLES2DecoderImpl::DoUniformMatrix2x3fv(GLint fake_location,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniformMatrix2x3fv",
                                    Program::kUniformMatrix2x3f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniformMatrix2x3fv(real_location, count, transpose, value);
+  glUniformMatrix2x3fv(real_location, count, transpose,
+                       const_cast<const GLfloat*>(value));
 }
 
-void GLES2DecoderImpl::DoUniformMatrix2x4fv(
-    GLint fake_location, GLsizei count, GLboolean transpose,
-    const GLfloat* value) {
+void GLES2DecoderImpl::DoUniformMatrix2x4fv(GLint fake_location,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniformMatrix2x4fv",
                                    Program::kUniformMatrix2x4f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniformMatrix2x4fv(real_location, count, transpose, value);
+  glUniformMatrix2x4fv(real_location, count, transpose,
+                       const_cast<const GLfloat*>(value));
 }
 
-void GLES2DecoderImpl::DoUniformMatrix3x2fv(
-    GLint fake_location, GLsizei count, GLboolean transpose,
-    const GLfloat* value) {
+void GLES2DecoderImpl::DoUniformMatrix3x2fv(GLint fake_location,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniformMatrix3x2fv",
                                    Program::kUniformMatrix3x2f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniformMatrix3x2fv(real_location, count, transpose, value);
+  glUniformMatrix3x2fv(real_location, count, transpose,
+                       const_cast<const GLfloat*>(value));
 }
 
-void GLES2DecoderImpl::DoUniformMatrix3x4fv(
-    GLint fake_location, GLsizei count, GLboolean transpose,
-    const GLfloat* value) {
+void GLES2DecoderImpl::DoUniformMatrix3x4fv(GLint fake_location,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniformMatrix3x4fv",
                                    Program::kUniformMatrix3x4f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniformMatrix3x4fv(real_location, count, transpose, value);
+  glUniformMatrix3x4fv(real_location, count, transpose,
+                       const_cast<const GLfloat*>(value));
 }
 
-void GLES2DecoderImpl::DoUniformMatrix4x2fv(
-    GLint fake_location, GLsizei count, GLboolean transpose,
-    const GLfloat* value) {
+void GLES2DecoderImpl::DoUniformMatrix4x2fv(GLint fake_location,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniformMatrix4x2fv",
                                    Program::kUniformMatrix4x2f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniformMatrix4x2fv(real_location, count, transpose, value);
+  glUniformMatrix4x2fv(real_location, count, transpose,
+                       const_cast<const GLfloat*>(value));
 }
 
-void GLES2DecoderImpl::DoUniformMatrix4x3fv(
-    GLint fake_location, GLsizei count, GLboolean transpose,
-    const GLfloat* value) {
+void GLES2DecoderImpl::DoUniformMatrix4x3fv(GLint fake_location,
+                                            GLsizei count,
+                                            GLboolean transpose,
+                                            const volatile GLfloat* value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(fake_location,
                                    "glUniformMatrix4x3fv",
                                    Program::kUniformMatrix4x3f,
                                    &real_location,
                                    &type,
                                    &count)) {
     return;
   }
-  glUniformMatrix4x3fv(real_location, count, transpose, value);
+  glUniformMatrix4x3fv(real_location, count, transpose,
+                       const_cast<const GLfloat*>(value));
 }
 
 void GLES2DecoderImpl::DoUseProgram(GLuint program_id) {
   const char* function_name = "glUseProgram";
   GLuint service_id = 0;
   Program* program = nullptr;
   if (program_id) {
     program = GetProgramInfoNotShader(program_id, function_name);
     if (!program) {
       return;
@@ skipping 584 matching lines @@
       // function even if it is simulated. This is because we will simulate
       // it in each draw call, and attrib 0 generic data queries use cached
       // values instead of passing down to the underlying driver.
       RestoreStateForAttrib(0, false);
     }
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleDrawArrays(uint32_t immediate_data_size,
-                                                const void* cmd_data) {
-  const cmds::DrawArrays& c = *static_cast<const cmds::DrawArrays*>(cmd_data);
+                                                const volatile void* cmd_data) {
+  const volatile cmds::DrawArrays& c =
+      *static_cast<const volatile cmds::DrawArrays*>(cmd_data);
   return DoDrawArrays("glDrawArrays",
                       false,
                       static_cast<GLenum>(c.mode),
                       static_cast<GLint>(c.first),
                       static_cast<GLsizei>(c.count),
                       1);
 }
 
 error::Error GLES2DecoderImpl::HandleDrawArraysInstancedANGLE(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::DrawArraysInstancedANGLE& c =
-      *static_cast<const gles2::cmds::DrawArraysInstancedANGLE*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::DrawArraysInstancedANGLE& c =
+      *static_cast<const volatile gles2::cmds::DrawArraysInstancedANGLE*>(
+          cmd_data);
   if (!features().angle_instanced_arrays)
     return error::kUnknownCommand;
 
   return DoDrawArrays("glDrawArraysIntancedANGLE",
                       true,
                       static_cast<GLenum>(c.mode),
                       static_cast<GLint>(c.first),
                       static_cast<GLsizei>(c.count),
                       static_cast<GLsizei>(c.primcount));
 }
@@ skipping 132 matching lines @@
       // We don't have to restore attrib 0 generic data at the end of this
       // function even if it is simulated. This is because we will simulate
       // it in each draw call, and attrib 0 generic data queries use cached
       // values instead of passing down to the underlying driver.
       RestoreStateForAttrib(0, false);
     }
   }
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleDrawElements(uint32_t immediate_data_size,
-                                                  const void* cmd_data) {
-  const gles2::cmds::DrawElements& c =
-      *static_cast<const gles2::cmds::DrawElements*>(cmd_data);
+error::Error GLES2DecoderImpl::HandleDrawElements(
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::DrawElements& c =
+      *static_cast<const volatile gles2::cmds::DrawElements*>(cmd_data);
   return DoDrawElements("glDrawElements", false, static_cast<GLenum>(c.mode),
                         static_cast<GLsizei>(c.count),
                         static_cast<GLenum>(c.type),
                         static_cast<int32_t>(c.index_offset), 1);
 }
 
 error::Error GLES2DecoderImpl::HandleDrawElementsInstancedANGLE(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::DrawElementsInstancedANGLE& c =
-      *static_cast<const gles2::cmds::DrawElementsInstancedANGLE*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::DrawElementsInstancedANGLE& c =
+      *static_cast<const volatile gles2::cmds::DrawElementsInstancedANGLE*>(
+          cmd_data);
   if (!features().angle_instanced_arrays)
     return error::kUnknownCommand;
 
   return DoDrawElements(
       "glDrawElementsInstancedANGLE", true, static_cast<GLenum>(c.mode),
       static_cast<GLsizei>(c.count), static_cast<GLenum>(c.type),
       static_cast<int32_t>(c.index_offset), static_cast<GLsizei>(c.primcount));
 }
 
 GLuint GLES2DecoderImpl::DoGetMaxValueInBufferCHROMIUM(
@@ skipping 116 matching lines @@
         ++(*params);
       return;
     default:
       break;
   }
   glGetShaderiv(shader->service_id(), pname, params);
 }
 
 error::Error GLES2DecoderImpl::HandleGetShaderSource(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GetShaderSource& c =
-      *static_cast<const gles2::cmds::GetShaderSource*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetShaderSource& c =
+      *static_cast<const volatile gles2::cmds::GetShaderSource*>(cmd_data);
   GLuint shader_id = c.shader;
   uint32_t bucket_id = static_cast<uint32_t>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
   Shader* shader = GetShaderInfoNotProgram(shader_id, "glGetShaderSource");
   if (!shader || shader->source().empty()) {
     bucket->SetSize(0);
     return error::kNoError;
   }
   bucket->SetFromString(shader->source().c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetTranslatedShaderSourceANGLE(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GetTranslatedShaderSourceANGLE& c =
-      *static_cast<const gles2::cmds::GetTranslatedShaderSourceANGLE*>(
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetTranslatedShaderSourceANGLE& c =
+      *static_cast<const volatile gles2::cmds::GetTranslatedShaderSourceANGLE*>(
           cmd_data);
   GLuint shader_id = c.shader;
   uint32_t bucket_id = static_cast<uint32_t>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
   Shader* shader = GetShaderInfoNotProgram(
       shader_id, "glGetTranslatedShaderSourceANGLE");
   if (!shader) {
     bucket->SetSize(0);
     return error::kNoError;
   }
 
   // Make sure translator has been utilized in compile.
   shader->DoCompile();
 
   bucket->SetFromString(shader->translated_source().c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetProgramInfoLog(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GetProgramInfoLog& c =
-      *static_cast<const gles2::cmds::GetProgramInfoLog*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetProgramInfoLog& c =
+      *static_cast<const volatile gles2::cmds::GetProgramInfoLog*>(cmd_data);
   GLuint program_id = c.program;
   uint32_t bucket_id = static_cast<uint32_t>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
   Program* program = GetProgramInfoNotShader(
       program_id, "glGetProgramInfoLog");
   if (!program || !program->log_info()) {
     bucket->SetFromString("");
     return error::kNoError;
   }
   bucket->SetFromString(program->log_info()->c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetShaderInfoLog(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GetShaderInfoLog& c =
-      *static_cast<const gles2::cmds::GetShaderInfoLog*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetShaderInfoLog& c =
+      *static_cast<const volatile gles2::cmds::GetShaderInfoLog*>(cmd_data);
   GLuint shader_id = c.shader;
   uint32_t bucket_id = static_cast<uint32_t>(c.bucket_id);
   Bucket* bucket = CreateBucket(bucket_id);
   Shader* shader = GetShaderInfoNotProgram(shader_id, "glGetShaderInfoLog");
   if (!shader) {
     bucket->SetFromString("");
     return error::kNoError;
   }
 
   // Shader must be compiled in order to get the info log.
@@ skipping 320 matching lines @@
 void GLES2DecoderImpl::DoVertexAttrib4f(
     GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
   GLfloat v[4] = { v0, v1, v2, v3, };
   if (SetVertexAttribValue("glVertexAttrib4f", index, v)) {
     state_.SetGenericVertexAttribBaseType(
         index, SHADER_VARIABLE_FLOAT);
     glVertexAttrib4f(index, v0, v1, v2, v3);
   }
 }
 
-void GLES2DecoderImpl::DoVertexAttrib1fv(GLuint index, const GLfloat* v) {
+void GLES2DecoderImpl::DoVertexAttrib1fv(GLuint index,
+                                         const volatile GLfloat* v) {
   GLfloat t[4] = { v[0], 0.0f, 0.0f, 1.0f, };
   if (SetVertexAttribValue("glVertexAttrib1fv", index, t)) {
     state_.SetGenericVertexAttribBaseType(
         index, SHADER_VARIABLE_FLOAT);
     glVertexAttrib1fv(index, t);
   }
 }
 
-void GLES2DecoderImpl::DoVertexAttrib2fv(GLuint index, const GLfloat* v) {
+void GLES2DecoderImpl::DoVertexAttrib2fv(GLuint index,
+                                         const volatile GLfloat* v) {
   GLfloat t[4] = { v[0], v[1], 0.0f, 1.0f, };
   if (SetVertexAttribValue("glVertexAttrib2fv", index, t)) {
     state_.SetGenericVertexAttribBaseType(
         index, SHADER_VARIABLE_FLOAT);
     glVertexAttrib2fv(index, t);
   }
 }
 
-void GLES2DecoderImpl::DoVertexAttrib3fv(GLuint index, const GLfloat* v) {
+void GLES2DecoderImpl::DoVertexAttrib3fv(GLuint index,
+                                         const volatile GLfloat* v) {
   GLfloat t[4] = { v[0], v[1], v[2], 1.0f, };
   if (SetVertexAttribValue("glVertexAttrib3fv", index, t)) {
     state_.SetGenericVertexAttribBaseType(
         index, SHADER_VARIABLE_FLOAT);
     glVertexAttrib3fv(index, t);
   }
 }
 
-void GLES2DecoderImpl::DoVertexAttrib4fv(GLuint index, const GLfloat* v) {
+void GLES2DecoderImpl::DoVertexAttrib4fv(GLuint index,
+                                         const volatile GLfloat* v) {
   GLfloat t[4] = {v[0], v[1], v[2], v[3]};
   if (SetVertexAttribValue("glVertexAttrib4fv", index, t)) {
     state_.SetGenericVertexAttribBaseType(
         index, SHADER_VARIABLE_FLOAT);
     glVertexAttrib4fv(index, t);
   }
 }
 
 void GLES2DecoderImpl::DoVertexAttribI4i(
     GLuint index, GLint v0, GLint v1, GLint v2, GLint v3) {
   GLint v[4] = { v0, v1, v2, v3 };
   if (SetVertexAttribValue("glVertexAttribI4i", index, v)) {
     state_.SetGenericVertexAttribBaseType(
         index, SHADER_VARIABLE_INT);
     glVertexAttribI4i(index, v0, v1, v2, v3);
   }
 }
 
-void GLES2DecoderImpl::DoVertexAttribI4iv(GLuint index, const GLint* v) {
+void GLES2DecoderImpl::DoVertexAttribI4iv(GLuint index,
+                                          const volatile GLint* v) {
   GLint t[4] = {v[0], v[1], v[2], v[3]};
   if (SetVertexAttribValue("glVertexAttribI4iv", index, t)) {
     state_.SetGenericVertexAttribBaseType(
         index, SHADER_VARIABLE_INT);
     glVertexAttribI4iv(index, t);
   }
 }
 
 void GLES2DecoderImpl::DoVertexAttribI4ui(
     GLuint index, GLuint v0, GLuint v1, GLuint v2, GLuint v3) {
   GLuint v[4] = { v0, v1, v2, v3 };
   if (SetVertexAttribValue("glVertexAttribI4ui", index, v)) {
     state_.SetGenericVertexAttribBaseType(
         index, SHADER_VARIABLE_UINT);
     glVertexAttribI4ui(index, v0, v1, v2, v3);
   }
 }
 
-void GLES2DecoderImpl::DoVertexAttribI4uiv(GLuint index, const GLuint* v) {
+void GLES2DecoderImpl::DoVertexAttribI4uiv(GLuint index,
+                                           const volatile GLuint* v) {
   GLuint t[4] = {v[0], v[1], v[2], v[3]};
   if (SetVertexAttribValue("glVertexAttribI4uiv", index, t)) {
     state_.SetGenericVertexAttribBaseType(
         index, SHADER_VARIABLE_UINT);
     glVertexAttribI4uiv(index, t);
   }
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribIPointer(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::VertexAttribIPointer& c =
-      *static_cast<const gles2::cmds::VertexAttribIPointer*>(cmd_data);
+  const volatile gles2::cmds::VertexAttribIPointer& c =
+      *static_cast<const volatile gles2::cmds::VertexAttribIPointer*>(cmd_data);
   GLuint indx = c.indx;
   GLint size = c.size;
   GLenum type = c.type;
   GLsizei stride = c.stride;
   GLsizei offset = c.offset;
 
   if (!state_.bound_array_buffer.get() ||
       state_.bound_array_buffer->IsDeleted()) {
     if (state_.vertex_attrib_manager.get() ==
         state_.default_vertex_attrib_manager.get()) {
@@ skipping 69 matching lines @@
                       stride,
                       stride != 0 ? stride : group_size,
                       offset,
                       GL_TRUE);
   glVertexAttribIPointer(indx, size, type, stride, ptr);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribPointer(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::VertexAttribPointer& c =
-      *static_cast<const gles2::cmds::VertexAttribPointer*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::VertexAttribPointer& c =
+      *static_cast<const volatile gles2::cmds::VertexAttribPointer*>(cmd_data);
   GLuint indx = c.indx;
   GLint size = c.size;
   GLenum type = c.type;
   GLboolean normalized = static_cast<GLboolean>(c.normalized);
   GLsizei stride = c.stride;
   GLsizei offset = c.offset;
 
   if (!state_.bound_array_buffer.get() ||
       state_.bound_array_buffer->IsDeleted()) {
     if (state_.vertex_attrib_manager.get() ==
@@ skipping 85 matching lines @@
                                   GLsizei height) {
   state_.viewport_x = x;
   state_.viewport_y = y;
   state_.viewport_width = std::min(width, viewport_max_width_);
   state_.viewport_height = std::min(height, viewport_max_height_);
   glViewport(x, y, width, height);
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribDivisorANGLE(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::VertexAttribDivisorANGLE& c =
-      *static_cast<const gles2::cmds::VertexAttribDivisorANGLE*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::VertexAttribDivisorANGLE& c =
+      *static_cast<const volatile gles2::cmds::VertexAttribDivisorANGLE*>(
+          cmd_data);
   if (!features().angle_instanced_arrays)
     return error::kUnknownCommand;
 
   GLuint index = c.index;
   GLuint divisor = c.divisor;
   if (index >= group_->max_vertex_attribs()) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glVertexAttribDivisorANGLE", "index out of range");
     return error::kNoError;
@@ skipping 135 matching lines @@
         case GL_HALF_FLOAT:
           WriteAlphaData<uint16_t>(pixels, height, channel_count, alpha_channel,
                                    unpadded_row_size, padded_row_size, 0x3C00);
           break;
       }
     }
   }
 }
 
 error::Error GLES2DecoderImpl::HandleReadPixels(uint32_t immediate_data_size,
-                                                const void* cmd_data) {
-  const gles2::cmds::ReadPixels& c =
-      *static_cast<const gles2::cmds::ReadPixels*>(cmd_data);
+                                                const volatile void* cmd_data) {
+  const volatile gles2::cmds::ReadPixels& c =
+      *static_cast<const volatile gles2::cmds::ReadPixels*>(cmd_data);
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandleReadPixels");
   error::Error fbo_error = WillAccessBoundFramebufferForRead();
   if (fbo_error != error::kNoError)
     return fbo_error;
   GLint x = c.x;
   GLint y = c.y;
   GLsizei width = c.width;
   GLsizei height = c.height;
   GLenum format = c.format;
   GLenum type = c.type;
@@ skipping 317 matching lines @@
       }
       FinishReadPixels(width, height, format, type, pixels_shm_id,
                        pixels_shm_offset, result_shm_id, result_shm_offset,
                        state_.pack_alignment, read_format, 0);
     }
   }
 
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandlePixelStorei(uint32_t immediate_data_size,
-                                                 const void* cmd_data) {
-  const gles2::cmds::PixelStorei& c =
-      *static_cast<const gles2::cmds::PixelStorei*>(cmd_data);
+error::Error GLES2DecoderImpl::HandlePixelStorei(
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::PixelStorei& c =
+      *static_cast<const volatile gles2::cmds::PixelStorei*>(cmd_data);
   GLenum pname = c.pname;
   GLint param = c.param;
   if (!validators_->pixel_store.IsValid(pname)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glPixelStorei", pname, "pname");
     return error::kNoError;
   }
   switch (pname) {
     case GL_PACK_ALIGNMENT:
     case GL_UNPACK_ALIGNMENT:
       if (!validators_->pixel_store_alignment.IsValid(param)) {
@@ skipping 59 matching lines @@
     default:
       // Validation should have prevented us from getting here.
       NOTREACHED();
       break;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePostSubBufferCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::PostSubBufferCHROMIUM& c =
-      *static_cast<const gles2::cmds::PostSubBufferCHROMIUM*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::PostSubBufferCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::PostSubBufferCHROMIUM*>(
+          cmd_data);
   TRACE_EVENT0("gpu", "GLES2DecoderImpl::HandlePostSubBufferCHROMIUM");
   {
     TRACE_EVENT_SYNTHETIC_DELAY("gpu.PresentingFrame");
   }
   if (!supports_post_sub_buffer_) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
         "glPostSubBufferCHROMIUM", "command not supported by surface");
     return error::kNoError;
   }
@@ skipping 17 matching lines @@
                    base::AsWeakPtr(this)));
   } else {
     FinishSwapBuffers(surface_->PostSubBuffer(c.x, c.y, c.width, c.height));
   }
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleScheduleOverlayPlaneCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::ScheduleOverlayPlaneCHROMIUM& c =
-      *static_cast<const gles2::cmds::ScheduleOverlayPlaneCHROMIUM*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::ScheduleOverlayPlaneCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::ScheduleOverlayPlaneCHROMIUM*>(
+          cmd_data);
   TextureRef* ref = texture_manager()->GetTexture(c.overlay_texture_id);
   if (!ref) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
                        "glScheduleOverlayPlaneCHROMIUM",
                        "unknown texture");
     return error::kNoError;
   }
   Texture::ImageState image_state;
   gl::GLImage* image =
       ref->texture()->GetLevelImage(ref->texture()->target(), 0, &image_state);
@@ skipping 18 matching lines @@
           gfx::RectF(c.uv_x, c.uv_y, c.uv_width, c.uv_height))) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
                        "glScheduleOverlayPlaneCHROMIUM",
                        "failed to schedule overlay");
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleScheduleCALayerSharedStateCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::ScheduleCALayerSharedStateCHROMIUM& c =
-      *static_cast<const gles2::cmds::ScheduleCALayerSharedStateCHROMIUM*>(
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::ScheduleCALayerSharedStateCHROMIUM& c =
+      *static_cast<
+          const volatile gles2::cmds::ScheduleCALayerSharedStateCHROMIUM*>(
           cmd_data);
 
   const GLfloat* mem = GetSharedMemoryAs<const GLfloat*>(c.shm_id, c.shm_offset,
                                                          20 * sizeof(GLfloat));
   if (!mem) {
     return error::kOutOfBounds;
   }
   gfx::RectF clip_rect(mem[0], mem[1], mem[2], mem[3]);
   gfx::Transform transform(mem[4], mem[8], mem[12], mem[16],
                            mem[5], mem[9], mem[13], mem[17],
                            mem[6], mem[10], mem[14], mem[18],
                            mem[7], mem[11], mem[15], mem[19]);
   ca_layer_shared_state_.reset(new CALayerSharedState);
   ca_layer_shared_state_->opacity = c.opacity;
   ca_layer_shared_state_->is_clipped = c.is_clipped ? true : false;
   ca_layer_shared_state_->clip_rect = gfx::ToEnclosingRect(clip_rect);
   ca_layer_shared_state_->sorting_context_id = c.sorting_context_id;
   ca_layer_shared_state_->transform = transform;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleScheduleCALayerCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::ScheduleCALayerCHROMIUM& c =
-      *static_cast<const gles2::cmds::ScheduleCALayerCHROMIUM*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::ScheduleCALayerCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::ScheduleCALayerCHROMIUM*>(
+          cmd_data);
   GLuint filter = c.filter;
   if (filter != GL_NEAREST && filter != GL_LINEAR) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glScheduleCALayerCHROMIUM",
                        "invalid filter");
     return error::kNoError;
   }
 
   if (!ca_layer_shared_state_) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, "glScheduleCALayerCHROMIUM",
@@ skipping 36 matching lines @@
       ca_layer_shared_state_->opacity, filter);
   if (!surface_->ScheduleCALayer(params)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glScheduleCALayerCHROMIUM",
                        "failed to schedule CALayer");
   }
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoScheduleCALayerInUseQueryCHROMIUM(
     GLsizei count,
-    const GLuint* textures) {
+    const volatile GLuint* textures) {
   std::vector<gl::GLSurface::CALayerInUseQuery> queries;
   queries.reserve(count);
   for (GLsizei i = 0; i < count; ++i) {
     gl::GLImage* image = nullptr;
     GLuint texture_id = textures[i];
     if (texture_id) {
       TextureRef* ref = texture_manager()->GetTexture(texture_id);
       if (!ref) {
         LOCAL_SET_GL_ERROR(GL_INVALID_VALUE,
                            "glScheduleCALayerInUseQueryCHROMIUM",
@@ skipping 41 matching lines @@
   // Check that the client initialized the result.
   if (*location != -1) {
     return error::kInvalidArguments;
   }
   *location = program->GetAttribLocation(name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetAttribLocation(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GetAttribLocation& c =
-      *static_cast<const gles2::cmds::GetAttribLocation*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetAttribLocation& c =
+      *static_cast<const volatile gles2::cmds::GetAttribLocation*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetAttribLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
@@ skipping 27 matching lines @@
   // Check that the client initialized the result.
   if (*location != -1) {
     return error::kInvalidArguments;
   }
   *location = program->GetUniformFakeLocation(name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformLocation(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GetUniformLocation& c =
-      *static_cast<const gles2::cmds::GetUniformLocation*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetUniformLocation& c =
+      *static_cast<const volatile gles2::cmds::GetUniformLocation*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetUniformLocationHelper(
     c.program, c.location_shm_id, c.location_shm_offset, name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformIndices(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::GetUniformIndices& c =
-      *static_cast<const gles2::cmds::GetUniformIndices*>(cmd_data);
+  const volatile gles2::cmds::GetUniformIndices& c =
+      *static_cast<const volatile gles2::cmds::GetUniformIndices*>(cmd_data);
   Bucket* bucket = GetBucket(c.names_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   GLsizei count = 0;
   std::vector<char*> names;
   std::vector<GLint> len;
   if (!bucket->GetAsStrings(&count, &names, &len) || count <= 0) {
     return error::kInvalidArguments;
   }
@@ skipping 56 matching lines @@
                        "program not linked");
     return error::kNoError;
   }
 
   *location = program->GetFragDataLocation(name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetFragDataLocation(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::GetFragDataLocation& c =
-      *static_cast<const gles2::cmds::GetFragDataLocation*>(cmd_data);
+  const volatile gles2::cmds::GetFragDataLocation& c =
+      *static_cast<const volatile gles2::cmds::GetFragDataLocation*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetFragDataLocationHelper(
       c.program, c.location_shm_id, c.location_shm_offset, name_str);
@@ skipping 23 matching lines @@
                        "program not linked");
     return error::kNoError;
   }
 
   *index = program->GetFragDataIndex(name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetFragDataIndexEXT(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!features().ext_blend_func_extended) {
     return error::kUnknownCommand;
   }
-  const gles2::cmds::GetFragDataIndexEXT& c =
-      *static_cast<const gles2::cmds::GetFragDataIndexEXT*>(cmd_data);
+  const volatile gles2::cmds::GetFragDataIndexEXT& c =
+      *static_cast<const volatile gles2::cmds::GetFragDataIndexEXT*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   return GetFragDataIndexHelper(c.program, c.index_shm_id, c.index_shm_offset,
                                 name_str);
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformBlockIndex(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::GetUniformBlockIndex& c =
-      *static_cast<const gles2::cmds::GetUniformBlockIndex*>(cmd_data);
+  const volatile gles2::cmds::GetUniformBlockIndex& c =
+      *static_cast<const volatile gles2::cmds::GetUniformBlockIndex*>(cmd_data);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   GLuint* index = GetSharedMemoryAs<GLuint*>(
       c.index_shm_id, c.index_shm_offset, sizeof(GLuint));
   if (!index) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (*index != GL_INVALID_INDEX) {
     return error::kInvalidArguments;
   }
   Program* program = GetProgramInfoNotShader(
       c.program, "glGetUniformBlockIndex");
   if (!program) {
     return error::kNoError;
   }
   *index = glGetUniformBlockIndex(program->service_id(), name_str.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetString(uint32_t immediate_data_size,
-                                               const void* cmd_data) {
-  const gles2::cmds::GetString& c =
-      *static_cast<const gles2::cmds::GetString*>(cmd_data);
+                                               const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetString& c =
+      *static_cast<const volatile gles2::cmds::GetString*>(cmd_data);
   GLenum name = static_cast<GLenum>(c.name);
   if (!validators_->string_type.IsValid(name)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetString", name, "name");
     return error::kNoError;
   }
 
   const char* str = nullptr;
   std::string extensions;
   switch (name) {
     case GL_VERSION:
@@ skipping 63 matching lines @@
     default:
       str = reinterpret_cast<const char*>(glGetString(name));
       break;
   }
   Bucket* bucket = CreateBucket(c.bucket_id);
   bucket->SetFromString(str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleBufferData(uint32_t immediate_data_size,
-                                                const void* cmd_data) {
-  const gles2::cmds::BufferData& c =
-      *static_cast<const gles2::cmds::BufferData*>(cmd_data);
+                                                const volatile void* cmd_data) {
+  const volatile gles2::cmds::BufferData& c =
+      *static_cast<const volatile gles2::cmds::BufferData*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
   uint32_t data_shm_id = static_cast<uint32_t>(c.data_shm_id);
   uint32_t data_shm_offset = static_cast<uint32_t>(c.data_shm_offset);
   GLenum usage = static_cast<GLenum>(c.usage);
   const void* data = NULL;
   if (data_shm_id != 0 || data_shm_offset != 0) {
     data = GetSharedMemoryAs<const void*>(data_shm_id, data_shm_offset, size);
     if (!data) {
       return error::kOutOfBounds;
@@ skipping 1117 matching lines @@
     glCompressedTexSubImage3D(target, level, xoffset, yoffset, zoffset, width,
                               height, depth, format, image_size, data);
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
 error::Error GLES2DecoderImpl::HandleTexImage2D(uint32_t immediate_data_size,
-                                                const void* cmd_data) {
-  const gles2::cmds::TexImage2D& c =
-      *static_cast<const gles2::cmds::TexImage2D*>(cmd_data);
+                                                const volatile void* cmd_data) {
+  const volatile gles2::cmds::TexImage2D& c =
+      *static_cast<const volatile gles2::cmds::TexImage2D*>(cmd_data);
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::HandleTexImage2D",
       "width", c.width, "height", c.height);
   // Set as failed for now, but if it successed, this will be set to not failed.
   texture_state_.tex_image_failed = true;
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint internal_format = static_cast<GLint>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLint border = static_cast<GLint>(c.border);
@@ skipping 63 matching lines @@
   texture_manager()->ValidateAndDoTexImage(
       &texture_state_, &state_, &framebuffer_state_, "glTexImage2D", args);
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleTexImage3D(uint32_t immediate_data_size,
-                                                const void* cmd_data) {
+                                                const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
 
-  const gles2::cmds::TexImage3D& c =
-      *static_cast<const gles2::cmds::TexImage3D*>(cmd_data);
+  const volatile gles2::cmds::TexImage3D& c =
+      *static_cast<const volatile gles2::cmds::TexImage3D*>(cmd_data);
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::HandleTexImage3D",
       "widthXheight", c.width * c.height, "depth", c.depth);
   // Set as failed for now, but if it successed, this will be set to not failed.
   texture_state_.tex_image_failed = true;
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint internal_format = static_cast<GLint>(c.internalformat);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLsizei depth = static_cast<GLsizei>(c.depth);
@@ skipping 647 matching lines @@
       glCopyTexSubImage3D(target, level, destX, destY, zoffset,
                           copyX, copyY, copyWidth, copyHeight);
     }
   }
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
 }
 
-error::Error GLES2DecoderImpl::HandleTexSubImage2D(uint32_t immediate_data_size,
-                                                   const void* cmd_data) {
-  const gles2::cmds::TexSubImage2D& c =
-      *static_cast<const gles2::cmds::TexSubImage2D*>(cmd_data);
+error::Error GLES2DecoderImpl::HandleTexSubImage2D(
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::TexSubImage2D& c =
+      *static_cast<const volatile gles2::cmds::TexSubImage2D*>(cmd_data);
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::HandleTexSubImage2D",
       "width", c.width, "height", c.height);
   GLboolean internal = static_cast<GLboolean>(c.internal);
   if (internal == GL_TRUE && texture_state_.tex_image_failed)
     return error::kNoError;
 
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
@@ skipping 54 matching lines @@
   texture_manager()->ValidateAndDoTexSubImage(this, &texture_state_, &state_,
                                               &framebuffer_state_,
                                               "glTexSubImage2D", args);
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleTexSubImage3D(uint32_t immediate_data_size,
-                                                   const void* cmd_data) {
+error::Error GLES2DecoderImpl::HandleTexSubImage3D(
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
 
-  const gles2::cmds::TexSubImage3D& c =
-      *static_cast<const gles2::cmds::TexSubImage3D*>(cmd_data);
+  const volatile gles2::cmds::TexSubImage3D& c =
+      *static_cast<const volatile gles2::cmds::TexSubImage3D*>(cmd_data);
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::HandleTexSubImage3D",
       "widthXheight", c.width * c.height, "depth", c.depth);
   GLboolean internal = static_cast<GLboolean>(c.internal);
   if (internal == GL_TRUE && texture_state_.tex_image_failed)
     return error::kNoError;
 
   GLenum target = static_cast<GLenum>(c.target);
   GLint level = static_cast<GLint>(c.level);
   GLint xoffset = static_cast<GLint>(c.xoffset);
   GLint yoffset = static_cast<GLint>(c.yoffset);
@@ skipping 58 matching lines @@
                                               "glTexSubImage3D", args);
 
   // This may be a slow command.  Exit command processing to allow for
   // context preemption and GPU watchdog checks.
   ExitCommandProcessingEarly();
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetVertexAttribPointerv(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GetVertexAttribPointerv& c =
-      *static_cast<const gles2::cmds::GetVertexAttribPointerv*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetVertexAttribPointerv& c =
+      *static_cast<const volatile gles2::cmds::GetVertexAttribPointerv*>(
+          cmd_data);
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
   typedef cmds::GetVertexAttribPointerv::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
         c.pointer_shm_id, c.pointer_shm_offset, Result::ComputeSize(1));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->size != 0) {
@@ skipping 76 matching lines @@
   if (!result) {
     *error = error::kOutOfBounds;
     return false;
   }
   result->SetNumResults(num_elements);
   *result_size = num_elements * sizeof(T);
   *result_type = type;
   return true;
 }
 
-error::Error GLES2DecoderImpl::HandleGetUniformiv(uint32_t immediate_data_size,
-                                                  const void* cmd_data) {
-  const gles2::cmds::GetUniformiv& c =
-      *static_cast<const gles2::cmds::GetUniformiv*>(cmd_data);
+error::Error GLES2DecoderImpl::HandleGetUniformiv(
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetUniformiv& c =
+      *static_cast<const volatile gles2::cmds::GetUniformiv*>(cmd_data);
   GLuint program = c.program;
   GLint fake_location = c.location;
   GLuint service_id;
   GLenum result_type;
   GLsizei result_size;
   GLint real_location = -1;
   Error error;
   cmds::GetUniformiv::Result* result;
   if (GetUniformSetup<GLint>(program, fake_location, c.params_shm_id,
                              c.params_shm_offset, &error, &real_location,
                              &service_id, &result, &result_type,
                              &result_size)) {
     glGetUniformiv(
         service_id, real_location, result->GetData());
   }
   return error;
 }
 
-error::Error GLES2DecoderImpl::HandleGetUniformuiv(uint32_t immediate_data_size,
-                                                   const void* cmd_data) {
+error::Error GLES2DecoderImpl::HandleGetUniformuiv(
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
 
-  const gles2::cmds::GetUniformuiv& c =
-      *static_cast<const gles2::cmds::GetUniformuiv*>(cmd_data);
+  const volatile gles2::cmds::GetUniformuiv& c =
+      *static_cast<const volatile gles2::cmds::GetUniformuiv*>(cmd_data);
   GLuint program = c.program;
   GLint fake_location = c.location;
   GLuint service_id;
   GLenum result_type;
   GLsizei result_size;
   GLint real_location = -1;
   Error error;
   cmds::GetUniformuiv::Result* result;
   if (GetUniformSetup<GLuint>(program, fake_location, c.params_shm_id,
                               c.params_shm_offset, &error, &real_location,
                               &service_id, &result, &result_type,
                               &result_size)) {
     glGetUniformuiv(
         service_id, real_location, result->GetData());
   }
   return error;
 }
 
-error::Error GLES2DecoderImpl::HandleGetUniformfv(uint32_t immediate_data_size,
-                                                  const void* cmd_data) {
-  const gles2::cmds::GetUniformfv& c =
-      *static_cast<const gles2::cmds::GetUniformfv*>(cmd_data);
+error::Error GLES2DecoderImpl::HandleGetUniformfv(
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetUniformfv& c =
+      *static_cast<const volatile gles2::cmds::GetUniformfv*>(cmd_data);
   GLuint program = c.program;
   GLint fake_location = c.location;
   GLuint service_id;
   GLint real_location = -1;
   Error error;
   cmds::GetUniformfv::Result* result;
   GLenum result_type;
   GLsizei result_size;
   if (GetUniformSetup<GLfloat>(program, fake_location, c.params_shm_id,
                                c.params_shm_offset, &error, &real_location,
@@ skipping 10 matching lines @@
       }
     } else {
       glGetUniformfv(service_id, real_location, result->GetData());
     }
   }
   return error;
 }
 
 error::Error GLES2DecoderImpl::HandleGetShaderPrecisionFormat(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GetShaderPrecisionFormat& c =
-      *static_cast<const gles2::cmds::GetShaderPrecisionFormat*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetShaderPrecisionFormat& c =
+      *static_cast<const volatile gles2::cmds::GetShaderPrecisionFormat*>(
+          cmd_data);
   GLenum shader_type = static_cast<GLenum>(c.shadertype);
   GLenum precision_type = static_cast<GLenum>(c.precisiontype);
   typedef cmds::GetShaderPrecisionFormat::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
   if (result->success != 0) {
@@ skipping 19 matching lines @@
 
   result->min_range = range[0];
   result->max_range = range[1];
   result->precision = precision;
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetAttachedShaders(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GetAttachedShaders& c =
-      *static_cast<const gles2::cmds::GetAttachedShaders*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetAttachedShaders& c =
+      *static_cast<const volatile gles2::cmds::GetAttachedShaders*>(cmd_data);
   uint32_t result_size = c.result_size;
   GLuint program_id = static_cast<GLuint>(c.program);
   Program* program = GetProgramInfoNotShader(
       program_id, "glGetAttachedShaders");
   if (!program) {
     return error::kNoError;
   }
   typedef cmds::GetAttachedShaders::Result Result;
   uint32_t max_count = Result::ComputeMaxResults(result_size);
   Result* result = GetSharedMemoryAs<Result*>(
@@ skipping 14 matching lines @@
       NOTREACHED();
       return error::kGenericError;
     }
   }
   result->SetNumResults(count);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetActiveUniform(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GetActiveUniform& c =
-      *static_cast<const gles2::cmds::GetActiveUniform*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetActiveUniform& c =
+      *static_cast<const volatile gles2::cmds::GetActiveUniform*>(cmd_data);
   GLuint program_id = c.program;
   GLuint index = c.index;
   uint32_t name_bucket_id = c.name_bucket_id;
   typedef cmds::GetActiveUniform::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
@@ skipping 15 matching lines @@
   result->success = 1;  // true.
   result->size = uniform_info->size;
   result->type = uniform_info->type;
   Bucket* bucket = CreateBucket(name_bucket_id);
   bucket->SetFromString(uniform_info->name.c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetActiveUniformBlockiv(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::GetActiveUniformBlockiv& c =
-      *static_cast<const gles2::cmds::GetActiveUniformBlockiv*>(cmd_data);
+  const volatile gles2::cmds::GetActiveUniformBlockiv& c =
+      *static_cast<const volatile gles2::cmds::GetActiveUniformBlockiv*>(
+          cmd_data);
   GLuint program_id = c.program;
   GLuint index = static_cast<GLuint>(c.index);
   GLenum pname = static_cast<GLenum>(c.pname);
   Program* program = GetProgramInfoNotShader(
       program_id, "glGetActiveUniformBlockiv");
   if (!program) {
     return error::kNoError;
   }
   GLuint service_id = program->service_id();
   GLint link_status = GL_FALSE;
@@ skipping 33 matching lines @@
   if (error == GL_NO_ERROR) {
     result->SetNumResults(num_values);
   } else {
     LOCAL_SET_GL_ERROR(error, "GetActiveUniformBlockiv", "");
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetActiveUniformBlockName(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::GetActiveUniformBlockName& c =
-      *static_cast<const gles2::cmds::GetActiveUniformBlockName*>(cmd_data);
+  const volatile gles2::cmds::GetActiveUniformBlockName& c =
+      *static_cast<const volatile gles2::cmds::GetActiveUniformBlockName*>(
+          cmd_data);
   GLuint program_id = c.program;
   GLuint index = c.index;
   uint32_t name_bucket_id = c.name_bucket_id;
   typedef cmds::GetActiveUniformBlockName::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
@@ skipping 29 matching lines @@
   *result = 1;
   Bucket* bucket = CreateBucket(name_bucket_id);
   DCHECK_GT(buf_size, length);
   DCHECK_EQ(0, buffer[length]);
   bucket->SetFromString(&buffer[0]);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetActiveUniformsiv(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::GetActiveUniformsiv& c =
-      *static_cast<const gles2::cmds::GetActiveUniformsiv*>(cmd_data);
+  const volatile gles2::cmds::GetActiveUniformsiv& c =
+      *static_cast<const volatile gles2::cmds::GetActiveUniformsiv*>(cmd_data);
   GLuint program_id = c.program;
   GLenum pname = static_cast<GLenum>(c.pname);
   Bucket* bucket = GetBucket(c.indices_bucket_id);
   if (!bucket) {
     return error::kInvalidArguments;
   }
   if (!validators_->uniform_parameter.IsValid(pname)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetActiveUniformsiv", pname, "pname");
     return error::kNoError;
   }
@@ skipping 29 matching lines @@
   if (error == GL_NO_ERROR) {
     result->SetNumResults(count);
   } else {
     LOCAL_SET_GL_ERROR(error, "GetActiveUniformsiv", "");
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetActiveAttrib(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GetActiveAttrib& c =
-      *static_cast<const gles2::cmds::GetActiveAttrib*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetActiveAttrib& c =
+      *static_cast<const volatile gles2::cmds::GetActiveAttrib*>(cmd_data);
   GLuint program_id = c.program;
   GLuint index = c.index;
   uint32_t name_bucket_id = c.name_bucket_id;
   typedef cmds::GetActiveAttrib::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
@@ skipping 13 matching lines @@
     return error::kNoError;
   }
   result->success = 1;  // true.
   result->size = attrib_info->size;
   result->type = attrib_info->type;
   Bucket* bucket = CreateBucket(name_bucket_id);
   bucket->SetFromString(attrib_info->name.c_str());
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleShaderBinary(uint32_t immediate_data_size,
-                                                  const void* cmd_data) {
+error::Error GLES2DecoderImpl::HandleShaderBinary(
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
 #if 1  // No binary shader support.
   LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "glShaderBinary", "not supported");
   return error::kNoError;
 #else
   GLsizei n = static_cast<GLsizei>(c.n);
   if (n < 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, "glShaderBinary", "n < 0");
     return error::kNoError;
   }
   GLsizei length = static_cast<GLsizei>(c.length);
@@ skipping 183 matching lines @@
     FinishSwapBuffers(surface_->CommitOverlayPlanes());
   }
 }
 
 void GLES2DecoderImpl::DoSwapInterval(int interval) {
   context_->SetSwapInterval(interval);
 }
 
 error::Error GLES2DecoderImpl::HandleEnableFeatureCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::EnableFeatureCHROMIUM& c =
-      *static_cast<const gles2::cmds::EnableFeatureCHROMIUM*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::EnableFeatureCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::EnableFeatureCHROMIUM*>(
+          cmd_data);
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   typedef cmds::EnableFeatureCHROMIUM::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
@@ skipping 24 matching lines @@
   } else {
     return error::kNoError;
   }
 
   *result = 1;  // true.
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetRequestableExtensionsCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GetRequestableExtensionsCHROMIUM& c =
-      *static_cast<const gles2::cmds::GetRequestableExtensionsCHROMIUM*>(
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetRequestableExtensionsCHROMIUM& c =
+      *static_cast<
+          const volatile gles2::cmds::GetRequestableExtensionsCHROMIUM*>(
           cmd_data);
   Bucket* bucket = CreateBucket(c.bucket_id);
   scoped_refptr<FeatureInfo> info(new FeatureInfo(workarounds()));
   DisallowedFeatures disallowed_features = feature_info_->disallowed_features();
   disallowed_features.AllowExtensions();
   info->Initialize(feature_info_->context_type(), disallowed_features);
   bucket->SetFromString(info->extensions().c_str());
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleRequestExtensionCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::RequestExtensionCHROMIUM& c =
-      *static_cast<const gles2::cmds::RequestExtensionCHROMIUM*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::RequestExtensionCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::RequestExtensionCHROMIUM*>(
+          cmd_data);
   Bucket* bucket = GetBucket(c.bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string feature_str;
   if (!bucket->GetAsString(&feature_str)) {
     return error::kInvalidArguments;
   }
   feature_str = feature_str + " ";
 
@@ skipping 41 matching lines @@
     feature_info_->EnableOESTextureHalfFloatLinear();
   }
 
   UpdateCapabilities();
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetProgramInfoCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GetProgramInfoCHROMIUM& c =
-      *static_cast<const gles2::cmds::GetProgramInfoCHROMIUM*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GetProgramInfoCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::GetProgramInfoCHROMIUM*>(
+          cmd_data);
   GLuint program_id = static_cast<GLuint>(c.program);
   uint32_t bucket_id = c.bucket_id;
   Bucket* bucket = CreateBucket(bucket_id);
   bucket->SetSize(sizeof(ProgramInfoHeader));  // in case we fail.
   Program* program = NULL;
   program = GetProgram(program_id);
   if (!program || !program->IsValid()) {
     return error::kNoError;
   }
   program->GetProgramInfo(program_manager(), bucket);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformBlocksCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::GetUniformBlocksCHROMIUM& c =
-      *static_cast<const gles2::cmds::GetUniformBlocksCHROMIUM*>(cmd_data);
+  const volatile gles2::cmds::GetUniformBlocksCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::GetUniformBlocksCHROMIUM*>(
+          cmd_data);
   GLuint program_id = static_cast<GLuint>(c.program);
   uint32_t bucket_id = c.bucket_id;
   Bucket* bucket = CreateBucket(bucket_id);
   bucket->SetSize(sizeof(UniformBlocksHeader));  // in case we fail.
   Program* program = NULL;
   program = GetProgram(program_id);
   if (!program || !program->IsValid()) {
     return error::kNoError;
   }
   program->GetUniformBlocks(bucket);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetUniformsES3CHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::GetUniformsES3CHROMIUM& c =
-      *static_cast<const gles2::cmds::GetUniformsES3CHROMIUM*>(cmd_data);
+  const volatile gles2::cmds::GetUniformsES3CHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::GetUniformsES3CHROMIUM*>(
+          cmd_data);
   GLuint program_id = static_cast<GLuint>(c.program);
   uint32_t bucket_id = c.bucket_id;
   Bucket* bucket = CreateBucket(bucket_id);
   bucket->SetSize(sizeof(UniformsES3Header));  // in case we fail.
   Program* program = NULL;
   program = GetProgram(program_id);
   if (!program || !program->IsValid()) {
     return error::kNoError;
   }
   program->GetUniformsES3(bucket);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetTransformFeedbackVarying(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::GetTransformFeedbackVarying& c =
-      *static_cast<const gles2::cmds::GetTransformFeedbackVarying*>(cmd_data);
+  const volatile gles2::cmds::GetTransformFeedbackVarying& c =
+      *static_cast<const volatile gles2::cmds::GetTransformFeedbackVarying*>(
+          cmd_data);
   GLuint program_id = c.program;
   GLuint index = c.index;
   uint32_t name_bucket_id = c.name_bucket_id;
   typedef cmds::GetTransformFeedbackVarying::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
     return error::kOutOfBounds;
   }
   // Check that the client initialized the result.
@@ skipping 34 matching lines @@
   result->type = static_cast<uint32_t>(type);
   Bucket* bucket = CreateBucket(name_bucket_id);
   DCHECK(length >= 0 && length < max_length);
   buffer[length] = '\0';  // Just to be safe.
   bucket->SetFromString(&buffer[0]);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleGetTransformFeedbackVaryingsCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::GetTransformFeedbackVaryingsCHROMIUM& c =
-      *static_cast<const gles2::cmds::GetTransformFeedbackVaryingsCHROMIUM*>(
+  const volatile gles2::cmds::GetTransformFeedbackVaryingsCHROMIUM& c =
+      *static_cast<
+          const volatile gles2::cmds::GetTransformFeedbackVaryingsCHROMIUM*>(
           cmd_data);
   GLuint program_id = static_cast<GLuint>(c.program);
   uint32_t bucket_id = c.bucket_id;
   Bucket* bucket = CreateBucket(bucket_id);
   bucket->SetSize(sizeof(TransformFeedbackVaryingsHeader));  // in case we fail.
   Program* program = NULL;
   program = GetProgram(program_id);
   if (!program || !program->IsValid()) {
     return error::kNoError;
   }
@@ skipping 81 matching lines @@
         return false;
     }
     reset_by_robustness_extension_ = true;
     return true;
   }
   return false;
 }
 
 error::Error GLES2DecoderImpl::HandleDescheduleUntilFinishedCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (deschedule_until_finished_callback_.is_null() ||
       reschedule_after_finished_callback_.is_null()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
                        "glDescheduleUntilFinishedCHROMIUM",
                        "Not fully implemented.");
     return error::kNoError;
   }
 
   std::unique_ptr<gl::GLFence> fence(gl::GLFence::Create());
   deschedule_until_finished_fences_.push_back(std::move(fence));
 
   if (deschedule_until_finished_fences_.size() == 1)
     return error::kNoError;
 
   DCHECK_EQ(2u, deschedule_until_finished_fences_.size());
   if (deschedule_until_finished_fences_[0]->HasCompleted()) {
     deschedule_until_finished_fences_.erase(
         deschedule_until_finished_fences_.begin());
     return error::kNoError;
   }
 
   TRACE_EVENT_ASYNC_BEGIN0("cc", "GLES2DecoderImpl::DescheduleUntilFinished",
                            this);
   deschedule_until_finished_callback_.Run();
   return error::kDeferLaterCommands;
 }
 
 error::Error GLES2DecoderImpl::HandleInsertFenceSyncCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::InsertFenceSyncCHROMIUM& c =
-      *static_cast<const gles2::cmds::InsertFenceSyncCHROMIUM*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::InsertFenceSyncCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::InsertFenceSyncCHROMIUM*>(
+          cmd_data);
 
   const uint64_t release_count = c.release_count();
   if (!fence_sync_release_callback_.is_null())
     fence_sync_release_callback_.Run(release_count);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleWaitSyncTokenCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::WaitSyncTokenCHROMIUM& c =
-      *static_cast<const gles2::cmds::WaitSyncTokenCHROMIUM*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::WaitSyncTokenCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::WaitSyncTokenCHROMIUM*>(
+          cmd_data);
 
   const gpu::CommandBufferNamespace kMinNamespaceId =
       gpu::CommandBufferNamespace::INVALID;
   const gpu::CommandBufferNamespace kMaxNamespaceId =
       gpu::CommandBufferNamespace::NUM_COMMAND_BUFFER_NAMESPACES;
 
   gpu::CommandBufferNamespace namespace_id =
       static_cast<gpu::CommandBufferNamespace>(c.namespace_id);
   if ((namespace_id < static_cast<int32_t>(kMinNamespaceId)) ||
        (namespace_id >= static_cast<int32_t>(kMaxNamespaceId))) {
     namespace_id = gpu::CommandBufferNamespace::INVALID;
   }
   const CommandBufferId command_buffer_id =
       CommandBufferId::FromUnsafeValue(c.command_buffer_id());
   const uint64_t release = c.release_count();
   if (wait_fence_sync_callback_.is_null())
     return error::kNoError;
 
   return wait_fence_sync_callback_.Run(namespace_id, command_buffer_id, release)
              ? error::kNoError
              : error::kDeferCommandUntilLater;
 }
 
 error::Error GLES2DecoderImpl::HandleDiscardBackbufferCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   if (surface_->DeferDraws())
     return error::kDeferCommandUntilLater;
   if (!surface_->SetBackbufferAllocation(false))
     return error::kLostContext;
   backbuffer_needs_clear_bits_ |= GL_COLOR_BUFFER_BIT;
   backbuffer_needs_clear_bits_ |= GL_DEPTH_BUFFER_BIT;
   backbuffer_needs_clear_bits_ |= GL_STENCIL_BUFFER_BIT;
   return error::kNoError;
 }
 
 bool GLES2DecoderImpl::GenQueriesEXTHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (query_manager_->IsValidQuery(client_ids[ii])) {
       return false;
     }
   }
   query_manager_->GenQueries(n, client_ids);
   return true;
 }
 
-void GLES2DecoderImpl::DeleteQueriesEXTHelper(GLsizei n,
-                                              const GLuint* client_ids) {
+void GLES2DecoderImpl::DeleteQueriesEXTHelper(
+    GLsizei n,
+    const volatile GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint client_id = client_ids[ii];
     query_manager_->RemoveQuery(client_id);
   }
 }
 
 bool GLES2DecoderImpl::HasPendingQueries() const {
   return query_manager_.get() && query_manager_->HavePendingQueries();
 }
 
@@ skipping 56 matching lines @@
 }
 
 bool GLES2DecoderImpl::HasPollingWork() const {
   return deschedule_until_finished_fences_.size() >= 2;
 }
 
 void GLES2DecoderImpl::PerformPollingWork() {
   ProcessDescheduleUntilFinished();
 }
 
-error::Error GLES2DecoderImpl::HandleBeginQueryEXT(uint32_t immediate_data_size,
-                                                   const void* cmd_data) {
-  const gles2::cmds::BeginQueryEXT& c =
-      *static_cast<const gles2::cmds::BeginQueryEXT*>(cmd_data);
+error::Error GLES2DecoderImpl::HandleBeginQueryEXT(
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::BeginQueryEXT& c =
+      *static_cast<const volatile gles2::cmds::BeginQueryEXT*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLuint client_id = static_cast<GLuint>(c.id);
   int32_t sync_shm_id = static_cast<int32_t>(c.sync_data_shm_id);
   uint32_t sync_shm_offset = static_cast<uint32_t>(c.sync_data_shm_offset);
 
   switch (target) {
     case GL_COMMANDS_ISSUED_CHROMIUM:
     case GL_LATENCY_QUERY_CHROMIUM:
     case GL_ASYNC_PIXEL_PACK_COMPLETED_CHROMIUM:
     case GL_GET_ERROR_QUERY_CHROMIUM:
@@ skipping 69 matching lines @@
     return error::kInvalidArguments;
   }
 
   if (!query_manager_->BeginQuery(query)) {
     return error::kOutOfBounds;
   }
 
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleEndQueryEXT(uint32_t immediate_data_size,
-                                                 const void* cmd_data) {
-  const gles2::cmds::EndQueryEXT& c =
-      *static_cast<const gles2::cmds::EndQueryEXT*>(cmd_data);
+error::Error GLES2DecoderImpl::HandleEndQueryEXT(
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::EndQueryEXT& c =
+      *static_cast<const volatile gles2::cmds::EndQueryEXT*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   uint32_t submit_count = static_cast<GLuint>(c.submit_count);
 
   QueryManager::Query* query = query_manager_->GetActiveQuery(target);
   if (!query) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, "glEndQueryEXT", "No active query");
     return error::kNoError;
   }
 
   if (!query_manager_->EndQuery(query, submit_count)) {
     return error::kOutOfBounds;
   }
 
   query_manager_->ProcessPendingTransferQueries();
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleQueryCounterEXT(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::QueryCounterEXT& c =
-      *static_cast<const gles2::cmds::QueryCounterEXT*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::QueryCounterEXT& c =
+      *static_cast<const volatile gles2::cmds::QueryCounterEXT*>(cmd_data);
   GLuint client_id = static_cast<GLuint>(c.id);
   GLenum target = static_cast<GLenum>(c.target);
   int32_t sync_shm_id = static_cast<int32_t>(c.sync_data_shm_id);
   uint32_t sync_shm_offset = static_cast<uint32_t>(c.sync_data_shm_offset);
   uint32_t submit_count = static_cast<GLuint>(c.submit_count);
 
   switch (target) {
     case GL_TIMESTAMP:
       if (!query_manager_->GPUTimingAvailable()) {
         LOCAL_SET_GL_ERROR(
@@ skipping 22 matching lines @@
   }
   if (!query_manager_->QueryCounter(query, submit_count)) {
     return error::kOutOfBounds;
   }
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleSetDisjointValueSyncCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::SetDisjointValueSyncCHROMIUM& c =
-      *static_cast<const gles2::cmds::SetDisjointValueSyncCHROMIUM*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::SetDisjointValueSyncCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::SetDisjointValueSyncCHROMIUM*>(
+          cmd_data);
   int32_t sync_shm_id = static_cast<int32_t>(c.sync_data_shm_id);
   uint32_t sync_shm_offset = static_cast<uint32_t>(c.sync_data_shm_offset);
 
   return query_manager_->SetDisjointSync(sync_shm_id, sync_shm_offset);
 }
 
 bool GLES2DecoderImpl::GenVertexArraysOESHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (GetVertexAttribManager(client_ids[ii])) {
@@ skipping 11 matching lines @@
 
     glGenVertexArraysOES(n, service_ids.get());
     for (GLsizei ii = 0; ii < n; ++ii) {
       CreateVertexAttribManager(client_ids[ii], service_ids[ii], true);
     }
   }
 
   return true;
 }
 
-void GLES2DecoderImpl::DeleteVertexArraysOESHelper(GLsizei n,
-                                                   const GLuint* client_ids) {
+void GLES2DecoderImpl::DeleteVertexArraysOESHelper(
+    GLsizei n,
+    const volatile GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     GLuint client_id = client_ids[ii];
     VertexAttribManager* vao = GetVertexAttribManager(client_id);
     if (vao && !vao->IsDeleted()) {
       if (state_.vertex_attrib_manager.get() == vao) {
         DoBindVertexArrayOES(0);
       }
       RemoveVertexAttribManager(client_id);
     }
   }
@@ skipping 876 matching lines @@
                                       GLsizei width,
                                       GLsizei height,
                                       GLsizei depth) {
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::DoTexStorage3D",
       "widthXheight", width * height, "depth", depth);
   TexStorageImpl(target, levels, internal_format, width, height, depth,
                  ContextState::k3D, "glTexStorage3D");
 }
 
 void GLES2DecoderImpl::DoProduceTextureCHROMIUM(GLenum target,
-                                                const GLbyte* data) {
+                                                const volatile GLbyte* data) {
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::DoProduceTextureCHROMIUM",
       "context", logger_.GetLogPrefix(),
       "mailbox[0]", static_cast<unsigned char>(data[0]));
 
   TextureRef* texture_ref = texture_manager()->GetTextureInfoForTarget(
       &state_, target);
   ProduceTextureRef("glProduceTextureCHROMIUM", false, texture_ref, target,
                     data);
 }
 
-void GLES2DecoderImpl::DoProduceTextureDirectCHROMIUM(GLuint client_id,
-    GLenum target, const GLbyte* data) {
+void GLES2DecoderImpl::DoProduceTextureDirectCHROMIUM(
+    GLuint client_id,
+    GLenum target,
+    const volatile GLbyte* data) {
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::DoProduceTextureDirectCHROMIUM",
       "context", logger_.GetLogPrefix(),
       "mailbox[0]", static_cast<unsigned char>(data[0]));
 
   ProduceTextureRef("glProduceTextureDirectCHROMIUM", !client_id,
                     GetTexture(client_id), target, data);
 }
 
 void GLES2DecoderImpl::ProduceTextureRef(const char* func_name,
                                          bool clear,
                                          TextureRef* texture_ref,
                                          GLenum target,
-                                         const GLbyte* data) {
-  Mailbox mailbox = *reinterpret_cast<const Mailbox*>(data);
+                                         const volatile GLbyte* data) {
+  Mailbox mailbox =
+      Mailbox::FromVolatile(*reinterpret_cast<const volatile Mailbox*>(data));
   DLOG_IF(ERROR, !mailbox.Verify()) << func_name << " was passed a "
                                        "mailbox that was not generated by "
                                        "GenMailboxCHROMIUM.";
 
   if (clear) {
     DCHECK(!texture_ref);
 
     group_->mailbox_manager()->ProduceTexture(mailbox, nullptr);
     return;
   }
@@ skipping 14 matching lines @@
   if (produced->target() != target) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION, func_name, "invalid target");
     return;
   }
 
   group_->mailbox_manager()->ProduceTexture(mailbox, produced);
 }
 
 void GLES2DecoderImpl::DoConsumeTextureCHROMIUM(GLenum target,
-                                                const GLbyte* data) {
+                                                const volatile GLbyte* data) {
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::DoConsumeTextureCHROMIUM",
       "context", logger_.GetLogPrefix(),
       "mailbox[0]", static_cast<unsigned char>(data[0]));
-  Mailbox mailbox = *reinterpret_cast<const Mailbox*>(data);
+  Mailbox mailbox =
+      Mailbox::FromVolatile(*reinterpret_cast<const volatile Mailbox*>(data));
   DLOG_IF(ERROR, !mailbox.Verify()) << "ConsumeTextureCHROMIUM was passed a "
                                        "mailbox that was not generated by "
                                        "GenMailboxCHROMIUM.";
 
   scoped_refptr<TextureRef> texture_ref =
       texture_manager()->GetTextureInfoForTargetUnlessDefault(&state_, target);
   if (!texture_ref.get()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
                        "glConsumeTextureCHROMIUM",
                        "unknown texture for target");
@@ skipping 37 matching lines @@
     GLuint service_id;
     glGenTextures(1, &service_id);
     DCHECK_NE(0u, service_id);
     texture_ref = CreateTexture(client_id, service_id);
     texture_manager()->SetTarget(texture_ref, target);
     glBindTexture(target, service_id);
     RestoreCurrentTextureBindings(&state_, target);
   }
 }
 
-void GLES2DecoderImpl::DoCreateAndConsumeTextureINTERNAL(GLenum target,
-                                                         GLuint client_id,
-                                                         const GLbyte* data) {
+void GLES2DecoderImpl::DoCreateAndConsumeTextureINTERNAL(
+    GLenum target,
+    GLuint client_id,
+    const volatile GLbyte* data) {
   TRACE_EVENT2("gpu", "GLES2DecoderImpl::DoCreateAndConsumeTextureINTERNAL",
       "context", logger_.GetLogPrefix(),
       "mailbox[0]", static_cast<unsigned char>(data[0]));
-  Mailbox mailbox = *reinterpret_cast<const Mailbox*>(data);
+  Mailbox mailbox =
+      Mailbox::FromVolatile(*reinterpret_cast<const volatile Mailbox*>(data));
   DLOG_IF(ERROR, !mailbox.Verify()) << "CreateAndConsumeTextureCHROMIUM was "
                                        "passed a mailbox that was not "
                                        "generated by GenMailboxCHROMIUM.";
 
   TextureRef* texture_ref = GetTexture(client_id);
   if (texture_ref) {
     // No need to call EnsureTextureForClientId here, the client_id already has
     // an associated texture.
     LOCAL_SET_GL_ERROR(
         GL_INVALID_OPERATION,
@@ skipping 151 matching lines @@
     texture_manager()->SetLevelInfo(texture_ref, target, 0, GL_RGBA, 0, 0, 1, 0,
                                     GL_RGBA, GL_UNSIGNED_BYTE, gfx::Rect());
   }
 
   texture_manager()->SetLevelImage(texture_ref, target, 0, nullptr,
                                    Texture::UNBOUND);
 }
 
 error::Error GLES2DecoderImpl::HandleTraceBeginCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::TraceBeginCHROMIUM& c =
-      *static_cast<const gles2::cmds::TraceBeginCHROMIUM*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::TraceBeginCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::TraceBeginCHROMIUM*>(cmd_data);
   Bucket* category_bucket = GetBucket(c.category_bucket_id);
   Bucket* name_bucket = GetBucket(c.name_bucket_id);
   if (!category_bucket || category_bucket->size() == 0 ||
       !name_bucket || name_bucket->size() == 0) {
     return error::kInvalidArguments;
   }
 
   std::string category_name;
   std::string trace_name;
   if (!category_bucket->GetAsString(&category_name) ||
@@ skipping 13 matching lines @@
 
 void GLES2DecoderImpl::DoTraceEndCHROMIUM() {
   debug_marker_manager_.PopGroup();
   if (!gpu_tracer_->End(kTraceCHROMIUM)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION,
                        "glTraceEndCHROMIUM", "no trace begin found");
     return;
   }
 }
 
-void GLES2DecoderImpl::DoDrawBuffersEXT(
-    GLsizei count, const GLenum* bufs) {
+void GLES2DecoderImpl::DoDrawBuffersEXT(GLsizei count,
+                                        const volatile GLenum* bufs) {
   DCHECK_LE(group_->max_draw_buffers(), 16u);
   if (count > static_cast<GLsizei>(group_->max_draw_buffers())) {
     LOCAL_SET_GL_ERROR(
         GL_INVALID_VALUE,
         "glDrawBuffersEXT", "greater than GL_MAX_DRAW_BUFFERS_EXT");
     return;
   }
 
   Framebuffer* framebuffer = GetFramebufferInfoForTarget(GL_FRAMEBUFFER);
   if (framebuffer) {
@@ skipping 40 matching lines @@
 void GLES2DecoderImpl::DoFlushDriverCachesCHROMIUM(void) {
   // On Adreno Android devices we need to use a workaround to force caches to
   // clear.
   if (feature_info_->workarounds().unbind_egl_context_to_flush_driver_caches) {
     context_->ReleaseCurrent(nullptr);
     context_->MakeCurrent(surface_.get());
   }
 }
 
 void GLES2DecoderImpl::DoMatrixLoadfCHROMIUM(GLenum matrix_mode,
-                                             const GLfloat* matrix) {
+                                             const volatile GLfloat* matrix) {
   DCHECK(matrix_mode == GL_PATH_PROJECTION_CHROMIUM ||
          matrix_mode == GL_PATH_MODELVIEW_CHROMIUM);
 
   GLfloat* target_matrix = matrix_mode == GL_PATH_PROJECTION_CHROMIUM
                                ? state_.projection_matrix
                                : state_.modelview_matrix;
-  memcpy(target_matrix, matrix, sizeof(GLfloat) * 16);
+  std::copy(matrix, matrix + 16, target_matrix);

[no sievers, 2016/09/02 21:17:34]

likewise

[piman, 2016/09/02 23:11:06]

ditto.

   // The matrix_mode is either GL_PATH_MODELVIEW_NV or GL_PATH_PROJECTION_NV
   // since the values of the _NV and _CHROMIUM tokens match.
   glMatrixLoadfEXT(matrix_mode, target_matrix);
 }
 
 void GLES2DecoderImpl::DoMatrixLoadIdentityCHROMIUM(GLenum matrix_mode) {
   DCHECK(matrix_mode == GL_PATH_PROJECTION_CHROMIUM ||
          matrix_mode == GL_PATH_MODELVIEW_CHROMIUM);
 
   GLfloat* target_matrix = matrix_mode == GL_PATH_PROJECTION_CHROMIUM
                                ? state_.projection_matrix
                                : state_.modelview_matrix;
   memcpy(target_matrix, kIdentityMatrix, sizeof(kIdentityMatrix));
   // The matrix_mode is either GL_PATH_MODELVIEW_NV or GL_PATH_PROJECTION_NV
   // since the values of the _NV and _CHROMIUM tokens match.
   glMatrixLoadIdentityEXT(matrix_mode);
 }
 
 error::Error GLES2DecoderImpl::HandleUniformBlockBinding(
-    uint32_t immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
   const char* func_name = "glUniformBlockBinding";
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::UniformBlockBinding& c =
-      *static_cast<const gles2::cmds::UniformBlockBinding*>(cmd_data);
+  const volatile gles2::cmds::UniformBlockBinding& c =
+      *static_cast<const volatile gles2::cmds::UniformBlockBinding*>(cmd_data);
   GLuint client_id = c.program;
   GLuint index = static_cast<GLuint>(c.index);
   GLuint binding = static_cast<GLuint>(c.binding);
   Program* program = GetProgramInfoNotShader(client_id, func_name);
   if (!program) {
     return error::kNoError;
   }
   if (index >= program->uniform_block_size_info().size()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name,
         "uniformBlockIndex is not an active uniform block index");
     return error::kNoError;
   }
   if (binding >= group_->max_uniform_buffer_bindings()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, func_name,
         "uniformBlockBinding >= MAX_UNIFORM_BUFFER_BINDINGS");
     return error::kNoError;
   }
   GLuint service_id = program->service_id();
   glUniformBlockBinding(service_id, index, binding);
   program->SetUniformBlockBinding(index, binding);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleClientWaitSync(
-    uint32_t immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
   const char* function_name = "glClientWaitSync";
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::ClientWaitSync& c =
-      *static_cast<const gles2::cmds::ClientWaitSync*>(cmd_data);
+  const volatile gles2::cmds::ClientWaitSync& c =
+      *static_cast<const volatile gles2::cmds::ClientWaitSync*>(cmd_data);
   const GLuint sync = static_cast<GLuint>(c.sync);
   GLbitfield flags = static_cast<GLbitfield>(c.flags);
   const GLuint64 timeout = c.timeout();
   typedef cmds::ClientWaitSync::Result Result;
   Result* result_dst = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result_dst));
   if (!result_dst) {
     return error::kOutOfBounds;
   }
   if (*result_dst != GL_WAIT_FAILED) {
@@ skipping 22 matching lines @@
       LOCAL_PEEK_GL_ERROR(function_name);
       break;
     default:
       NOTREACHED();
       break;
   }
   *result_dst = status;
   return error::kNoError;
 }
 
-error::Error GLES2DecoderImpl::HandleWaitSync(
-    uint32_t immediate_data_size, const void* cmd_data) {
+error::Error GLES2DecoderImpl::HandleWaitSync(uint32_t immediate_data_size,
+                                              const volatile void* cmd_data) {
   const char* function_name = "glWaitSync";
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::WaitSync& c =
-      *static_cast<const gles2::cmds::WaitSync*>(cmd_data);
+  const volatile gles2::cmds::WaitSync& c =
+      *static_cast<const volatile gles2::cmds::WaitSync*>(cmd_data);
   const GLuint sync = static_cast<GLuint>(c.sync);
   const GLbitfield flags = static_cast<GLbitfield>(c.flags);
   const GLuint64 timeout = c.timeout();
   GLsync service_sync = 0;
   if (!group_->GetSyncServiceId(sync, &service_sync)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "invalid sync");
     return error::kNoError;
   }
   if (flags != 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "invalid flags");
@@ skipping 14 matching lines @@
     return 0;
   }
   if (flags != 0) {
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, function_name, "invalid flags");
     return 0;
   }
   return glFenceSync(condition, flags);
 }
 
 error::Error GLES2DecoderImpl::HandleGetInternalformativ(
-    uint32_t immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled())
     return error::kUnknownCommand;
-  const gles2::cmds::GetInternalformativ& c =
-      *static_cast<const gles2::cmds::GetInternalformativ*>(cmd_data);
+  const volatile gles2::cmds::GetInternalformativ& c =
+      *static_cast<const volatile gles2::cmds::GetInternalformativ*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum pname = static_cast<GLenum>(c.pname);
   if (!validators_->render_buffer_target.IsValid(target)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetInternalformativ", target, "target");
     return error::kNoError;
   }
   if (!validators_->render_buffer_format.IsValid(format)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glGetInternalformativ", format, "format");
     return error::kNoError;
@@ skipping 69 matching lines @@
         break;
     }
   } else {
     glGetInternalformativ(target, format, pname, num_values, params);
   }
   result->SetNumResults(num_values);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleMapBufferRange(
-    uint32_t immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled()) {
     return error::kUnknownCommand;
   }
-  const gles2::cmds::MapBufferRange& c =
-      *static_cast<const gles2::cmds::MapBufferRange*>(cmd_data);
+  const volatile gles2::cmds::MapBufferRange& c =
+      *static_cast<const volatile gles2::cmds::MapBufferRange*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
   GLbitfield access = static_cast<GLbitfield>(c.access);
   GLintptr offset = static_cast<GLintptr>(c.offset);
   GLsizeiptr size = static_cast<GLsizeiptr>(c.size);
   uint32_t data_shm_id = static_cast<uint32_t>(c.data_shm_id);
 
   typedef cmds::MapBufferRange::Result Result;
   Result* result = GetSharedMemoryAs<Result*>(
       c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!result) {
@@ skipping 43 matching lines @@
   buffer->SetMappedRange(offset, size, access, ptr,
                          GetSharedMemoryBuffer(data_shm_id));
   if ((access & GL_MAP_INVALIDATE_RANGE_BIT) == 0) {
     memcpy(mem, ptr, size);
   }
   *result = 1;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleUnmapBuffer(
-    uint32_t immediate_data_size, const void* cmd_data) {
+    uint32_t immediate_data_size,
+    const volatile void* cmd_data) {
   if (!unsafe_es3_apis_enabled()) {
     return error::kUnknownCommand;
   }
-  const gles2::cmds::UnmapBuffer& c =
-      *static_cast<const gles2::cmds::UnmapBuffer*>(cmd_data);
+  const volatile gles2::cmds::UnmapBuffer& c =
+      *static_cast<const volatile gles2::cmds::UnmapBuffer*>(cmd_data);
   GLenum target = static_cast<GLenum>(c.target);
 
   if (!validators_->buffer_target.IsValid(target)) {
     LOCAL_SET_GL_ERROR_INVALID_ENUM("glMapBufferRange", target, "target");
     return error::kNoError;
   }
 
   Buffer* buffer = buffer_manager()->GetBufferInfoForTarget(&state_, target);
   if (!buffer) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, "UnmapBuffer", "no buffer bound");
@@ skipping 284 matching lines @@
   }
   GLES2DecoderImpl* decoder_;
   ErrorState* error_state_;
   const Validators* validators_;
   const char* function_name_;
   error::Error error_;
 };
 
 error::Error GLES2DecoderImpl::HandleGenPathsCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::GenPathsCHROMIUM& c =
-      *static_cast<const gles2::cmds::GenPathsCHROMIUM*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::GenPathsCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::GenPathsCHROMIUM*>(cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, "glGenPathsCHROMIUM");
   GLsizei range = 0;
   if (!v.GetPathRange(c, &range))
     return v.error();
 
   GLuint first_client_id = static_cast<GLuint>(c.first_client_id);
   if (first_client_id == 0)
     return error::kInvalidArguments;
 
   if (range == 0)
     return error::kNoError;
 
   if (!GenPathsCHROMIUMHelper(first_client_id, range))
     return error::kInvalidArguments;
 
   return error::kNoError;
 }
 error::Error GLES2DecoderImpl::HandleDeletePathsCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::DeletePathsCHROMIUM& c =
-      *static_cast<const gles2::cmds::DeletePathsCHROMIUM*>(cmd_data);
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::DeletePathsCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::DeletePathsCHROMIUM*>(cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, "glDeletePathsCHROMIUM");
   GLsizei range = 0;
   if (!v.GetPathRange(c, &range))
     return v.error();
 
   if (range == 0)
     return error::kNoError;
 
   GLuint first_client_id = c.first_client_id;
   // first_client_id can be 0, because non-existing path ids are skipped.
 
   if (!DeletePathsCHROMIUMHelper(first_client_id, range))
     return error::kInvalidArguments;
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePathCommandsCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glPathCommandsCHROMIUM";
-  const gles2::cmds::PathCommandsCHROMIUM& c =
-      *static_cast<const gles2::cmds::PathCommandsCHROMIUM*>(cmd_data);
+  const volatile gles2::cmds::PathCommandsCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::PathCommandsCHROMIUM*>(cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
                        "invalid path name");
     return error::kNoError;
   }
 
@@ skipping 85 matching lines @@
   }
 
   glPathCommandsNV(service_id, num_commands, commands.get(), num_coords,
                    coord_type, coords);
 
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePathParameterfCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glPathParameterfCHROMIUM";
-  const gles2::cmds::PathParameterfCHROMIUM& c =
-      *static_cast<const gles2::cmds::PathParameterfCHROMIUM*>(cmd_data);
+  const volatile gles2::cmds::PathParameterfCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::PathParameterfCHROMIUM*>(
+          cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
                        "invalid path name");
     return error::kNoError;
   }
 
@@ skipping 28 matching lines @@
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "value not correct");
     return error::kNoError;
   }
 
   glPathParameterfNV(service_id, pname, value);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePathParameteriCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glPathParameteriCHROMIUM";
-  const gles2::cmds::PathParameteriCHROMIUM& c =
-      *static_cast<const gles2::cmds::PathParameteriCHROMIUM*>(cmd_data);
+  const volatile gles2::cmds::PathParameteriCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::PathParameteriCHROMIUM*>(
+          cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName,
                        "invalid path name");
     return error::kNoError;
   }
 
@@ skipping 26 matching lines @@
     LOCAL_SET_GL_ERROR(GL_INVALID_VALUE, kFunctionName, "value not correct");
     return error::kNoError;
   }
 
   glPathParameteriNV(service_id, pname, value);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilFillPathCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glStencilFillPathCHROMIUM";
-  const gles2::cmds::StencilFillPathCHROMIUM& c =
-      *static_cast<const gles2::cmds::StencilFillPathCHROMIUM*>(cmd_data);
+  const volatile gles2::cmds::StencilFillPathCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::StencilFillPathCHROMIUM*>(
+          cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
   PathCommandValidatorContext v(this, kFunctionName);
   GLenum fill_mode = GL_COUNT_UP_CHROMIUM;
   GLuint mask = 0;
   if (!v.GetFillModeAndMask(c, &fill_mode, &mask))
     return v.error();
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) {
     // "If /path/ does not name an existing path object, the command does
     // nothing (and no error is generated)."
     // This holds for other rendering functions, too.
     return error::kNoError;
   }
   if (!CheckBoundDrawFramebufferValid(kFunctionName))
     return error::kNoError;
   ApplyDirtyState();
   glStencilFillPathNV(service_id, fill_mode, mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilStrokePathCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glStencilStrokePathCHROMIUM";
-  const gles2::cmds::StencilStrokePathCHROMIUM& c =
-      *static_cast<const gles2::cmds::StencilStrokePathCHROMIUM*>(cmd_data);
+  const volatile gles2::cmds::StencilStrokePathCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::StencilStrokePathCHROMIUM*>(
+          cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id)) {
     return error::kNoError;
   }
   GLint reference = static_cast<GLint>(c.reference);
   GLuint mask = static_cast<GLuint>(c.mask);
   if (!CheckBoundDrawFramebufferValid(kFunctionName))
     return error::kNoError;
   ApplyDirtyState();
   glStencilStrokePathNV(service_id, reference, mask);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCoverFillPathCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glCoverFillPathCHROMIUM";
-  const gles2::cmds::CoverFillPathCHROMIUM& c =
-      *static_cast<const gles2::cmds::CoverFillPathCHROMIUM*>(cmd_data);
+  const volatile gles2::cmds::CoverFillPathCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::CoverFillPathCHROMIUM*>(
+          cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, kFunctionName);
   GLenum cover_mode = GL_BOUNDING_BOX_CHROMIUM;
   if (!v.GetCoverMode(c, &cover_mode))
     return v.error();
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id))
     return error::kNoError;
   if (!CheckBoundDrawFramebufferValid(kFunctionName))
     return error::kNoError;
   ApplyDirtyState();
   glCoverFillPathNV(service_id, cover_mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCoverStrokePathCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glCoverStrokePathCHROMIUM";
-  const gles2::cmds::CoverStrokePathCHROMIUM& c =
-      *static_cast<const gles2::cmds::CoverStrokePathCHROMIUM*>(cmd_data);
+  const volatile gles2::cmds::CoverStrokePathCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::CoverStrokePathCHROMIUM*>(
+          cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, kFunctionName);
   GLenum cover_mode = GL_BOUNDING_BOX_CHROMIUM;
   if (!v.GetCoverMode(c, &cover_mode))
     return v.error();
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id))
     return error::kNoError;
 
   if (!CheckBoundDrawFramebufferValid(kFunctionName))
     return error::kNoError;
   ApplyDirtyState();
   glCoverStrokePathNV(service_id, cover_mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilThenCoverFillPathCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glStencilThenCoverFillPathCHROMIUM";
-  const gles2::cmds::StencilThenCoverFillPathCHROMIUM& c =
-      *static_cast<const gles2::cmds::StencilThenCoverFillPathCHROMIUM*>(
+  const volatile gles2::cmds::StencilThenCoverFillPathCHROMIUM& c =
+      *static_cast<
+          const volatile gles2::cmds::StencilThenCoverFillPathCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, kFunctionName);
   GLenum fill_mode = GL_COUNT_UP_CHROMIUM;
   GLuint mask = 0;
   GLenum cover_mode = GL_BOUNDING_BOX_CHROMIUM;
   if (!v.GetFillModeAndMask(c, &fill_mode, &mask) ||
       !v.GetCoverMode(c, &cover_mode))
     return v.error();
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id))
     return error::kNoError;
 
   if (!CheckBoundDrawFramebufferValid(kFunctionName))
     return error::kNoError;
   ApplyDirtyState();
   glStencilThenCoverFillPathNV(service_id, fill_mode, mask, cover_mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilThenCoverStrokePathCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glStencilThenCoverStrokePathCHROMIUM";
-  const gles2::cmds::StencilThenCoverStrokePathCHROMIUM& c =
-      *static_cast<const gles2::cmds::StencilThenCoverStrokePathCHROMIUM*>(
+  const volatile gles2::cmds::StencilThenCoverStrokePathCHROMIUM& c =
+      *static_cast<
+          const volatile gles2::cmds::StencilThenCoverStrokePathCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, kFunctionName);
   GLenum cover_mode = GL_BOUNDING_BOX_CHROMIUM;
   if (!v.GetCoverMode(c, &cover_mode))
     return v.error();
 
   GLuint service_id = 0;
   if (!path_manager()->GetPath(static_cast<GLuint>(c.path), &service_id))
     return error::kNoError;
 
   GLint reference = static_cast<GLint>(c.reference);
   GLuint mask = static_cast<GLuint>(c.mask);
 
   if (!CheckBoundDrawFramebufferValid(kFunctionName))
     return error::kNoError;
   ApplyDirtyState();
   glStencilThenCoverStrokePathNV(service_id, reference, mask, cover_mode);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilFillPathInstancedCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glStencilFillPathInstancedCHROMIUM";
-  const gles2::cmds::StencilFillPathInstancedCHROMIUM& c =
-      *static_cast<const gles2::cmds::StencilFillPathInstancedCHROMIUM*>(
+  const volatile gles2::cmds::StencilFillPathInstancedCHROMIUM& c =
+      *static_cast<
+          const volatile gles2::cmds::StencilFillPathInstancedCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, kFunctionName);
   GLuint num_paths = 0;
   GLenum path_name_type = GL_NONE;
   GLenum fill_mode = GL_COUNT_UP_CHROMIUM;
   GLuint mask = 0;
   GLenum transform_type = GL_NONE;
@@ skipping 16 matching lines @@
   if (!CheckBoundDrawFramebufferValid(kFunctionName))
     return error::kNoError;
   ApplyDirtyState();
   glStencilFillPathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(), 0,
                                fill_mode, mask, transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilStrokePathInstancedCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glStencilStrokePathInstancedCHROMIUM";
-  const gles2::cmds::StencilStrokePathInstancedCHROMIUM& c =
-      *static_cast<const gles2::cmds::StencilStrokePathInstancedCHROMIUM*>(
+  const volatile gles2::cmds::StencilStrokePathInstancedCHROMIUM& c =
+      *static_cast<
+          const volatile gles2::cmds::StencilStrokePathInstancedCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, kFunctionName);
   GLuint num_paths = 0;
   GLenum path_name_type = GL_NONE;
   GLenum transform_type = GL_NONE;
   if (!v.GetPathCountAndType(c, &num_paths, &path_name_type) ||
       !v.GetTransformType(c, &transform_type))
@@ skipping 15 matching lines @@
   if (!CheckBoundDrawFramebufferValid(kFunctionName))
     return error::kNoError;
   ApplyDirtyState();
   glStencilStrokePathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(), 0,
                                  reference, mask, transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCoverFillPathInstancedCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glCoverFillPathInstancedCHROMIUM";
-  const gles2::cmds::CoverFillPathInstancedCHROMIUM& c =
-      *static_cast<const gles2::cmds::CoverFillPathInstancedCHROMIUM*>(
+  const volatile gles2::cmds::CoverFillPathInstancedCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::CoverFillPathInstancedCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, kFunctionName);
   GLuint num_paths = 0;
   GLenum path_name_type = GL_NONE;
   GLenum cover_mode = GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM;
   GLenum transform_type = GL_NONE;
   if (!v.GetPathCountAndType(c, &num_paths, &path_name_type) ||
@@ skipping 15 matching lines @@
   if (!CheckBoundDrawFramebufferValid(kFunctionName))
     return error::kNoError;
   ApplyDirtyState();
   glCoverFillPathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(), 0,
                              cover_mode, transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleCoverStrokePathInstancedCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glCoverStrokePathInstancedCHROMIUM";
-  const gles2::cmds::CoverStrokePathInstancedCHROMIUM& c =
-      *static_cast<const gles2::cmds::CoverStrokePathInstancedCHROMIUM*>(
+  const volatile gles2::cmds::CoverStrokePathInstancedCHROMIUM& c =
+      *static_cast<
+          const volatile gles2::cmds::CoverStrokePathInstancedCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
 
   PathCommandValidatorContext v(this, kFunctionName);
   GLuint num_paths = 0;
   GLenum path_name_type = GL_NONE;
   GLenum cover_mode = GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM;
   GLenum transform_type = GL_NONE;
   if (!v.GetPathCountAndType(c, &num_paths, &path_name_type) ||
@@ skipping 15 matching lines @@
   if (!CheckBoundDrawFramebufferValid(kFunctionName))
     return error::kNoError;
   ApplyDirtyState();
   glCoverStrokePathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(), 0,
                                cover_mode, transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleStencilThenCoverFillPathInstancedCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] =
       "glStencilThenCoverFillPathInstancedCHROMIUM";
-  const gles2::cmds::StencilThenCoverFillPathInstancedCHROMIUM& c =
-      *static_cast<
-          const gles2::cmds::StencilThenCoverFillPathInstancedCHROMIUM*>(
-          cmd_data);
+  const volatile gles2::cmds::StencilThenCoverFillPathInstancedCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::
+                       StencilThenCoverFillPathInstancedCHROMIUM*>(cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
   PathCommandValidatorContext v(this, kFunctionName);
 
   GLuint num_paths = 0;
   GLenum path_name_type = GL_NONE;
   GLenum fill_mode = GL_COUNT_UP_CHROMIUM;
   GLuint mask = 0;
   GLenum cover_mode = GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM;
   GLenum transform_type = GL_NONE;
@@ skipping 19 matching lines @@
   ApplyDirtyState();
   glStencilThenCoverFillPathInstancedNV(num_paths, GL_UNSIGNED_INT, paths.get(),
                                         0, fill_mode, mask, cover_mode,
                                         transform_type, transforms);
   return error::kNoError;
 }
 
 error::Error
 GLES2DecoderImpl::HandleStencilThenCoverStrokePathInstancedCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] =
       "glStencilThenCoverStrokeInstancedCHROMIUM";
-  const gles2::cmds::StencilThenCoverStrokePathInstancedCHROMIUM& c =
-      *static_cast<
-          const gles2::cmds::StencilThenCoverStrokePathInstancedCHROMIUM*>(
-          cmd_data);
+  const volatile gles2::cmds::StencilThenCoverStrokePathInstancedCHROMIUM& c =
+      *static_cast<const volatile gles2::cmds::
+                       StencilThenCoverStrokePathInstancedCHROMIUM*>(cmd_data);
   if (!features().chromium_path_rendering)
     return error::kUnknownCommand;
   PathCommandValidatorContext v(this, kFunctionName);
   GLuint num_paths = 0;
   GLenum path_name_type = GL_NONE;
   GLenum cover_mode = GL_BOUNDING_BOX_OF_BOUNDING_BOXES_CHROMIUM;
   GLenum transform_type = GL_NONE;
   if (!v.GetPathCountAndType(c, &num_paths, &path_name_type) ||
       !v.GetCoverMode(c, &cover_mode) ||
       !v.GetTransformType(c, &transform_type))
@@ skipping 125 matching lines @@
   ScopedGLErrorSuppressor suppressor("GLES2DecoderImpl::ClearWorkaround",
                                      GetErrorState());
   clear_framebuffer_blit_->ClearFramebuffer(
       this, GetBoundReadFramebufferSize(), mask, state_.color_clear_red,
       state_.color_clear_green, state_.color_clear_blue,
       state_.color_clear_alpha, state_.depth_clear, state_.stencil_clear);
 }
 
 error::Error GLES2DecoderImpl::HandleBindFragmentInputLocationCHROMIUMBucket(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
-  const gles2::cmds::BindFragmentInputLocationCHROMIUMBucket& c =
-      *static_cast<const gles2::cmds::BindFragmentInputLocationCHROMIUMBucket*>(
+    const volatile void* cmd_data) {
+  const volatile gles2::cmds::BindFragmentInputLocationCHROMIUMBucket& c =
+      *static_cast<
+          const volatile gles2::cmds::BindFragmentInputLocationCHROMIUMBucket*>(
           cmd_data);
   if (!features().chromium_path_rendering) {
     return error::kUnknownCommand;
   }
 
   GLuint program = static_cast<GLuint>(c.program);
   GLint location = static_cast<GLint>(c.location);
   Bucket* bucket = GetBucket(c.name_bucket_id);
   if (!bucket || bucket->size() == 0) {
     return error::kInvalidArguments;
   }
   std::string name_str;
   if (!bucket->GetAsString(&name_str)) {
     return error::kInvalidArguments;
   }
   DoBindFragmentInputLocationCHROMIUM(program, location, name_str);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleProgramPathFragmentInputGenCHROMIUM(
     uint32_t immediate_data_size,
-    const void* cmd_data) {
+    const volatile void* cmd_data) {
   static const char kFunctionName[] = "glProgramPathFragmentInputGenCHROMIUM";
-  const gles2::cmds::ProgramPathFragmentInputGenCHROMIUM& c =
-      *static_cast<const gles2::cmds::ProgramPathFragmentInputGenCHROMIUM*>(
+  const volatile gles2::cmds::ProgramPathFragmentInputGenCHROMIUM& c =
+      *static_cast<
+          const volatile gles2::cmds::ProgramPathFragmentInputGenCHROMIUM*>(
           cmd_data);
   if (!features().chromium_path_rendering) {
     return error::kUnknownCommand;
   }
 
   GLint program_id = static_cast<GLint>(c.program);
 
   Program* program = GetProgram(program_id);
   if (!program || !program->IsValid() || program->IsDeleted()) {
     LOCAL_SET_GL_ERROR(GL_INVALID_OPERATION, kFunctionName, "invalid program");
@@ skipping 113 matching lines @@
 }
 
 // Include the auto-generated part of this file. We split this because it means
 // we can easily edit the non-auto generated parts right here in this file
 // instead of having to edit some template or the code generator.
 #include "base/macros.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu