Move per context GL state to a separate object.

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 <stdio.h>
 
 #include <algorithm>
 #include <list>
@@ skipping 14 matching lines @@
 #include "base/string_number_conversions.h"
 #include "build/build_config.h"
 #define GLES2_GPU_SERVICE 1
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
 #include "gpu/command_buffer/common/debug_marker_manager.h"
 #include "gpu/command_buffer/common/id_allocator.h"
 #include "gpu/command_buffer/service/buffer_manager.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "gpu/command_buffer/service/context_group.h"
+#include "gpu/command_buffer/service/context_state.h"
 #include "gpu/command_buffer/service/feature_info.h"
 #include "gpu/command_buffer/service/framebuffer_manager.h"
 #include "gpu/command_buffer/service/gl_utils.h"
 #include "gpu/command_buffer/service/gles2_cmd_copy_texture_chromium.h"
 #include "gpu/command_buffer/service/gles2_cmd_validation.h"
 #include "gpu/command_buffer/service/gpu_switches.h"
 #include "gpu/command_buffer/service/mailbox_manager.h"
 #include "gpu/command_buffer/service/memory_tracking.h"
 #include "gpu/command_buffer/service/program_manager.h"
 #include "gpu/command_buffer/service/query_manager.h"
@@ skipping 515 matching lines @@
   virtual error::ContextLostReason GetContextLostReason() OVERRIDE;
 
  private:
   friend class ScopedGLErrorSuppressor;
   friend class ScopedResolvedFrameBufferBinder;
   friend class ScopedTextureUploadTimer;
   friend class Texture;
   friend class RenderBuffer;
   friend class FrameBuffer;
 
-  // State associated with each texture unit.
-  struct TextureUnit {
-    TextureUnit() : bind_target(GL_TEXTURE_2D) { }
-
-    // The last target that was bound to this texture unit.
-    GLenum bind_target;
-
-    // texture currently bound to this unit's GL_TEXTURE_2D with glBindTexture
-    TextureManager::TextureInfo::Ref bound_texture_2d;
-
-    // texture currently bound to this unit's GL_TEXTURE_CUBE_MAP with
-    // glBindTexture
-    TextureManager::TextureInfo::Ref bound_texture_cube_map;
-
-    // texture currently bound to this unit's GL_TEXTURE_EXTERNAL_OES with
-    // glBindTexture
-    TextureManager::TextureInfo::Ref bound_texture_external_oes;
-
-    // texture currently bound to this unit's GL_TEXTURE_RECTANGLE_ARB with
-    // glBindTexture
-    TextureManager::TextureInfo::Ref bound_texture_rectangle_arb;
-
-    TextureManager::TextureInfo::Ref GetInfoForSamplerType(GLenum type) {
-      DCHECK(type == GL_SAMPLER_2D || type == GL_SAMPLER_CUBE ||
-             type == GL_SAMPLER_EXTERNAL_OES || type == GL_SAMPLER_2D_RECT_ARB);
-      switch (type) {
-        case GL_SAMPLER_2D:
-          return bound_texture_2d;
-        case GL_SAMPLER_CUBE:
-          return bound_texture_cube_map;
-        case GL_SAMPLER_EXTERNAL_OES:
-          return bound_texture_external_oes;
-        case GL_SAMPLER_2D_RECT_ARB:
-          return bound_texture_rectangle_arb;
-      }
-
-      NOTREACHED();
-      return NULL;
-    }
-
-    void Unbind(TextureManager::TextureInfo* texture) {
-      if (bound_texture_2d == texture) {
-        bound_texture_2d = NULL;
-      }
-      if (bound_texture_cube_map == texture) {
-        bound_texture_cube_map = NULL;
-      }
-      if (bound_texture_external_oes == texture) {
-        bound_texture_external_oes = NULL;
-      }
-    }
-  };
-
   // 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);
   bool GenBuffersHelper(GLsizei n, const GLuint* client_ids);
   void DeleteBuffersHelper(GLsizei n, const GLuint* client_ids);
@@ skipping 644 matching lines @@
       GLsizei primcount);
   error::Error DoDrawElements(
       const char* function_name,
       bool instanced, GLenum mode, GLsizei count, GLenum type,
       int32 offset, GLsizei primcount);
 
   // Gets the buffer id for a given target.
   BufferManager::BufferInfo* GetBufferInfoForTarget(GLenum target) {
     DCHECK(target == GL_ARRAY_BUFFER || target == GL_ELEMENT_ARRAY_BUFFER);
     if (target == GL_ARRAY_BUFFER) {
-      return bound_array_buffer_;
+      return state_.bound_array_buffer;
     } else {
-      return vertex_attrib_manager_->element_array_buffer();
+      return state_.vertex_attrib_manager->element_array_buffer();
     }
   }
 
   // Gets the texture id for a given target.
   TextureManager::TextureInfo* GetTextureInfoForTarget(GLenum target) {
-    TextureUnit& unit = texture_units_[active_texture_unit_];
+    TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
     TextureManager::TextureInfo* info = NULL;
     switch (target) {
       case GL_TEXTURE_2D:
         info = unit.bound_texture_2d;
         break;
       case GL_TEXTURE_CUBE_MAP:
       case GL_TEXTURE_CUBE_MAP_POSITIVE_X:
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_X:
       case GL_TEXTURE_CUBE_MAP_POSITIVE_Y:
       case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y:
@@ skipping 32 matching lines @@
     return 0;
   }
 
   // Gets the framebuffer info for a particular target.
   FramebufferManager::FramebufferInfo* GetFramebufferInfoForTarget(
       GLenum target) {
     FramebufferManager::FramebufferInfo* info = NULL;
     switch (target) {
       case GL_FRAMEBUFFER:
       case GL_DRAW_FRAMEBUFFER_EXT:
-        info = bound_draw_framebuffer_;
+        info = state_.bound_draw_framebuffer;
         break;
       case GL_READ_FRAMEBUFFER_EXT:
-        info = bound_read_framebuffer_;
+        info = state_.bound_read_framebuffer;
         break;
       default:
         NOTREACHED();
         break;
     }
     return info;
   }
 
   RenderbufferManager::RenderbufferInfo* GetRenderbufferInfoForTarget(
       GLenum target) {
     RenderbufferManager::RenderbufferInfo* info = NULL;
     switch (target) {
       case GL_RENDERBUFFER:
-        info = bound_renderbuffer_;
+        info = state_.bound_renderbuffer;
         break;
       default:
         NOTREACHED();
         break;
     }
     return info;
   }
 
   // Validates the program and location for a glGetUniform call and returns
   // a SizeResult setup to receive the result. Returns true if glGetUniform
@@ skipping 34 matching lines @@
     GLsizei width, GLsizei height, GLenum format,
     TextureManager::TextureInfo* texture);
 
   void LogMessage(const std::string& msg);
   void RenderWarning(const std::string& msg);
   void PerformanceWarning(const std::string& msg);
   const std::string& GetLogPrefix() const;
 
   bool ShouldDeferDraws() {
     return !offscreen_target_frame_buffer_.get() &&
-           bound_draw_framebuffer_ == NULL &&
+           state_.bound_draw_framebuffer == NULL &&
            surface_->DeferDraws();
   }
 
   void ForceCompileShaderIfPending(ShaderManager::ShaderInfo* info);
 
   // Generate a member function prototype for each command in an automated and
   // typesafe way.
   #define GLES2_CMD_OP(name) \
      Error Handle ## name(             \
        uint32 immediate_data_size,          \
        const gles2::name& args);            \
 
   GLES2_COMMAND_LIST(GLES2_CMD_OP)
 
   #undef GLES2_CMD_OP
 
   // The GL context this decoder renders to on behalf of the client.
   scoped_refptr<gfx::GLSurface> surface_;
   scoped_refptr<gfx::GLContext> context_;
 
   // The ContextGroup for this decoder uses to track resources.
   ContextGroup::Ref group_;
 
+  // All the state for this context.
+  ContextState state_;
+
   // A parent decoder can access this decoders saved offscreen frame buffer.
   // The parent pointer is reset if the parent is destroyed.
   base::WeakPtr<GLES2DecoderImpl> parent_;
 
   // Current width and height of the offscreen frame buffer.
   gfx::Size offscreen_size_;
 
   // Current GL error bits.
   uint32 error_bits_;
 
   // Util to help with GL.
   GLES2Util util_;
 
-  // pack alignment as last set by glPixelStorei
-  GLint pack_alignment_;
-
-  // unpack alignment as last set by glPixelStorei
-  GLint unpack_alignment_;
-
   // unpack flip y as last set by glPixelStorei
   bool unpack_flip_y_;
 
   // unpack (un)premultiply alpha as last set by glPixelStorei
   bool unpack_premultiply_alpha_;
   bool unpack_unpremultiply_alpha_;
 
-  // The currently bound array buffer. If this is 0 it is illegal to call
-  // glVertexAttribPointer.
-  BufferManager::BufferInfo::Ref bound_array_buffer_;
-
-  // Class that manages vertex attribs.
-  VertexAttribManager::Ref vertex_attrib_manager_;
-
   // Default vertex attribs manager, used when no VAOs are bound.
   VertexAttribManager::Ref default_vertex_attrib_manager_;

[bajones, 2012/10/12 21:02:54]

I think the default_vertex_attrib_manager_ should also be per-context. It
contains the buffer binding state whenever a VAO is not bound.

[greggman, 2012/10/12 21:14:04]

It seems like GLES2CmdDecoder assigns default_vertex_attrib_manager to
vertex_attrib_manager so from the POV of the ContextState it doesn't need to
know about default_vertex_attrib_manager_

 
   // The buffer we bind to attrib 0 since OpenGL requires it (ES does not).
   GLuint attrib_0_buffer_id_;
 
   // The value currently in attrib_0.
   VertexAttribManager::VertexAttribInfo::Vec4 attrib_0_value_;
 
   // Whether or not the attrib_0 buffer holds the attrib_0_value.
   bool attrib_0_buffer_matches_value_;
 
   // The size of attrib 0.
   GLsizei attrib_0_size_;
 
   // The buffer used to simulate GL_FIXED attribs.
   GLuint fixed_attrib_buffer_id_;
 
   // The size of fiixed attrib buffer.
   GLsizei fixed_attrib_buffer_size_;
 
-  // Current active texture by 0 - n index.
-  // In other words, if we call glActiveTexture(GL_TEXTURE2) this value would
-  // be 2.
-  GLuint active_texture_unit_;
-
-  // Which textures are bound to texture units through glActiveTexture.
-  scoped_array<TextureUnit> texture_units_;
-
   // state saved for clearing so we can clear render buffers and then
   // restore to these values.
-  GLclampf clear_red_;
-  GLclampf clear_green_;
-  GLclampf clear_blue_;
-  GLclampf clear_alpha_;
-  GLboolean mask_red_;
-  GLboolean mask_green_;
-  GLboolean mask_blue_;
-  GLboolean mask_alpha_;
-  GLint clear_stencil_;
-  GLuint mask_stencil_front_;
-  GLuint mask_stencil_back_;
-  GLclampf clear_depth_;
-  GLboolean mask_depth_;
-  bool enable_blend_;
-  bool enable_cull_face_;
-  bool enable_scissor_test_;
-  bool enable_depth_test_;
-  bool enable_stencil_test_;
   bool state_dirty_;
 
-  // The program in use by glUseProgram
-  ProgramManager::ProgramInfo::Ref current_program_;
-
-  // The currently bound framebuffers
-  FramebufferManager::FramebufferInfo::Ref bound_read_framebuffer_;
-  FramebufferManager::FramebufferInfo::Ref bound_draw_framebuffer_;
-
-  // The currently bound renderbuffer
-  RenderbufferManager::RenderbufferInfo::Ref bound_renderbuffer_;
-
   // The offscreen frame buffer that the client renders to. With EGL, the
   // depth and stencil buffers are separate. With regular GL there is a single
   // packed depth stencil buffer in offscreen_target_depth_render_buffer_.
   // offscreen_target_stencil_render_buffer_ is unused.
   scoped_ptr<FrameBuffer> offscreen_target_frame_buffer_;
   scoped_ptr<Texture> offscreen_target_color_texture_;
   scoped_ptr<RenderBuffer> offscreen_target_color_render_buffer_;
   scoped_ptr<RenderBuffer> offscreen_target_depth_render_buffer_;
   scoped_ptr<RenderBuffer> offscreen_target_stencil_render_buffer_;
   GLenum offscreen_target_color_format_;
   GLenum offscreen_target_depth_format_;
   GLenum offscreen_target_stencil_format_;
   GLsizei offscreen_target_samples_;
   GLboolean offscreen_target_buffer_preserved_;
 
   // The copy that is saved when SwapBuffers is called.
   scoped_ptr<FrameBuffer> offscreen_saved_frame_buffer_;
   scoped_ptr<Texture> offscreen_saved_color_texture_;
   TextureManager::TextureInfo::Ref offscreen_saved_color_texture_info_;
 
   // The copy that is used as the destination for multi-sample resolves.
   scoped_ptr<FrameBuffer> offscreen_resolved_frame_buffer_;
   scoped_ptr<Texture> offscreen_resolved_color_texture_;
   GLenum offscreen_saved_color_format_;
 
   scoped_ptr<QueryManager> query_manager_;
-  QueryManager::Query::Ref current_query_;
 
   scoped_ptr<VertexArrayManager> vertex_array_manager_;
 
   base::Callback<void(gfx::Size)> resize_callback_;
 
   MsgCallback msg_callback_;
 
   StreamTextureManager* stream_texture_manager_;
 
   // The format of the back buffer_
@@ skipping 49 matching lines @@
 #if defined(OS_MACOSX)
   typedef std::map<GLuint, CFTypeRef> TextureToIOSurfaceMap;
   TextureToIOSurfaceMap texture_to_io_surface_map_;
 #endif
 
   typedef std::vector<GLES2DecoderImpl*> ChildList;
   ChildList children_;
 
   scoped_ptr<CopyTextureCHROMIUMResourceManager> copy_texture_CHROMIUM_;
 
-  // Cached values of the currently assigned viewport dimensions.
-  GLint viewport_x_, viewport_y_;
-  GLsizei viewport_width_, viewport_height_;
-  GLsizei viewport_max_width_, viewport_max_height_;
-
   // Command buffer stats.
   int texture_upload_count_;
   base::TimeDelta total_texture_upload_time_;
   base::TimeDelta total_processing_commands_time_;
 
   DISALLOW_COPY_AND_ASSIGN(GLES2DecoderImpl);
 };
 
 ScopedGLErrorSuppressor::ScopedGLErrorSuppressor(GLES2DecoderImpl* decoder)
     : decoder_(decoder) {
@@ skipping 42 matching lines @@
 ScopedFrameBufferBinder::~ScopedFrameBufferBinder() {
   ScopedGLErrorSuppressor suppressor(decoder_);
   decoder_->RestoreCurrentFramebufferBindings();
 }
 
 ScopedResolvedFrameBufferBinder::ScopedResolvedFrameBufferBinder(
     GLES2DecoderImpl* decoder, bool enforce_internal_framebuffer, bool internal)
     : decoder_(decoder) {
   resolve_and_bind_ = (decoder_->offscreen_target_frame_buffer_.get() &&
                        decoder_->IsOffscreenBufferMultisampled() &&
-                       (!decoder_->bound_read_framebuffer_.get() ||
+                       (!decoder_->state_.bound_read_framebuffer.get() ||
                         enforce_internal_framebuffer));
   if (!resolve_and_bind_)
     return;
 
   ScopedGLErrorSuppressor suppressor(decoder_);
   glBindFramebufferEXT(GL_READ_FRAMEBUFFER_EXT,
                        decoder_->offscreen_target_frame_buffer_->id());
   GLuint targetid;
   if (internal) {
     if (!decoder_->offscreen_resolved_frame_buffer_.get()) {
@@ skipping 32 matching lines @@
   }
   glBindFramebufferEXT(GL_FRAMEBUFFER, targetid);
 }
 
 ScopedResolvedFrameBufferBinder::~ScopedResolvedFrameBufferBinder() {
   if (!resolve_and_bind_)
     return;
 
   ScopedGLErrorSuppressor suppressor(decoder_);
   decoder_->RestoreCurrentFramebufferBindings();
-  if (decoder_->enable_scissor_test_) {
+  if (decoder_->state_.enable_scissor_test) {
     glEnable(GL_SCISSOR_TEST);
   }
 }
 
 ScopedTextureUploadTimer::ScopedTextureUploadTimer(GLES2DecoderImpl* decoder)
     : decoder_(decoder),
       begin_time_(base::TimeTicks::HighResNow()) {
 }
 
 ScopedTextureUploadTimer::~ScopedTextureUploadTimer() {
@@ skipping 217 matching lines @@
 }
 
 GLES2Decoder* GLES2Decoder::Create(ContextGroup* group) {
   return new GLES2DecoderImpl(group);
 }
 
 GLES2DecoderImpl::GLES2DecoderImpl(ContextGroup* group)
     : GLES2Decoder(),
       group_(group),
       error_bits_(0),
-      pack_alignment_(4),
-      unpack_alignment_(4),
       unpack_flip_y_(false),
       unpack_premultiply_alpha_(false),
       unpack_unpremultiply_alpha_(false),
       attrib_0_buffer_id_(0),
       attrib_0_buffer_matches_value_(true),
       attrib_0_size_(0),
       fixed_attrib_buffer_id_(0),
       fixed_attrib_buffer_size_(0),
-      active_texture_unit_(0),
-      clear_red_(0),
-      clear_green_(0),
-      clear_blue_(0),
-      clear_alpha_(0),
-      mask_red_(true),
-      mask_green_(true),
-      mask_blue_(true),
-      mask_alpha_(true),
-      clear_stencil_(0),
-      mask_stencil_front_(-1),
-      mask_stencil_back_(-1),
-      clear_depth_(1.0f),
-      mask_depth_(true),
-      enable_blend_(false),
-      enable_cull_face_(false),
-      enable_scissor_test_(false),
-      enable_depth_test_(false),
-      enable_stencil_test_(false),
       state_dirty_(true),
       offscreen_target_color_format_(0),
       offscreen_target_depth_format_(0),
       offscreen_target_stencil_format_(0),
       offscreen_target_samples_(0),
       offscreen_target_buffer_preserved_(true),
       offscreen_saved_color_format_(0),
       stream_texture_manager_(NULL),
       back_buffer_color_format_(0),
       back_buffer_has_depth_(false),
       back_buffer_has_stencil_(false),
       teximage2d_faster_than_texsubimage2d_(true),
       log_message_count_(0),
       current_decoder_error_(error::kNoError),
       use_shader_translator_(true),
       validators_(group_->feature_info()->validators()),
       feature_info_(group_->feature_info()),
       tex_image_2d_failed_(false),
       frame_number_(0),
       has_robustness_extension_(false),
       reset_status_(GL_NO_ERROR),
       needs_mac_nvidia_driver_workaround_(false),
       needs_glsl_built_in_function_emulation_(false),
       force_webgl_glsl_validation_(false),
       derivatives_explicitly_enabled_(false),
       compile_shader_always_succeeds_(false),
-      viewport_x_(0),
-      viewport_y_(0),
-      viewport_width_(0),
-      viewport_height_(0),
-      viewport_max_width_(0),
-      viewport_max_height_(0),
       texture_upload_count_(0) {
   DCHECK(group);
 
   GLES2DecoderImpl* this_temp = this;
   this_in_hex_ = HexEncode(&this_temp, sizeof(this_temp));
 
   attrib_0_value_.v[0] = 0.0f;
   attrib_0_value_.v[1] = 0.0f;
   attrib_0_value_.v[2] = 0.0f;
   attrib_0_value_.v[3] = 1.0f;
@@ skipping 81 matching lines @@
     // We have to enable vertex array 0 on OpenGL or it won't render. Note that
     // OpenGL ES 2.0 does not have this issue.
     glEnableVertexAttribArray(0);
   }
   glGenBuffersARB(1, &attrib_0_buffer_id_);
   glBindBuffer(GL_ARRAY_BUFFER, attrib_0_buffer_id_);
   glVertexAttribPointer(0, 1, GL_FLOAT, GL_FALSE, 0, NULL);
   glBindBuffer(GL_ARRAY_BUFFER, 0);
   glGenBuffersARB(1, &fixed_attrib_buffer_id_);
 
-  texture_units_.reset(
+  state_.texture_units.reset(
       new TextureUnit[group_->max_texture_units()]);
   for (uint32 tt = 0; tt < group_->max_texture_units(); ++tt) {
     glActiveTexture(GL_TEXTURE0 + tt);
     // We want the last bind to be 2D.
     TextureManager::TextureInfo* info;
     if (feature_info_->feature_flags().oes_egl_image_external) {
       info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_EXTERNAL_OES);
-      texture_units_[tt].bound_texture_external_oes = info;
+      state_.texture_units[tt].bound_texture_external_oes = info;
       glBindTexture(GL_TEXTURE_EXTERNAL_OES, info->service_id());
     }
     if (feature_info_->feature_flags().arb_texture_rectangle) {
       info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_RECTANGLE_ARB);
-      texture_units_[tt].bound_texture_rectangle_arb = info;
+      state_.texture_units[tt].bound_texture_rectangle_arb = info;
       glBindTexture(GL_TEXTURE_RECTANGLE_ARB, info->service_id());
     }
     info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_CUBE_MAP);
-    texture_units_[tt].bound_texture_cube_map = info;
+    state_.texture_units[tt].bound_texture_cube_map = info;
     glBindTexture(GL_TEXTURE_CUBE_MAP, info->service_id());
     info = texture_manager()->GetDefaultTextureInfo(GL_TEXTURE_2D);
-    texture_units_[tt].bound_texture_2d = info;
+    state_.texture_units[tt].bound_texture_2d = info;
     glBindTexture(GL_TEXTURE_2D, info->service_id());
   }
   glActiveTexture(GL_TEXTURE0);
   CHECK_GL_ERROR();
 
   ContextCreationAttribParser attrib_parser;
   if (!attrib_parser.Parse(attribs))
     return false;
 
   // These are NOT if the back buffer has these proprorties. They are
@@ skipping 156 matching lines @@
         feature_info_->feature_flags().is_nvidia;
     needs_glsl_built_in_function_emulation_ =
         feature_info_->feature_flags().is_amd;
 #endif
   }
 
   if (!InitializeShaderTranslator()) {
     return false;
   }
 
-  viewport_width_ = size.width();
-  viewport_height_ = size.height();
-  glViewport(viewport_x_, viewport_y_, viewport_width_, viewport_height_);
+  state_.viewport_width = size.width();
+  state_.viewport_height = size.height();
+  glViewport(
+      state_.viewport_x, state_.viewport_y,
+      state_.viewport_width, state_.viewport_height);
 
   GLint viewport_params[4] = { 0 };
   glGetIntegerv(GL_MAX_VIEWPORT_DIMS, viewport_params);
-  viewport_max_width_ = viewport_params[0];
-  viewport_max_height_ = viewport_params[1];
+  state_.viewport_max_width = viewport_params[0];
+  state_.viewport_max_height = viewport_params[1];
 
   // Set all the default state because some GL drivers get it wrong.
-  glActiveTexture(GL_TEXTURE0 + active_texture_unit_);
+  glActiveTexture(GL_TEXTURE0 + state_.active_texture_unit);
   glLineWidth(1.0);
-  EnableDisable(GL_BLEND, enable_blend_);
+  EnableDisable(GL_BLEND, state_.enable_blend);
   glBlendColor(0.0f, 0.0, 0.0f, 0.0f);
   glBlendFunc(GL_ONE, GL_ZERO);
   glBlendEquation(GL_FUNC_ADD);
   glBlendFuncSeparate(GL_ONE, GL_ZERO, GL_ONE, GL_ZERO);
-  glClearColor(clear_red_, clear_green_, clear_blue_, clear_alpha_);
-  glColorMask(mask_red_, mask_green_, mask_blue_, mask_alpha_);
-  EnableDisable(GL_CULL_FACE, enable_cull_face_);
+  glClearColor(
+      state_.color_clear_red, state_.color_clear_green, state_.color_clear_blue,
+      state_.color_clear_alpha);
+  glColorMask(
+      state_.color_mask_red, state_.color_mask_green, state_.color_mask_blue,
+      state_.color_mask_alpha);
+  EnableDisable(GL_CULL_FACE, state_.enable_cull_face);
   glCullFace(GL_BACK);
-  glClearDepth(clear_depth_);
+  glClearDepth(state_.depth_clear);
   glDepthFunc(GL_LESS);
   glDepthRange(0.0f, 1.0f);
-  EnableDisable(GL_DEPTH_TEST, enable_depth_test_);
+  EnableDisable(GL_DEPTH_TEST, state_.enable_depth_test);
   glEnable(GL_DITHER);
   glFrontFace(GL_CCW);
   glHint(GL_GENERATE_MIPMAP_HINT, GL_DONT_CARE);
   glLineWidth(1.0f);
-  glPixelStorei(GL_PACK_ALIGNMENT, pack_alignment_);
+  glPixelStorei(GL_PACK_ALIGNMENT, state_.pack_alignment);
   glPolygonOffset(0.0f, 0.0f);
   glDisable(GL_POLYGON_OFFSET_FILL);
   glSampleCoverage(1.0, false);
-  glScissor(viewport_x_, viewport_y_, viewport_width_, viewport_height_);
-  EnableDisable(GL_SCISSOR_TEST, enable_scissor_test_);
-  EnableDisable(GL_STENCIL_TEST, enable_stencil_test_);
-  glClearStencil(clear_stencil_);
+  glScissor(
+      state_.viewport_x, state_.viewport_y,
+      state_.viewport_width, state_.viewport_height);
+  EnableDisable(GL_SCISSOR_TEST, state_.enable_scissor_test);
+  EnableDisable(GL_STENCIL_TEST, state_.enable_stencil_test);
+  glClearStencil(state_.stencil_clear);
   glStencilFunc(GL_ALWAYS, 0, 0xFFFFFFFFU);
   glStencilOp(GL_KEEP, GL_KEEP, GL_KEEP);
-  glStencilMaskSeparate(GL_FRONT, mask_stencil_front_);
-  glStencilMaskSeparate(GL_BACK, mask_stencil_back_);
-  glPixelStorei(GL_UNPACK_ALIGNMENT, unpack_alignment_);
+  glStencilMaskSeparate(GL_FRONT, state_.stencil_mask_front);
+  glStencilMaskSeparate(GL_BACK, state_.stencil_mask_back);
+  glPixelStorei(GL_UNPACK_ALIGNMENT, state_.unpack_alignment);
 
   DoBindBuffer(GL_ARRAY_BUFFER, 0);
   DoBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
   DoBindFramebuffer(GL_FRAMEBUFFER, 0);
   DoBindRenderbuffer(GL_RENDERBUFFER, 0);
 
   // AMD and Intel drivers on Mac OS apparently get gl_PointCoord
   // backward from the spec and this setting makes them work
   // correctly. rdar://problem/11883495
 #if defined(OS_MACOSX)
@@ skipping 141 matching lines @@
     CreateTextureInfo(client_ids[ii], service_ids[ii]);
   }
   return true;
 }
 
 void GLES2DecoderImpl::DeleteBuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     BufferManager::BufferInfo* buffer = GetBufferInfo(client_ids[ii]);
     if (buffer && !buffer->IsDeleted()) {
-      vertex_attrib_manager_->Unbind(buffer);
-      if (bound_array_buffer_ == buffer) {
-        bound_array_buffer_ = NULL;
+      state_.vertex_attrib_manager->Unbind(buffer);
+      if (state_.bound_array_buffer == buffer) {
+        state_.bound_array_buffer = NULL;
       }
       RemoveBufferInfo(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteFramebuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      feature_info_->feature_flags().chromium_framebuffer_multisample;
 
   for (GLsizei ii = 0; ii < n; ++ii) {
     FramebufferManager::FramebufferInfo* framebuffer =
         GetFramebufferInfo(client_ids[ii]);
     if (framebuffer && !framebuffer->IsDeleted()) {
-      if (framebuffer == bound_draw_framebuffer_) {
-        bound_draw_framebuffer_ = NULL;
+      if (framebuffer == state_.bound_draw_framebuffer) {
+        state_.bound_draw_framebuffer = NULL;
         state_dirty_ = true;
         GLenum target = supports_separate_framebuffer_binds ?
             GL_DRAW_FRAMEBUFFER_EXT : GL_FRAMEBUFFER;
         glBindFramebufferEXT(target, GetBackbufferServiceId());
       }
-      if (framebuffer == bound_read_framebuffer_) {
-        bound_read_framebuffer_ = NULL;
+      if (framebuffer == state_.bound_read_framebuffer) {
+        state_.bound_read_framebuffer = NULL;
         GLenum target = supports_separate_framebuffer_binds ?
             GL_READ_FRAMEBUFFER_EXT : GL_FRAMEBUFFER;
         glBindFramebufferEXT(target, GetBackbufferServiceId());
       }
       RemoveFramebufferInfo(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteRenderbuffersHelper(
     GLsizei n, const GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      feature_info_->feature_flags().chromium_framebuffer_multisample;
   for (GLsizei ii = 0; ii < n; ++ii) {
     RenderbufferManager::RenderbufferInfo* renderbuffer =
         GetRenderbufferInfo(client_ids[ii]);
     if (renderbuffer && !renderbuffer->IsDeleted()) {
-      if (bound_renderbuffer_ == renderbuffer) {
-        bound_renderbuffer_ = NULL;
+      if (state_.bound_renderbuffer == renderbuffer) {
+        state_.bound_renderbuffer = NULL;
       }
       // Unbind from current framebuffers.
       if (supports_separate_framebuffer_binds) {
-        if (bound_read_framebuffer_) {
-          bound_read_framebuffer_->UnbindRenderbuffer(
+        if (state_.bound_read_framebuffer) {
+          state_.bound_read_framebuffer->UnbindRenderbuffer(
               GL_READ_FRAMEBUFFER_EXT, renderbuffer);
         }
-        if (bound_draw_framebuffer_) {
-          bound_draw_framebuffer_->UnbindRenderbuffer(
+        if (state_.bound_draw_framebuffer) {
+          state_.bound_draw_framebuffer->UnbindRenderbuffer(
               GL_DRAW_FRAMEBUFFER_EXT, renderbuffer);
         }
       } else {
-        if (bound_draw_framebuffer_) {
-          bound_draw_framebuffer_->UnbindRenderbuffer(
+        if (state_.bound_draw_framebuffer) {
+          state_.bound_draw_framebuffer->UnbindRenderbuffer(
               GL_FRAMEBUFFER, renderbuffer);
         }
       }
       state_dirty_ = true;
       RemoveRenderbufferInfo(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DeleteTexturesHelper(
     GLsizei n, const GLuint* client_ids) {
   bool supports_separate_framebuffer_binds =
      feature_info_->feature_flags().chromium_framebuffer_multisample;
   for (GLsizei ii = 0; ii < n; ++ii) {
     TextureManager::TextureInfo* texture = GetTextureInfo(client_ids[ii]);
     if (texture && !texture->IsDeleted()) {
       if (texture->IsAttachedToFramebuffer()) {
         state_dirty_ = true;
       }
       // Unbind texture from texture units.
       for (size_t jj = 0; jj < group_->max_texture_units(); ++jj) {
-        texture_units_[jj].Unbind(texture);
+        state_.texture_units[jj].Unbind(texture);
       }
       // Unbind from current framebuffers.
       if (supports_separate_framebuffer_binds) {
-        if (bound_read_framebuffer_) {
-          bound_read_framebuffer_->UnbindTexture(
+        if (state_.bound_read_framebuffer) {
+          state_.bound_read_framebuffer->UnbindTexture(
               GL_READ_FRAMEBUFFER_EXT, texture);
         }
-        if (bound_draw_framebuffer_) {
-          bound_draw_framebuffer_->UnbindTexture(
+        if (state_.bound_draw_framebuffer) {
+          state_.bound_draw_framebuffer->UnbindTexture(
               GL_DRAW_FRAMEBUFFER_EXT, texture);
         }
       } else {
-        if (bound_draw_framebuffer_) {
-          bound_draw_framebuffer_->UnbindTexture(GL_FRAMEBUFFER, texture);
+        if (state_.bound_draw_framebuffer) {
+          state_.bound_draw_framebuffer->UnbindTexture(GL_FRAMEBUFFER, texture);
         }
       }
       GLuint service_id = texture->service_id();
       if (texture->IsStreamTexture() && stream_texture_manager_) {
         stream_texture_manager_->DestroyStreamTexture(service_id);
       }
 #if defined(OS_MACOSX)
       if (texture->target() == GL_TEXTURE_RECTANGLE_ARB) {
         ReleaseIOSurfaceForTexture(service_id);
       }
@@ skipping 41 matching lines @@
 
   glBindFramebufferEXT(target, framebuffer_id);
 }
 
 void GLES2DecoderImpl::RestoreCurrentFramebufferBindings() {
   state_dirty_ = true;
 
   if (!feature_info_->feature_flags().chromium_framebuffer_multisample) {
     RebindCurrentFramebuffer(
         GL_FRAMEBUFFER,
-        bound_draw_framebuffer_.get(),
+        state_.bound_draw_framebuffer.get(),
         GetBackbufferServiceId());
   } else {
     RebindCurrentFramebuffer(
         GL_READ_FRAMEBUFFER_EXT,
-        bound_read_framebuffer_.get(),
+        state_.bound_read_framebuffer.get(),
         GetBackbufferServiceId());
     RebindCurrentFramebuffer(
         GL_DRAW_FRAMEBUFFER_EXT,
-        bound_draw_framebuffer_.get(),
+        state_.bound_draw_framebuffer.get(),
         GetBackbufferServiceId());
   }
 }
 
 void GLES2DecoderImpl::RestoreCurrentTexture2DBindings() {
-  GLES2DecoderImpl::TextureUnit& info = texture_units_[0];
+  TextureUnit& info = state_.texture_units[0];
   GLuint last_id;
   if (info.bound_texture_2d) {
     last_id = info.bound_texture_2d->service_id();
   } else {
     last_id = 0;
   }
 
   glBindTexture(GL_TEXTURE_2D, last_id);
-  glActiveTexture(GL_TEXTURE0 + active_texture_unit_);
+  glActiveTexture(GL_TEXTURE0 + state_.active_texture_unit);
 }
 
 bool GLES2DecoderImpl::CheckFramebufferValid(
     FramebufferManager::FramebufferInfo* framebuffer,
     GLenum target, const char* func_name) {
   if (!framebuffer) {
     return true;
   }
 
   if (framebuffer_manager()->IsComplete(framebuffer)) {
@@ skipping 33 matching lines @@
   }
 
   // NOTE: At this point we don't know if the framebuffer is complete but
   // we DO know that everything that needs to be cleared has been cleared.
   return true;
 }
 
 bool GLES2DecoderImpl::CheckBoundFramebuffersValid(const char* func_name) {
   if (!feature_info_->feature_flags().chromium_framebuffer_multisample) {
     return CheckFramebufferValid(
-        bound_draw_framebuffer_, GL_FRAMEBUFFER_EXT, func_name);
+        state_.bound_draw_framebuffer, GL_FRAMEBUFFER_EXT, func_name);
   }
   return CheckFramebufferValid(
-             bound_draw_framebuffer_, GL_DRAW_FRAMEBUFFER_EXT, func_name) &&
+             state_.bound_draw_framebuffer,
+             GL_DRAW_FRAMEBUFFER_EXT, func_name) &&
          CheckFramebufferValid(
-             bound_read_framebuffer_, GL_READ_FRAMEBUFFER_EXT, func_name);
+             state_.bound_read_framebuffer,
+             GL_READ_FRAMEBUFFER_EXT, func_name);
 }
 
 gfx::Size GLES2DecoderImpl::GetBoundReadFrameBufferSize() {
   FramebufferManager::FramebufferInfo* framebuffer =
       GetFramebufferInfoForTarget(GL_READ_FRAMEBUFFER_EXT);
   if (framebuffer != NULL) {
     const FramebufferManager::FramebufferInfo::Attachment* attachment =
         framebuffer->GetAttachment(GL_COLOR_ATTACHMENT0);
     if (attachment) {
       return gfx::Size(attachment->width(), attachment->height());
@@ skipping 112 matching lines @@
 void GLES2DecoderImpl::Destroy(bool have_context) {
   DCHECK(!have_context || context_->IsCurrent(NULL));
 
   ChildList children = children_;
   for (ChildList::iterator it = children.begin(); it != children.end(); ++it)
     (*it)->SetParent(NULL, 0);
   DCHECK(children_.empty());
   SetParent(NULL, 0);
 
   // Unbind everything.
-  vertex_attrib_manager_ = NULL;
+  state_.vertex_attrib_manager = NULL;
   default_vertex_attrib_manager_ = NULL;
-  texture_units_.reset();
-  bound_array_buffer_ = NULL;
-  current_query_ = NULL;
-  current_program_ = NULL;
-  bound_read_framebuffer_ = NULL;
-  bound_draw_framebuffer_ = NULL;
-  bound_renderbuffer_ = NULL;
+  state_.texture_units.reset();
+  state_.bound_array_buffer = NULL;
+  state_.current_query = NULL;
+  state_.current_program = NULL;
+  state_.bound_read_framebuffer = NULL;
+  state_.bound_draw_framebuffer = NULL;
+  state_.bound_renderbuffer = NULL;
 
   if (have_context) {
     if (copy_texture_CHROMIUM_.get()) {
       copy_texture_CHROMIUM_->Destroy();
       copy_texture_CHROMIUM_.reset();
     }
 
-    if (current_program_) {
-      program_manager()->UnuseProgram(shader_manager(), current_program_);
-      current_program_ = NULL;
+    if (state_.current_program) {
+      program_manager()->UnuseProgram(shader_manager(), state_.current_program);
+      state_.current_program = NULL;
     }
 
     if (attrib_0_buffer_id_) {
       glDeleteBuffersARB(1, &attrib_0_buffer_id_);
     }
     if (fixed_attrib_buffer_id_) {
       glDeleteBuffersARB(1, &fixed_attrib_buffer_id_);
     }
 
     if (offscreen_target_frame_buffer_.get())
@@ skipping 423 matching lines @@
   ProcessPendingQueries();
 }
 
 void GLES2DecoderImpl::DoActiveTexture(GLenum texture_unit) {
   GLuint texture_index = texture_unit - GL_TEXTURE0;
   if (texture_index >= group_->max_texture_units()) {
     SetGLErrorInvalidEnum(
         "glActiveTexture", texture_unit, "texture_unit");
     return;
   }
-  active_texture_unit_ = texture_index;
+  state_.active_texture_unit = texture_index;
   glActiveTexture(texture_unit);
 }
 
 void GLES2DecoderImpl::DoBindBuffer(GLenum target, GLuint client_id) {
   BufferManager::BufferInfo* info = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
     info = GetBufferInfo(client_id);
     if (!info) {
       if (!group_->bind_generates_resource()) {
@@ skipping 14 matching lines @@
   if (info) {
     if (!buffer_manager()->SetTarget(info, target)) {
       SetGLError(GL_INVALID_OPERATION,
                  "glBindBuffer", "buffer bound to more than 1 target");
       return;
     }
     service_id = info->service_id();
   }
   switch (target) {
     case GL_ARRAY_BUFFER:
-      bound_array_buffer_ = info;
+      state_.bound_array_buffer = info;
       break;
     case GL_ELEMENT_ARRAY_BUFFER:
-      vertex_attrib_manager_->SetElementArrayBuffer(info);
+      state_.vertex_attrib_manager->SetElementArrayBuffer(info);
       break;
     default:
       NOTREACHED();  // Validation should prevent us getting here.
       break;
   }
   glBindBuffer(target, service_id);
 }
 
 bool GLES2DecoderImpl::BoundFramebufferHasColorAttachmentWithAlpha() {
   return (GLES2Util::GetChannelsForFormat(
@@ skipping 21 matching lines @@
   if (offscreen_target_frame_buffer_.get()) {
     return offscreen_target_stencil_format_ != 0 ||
            offscreen_target_depth_format_ == GL_DEPTH24_STENCIL8;
   }
   return back_buffer_has_stencil_;
 }
 
 void GLES2DecoderImpl::ApplyDirtyState() {
   if (state_dirty_) {
     glColorMask(
-        mask_red_, mask_green_, mask_blue_,
-        mask_alpha_ && BoundFramebufferHasColorAttachmentWithAlpha());
+        state_.color_mask_red, state_.color_mask_green, state_.color_mask_blue,
+        state_.color_mask_alpha &&
+            BoundFramebufferHasColorAttachmentWithAlpha());
     bool have_depth = BoundFramebufferHasDepthAttachment();
-    glDepthMask(mask_depth_ && have_depth);
-    EnableDisable(GL_DEPTH_TEST, enable_depth_test_ && have_depth);
+    glDepthMask(state_.depth_mask && have_depth);
+    EnableDisable(GL_DEPTH_TEST, state_.enable_depth_test && have_depth);
     bool have_stencil = BoundFramebufferHasStencilAttachment();
-    glStencilMaskSeparate(GL_FRONT, have_stencil ? mask_stencil_front_ : 0);
-    glStencilMaskSeparate(GL_BACK, have_stencil ? mask_stencil_back_ : 0);
-    EnableDisable(GL_STENCIL_TEST, enable_stencil_test_ && have_stencil);
-    EnableDisable(GL_CULL_FACE, enable_cull_face_);
-    EnableDisable(GL_SCISSOR_TEST, enable_scissor_test_);
-    EnableDisable(GL_BLEND, enable_blend_);
+    glStencilMaskSeparate(
+        GL_FRONT, have_stencil ? state_.stencil_mask_front : 0);
+    glStencilMaskSeparate(
+        GL_BACK, have_stencil ? state_.stencil_mask_back : 0);
+    EnableDisable(GL_STENCIL_TEST, state_.enable_stencil_test && have_stencil);
+    EnableDisable(GL_CULL_FACE, state_.enable_cull_face);
+    EnableDisable(GL_SCISSOR_TEST, state_.enable_scissor_test);
+    EnableDisable(GL_BLEND, state_.enable_blend);
     state_dirty_ = false;
   }
 }
 
 void GLES2DecoderImpl::BindAndApplyTextureParameters(
     TextureManager::TextureInfo* info) {
   glBindTexture(info->target(), info->service_id());
   glTexParameteri(info->target(), GL_TEXTURE_MIN_FILTER, info->min_filter());
   glTexParameteri(info->target(), GL_TEXTURE_MAG_FILTER, info->mag_filter());
   glTexParameteri(info->target(), GL_TEXTURE_WRAP_S, info->wrap_s());
@@ skipping 26 matching lines @@
       IdAllocatorInterface* id_allocator =
           group_->GetIdAllocator(id_namespaces::kFramebuffers);
       id_allocator->MarkAsUsed(client_id);
     } else {
       service_id = info->service_id();
     }
     info->MarkAsValid();
   }
 
   if (target == GL_FRAMEBUFFER || target == GL_DRAW_FRAMEBUFFER_EXT) {
-    bound_draw_framebuffer_ = info;
+    state_.bound_draw_framebuffer = info;
   }
   if (target == GL_FRAMEBUFFER || target == GL_READ_FRAMEBUFFER_EXT) {
-    bound_read_framebuffer_ = info;
+    state_.bound_read_framebuffer = info;
   }
 
   state_dirty_ = true;
 
   // If we are rendering to the backbuffer get the FBO id for any simulated
   // backbuffer.
   if (info == NULL) {
     service_id = GetBackbufferServiceId();
   }
 
@@ skipping 18 matching lines @@
       CreateRenderbufferInfo(client_id, service_id);
       info = GetRenderbufferInfo(client_id);
       IdAllocatorInterface* id_allocator =
           group_->GetIdAllocator(id_namespaces::kRenderbuffers);
       id_allocator->MarkAsUsed(client_id);
     } else {
       service_id = info->service_id();
     }
     info->MarkAsValid();
   }
-  bound_renderbuffer_ = info;
+  state_.bound_renderbuffer = info;
   glBindRenderbufferEXT(target, service_id);
 }
 
 void GLES2DecoderImpl::DoBindTexture(GLenum target, GLuint client_id) {
   TextureManager::TextureInfo* info = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
     info = GetTextureInfo(client_id);
     if (!info) {
       if (!group_->bind_generates_resource()) {
@@ skipping 24 matching lines @@
   }
   if (info->IsStreamTexture() && target != GL_TEXTURE_EXTERNAL_OES) {
     SetGLError(GL_INVALID_OPERATION,
                "glBindTexture", "illegal target for stream texture.");
     return;
   }
   if (info->target() == 0) {
     texture_manager()->SetInfoTarget(info, target);
   }
   glBindTexture(target, info->service_id());
-  TextureUnit& unit = texture_units_[active_texture_unit_];
+  TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
   unit.bind_target = target;
   switch (target) {
     case GL_TEXTURE_2D:
       unit.bound_texture_2d = info;
       break;
     case GL_TEXTURE_CUBE_MAP:
       unit.bound_texture_cube_map = info;
       break;
     case GL_TEXTURE_EXTERNAL_OES:
       unit.bound_texture_external_oes = info;
       if (info->IsStreamTexture()) {
         DCHECK(stream_texture_manager_);
         StreamTexture* stream_tex =
             stream_texture_manager_->LookupStreamTexture(info->service_id());
         if (stream_tex)
           stream_tex->Update();
       }
       break;
     case GL_TEXTURE_RECTANGLE_ARB:
       unit.bound_texture_rectangle_arb = info;
       break;
     default:
       NOTREACHED();  // Validation should prevent us getting here.
       break;
   }
 }
 
 void GLES2DecoderImpl::DoDisableVertexAttribArray(GLuint index) {
-  if (vertex_attrib_manager_->Enable(index, false)) {
+  if (state_.vertex_attrib_manager->Enable(index, false)) {
     if (index != 0 ||
         gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2) {
       glDisableVertexAttribArray(index);
     }
   } else {
     SetGLError(GL_INVALID_VALUE,
                "glDisableVertexAttribArray", "index out of range");
   }
 }
 
 void GLES2DecoderImpl::DoEnableVertexAttribArray(GLuint index) {
-  if (vertex_attrib_manager_->Enable(index, true)) {
+  if (state_.vertex_attrib_manager->Enable(index, true)) {
     glEnableVertexAttribArray(index);
   } else {
     SetGLError(GL_INVALID_VALUE,
                "glEnableVertexAttribArray", "index out of range");
   }
 }
 
 void GLES2DecoderImpl::DoGenerateMipmap(GLenum target) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info ||
@@ skipping 96 matching lines @@
       return true;
     case GL_MAX_CUBE_MAP_TEXTURE_SIZE:
       *num_written = 1;
       if (params) {
         params[0] = texture_manager()->MaxSizeForTarget(GL_TEXTURE_CUBE_MAP);
       }
       return true;
     case GL_COLOR_WRITEMASK:
       *num_written = 4;
       if (params) {
-        params[0] = mask_red_;
-        params[1] = mask_green_;
-        params[2] = mask_blue_;
-        params[3] = mask_alpha_;
+        params[0] = state_.color_mask_red;
+        params[1] = state_.color_mask_green;
+        params[2] = state_.color_mask_blue;
+        params[3] = state_.color_mask_alpha;
       }
       return true;
     case GL_DEPTH_WRITEMASK:
       *num_written = 1;
       if (params) {
-        params[0] = mask_depth_;
+        params[0] = state_.depth_mask;
       }
       return true;
     case GL_STENCIL_BACK_WRITEMASK:
       *num_written = 1;
       if (params) {
-        params[0] = mask_stencil_back_;
+        params[0] = state_.stencil_mask_back;
       }
       return true;
     case GL_STENCIL_WRITEMASK:
       *num_written = 1;
       if (params) {
-        params[0] = mask_stencil_front_;
+        params[0] = state_.stencil_mask_front;
       }
       return true;
     case GL_DEPTH_TEST:
       *num_written = 1;
       if (params) {
-        params[0] = enable_depth_test_;
+        params[0] = state_.enable_depth_test;
       }
       return true;
     case GL_STENCIL_TEST:
       *num_written = 1;
       if (params) {
-        params[0] = enable_stencil_test_;
+        params[0] = state_.enable_stencil_test;
       }
       return true;
     case GL_ALPHA_BITS:
       *num_written = 1;
       if (params) {
         GLint v = 0;
         glGetIntegerv(GL_ALPHA_BITS, &v);
         params[0] = BoundFramebufferHasColorAttachmentWithAlpha() ? v : 0;
       }
       return true;
@@ skipping 43 matching lines @@
       return true;
     case GL_SHADER_COMPILER:
       *num_written = 1;
       if (params) {
         *params = GL_TRUE;
       }
       return true;
     case GL_ARRAY_BUFFER_BINDING:
       *num_written = 1;
       if (params) {
-        if (bound_array_buffer_) {
+        if (state_.bound_array_buffer) {
           GLuint client_id = 0;
-          buffer_manager()->GetClientId(bound_array_buffer_->service_id(),
+          buffer_manager()->GetClientId(state_.bound_array_buffer->service_id(),
                                         &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_ELEMENT_ARRAY_BUFFER_BINDING:
       *num_written = 1;
       if (params) {
-        if (vertex_attrib_manager_->element_array_buffer()) {
+        if (state_.vertex_attrib_manager->element_array_buffer()) {
           GLuint client_id = 0;
           buffer_manager()->GetClientId(
-              vertex_attrib_manager_->element_array_buffer()->service_id(),
-              &client_id);
+              state_.vertex_attrib_manager->element_array_buffer(
+                  )->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_FRAMEBUFFER_BINDING:
     // case GL_DRAW_FRAMEBUFFER_BINDING_EXT: (same as GL_FRAMEBUFFER_BINDING)
       *num_written = 1;
       if (params) {
@@ skipping 35 matching lines @@
               renderbuffer->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_CURRENT_PROGRAM:
       *num_written = 1;
       if (params) {
-        if (current_program_) {
+        if (state_.current_program) {
           GLuint client_id = 0;
           program_manager()->GetClientId(
-              current_program_->service_id(), &client_id);
+              state_.current_program->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_TEXTURE_BINDING_2D:
       *num_written = 1;
       if (params) {
-        TextureUnit& unit = texture_units_[active_texture_unit_];
+        TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
         if (unit.bound_texture_2d) {
           GLuint client_id = 0;
           texture_manager()->GetClientId(
               unit.bound_texture_2d->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_TEXTURE_BINDING_CUBE_MAP:
       *num_written = 1;
       if (params) {
-        TextureUnit& unit = texture_units_[active_texture_unit_];
+        TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
         if (unit.bound_texture_cube_map) {
           GLuint client_id = 0;
           texture_manager()->GetClientId(
               unit.bound_texture_cube_map->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_TEXTURE_BINDING_EXTERNAL_OES:
       *num_written = 1;
       if (params) {
-        TextureUnit& unit = texture_units_[active_texture_unit_];
+        TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
         if (unit.bound_texture_external_oes) {
           GLuint client_id = 0;
           texture_manager()->GetClientId(
               unit.bound_texture_external_oes->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
     case GL_TEXTURE_BINDING_RECTANGLE_ARB:
       *num_written = 1;
       if (params) {
-        TextureUnit& unit = texture_units_[active_texture_unit_];
+        TextureUnit& unit = state_.texture_units[state_.active_texture_unit];
         if (unit.bound_texture_rectangle_arb) {
           GLuint client_id = 0;
           texture_manager()->GetClientId(
               unit.bound_texture_rectangle_arb->service_id(), &client_id);
           *params = client_id;
         } else {
           *params = 0;
         }
       }
       return true;
@@ skipping 352 matching lines @@
     return error::kOutOfBounds;
   }
   DoRegisterSharedIdsCHROMIUM(namespace_id, n, ids);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::DoClear(GLbitfield mask) {
   if (ShouldDeferDraws())
     return error::kDeferCommandUntilLater;
   if (CheckBoundFramebuffersValid("glClear")) {
-    UNSHIPPED_TRACE_EVENT_INSTANT2("test_gpu", "DoClear", "red", clear_red_,
-                                   "green", clear_green_);
+    UNSHIPPED_TRACE_EVENT_INSTANT2(
+        "test_gpu", "DoClear",
+        "red", state_.color_clear_red,
+        "green", state_.color_clear_green);
     ApplyDirtyState();
     glClear(mask);
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleClear(
     uint32 immediate_data_size, const gles2::Clear& c) {
   GLbitfield mask = static_cast<GLbitfield>(c.mask);
   return DoClear(mask);
@@ skipping 20 matching lines @@
     }
     service_id = info->service_id();
   }
   CopyRealGLErrorsToWrapper();
   glFramebufferRenderbufferEXT(
       target, attachment, renderbuffertarget, service_id);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     framebuffer_info->AttachRenderbuffer(attachment, info);
   }
-  if (framebuffer_info == bound_draw_framebuffer_) {
+  if (framebuffer_info == state_.bound_draw_framebuffer) {
     state_dirty_ = true;
   }
 }
 
 bool GLES2DecoderImpl::SetCapabilityState(GLenum cap, bool enabled) {
   switch (cap) {
     case GL_BLEND:
-      enable_blend_ = enabled;
+      state_.enable_blend = enabled;
       return true;
     case GL_CULL_FACE:
-      enable_cull_face_ = enabled;
+      state_.enable_cull_face = enabled;
       return true;
     case GL_SCISSOR_TEST:
-      enable_scissor_test_ = enabled;
+      state_.enable_scissor_test = enabled;
       return true;
     case GL_DEPTH_TEST: {
-      if (enable_depth_test_ != enabled) {
-        enable_depth_test_ = enabled;
+      if (state_.enable_depth_test != enabled) {
+        state_.enable_depth_test = enabled;
         state_dirty_ = true;
       }
       return false;
     }
     case GL_STENCIL_TEST:
-      if (enable_stencil_test_ != enabled) {
-        enable_stencil_test_ = enabled;
+      if (state_.enable_stencil_test != enabled) {
+        state_.enable_stencil_test = enabled;
         state_dirty_ = true;
       }
       return false;
     default:
       return true;
   }
 }
 
 void GLES2DecoderImpl::DoDisable(GLenum cap) {
   if (SetCapabilityState(cap, false)) {
     glDisable(cap);
   }
 }
 
 void GLES2DecoderImpl::DoEnable(GLenum cap) {
   if (SetCapabilityState(cap, true)) {
     glEnable(cap);
   }
 }
 
 bool GLES2DecoderImpl::DoIsEnabled(GLenum cap) {
   switch (cap) {
     case GL_BLEND:
-      return enable_blend_;
+      return state_.enable_blend;
     case GL_CULL_FACE:
-      return enable_cull_face_;
+      return state_.enable_cull_face;
     case GL_SCISSOR_TEST:
-      return enable_scissor_test_;
+      return state_.enable_scissor_test;
     case GL_DEPTH_TEST:
-      return enable_depth_test_;
+      return state_.enable_depth_test;
     case GL_STENCIL_TEST:
-      return enable_stencil_test_;
+      return state_.enable_stencil_test;
     default:
       return glIsEnabled(cap) != 0;
   }
 }
 
 void GLES2DecoderImpl::DoClearColor(
       GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) {
-  clear_red_ = red;
-  clear_green_ = green;
-  clear_blue_ = blue;
-  clear_alpha_ = alpha;
+  state_.color_clear_red = red;
+  state_.color_clear_green = green;
+  state_.color_clear_blue = blue;
+  state_.color_clear_alpha = alpha;
   glClearColor(red, green, blue, alpha);
 }
 
 void GLES2DecoderImpl::DoClearDepthf(GLclampf depth) {
-  clear_depth_ = depth;
+  state_.depth_clear = depth;
   glClearDepth(depth);
 }
 
 void GLES2DecoderImpl::DoClearStencil(GLint s) {
-  clear_stencil_ = s;
+  state_.stencil_clear = s;
   glClearStencil(s);
 }
 
 void GLES2DecoderImpl::DoColorMask(
     GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) {
-  mask_red_ = red;
-  mask_green_ = green;
-  mask_blue_ = blue;
-  mask_alpha_ = alpha;
+  state_.color_mask_red = red;
+  state_.color_mask_green = green;
+  state_.color_mask_blue = blue;
+  state_.color_mask_alpha = alpha;
   state_dirty_ = true;
 }
 
 void GLES2DecoderImpl::DoDepthMask(GLboolean depth) {
-  mask_depth_ = depth;
+  state_.depth_mask = depth;
   state_dirty_ = true;
 }
 
 void GLES2DecoderImpl::DoStencilMask(GLuint mask) {
-  mask_stencil_front_ = mask;
-  mask_stencil_back_ = mask;
+  state_.stencil_mask_front = mask;
+  state_.stencil_mask_back = mask;
   state_dirty_ = true;
 }
 
 void GLES2DecoderImpl::DoStencilMaskSeparate(GLenum face, GLuint mask) {
   if (face == GL_FRONT || face == GL_FRONT_AND_BACK) {
-    mask_stencil_front_ = mask;
+    state_.stencil_mask_front = mask;
   }
   if (face == GL_BACK || face == GL_FRONT_AND_BACK) {
-    mask_stencil_back_ = mask;
+    state_.stencil_mask_back = mask;
   }
   state_dirty_ = true;
 }
 
 // Assumes framebuffer is complete.
 void GLES2DecoderImpl::ClearUnclearedAttachments(
     GLenum target, FramebufferManager::FramebufferInfo* info) {
   if (target == GL_READ_FRAMEBUFFER_EXT) {
     // bind this to the DRAW point, clear then bind back to READ
     // TODO(gman): I don't think there is any guarantee that an FBO that
@@ skipping 39 matching lines @@
     FramebufferManager::FramebufferInfo* framebuffer =
         GetFramebufferInfoForTarget(GL_DRAW_FRAMEBUFFER_EXT);
     GLuint service_id =
         framebuffer ? framebuffer->service_id() : GetBackbufferServiceId();
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, service_id);
   }
 }
 
 void GLES2DecoderImpl::RestoreClearState() {
   state_dirty_ = true;
-  glClearColor(clear_red_, clear_green_, clear_blue_, clear_alpha_);
-  glClearStencil(clear_stencil_);
-  glClearDepth(clear_depth_);
-  if (enable_scissor_test_) {
+  glClearColor(
+      state_.color_clear_red, state_.color_clear_green, state_.color_clear_blue,
+      state_.color_clear_alpha);
+  glClearStencil(state_.stencil_clear);
+  glClearDepth(state_.depth_clear);
+  if (state_.enable_scissor_test) {
     glEnable(GL_SCISSOR_TEST);
   }
 }
 
 GLenum GLES2DecoderImpl::DoCheckFramebufferStatus(GLenum target) {
   FramebufferManager::FramebufferInfo* framebuffer =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer) {
     return GL_FRAMEBUFFER_COMPLETE;
   }
@@ skipping 31 matching lines @@
                "glFramebufferTexture2D", "level out of range");
     return;
   }
 
   CopyRealGLErrorsToWrapper();
   glFramebufferTexture2DEXT(target, attachment, textarget, service_id, level);
   GLenum error = PeekGLError();
   if (error == GL_NO_ERROR) {
     framebuffer_info->AttachTexture(attachment, info, textarget, level);
   }
-  if (framebuffer_info == bound_draw_framebuffer_) {
+  if (framebuffer_info == state_.bound_draw_framebuffer) {
     state_dirty_ = true;
   }
 }
 
 void GLES2DecoderImpl::DoGetFramebufferAttachmentParameteriv(
     GLenum target, GLenum attachment, GLenum pname, GLint* params) {
   FramebufferManager::FramebufferInfo* framebuffer_info =
       GetFramebufferInfoForTarget(target);
   if (!framebuffer_info) {
     SetGLError(GL_INVALID_OPERATION,
@@ skipping 185 matching lines @@
   ShaderTranslator* vertex_translator = NULL;
   ShaderTranslator* fragment_translator = NULL;
   if (use_shader_translator_) {
     vertex_translator = vertex_translator_;
     fragment_translator = fragment_translator_;
   }
   if (info->Link(shader_manager(),
                  vertex_translator,
                  fragment_translator,
                  feature_info_)) {
-    if (info == current_program_.get()) {
+    if (info == state_.current_program.get()) {
       program_manager()->ClearUniforms(info);
     }
   }
 };
 
 void GLES2DecoderImpl::DoTexParameterf(
     GLenum target, GLenum pname, GLfloat param) {
   TextureManager::TextureInfo* info = GetTextureInfoForTarget(target);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glTexParameterf", "unknown texture");
@@ skipping 48 matching lines @@
   }
 
   if (!texture_manager()->SetParameter(info, pname, *params)) {
     SetGLErrorInvalidEnum("glTexParameteriv", pname, "pname");
     return;
   }
   glTexParameteriv(target, pname, params);
 }
 
 bool GLES2DecoderImpl::CheckCurrentProgram(const char* function_name) {
-  if (!current_program_) {
+  if (!state_.current_program) {
     // The program does not exist.
     SetGLError(GL_INVALID_OPERATION, function_name, "no program in use");
     return false;
   }
-  if (!current_program_->InUse()) {
+  if (!state_.current_program->InUse()) {
     SetGLError(GL_INVALID_OPERATION, function_name, "program not linked");
     return false;
   }
   return true;
 }
 
 bool GLES2DecoderImpl::CheckCurrentProgramForUniform(
     GLint location, const char* function_name) {
   if (!CheckCurrentProgram(function_name)) {
     return false;
   }
   return location != -1;
 }
 
 bool GLES2DecoderImpl::PrepForSetUniformByLocation(
     GLint fake_location, const char* function_name,
     GLint* real_location, GLenum* type, GLsizei* count) {
   DCHECK(type);
   DCHECK(count);
   DCHECK(real_location);
   if (!CheckCurrentProgramForUniform(fake_location, function_name)) {
     return false;
   }
   GLint array_index = -1;
   const ProgramManager::ProgramInfo::UniformInfo* info =
-      current_program_->GetUniformInfoByFakeLocation(
+      state_.current_program->GetUniformInfoByFakeLocation(
           fake_location, real_location, &array_index);
   if (!info) {
     SetGLError(GL_INVALID_OPERATION, function_name, "unknown location");
     return false;
   }
   if (*count > 1 && !info->is_array) {
     SetGLError(
         GL_INVALID_OPERATION, function_name, "count > 1 for non-array");
     return false;
   }
   *count = std::min(info->size - array_index, *count);
   if (*count <= 0) {
     return false;
   }
   *type = info->type;
   return true;
 }
 
 void GLES2DecoderImpl::DoUniform1i(GLint fake_location, GLint v0) {
   GLenum type = 0;
   GLsizei count = 1;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(
       fake_location, "glUniform1iv", &real_location, &type, &count)) {
     return;
   }
-  if (!current_program_->SetSamplers(
+  if (!state_.current_program->SetSamplers(
       group_->max_texture_units(), fake_location, 1, &v0)) {
     SetGLError(GL_INVALID_VALUE, "glUniform1i", "texture unit out of range");
     return;
   }
   glUniform1i(real_location, v0);
 }
 
 void GLES2DecoderImpl::DoUniform1iv(
     GLint fake_location, GLsizei count, const GLint *value) {
   GLenum type = 0;
   GLint real_location = -1;
   if (!PrepForSetUniformByLocation(
       fake_location, "glUniform1iv", &real_location, &type, &count)) {
     return;
   }
   if (type == GL_SAMPLER_2D || type == GL_SAMPLER_2D_RECT_ARB ||
       type == GL_SAMPLER_CUBE || type == GL_SAMPLER_EXTERNAL_OES) {
-    if (!current_program_->SetSamplers(
+    if (!state_.current_program->SetSamplers(
           group_->max_texture_units(), fake_location, count, value)) {
       SetGLError(GL_INVALID_VALUE, "glUniform1iv", "texture unit out of range");
       return;
     }
   }
   glUniform1iv(real_location, count, value);
 }
 
 void GLES2DecoderImpl::DoUniform1fv(
     GLint fake_location, GLsizei count, const GLfloat* value) {
@@ skipping 151 matching lines @@
     if (!info) {
       return;
     }
     if (!info->IsValid()) {
       // Program was not linked successfully. (ie, glLinkProgram)
       SetGLError(GL_INVALID_OPERATION, "glUseProgram", "program not linked");
       return;
     }
     service_id = info->service_id();
   }
-  if (current_program_) {
-    program_manager()->UnuseProgram(shader_manager(), current_program_);
+  if (state_.current_program) {
+    program_manager()->UnuseProgram(shader_manager(), state_.current_program);
   }
-  current_program_ = info;
+  state_.current_program = info;
   glUseProgram(service_id);
-  if (current_program_) {
-    program_manager()->UseProgram(current_program_);
+  if (state_.current_program) {
+    program_manager()->UseProgram(state_.current_program);
   }
 }
 
 uint32 GLES2DecoderImpl::GetGLError() {
   // Check the GL error first, then our wrapped error.
   GLenum error = glGetError();
   if (error == GL_NO_ERROR && error_bits_ != 0) {
     for (uint32 mask = 1; mask != 0; mask = mask << 1) {
       if ((error_bits_ & mask) != 0) {
         error = GLES2Util::GLErrorBitToGLError(mask);
@@ skipping 68 matching lines @@
 }
 
 void GLES2DecoderImpl::PerformanceWarning(const std::string& msg) {
   LogMessage(std::string("PERFORMANCE WARNING: ") + msg);
 }
 
 void GLES2DecoderImpl::ForceCompileShaderIfPending(
     ShaderManager::ShaderInfo* info) {
   if (info->compilation_status() ==
       ShaderManager::ShaderInfo::PENDING_DEFERRED_COMPILE) {
-
     ShaderTranslator* translator = NULL;
     if (use_shader_translator_) {
       translator = info->shader_type() == GL_VERTEX_SHADER ?
           vertex_translator_.get() : fragment_translator_.get();
     }
     // We know there will be no errors, because we only defer compilation on
     // shaders that were previously compiled successfully.
     program_manager()->ForceCompileShader(info->deferred_compilation_source(),
                                           info,
                                           translator,
@@ skipping 12 matching lines @@
   GLenum error;
   while ((error = glGetError()) != GL_NO_ERROR) {
     if (error != GL_OUT_OF_MEMORY) {
       // GL_OUT_OF_MEMORY can legally happen on lost device.
       NOTREACHED() << "GL error " << error << " was unhandled.";
     }
   }
 }
 
 bool GLES2DecoderImpl::SetBlackTextureForNonRenderableTextures() {
-  DCHECK(current_program_);
+  DCHECK(state_.current_program);
   // Only check if there are some unrenderable textures.
   if (!texture_manager()->HaveUnrenderableTextures()) {
     return false;
   }
   bool textures_set = false;
   const ProgramManager::ProgramInfo::SamplerIndices& sampler_indices =
-     current_program_->sampler_indices();
+     state_.current_program->sampler_indices();
   for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
     const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
-        current_program_->GetUniformInfo(sampler_indices[ii]);
+        state_.current_program->GetUniformInfo(sampler_indices[ii]);
     DCHECK(uniform_info);
     for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
       GLuint texture_unit_index = uniform_info->texture_units[jj];
       if (texture_unit_index < group_->max_texture_units()) {
-        TextureUnit& texture_unit = texture_units_[texture_unit_index];
+        TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
         TextureManager::TextureInfo* texture_info =
             texture_unit.GetInfoForSamplerType(uniform_info->type);
         if (!texture_info || !texture_manager()->CanRender(texture_info)) {
           textures_set = true;
           glActiveTexture(GL_TEXTURE0 + texture_unit_index);
           glBindTexture(
               GetBindTargetForSamplerType(uniform_info->type),
               texture_manager()->black_texture_id(uniform_info->type));
           RenderWarning(
               std::string("texture bound to texture unit ") +
               base::IntToString(texture_unit_index) +
               " is not renderable. It maybe non-power-of-2 and have "
               " incompatible texture filtering or is not "
               "'texture complete'");
         }
       }
       // else: should this be an error?
     }
   }
   return textures_set;
 }
 
 void GLES2DecoderImpl::RestoreStateForNonRenderableTextures() {
-  DCHECK(current_program_);
+  DCHECK(state_.current_program);
   const ProgramManager::ProgramInfo::SamplerIndices& sampler_indices =
-     current_program_->sampler_indices();
+     state_.current_program->sampler_indices();
   for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
     const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
-        current_program_->GetUniformInfo(sampler_indices[ii]);
+        state_.current_program->GetUniformInfo(sampler_indices[ii]);
     DCHECK(uniform_info);
     for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
       GLuint texture_unit_index = uniform_info->texture_units[jj];
       if (texture_unit_index < group_->max_texture_units()) {
-        TextureUnit& texture_unit = texture_units_[texture_unit_index];
+        TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
         TextureManager::TextureInfo* texture_info =
             uniform_info->type == GL_SAMPLER_2D ?
                 texture_unit.bound_texture_2d :
                 texture_unit.bound_texture_cube_map;
         if (!texture_info || !texture_manager()->CanRender(texture_info)) {
           glActiveTexture(GL_TEXTURE0 + texture_unit_index);
           // Get the texture info that was previously bound here.
           texture_info = texture_unit.bind_target == GL_TEXTURE_2D ?
               texture_unit.bound_texture_2d :
               texture_unit.bound_texture_cube_map;
           glBindTexture(texture_unit.bind_target,
                         texture_info ? texture_info->service_id() : 0);
         }
       }
     }
   }
   // Set the active texture back to whatever the user had it as.
-  glActiveTexture(GL_TEXTURE0 + active_texture_unit_);
+  glActiveTexture(GL_TEXTURE0 + state_.active_texture_unit);
 }
 
 bool GLES2DecoderImpl::ClearUnclearedTextures() {
   // Only check if there are some uncleared textures.
   if (!texture_manager()->HaveUnsafeTextures()) {
     return true;
   }
 
   // 1: Check all textures we are about to render with.
-  if (current_program_) {
+  if (state_.current_program) {
     const ProgramManager::ProgramInfo::SamplerIndices& sampler_indices =
-       current_program_->sampler_indices();
+       state_.current_program->sampler_indices();
     for (size_t ii = 0; ii < sampler_indices.size(); ++ii) {
       const ProgramManager::ProgramInfo::UniformInfo* uniform_info =
-          current_program_->GetUniformInfo(sampler_indices[ii]);
+          state_.current_program->GetUniformInfo(sampler_indices[ii]);
       DCHECK(uniform_info);
       for (size_t jj = 0; jj < uniform_info->texture_units.size(); ++jj) {
         GLuint texture_unit_index = uniform_info->texture_units[jj];
         if (texture_unit_index < group_->max_texture_units()) {
-          TextureUnit& texture_unit = texture_units_[texture_unit_index];
+          TextureUnit& texture_unit = state_.texture_units[texture_unit_index];
           TextureManager::TextureInfo* texture_info =
               texture_unit.GetInfoForSamplerType(uniform_info->type);
           if (texture_info && !texture_info->SafeToRenderFrom()) {
             if (!texture_manager()->ClearRenderableLevels(this, texture_info)) {
               return false;
             }
           }
         }
       }
     }
   }
   return true;
 }
 
 bool GLES2DecoderImpl::IsDrawValid(
     const char* function_name, GLuint max_vertex_accessed, GLsizei primcount) {
   // NOTE: We specifically do not check current_program->IsValid() because
   // it could never be invalid since glUseProgram would have failed. While
   // glLinkProgram could later mark the program as invalid the previous
   // valid program will still function if it is still the current program.
-  if (!current_program_) {
+  if (!state_.current_program) {
     // The program does not exist.
     // But GL says no ERROR.
     RenderWarning("Drawing with no current shader program.");
     return false;
   }
 
   // true if any enabled, used divisor is zero
   bool divisor0 = false;
   // Validate all attribs currently enabled. If they are used by the current
   // program then check that they have enough elements to handle the draw call.
   // If they are not used by the current program check that they have a buffer
   // assigned.
   const VertexAttribManager::VertexAttribInfoList& infos =
-      vertex_attrib_manager_->GetEnabledVertexAttribInfos();
+      state_.vertex_attrib_manager->GetEnabledVertexAttribInfos();
   for (VertexAttribManager::VertexAttribInfoList::const_iterator it =
        infos.begin(); it != infos.end(); ++it) {
     const VertexAttribManager::VertexAttribInfo* info = *it;
     const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
-        current_program_->GetAttribInfoByLocation(info->index());
+        state_.current_program->GetAttribInfoByLocation(info->index());
     if (attrib_info) {
       divisor0 |= (info->divisor() == 0);
       GLuint count = info->MaxVertexAccessed(primcount, max_vertex_accessed);
       // This attrib is used in the current program.
       if (!info->CanAccess(count)) {
         SetGLError(
             GL_INVALID_OPERATION, function_name,
             (std::string(
                  "attempt to access out of range vertices in attribute ") +
              base::IntToString(info->index())).c_str());
@@ skipping 26 matching lines @@
 
 bool GLES2DecoderImpl::SimulateAttrib0(
     const char* function_name, GLuint max_vertex_accessed, bool* simulated) {
   DCHECK(simulated);
   *simulated = false;
 
   if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2)
     return true;
 
   const VertexAttribManager::VertexAttribInfo* info =
-      vertex_attrib_manager_->GetVertexAttribInfo(0);
+      state_.vertex_attrib_manager->GetVertexAttribInfo(0);
   // If it's enabled or it's not used then we don't need to do anything.
-  bool attrib_0_used = current_program_->GetAttribInfoByLocation(0) != NULL;
+  bool attrib_0_used =
+      state_.current_program->GetAttribInfoByLocation(0) != NULL;
   if (info->enabled() && attrib_0_used) {
     return true;
   }
 
   // Make a buffer with a single repeated vec4 value enough to
   // simulate the constant value that is supposed to be here.
   // This is required to emulate GLES2 on GL.
   typedef VertexAttribManager::VertexAttribInfo::Vec4 Vec4;
 
   GLuint num_vertices = max_vertex_accessed + 1;
@@ skipping 39 matching lines @@
 
   if (info->divisor())
     glVertexAttribDivisorANGLE(0, 0);
 
   *simulated = true;
   return true;
 }
 
 void GLES2DecoderImpl::RestoreStateForAttrib(GLuint attrib) {
   const VertexAttribManager::VertexAttribInfo* info =
-      vertex_attrib_manager_->GetVertexAttribInfo(attrib);
+      state_.vertex_attrib_manager->GetVertexAttribInfo(attrib);
   const void* ptr = reinterpret_cast<const void*>(info->offset());
   BufferManager::BufferInfo* buffer_info = info->buffer();
   glBindBuffer(GL_ARRAY_BUFFER, buffer_info ? buffer_info->service_id() : 0);
   glVertexAttribPointer(
       attrib, info->size(), info->type(), info->normalized(), info->gl_stride(),
       ptr);
   if (info->divisor())
     glVertexAttribDivisorANGLE(attrib, info->divisor());
-  glBindBuffer(GL_ARRAY_BUFFER,
-               bound_array_buffer_ ? bound_array_buffer_->service_id() : 0);
+  glBindBuffer(
+      GL_ARRAY_BUFFER,
+      state_.bound_array_buffer ? state_.bound_array_buffer->service_id() : 0);
 
   // Never touch vertex attribute 0's state (in particular, never
   // disable it) when running on desktop GL because it will never be
   // re-enabled.
   if (attrib != 0 ||
       gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2) {
     if (info->enabled()) {
       glEnableVertexAttribArray(attrib);
     } else {
       glDisableVertexAttribArray(attrib);
     }
   }
 }
 
 bool GLES2DecoderImpl::SimulateFixedAttribs(
     const char* function_name,
     GLuint max_vertex_accessed, bool* simulated, GLsizei primcount) {
   DCHECK(simulated);
   *simulated = false;
   if (gfx::GetGLImplementation() == gfx::kGLImplementationEGLGLES2)
     return true;
 
-  if (!vertex_attrib_manager_->HaveFixedAttribs()) {
+  if (!state_.vertex_attrib_manager->HaveFixedAttribs()) {
     return true;
   }
 
   PerformanceWarning(
       "GL_FIXED attributes have a signficant performance penalty");
 
   // NOTE: we could be smart and try to check if a buffer is used
   // twice in 2 different attribs, find the overlapping parts and therefore
   // duplicate the minimum amount of data but this whole code path is not meant
   // to be used normally. It's just here to pass that OpenGL ES 2.0 conformance
   // tests so we just add to the buffer attrib used.
 
   GLuint elements_needed = 0;
   const VertexAttribManager::VertexAttribInfoList& infos =
-      vertex_attrib_manager_->GetEnabledVertexAttribInfos();
+      state_.vertex_attrib_manager->GetEnabledVertexAttribInfos();
   for (VertexAttribManager::VertexAttribInfoList::const_iterator it =
        infos.begin(); it != infos.end(); ++it) {
     const VertexAttribManager::VertexAttribInfo* info = *it;
     const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
-        current_program_->GetAttribInfoByLocation(info->index());
+        state_.current_program->GetAttribInfoByLocation(info->index());
     GLuint max_accessed = info->MaxVertexAccessed(primcount,
                                                   max_vertex_accessed);
     GLuint num_vertices = max_accessed + 1;
     if (num_vertices == 0) {
       SetGLError(GL_OUT_OF_MEMORY, function_name, "Simulating attrib 0");
       return false;
     }
     if (attrib_info &&
         info->CanAccess(max_accessed) &&
         info->type() == GL_FIXED) {
@@ skipping 27 matching lines @@
       return false;
     }
   }
 
   // Copy the elements and convert to float
   GLintptr offset = 0;
   for (VertexAttribManager::VertexAttribInfoList::const_iterator it =
            infos.begin(); it != infos.end(); ++it) {
     const VertexAttribManager::VertexAttribInfo* info = *it;
     const ProgramManager::ProgramInfo::VertexAttribInfo* attrib_info =
-        current_program_->GetAttribInfoByLocation(info->index());
+        state_.current_program->GetAttribInfoByLocation(info->index());
     GLuint max_accessed = info->MaxVertexAccessed(primcount,
                                                   max_vertex_accessed);
     GLuint num_vertices = max_accessed + 1;
     if (num_vertices == 0) {
       SetGLError(GL_OUT_OF_MEMORY, function_name, "Simulating attrib 0");
       return false;
     }
     if (attrib_info &&
         info->CanAccess(max_accessed) &&
         info->type() == GL_FIXED) {
@@ skipping 14 matching lines @@
       offset += size;
     }
   }
   *simulated = true;
   return true;
 }
 
 void GLES2DecoderImpl::RestoreStateForSimulatedFixedAttribs() {
   // There's no need to call glVertexAttribPointer because we shadow all the
   // settings and passing GL_FIXED to it will not work.
-  glBindBuffer(GL_ARRAY_BUFFER,
-               bound_array_buffer_ ? bound_array_buffer_->service_id() : 0);
+  glBindBuffer(
+      GL_ARRAY_BUFFER,
+      state_.bound_array_buffer ? state_.bound_array_buffer->service_id() : 0);
 }
 
 error::Error GLES2DecoderImpl::DoDrawArrays(
     const char* function_name,
     bool instanced,
     GLenum mode,
     GLint first,
     GLsizei count,
     GLsizei primcount) {
   if (ShouldDeferDraws())
@@ skipping 94 matching lines @@
 error::Error GLES2DecoderImpl::DoDrawElements(
     const char* function_name,
     bool instanced,
     GLenum mode,
     GLsizei count,
     GLenum type,
     int32 offset,
     GLsizei primcount) {
   if (ShouldDeferDraws())
     return error::kDeferCommandUntilLater;
-  if (!vertex_attrib_manager_->element_array_buffer()) {
+  if (!state_.vertex_attrib_manager->element_array_buffer()) {
     SetGLError(GL_INVALID_OPERATION,
                function_name, "No element array buffer bound");
     return error::kNoError;
   }
 
   if (count < 0) {
     SetGLError(GL_INVALID_VALUE, function_name, "count < 0");
     return error::kNoError;
   }
   if (offset < 0) {
@@ skipping 15 matching lines @@
 
   if (!CheckBoundFramebuffersValid(function_name)) {
     return error::kNoError;
   }
 
   if (count == 0 || (instanced && primcount == 0)) {
     return error::kNoError;
   }
 
   GLuint max_vertex_accessed;
-  if (!vertex_attrib_manager_->element_array_buffer()->GetMaxValueForRange(
-      offset, count, type, &max_vertex_accessed)) {
+  if (!state_.vertex_attrib_manager->element_array_buffer(
+      )->GetMaxValueForRange(offset, count, type, &max_vertex_accessed)) {
     SetGLError(GL_INVALID_OPERATION,
                function_name, "range out of bounds for buffer");
     return error::kNoError;
   }
 
   if (IsDrawValid(function_name, max_vertex_accessed, primcount)) {
     if (!ClearUnclearedTextures()) {
       SetGLError(GL_INVALID_VALUE, function_name, "out of memory");
       return error::kNoError;
     }
@@ skipping 321 matching lines @@
       program_client_id, "glValidateProgram");
   if (!info) {
     return;
   }
   info->Validate();
 }
 
 void GLES2DecoderImpl::DoGetVertexAttribfv(
     GLuint index, GLenum pname, GLfloat* params) {
   VertexAttribManager::VertexAttribInfo* info =
-      vertex_attrib_manager_->GetVertexAttribInfo(index);
+      state_.vertex_attrib_manager->GetVertexAttribInfo(index);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glGetVertexAttribfv", "index out of range");
     return;
   }
   switch (pname) {
     case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: {
         BufferManager::BufferInfo* buffer = info->buffer();
         if (buffer && !buffer->IsDeleted()) {
           GLuint client_id;
           buffer_manager()->GetClientId(buffer->service_id(), &client_id);
@@ skipping 27 matching lines @@
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void GLES2DecoderImpl::DoGetVertexAttribiv(
     GLuint index, GLenum pname, GLint* params) {
   VertexAttribManager::VertexAttribInfo* info =
-      vertex_attrib_manager_->GetVertexAttribInfo(index);
+      state_.vertex_attrib_manager->GetVertexAttribInfo(index);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glGetVertexAttribiv", "index out of range");
     return;
   }
   switch (pname) {
     case GL_VERTEX_ATTRIB_ARRAY_BUFFER_BINDING: {
         BufferManager::BufferInfo* buffer = info->buffer();
         if (buffer && !buffer->IsDeleted()) {
           GLuint client_id;
           buffer_manager()->GetClientId(buffer->service_id(), &client_id);
@@ skipping 26 matching lines @@
       params[3] = static_cast<GLint>(info->value().v[3]);
       break;
     default:
       NOTREACHED();
       break;
   }
 }
 
 void GLES2DecoderImpl::DoVertexAttrib1f(GLuint index, GLfloat v0) {
   VertexAttribManager::VertexAttribInfo* info =
-      vertex_attrib_manager_->GetVertexAttribInfo(index);
+      state_.vertex_attrib_manager->GetVertexAttribInfo(index);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glVertexAttrib1f", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v0;
   value.v[1] = 0.0f;
   value.v[2] = 0.0f;
   value.v[3] = 1.0f;
   info->set_value(value);
   glVertexAttrib1f(index, v0);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib2f(GLuint index, GLfloat v0, GLfloat v1) {
   VertexAttribManager::VertexAttribInfo* info =
-      vertex_attrib_manager_->GetVertexAttribInfo(index);
+      state_.vertex_attrib_manager->GetVertexAttribInfo(index);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glVertexAttrib2f", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v0;
   value.v[1] = v1;
   value.v[2] = 0.0f;
   value.v[3] = 1.0f;
   info->set_value(value);
   glVertexAttrib2f(index, v0, v1);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib3f(
     GLuint index, GLfloat v0, GLfloat v1, GLfloat v2) {
   VertexAttribManager::VertexAttribInfo* info =
-      vertex_attrib_manager_->GetVertexAttribInfo(index);
+      state_.vertex_attrib_manager->GetVertexAttribInfo(index);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glVertexAttrib3f", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v0;
   value.v[1] = v1;
   value.v[2] = v2;
   value.v[3] = 1.0f;
   info->set_value(value);
   glVertexAttrib3f(index, v0, v1, v2);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib4f(
     GLuint index, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3) {
   VertexAttribManager::VertexAttribInfo* info =
-      vertex_attrib_manager_->GetVertexAttribInfo(index);
+      state_.vertex_attrib_manager->GetVertexAttribInfo(index);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glVertexAttrib4f", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v0;
   value.v[1] = v1;
   value.v[2] = v2;
   value.v[3] = v3;
   info->set_value(value);
   glVertexAttrib4f(index, v0, v1, v2, v3);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib1fv(GLuint index, const GLfloat* v) {
   VertexAttribManager::VertexAttribInfo* info =
-      vertex_attrib_manager_->GetVertexAttribInfo(index);
+      state_.vertex_attrib_manager->GetVertexAttribInfo(index);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glVertexAttrib1fv", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v[0];
   value.v[1] = 0.0f;
   value.v[2] = 0.0f;
   value.v[3] = 1.0f;
   info->set_value(value);
   glVertexAttrib1fv(index, v);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib2fv(GLuint index, const GLfloat* v) {
   VertexAttribManager::VertexAttribInfo* info =
-      vertex_attrib_manager_->GetVertexAttribInfo(index);
+      state_.vertex_attrib_manager->GetVertexAttribInfo(index);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glVertexAttrib2fv", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v[0];
   value.v[1] = v[1];
   value.v[2] = 0.0f;
   value.v[3] = 1.0f;
   info->set_value(value);
   glVertexAttrib2fv(index, v);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib3fv(GLuint index, const GLfloat* v) {
   VertexAttribManager::VertexAttribInfo* info =
-      vertex_attrib_manager_->GetVertexAttribInfo(index);
+      state_.vertex_attrib_manager->GetVertexAttribInfo(index);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glVertexAttrib3fv", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v[0];
   value.v[1] = v[1];
   value.v[2] = v[2];
   value.v[3] = 1.0f;
   info->set_value(value);
   glVertexAttrib3fv(index, v);
 }
 
 void GLES2DecoderImpl::DoVertexAttrib4fv(GLuint index, const GLfloat* v) {
   VertexAttribManager::VertexAttribInfo* info =
-      vertex_attrib_manager_->GetVertexAttribInfo(index);
+      state_.vertex_attrib_manager->GetVertexAttribInfo(index);
   if (!info) {
     SetGLError(GL_INVALID_VALUE, "glVertexAttrib4fv", "index out of range");
     return;
   }
   VertexAttribManager::VertexAttribInfo::Vec4 value;
   value.v[0] = v[0];
   value.v[1] = v[1];
   value.v[2] = v[2];
   value.v[3] = v[3];
   info->set_value(value);
   glVertexAttrib4fv(index, v);
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribPointer(
     uint32 immediate_data_size, const gles2::VertexAttribPointer& c) {
 
-  if (!bound_array_buffer_ || bound_array_buffer_->IsDeleted()) {
-    if (vertex_attrib_manager_ == default_vertex_attrib_manager_) {
+  if (!state_.bound_array_buffer || state_.bound_array_buffer->IsDeleted()) {
+    if (state_.vertex_attrib_manager == default_vertex_attrib_manager_) {
       SetGLError(GL_INVALID_VALUE,
                 "glVertexAttribPointer", "no array buffer bound");
       return error::kNoError;
     } else if (c.offset != 0) {
       SetGLError(GL_INVALID_VALUE,
                 "glVertexAttribPointer", "client side arrays are not allowed");
       return error::kNoError;
     }
   }
 
@@ skipping 37 matching lines @@
   if (offset % component_size > 0) {
     SetGLError(GL_INVALID_OPERATION,
                "glVertexAttribPointer", "offset not valid for type");
     return error::kNoError;
   }
   if (stride % component_size > 0) {
     SetGLError(GL_INVALID_OPERATION,
                "glVertexAttribPointer", "stride not valid for type");
     return error::kNoError;
   }
-  vertex_attrib_manager_->SetAttribInfo(
+  state_.vertex_attrib_manager->SetAttribInfo(
       indx,
-      bound_array_buffer_,
+      state_.bound_array_buffer,
       size,
       type,
       normalized,
       stride,
       stride != 0 ? stride : component_size * size,
       offset);
   if (type != GL_FIXED) {
     glVertexAttribPointer(indx, size, type, normalized, stride, ptr);
   }
   return error::kNoError;
 }
 
 void GLES2DecoderImpl::DoViewport(GLint x, GLint y, GLsizei width,
                                   GLsizei height) {
-  viewport_x_ = x;
-  viewport_y_ = y;
-  viewport_width_ = std::min(width, viewport_max_width_);
-  viewport_height_ = std::min(height, viewport_max_height_);
+  state_.viewport_x = x;
+  state_.viewport_y = y;
+  state_.viewport_width = std::min(width, state_.viewport_max_width);
+  state_.viewport_height = std::min(height, state_.viewport_max_height);
   glViewport(x, y, width, height);
 }
 
 error::Error GLES2DecoderImpl::HandleVertexAttribDivisorANGLE(
     uint32 immediate_data_size, const gles2::VertexAttribDivisorANGLE& c) {
   if (!feature_info_->feature_flags().angle_instanced_arrays) {
     SetGLError(GL_INVALID_OPERATION,
                "glVertexAttribDivisorANGLE", "function not available");
   }
   GLuint index = c.index;
   GLuint divisor = c.divisor;
   if (index >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE,
                "glVertexAttribDivisorANGLE", "index out of range");
     return error::kNoError;
   }
 
-  vertex_attrib_manager_->SetDivisor(
+  state_.vertex_attrib_manager->SetDivisor(
       index,
       divisor);
   glVertexAttribDivisorANGLE(index, divisor);
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleReadPixels(
     uint32 immediate_data_size, const gles2::ReadPixels& c) {
   GLint x = c.x;
   GLint y = c.y;
   GLsizei width = c.width;
   GLsizei height = c.height;
   GLenum format = c.format;
   GLenum type = c.type;
   if (width < 0 || height < 0) {
     SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions < 0");
     return error::kNoError;
   }
   typedef gles2::ReadPixels::Result Result;
   uint32 pixels_size;
   if (!GLES2Util::ComputeImageDataSizes(
-      width, height, format, type, pack_alignment_, &pixels_size, NULL, NULL)) {
+      width, height, format, type, state_.pack_alignment, &pixels_size,
+      NULL, NULL)) {
     return error::kOutOfBounds;
   }
   void* pixels = GetSharedMemoryAs<void*>(
       c.pixels_shm_id, c.pixels_shm_offset, pixels_size);
   Result* result = GetSharedMemoryAs<Result*>(
         c.result_shm_id, c.result_shm_offset, sizeof(*result));
   if (!pixels || !result) {
     return error::kOutOfBounds;
   }
 
@@ skipping 27 matching lines @@
 
   ScopedResolvedFrameBufferBinder binder(this, false, true);
 
   if (x < 0 || y < 0 || max_x > max_size.width() || max_y > max_size.height()) {
     // The user requested an out of range area. Get the results 1 line
     // at a time.
     uint32 temp_size;
     uint32 unpadded_row_size;
     uint32 padded_row_size;
     if (!GLES2Util::ComputeImageDataSizes(
-        width, 2, format, type, pack_alignment_, &temp_size,
+        width, 2, format, type, state_.pack_alignment, &temp_size,
         &unpadded_row_size, &padded_row_size)) {
       SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions out of range");
       return error::kNoError;
     }
 
     GLint dest_x_offset = std::max(-x, 0);
     uint32 dest_row_offset;
     if (!GLES2Util::ComputeImageDataSizes(
-        dest_x_offset, 1, format, type, pack_alignment_, &dest_row_offset, NULL,
-        NULL)) {
+        dest_x_offset, 1, format, type, state_.pack_alignment, &dest_row_offset,
+        NULL, NULL)) {
       SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions out of range");
       return error::kNoError;
     }
 
     // Copy each row into the larger dest rect.
     int8* dst = static_cast<int8*>(pixels);
     GLint read_x = std::max(0, x);
     GLint read_end_x = std::max(0, std::min(max_size.width(), max_x));
     GLint read_width = read_end_x - read_x;
     for (GLint yy = 0; yy < height; ++yy) {
@@ skipping 19 matching lines @@
     GLenum read_format = GetBoundReadFrameBufferInternalFormat();
     uint32 channels_exist = GLES2Util::GetChannelsForFormat(read_format);
     if ((channels_exist & 0x0008) == 0 &&
         !feature_info_->feature_flags().disable_workarounds) {
       // Set the alpha to 255 because some drivers are buggy in this regard.
       uint32 temp_size;
 
       uint32 unpadded_row_size;
       uint32 padded_row_size;
       if (!GLES2Util::ComputeImageDataSizes(
-          width, 2, format, type, pack_alignment_, &temp_size,
+          width, 2, format, type, state_.pack_alignment, &temp_size,
           &unpadded_row_size, &padded_row_size)) {
         SetGLError(GL_INVALID_VALUE, "glReadPixels", "dimensions out of range");
         return error::kNoError;
       }
       // NOTE: Assumes the type is GL_UNSIGNED_BYTE which was true at the time
       // of this implementation.
       if (type != GL_UNSIGNED_BYTE) {
         SetGLError(
             GL_INVALID_OPERATION, "glReadPixels",
             "unsupported readPixel format");
@@ skipping 49 matching lines @@
         return error::kNoError;
     case GL_UNPACK_UNPREMULTIPLY_ALPHA_CHROMIUM:
         unpack_unpremultiply_alpha_ = (param != 0);
         return error::kNoError;
     default:
         break;
   }
   glPixelStorei(pname, param);
   switch (pname) {
     case GL_PACK_ALIGNMENT:
-        pack_alignment_ = param;
+        state_.pack_alignment = param;
         break;
     case GL_PACK_REVERSE_ROW_ORDER_ANGLE:
         break;
     case GL_UNPACK_ALIGNMENT:
-        unpack_alignment_ = param;
+        state_.unpack_alignment = param;
         break;
     default:
         // Validation should have prevented us from getting here.
         NOTREACHED();
         break;
   }
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandlePostSubBufferCHROMIUM(
@@ skipping 337 matching lines @@
         framebuffer ? framebuffer->service_id() : GetBackbufferServiceId();
     glBindFramebufferEXT(GL_DRAW_FRAMEBUFFER_EXT, fb_service_id);
     return true;
   }
 
   static const uint32 kMaxZeroSize = 1024 * 1024 * 4;
 
   uint32 size;
   uint32 padded_row_size;
   if (!GLES2Util::ComputeImageDataSizes(
-          width, height, format, type, unpack_alignment_, &size,
+          width, height, format, type, state_.unpack_alignment, &size,
           NULL, &padded_row_size)) {
     return false;
   }
 
   TRACE_EVENT1("gpu", "GLES2DecoderImpl::ClearLevel", "size", size);
 
   int tile_height;
 
   if (size > kMaxZeroSize) {
     if (kMaxZeroSize < padded_row_size) {
         // That'd be an awfully large texture.
         return false;
     }
     // We should never have a large total size with a zero row size.
     DCHECK_GT(padded_row_size, 0U);
     tile_height = kMaxZeroSize / padded_row_size;
     if (!GLES2Util::ComputeImageDataSizes(
-            width, tile_height, format, type, unpack_alignment_, &size, NULL,
-            NULL)) {
+            width, tile_height, format, type, state_.unpack_alignment, &size,
+            NULL, NULL)) {
       return false;
     }
   } else {
     tile_height = height;
   }
 
   // Assumes the size has already been checked.
   scoped_array<char> zero(new char[size]);
   memset(zero.get(), 0, size);
   glBindTexture(bind_target, service_id);
@@ skipping 476 matching lines @@
   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);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 pixels_shm_id = static_cast<uint32>(c.pixels_shm_id);
   uint32 pixels_shm_offset = static_cast<uint32>(c.pixels_shm_offset);
   uint32 pixels_size;
   if (!GLES2Util::ComputeImageDataSizes(
-      width, height, format, type, unpack_alignment_, &pixels_size, NULL,
+      width, height, format, type, state_.unpack_alignment, &pixels_size, NULL,
       NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = NULL;
   if (pixels_shm_id != 0 || pixels_shm_offset != 0) {
     pixels = GetSharedMemoryAs<const void*>(
         pixels_shm_id, pixels_shm_offset, pixels_size);
     if (!pixels) {
       return error::kOutOfBounds;
     }
   }
   return DoTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels, pixels_size);
 }
 
 error::Error GLES2DecoderImpl::HandleTexImage2DImmediate(
     uint32 immediate_data_size, const gles2::TexImage2DImmediate& c) {
   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);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 size;
   if (!GLES2Util::ComputeImageDataSizes(
-      width, height, format, type, unpack_alignment_, &size, NULL, NULL)) {
+      width, height, format, type, state_.unpack_alignment, &size,
+      NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetImmediateDataAs<const void*>(
       c, size, immediate_data_size);
   if (!pixels) {
     return error::kOutOfBounds;
   }
   DoTexImage2D(
       target, level, internal_format, width, height, border, format, type,
       pixels, size);
@@ skipping 235 matching lines @@
     return;
   }
 
   if (copyX != x ||
       copyY != y ||
       copyWidth != width ||
       copyHeight != height) {
     // some part was clipped so clear the sub rect.
     uint32 pixels_size = 0;
     if (!GLES2Util::ComputeImageDataSizes(
-        width, height, format, type, unpack_alignment_, &pixels_size, NULL,
-        NULL)) {
+        width, height, format, type, state_.unpack_alignment, &pixels_size,
+        NULL, NULL)) {
       SetGLError(
           GL_INVALID_VALUE, "glCopyTexSubImage2D", "dimensions too large");
       return;
     }
     scoped_array<char> zero(new char[pixels_size]);
     memset(zero.get(), 0, pixels_size);
     glTexSubImage2D(
         target, level, xoffset, yoffset, width, height,
         format, type, zero.get());
   }
@@ skipping 97 matching lines @@
   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);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 data_size;
   if (!GLES2Util::ComputeImageDataSizes(
-      width, height, format, type, unpack_alignment_, &data_size, NULL, NULL)) {
+      width, height, format, type, state_.unpack_alignment, &data_size,
+      NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetSharedMemoryAs<const void*>(
       c.pixels_shm_id, c.pixels_shm_offset, data_size);
   if (!validators_->texture_target.IsValid(target)) {
     SetGLErrorInvalidEnum("glTexSubImage2D", target, "target");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "width < 0");
@@ skipping 28 matching lines @@
   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);
   GLsizei width = static_cast<GLsizei>(c.width);
   GLsizei height = static_cast<GLsizei>(c.height);
   GLenum format = static_cast<GLenum>(c.format);
   GLenum type = static_cast<GLenum>(c.type);
   uint32 data_size;
   if (!GLES2Util::ComputeImageDataSizes(
-      width, height, format, type, unpack_alignment_, &data_size, NULL, NULL)) {
+      width, height, format, type, state_.unpack_alignment, &data_size,
+      NULL, NULL)) {
     return error::kOutOfBounds;
   }
   const void* pixels = GetImmediateDataAs<const void*>(
       c, data_size, immediate_data_size);
   if (!validators_->texture_target.IsValid(target)) {
     SetGLErrorInvalidEnum("glTexSubImage2D", target, "target");
     return error::kNoError;
   }
   if (width < 0) {
     SetGLError(GL_INVALID_VALUE, "glTexSubImage2D", "width < 0");
@@ skipping 37 matching lines @@
     SetGLErrorInvalidEnum("glGetVertexAttribPointerv", pname, "pname");
     return error::kNoError;
   }
   if (index >= group_->max_vertex_attribs()) {
     SetGLError(GL_INVALID_VALUE,
                "glGetVertexAttribPointerv", "index out of range.");
     return error::kNoError;
   }
   result->SetNumResults(1);
   *result->GetData() =
-      vertex_attrib_manager_->GetVertexAttribInfo(index)->offset();
+      state_.vertex_attrib_manager->GetVertexAttribInfo(index)->offset();
   return error::kNoError;
 }
 
 bool GLES2DecoderImpl::GetUniformSetup(
     GLuint program, GLint fake_location,
     uint32 shm_id, uint32 shm_offset,
     error::Error* error, GLint* real_location,
     GLuint* service_id, void** result_pointer, GLenum* result_type) {
   DCHECK(error);
   DCHECK(service_id);
@@ skipping 631 matching lines @@
   }
   // NOTE: We don't generate Query objects here. Only in BeginQueryEXT
   return true;
 }
 
 void GLES2DecoderImpl::DeleteQueriesEXTHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     QueryManager::Query* query = query_manager_->GetQuery(client_ids[ii]);
     if (query && !query->IsDeleted()) {
-      if (query == current_query_) {
-        current_query_ = NULL;
+      if (query == state_.current_query) {
+        state_.current_query = NULL;
       }
       query->Destroy(true);
       query_manager_->RemoveQuery(client_ids[ii]);
     }
   }
 }
 
 bool GLES2DecoderImpl::ProcessPendingQueries() {
   if (query_manager_.get() == NULL) {
     return false;
@@ skipping 15 matching lines @@
     case GL_COMMANDS_ISSUED_CHROMIUM:
       break;
     default:
       if (!feature_info_->feature_flags().occlusion_query_boolean) {
         SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT", "not enabled");
         return error::kNoError;
       }
       break;
   }
 
-  if (current_query_) {
+  if (state_.current_query) {
     SetGLError(
         GL_INVALID_OPERATION, "glBeginQueryEXT", "query already in progress");
     return error::kNoError;
   }
 
   if (client_id == 0) {
     SetGLError(GL_INVALID_OPERATION, "glBeginQueryEXT", "id is 0");
     return error::kNoError;
   }
 
@@ skipping 27 matching lines @@
   } else if (query->shm_id() != sync_shm_id ||
              query->shm_offset() != sync_shm_offset) {
     DLOG(ERROR) << "Shared memory used by query not the same as before";
     return error::kInvalidArguments;
   }
 
   if (!query_manager_->BeginQuery(query)) {
     return error::kOutOfBounds;
   }
 
-  current_query_ = query;
+  state_.current_query = query;
   return error::kNoError;
 }
 
 error::Error GLES2DecoderImpl::HandleEndQueryEXT(
     uint32 immediate_data_size, const gles2::EndQueryEXT& c) {
   GLenum target = static_cast<GLenum>(c.target);
   uint32 submit_count = static_cast<GLuint>(c.submit_count);
 
-  if (!current_query_) {
+  if (!state_.current_query) {
     SetGLError(GL_INVALID_OPERATION, "glEndQueryEXT", "No active query");
     return error::kNoError;
   }
-  if (current_query_->target() != target) {
+  if (state_.current_query->target() != target) {
     SetGLError(GL_INVALID_OPERATION,
                "glEndQueryEXT", "target does not match active query");
     return error::kNoError;
   }
 
-  if (!query_manager_->EndQuery(current_query_, submit_count)) {
+  if (!query_manager_->EndQuery(state_.current_query, submit_count)) {
     return error::kOutOfBounds;
   }
 
-  current_query_ = NULL;
+  state_.current_query = NULL;
   return error::kNoError;
 }
 
 bool GLES2DecoderImpl::GenVertexArraysOESHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     if (GetVertexAttribManager(client_ids[ii])) {
       return false;
     }
   }
@@ skipping 14 matching lines @@
 
   return true;
 }
 
 void GLES2DecoderImpl::DeleteVertexArraysOESHelper(
     GLsizei n, const GLuint* client_ids) {
   for (GLsizei ii = 0; ii < n; ++ii) {
     VertexAttribManager* vao =
         GetVertexAttribManager(client_ids[ii]);
     if (vao && !vao->IsDeleted()) {
-      if (vertex_attrib_manager_ == vao) {
-        vertex_attrib_manager_ = default_vertex_attrib_manager_;
+      if (state_.vertex_attrib_manager == vao) {
+        state_.vertex_attrib_manager = default_vertex_attrib_manager_;
       }
       RemoveVertexAttribManager(client_ids[ii]);
     }
   }
 }
 
 void GLES2DecoderImpl::DoBindVertexArrayOES(GLuint client_id) {
   VertexAttribManager* vao = NULL;
   GLuint service_id = 0;
   if (client_id != 0) {
     vao = GetVertexAttribManager(client_id);
     if (!vao) {
       // Unlike most Bind* methods, the spec explicitly states that VertexArray
       // only allows names that have been previously generated. As such, we do
       // not generate new names here.
       SetGLError(GL_INVALID_OPERATION,
           "glBindVertexArrayOES", ""
           "bad vertex array id.");
       current_decoder_error_ = error::kNoError;
       return;
     } else {
       service_id = vao->service_id();
     }
   } else {
     vao = default_vertex_attrib_manager_;
   }
 
   // Only set the VAO state if it's changed
-  if (vertex_attrib_manager_ != vao) {
-    vertex_attrib_manager_ = vao;
+  if (state_.vertex_attrib_manager != vao) {
+    state_.vertex_attrib_manager = vao;
     if (!feature_info_->feature_flags().native_vertex_array_object_) {
       EmulateVertexArrayState();
     } else {
       glBindVertexArrayOES(service_id);
     }
   }
 }
 
 // Used when OES_vertex_array_object isn't natively supported
 void GLES2DecoderImpl::EmulateVertexArrayState() {
   // Setup the Vertex attribute state
   for (uint32 vv = 0; vv < group_->max_vertex_attribs(); ++vv) {
     RestoreStateForAttrib(vv);
   }
 
   // Setup the element buffer
   BufferManager::BufferInfo* element_array_buffer =
-      vertex_attrib_manager_->element_array_buffer();
+      state_.vertex_attrib_manager->element_array_buffer();
   glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,
       element_array_buffer ? element_array_buffer->service_id() : 0);
 }
 
 bool GLES2DecoderImpl::DoIsVertexArrayOES(GLuint client_id) {
   const VertexAttribManager* vao =
       GetVertexAttribManager(client_id);
   return vao && vao->IsValid() && !vao->IsDeleted();
 }
 
@@ skipping 318 matching lines @@
     texture_manager()->SetLevelCleared(dest_info, GL_TEXTURE_2D, level);
   }
 
   state_dirty_ = true;
   glViewport(0, 0, source_width, source_height);
   copy_texture_CHROMIUM_->DoCopyTexture(target, source_info->service_id(),
                                         dest_info->service_id(), level,
                                         unpack_flip_y_,
                                         unpack_premultiply_alpha_,
                                         unpack_unpremultiply_alpha_);
-  glViewport(viewport_x_, viewport_y_, viewport_width_, viewport_height_);
+  glViewport(
+      state_.viewport_x, state_.viewport_y,
+      state_.viewport_width, state_.viewport_height);
 
   // Restore all of the state touched by the extension.
-  if (current_program_)
-    glUseProgram(current_program_->service_id());
+  if (state_.current_program)
+    glUseProgram(state_.current_program->service_id());
   else
     glUseProgram(0);
 
   RestoreCurrentFramebufferBindings();
   RestoreCurrentTexture2DBindings();
   RestoreStateForAttrib(
       CopyTextureCHROMIUMResourceManager::kVertexPositionAttrib);
   RestoreStateForAttrib(
       CopyTextureCHROMIUMResourceManager::kVertexTextureAttrib);
 
@@ skipping 187 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 "gpu/command_buffer/service/gles2_cmd_decoder_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu