Fix querying GLfloat state

It used to be only state that was an int
was cached. Now that all state is cached
I needed add code getting GLfloat state
as a GLfloat

BUG=155557,158607


Review URL: https://chromiumcodereview.appspot.com/11355005

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@165121 0039d316-1c4b-4281-b951-d872f2087c98

5 files changed, 462 insertions, 138 deletions

diff --git a/gpu/command_buffer/build_gles2_cmd_buffer.py b/gpu/command_buffer/build_gles2_cmd_buffer.py
index 8a56eb8..1a1deed 100755
--- a/gpu/command_buffer/build_gles2_cmd_buffer.py
+++ b/gpu/command_buffer/build_gles2_cmd_buffer.py
@@ -370,26 +370,26 @@ _STATES = {
       # NOTE: These defaults reset at GLES2DecoderImpl::Initialization.
       {
         'name': 'scissor_x',
-        'type': 'GLfloat',
-        'default': '0.0f',
+        'type': 'GLint',
+        'default': '0',
         'expected': 'kViewportX',
       },
       {
         'name': 'scissor_y',
-        'type': 'GLfloat',
-        'default': '0.0f',
+        'type': 'GLint',
+        'default': '0',
         'expected': 'kViewportY',
       },
       {
         'name': 'scissor_width',
-        'type': 'GLfloat',
-        'default': '1.0f',
+        'type': 'GLsizei',
+        'default': '1',
         'expected': 'kViewportWidth',
       },
       {
         'name': 'scissor_height',
-        'type': 'GLfloat',
-        'default': '1.0f',
+        'type': 'GLsizei',
+        'default': '1',
         'expected': 'kViewportHeight',
       },
     ],
@@ -402,26 +402,26 @@ _STATES = {
       # NOTE: These defaults reset at GLES2DecoderImpl::Initialization.
       {
         'name': 'viewport_x',
-        'type': 'GLfloat',
-        'default': '0.0f',
+        'type': 'GLint',
+        'default': '0',
         'expected': 'kViewportX',
       },
       {
         'name': 'viewport_y',
-        'type': 'GLfloat',
-        'default': '0.0f',
+        'type': 'GLint',
+        'default': '0',
         'expected': 'kViewportY',
       },
       {
         'name': 'viewport_width',
-        'type': 'GLfloat',
-        'default': '1.0f',
+        'type': 'GLsizei',
+        'default': '1',
         'expected': 'kViewportWidth',
       },
       {
         'name': 'viewport_height',
-        'type': 'GLfloat',
-        'default': '1.0f',
+        'type': 'GLsizei',
+        'default': '1',
         'expected': 'kViewportHeight',
       },
     ],
@@ -1973,6 +1973,10 @@ _FUNCTION_INFO = {
                   'GLsizei stride, GLuint offset',
       'client_test': False,
   },
+  'Scissor': {
+    'type': 'StateSet',
+    'state': 'Scissor',
+  },
   'Viewport': {
     'decoder_func': 'DoViewport',
   },
@@ -6603,38 +6607,43 @@ bool GLES2DecoderImpl::DoIsEnabled(GLenum cap) {
       return false;
   }
 }
-
-bool GLES2DecoderImpl::GetState(
-    GLenum pname, GLint* params, GLsizei* num_written) {
-  switch (pname) {
 """)
-    for state_name in _STATES.keys():
-      state = _STATES[state_name]
-      if 'enum' in state:
-        file.Write("    case %s:\n" % state['enum'])
-        file.Write("      *num_written = %d;\n" % len(state['states']))
-        file.Write("      if (params) {\n")
-        for ndx,item in enumerate(state['states']):
-          file.Write("        params[%d] = state_.%s;\n" % (ndx, item['name']))
-        file.Write("      }\n")
-        file.Write("      return true;\n")
-      else:
-        for item in state['states']:
-          file.Write("    case %s:\n" % item['enum'])
-          file.Write("      *num_written = 1;\n")
-          file.Write("      if (params) {\n")
-          file.Write("        params[0] = state_.%s;\n" % item['name'])
-          file.Write("      }\n")
-          file.Write("      return true;\n")
-    for capability in _CAPABILITY_FLAGS:
-          file.Write("    case GL_%s:\n" % capability['name'].upper())
-          file.Write("      *num_written = 1;\n")
+    for gl_type in ["GLint", "GLfloat"]:
+      file.Write("""
+bool GLES2DecoderImpl::GetStateAs%s(
+    GLenum pname, %s* params, GLsizei* num_written) {
+  switch (pname) {
+""" % (gl_type, gl_type))
+      for state_name in _STATES.keys():
+        state = _STATES[state_name]
+        if 'enum' in state:
+          file.Write("    case %s:\n" % state['enum'])
+          file.Write("      *num_written = %d;\n" % len(state['states']))
           file.Write("      if (params) {\n")
-          file.Write("        params[0] = state_.enable_flags.%s;\n" %
-                     capability['name'])
+          for ndx,item in enumerate(state['states']):
+            file.Write("        params[%d] = static_cast<%s>(state_.%s);\n" %
+                       (ndx, gl_type, item['name']))
           file.Write("      }\n")
           file.Write("      return true;\n")
-    file.Write("""    default:
+        else:
+          for item in state['states']:
+            file.Write("    case %s:\n" % item['enum'])
+            file.Write("      *num_written = 1;\n")
+            file.Write("      if (params) {\n")
+            file.Write("        params[0] = static_cast<%s>(state_.%s);\n" %
+                       (gl_type, item['name']))
+            file.Write("      }\n")
+            file.Write("      return true;\n")
+      for capability in _CAPABILITY_FLAGS:
+            file.Write("    case GL_%s:\n" % capability['name'].upper())
+            file.Write("      *num_written = 1;\n")
+            file.Write("      if (params) {\n")
+            file.Write("        params[0] = static_cast<%s>("
+                       "state_.enable_flags.%s);\n" %
+                       (gl_type, capability['name']))
+            file.Write("      }\n")
+            file.Write("      return true;\n")
+      file.Write("""    default:
       return false;
   }
 }
diff --git a/gpu/command_buffer/service/context_state_autogen.h b/gpu/command_buffer/service/context_state_autogen.h
index 85835b1..ef4996b 100644
--- a/gpu/command_buffer/service/context_state_autogen.h
+++ b/gpu/command_buffer/service/context_state_autogen.h
@@ -54,10 +54,10 @@ GLfloat polygon_offset_factor;
 GLfloat polygon_offset_units;
 GLclampf sample_coverage_value;
 GLboolean sample_coverage_invert;
-GLfloat scissor_x;
-GLfloat scissor_y;
-GLfloat scissor_width;
-GLfloat scissor_height;
+GLint scissor_x;
+GLint scissor_y;
+GLsizei scissor_width;
+GLsizei scissor_height;
 GLenum stencil_front_func;
 GLint stencil_front_ref;
 GLuint stencil_front_mask;
@@ -72,10 +72,10 @@ GLenum stencil_front_z_pass_op;
 GLenum stencil_back_fail_op;
 GLenum stencil_back_z_fail_op;
 GLenum stencil_back_z_pass_op;
-GLfloat viewport_x;
-GLfloat viewport_y;
-GLfloat viewport_width;
-GLfloat viewport_height;
+GLint viewport_x;
+GLint viewport_y;
+GLsizei viewport_width;
+GLsizei viewport_height;
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_CONTEXT_STATE_AUTOGEN_H_
 
diff --git a/gpu/command_buffer/service/context_state_impl_autogen.h b/gpu/command_buffer/service/context_state_impl_autogen.h
index a930259..ed9350d 100644
--- a/gpu/command_buffer/service/context_state_impl_autogen.h
+++ b/gpu/command_buffer/service/context_state_impl_autogen.h
@@ -54,10 +54,10 @@ void ContextState::Initialize() {
   polygon_offset_units = 0.0f;
   sample_coverage_value = 1.0f;
   sample_coverage_invert = false;
-  scissor_x = 0.0f;
-  scissor_y = 0.0f;
-  scissor_width = 1.0f;
-  scissor_height = 1.0f;
+  scissor_x = 0;
+  scissor_y = 0;
+  scissor_width = 1;
+  scissor_height = 1;
   stencil_front_func = GL_ALWAYS;
   stencil_front_ref = 0;
   stencil_front_mask = 0xFFFFFFFFU;
@@ -72,10 +72,10 @@ void ContextState::Initialize() {
   stencil_back_fail_op = GL_KEEP;
   stencil_back_z_fail_op = GL_KEEP;
   stencil_back_z_pass_op = GL_KEEP;
-  viewport_x = 0.0f;
-  viewport_y = 0.0f;
-  viewport_width = 1.0f;
-  viewport_height = 1.0f;
+  viewport_x = 0;
+  viewport_y = 0;
+  viewport_width = 1;
+  viewport_height = 1;
 }
 
 void ContextState::InitCapabilities() {
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder.cc b/gpu/command_buffer/service/gles2_cmd_decoder.cc
index ca0b4e9..1ad7cba 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder.cc
+++ b/gpu/command_buffer/service/gles2_cmd_decoder.cc
@@ -972,7 +972,8 @@ class GLES2DecoderImpl : public base::SupportsWeakPtr<GLES2DecoderImpl>,
   // Helper for glGetBooleanv, glGetFloatv and glGetIntegerv
   bool GetHelper(GLenum pname, GLint* params, GLsizei* num_written);
   // Same as GetHelper except for auto-generated state.
-  bool GetState(GLenum pname, GLint* params, GLsizei* num_written);
+  bool GetStateAsGLint(GLenum pname, GLint* params, GLsizei* num_written);
+  bool GetStateAsGLfloat(GLenum pname, GLfloat* params, GLsizei* num_written);
 
   // Wrapper for glCreateProgram
   bool CreateProgramHelper(GLuint client_id);
@@ -3587,9 +3588,6 @@ bool GLES2DecoderImpl::GetHelper(
         return true;
       }
   }
-  if (GetState(pname, params, num_written)) {
-    return true;
-  }
   switch (pname) {
     case GL_MAX_VIEWPORT_DIMS:
       if (offscreen_target_frame_buffer_.get()) {
@@ -3851,15 +3849,20 @@ bool GLES2DecoderImpl::GetHelper(
 
 bool GLES2DecoderImpl::GetNumValuesReturnedForGLGet(
     GLenum pname, GLsizei* num_values) {
+  if (GetStateAsGLint(pname, NULL, num_values)) {
+    return true;
+  }
   return GetHelper(pname, NULL, num_values);
 }
 
 void GLES2DecoderImpl::DoGetBooleanv(GLenum pname, GLboolean* params) {
   DCHECK(params);
   GLsizei num_written = 0;
-  if (GetHelper(pname, NULL, &num_written)) {
+  if (GetNumValuesReturnedForGLGet(pname, &num_written)) {
     scoped_array<GLint> values(new GLint[num_written]);
-    GetHelper(pname, values.get(), &num_written);
+    if (!GetStateAsGLint(pname, values.get(), &num_written)) {
+      GetHelper(pname, values.get(), &num_written);
+    }
     for (GLsizei ii = 0; ii < num_written; ++ii) {
       params[ii] = static_cast<GLboolean>(values[ii]);
     }
@@ -3871,21 +3874,24 @@ void GLES2DecoderImpl::DoGetBooleanv(GLenum pname, GLboolean* params) {
 void GLES2DecoderImpl::DoGetFloatv(GLenum pname, GLfloat* params) {
   DCHECK(params);
   GLsizei num_written = 0;
-  if (GetHelper(pname, NULL, &num_written)) {
-    scoped_array<GLint> values(new GLint[num_written]);
-    GetHelper(pname, values.get(), &num_written);
-    for (GLsizei ii = 0; ii < num_written; ++ii) {
-      params[ii] = static_cast<GLfloat>(values[ii]);
+  if (!GetStateAsGLfloat(pname, params, &num_written)) {
+    if (GetHelper(pname, NULL, &num_written)) {
+      scoped_array<GLint> values(new GLint[num_written]);
+      GetHelper(pname, values.get(), &num_written);
+      for (GLsizei ii = 0; ii < num_written; ++ii) {
+        params[ii] = static_cast<GLfloat>(values[ii]);
+      }
+    } else {
+      glGetFloatv(pname, params);
     }
-  } else {
-    glGetFloatv(pname, params);
   }
 }
 
 void GLES2DecoderImpl::DoGetIntegerv(GLenum pname, GLint* params) {
   DCHECK(params);
   GLsizei num_written;
-  if (!GetHelper(pname, params, &num_written)) {
+  if (!GetStateAsGLint(pname, params, &num_written) &&
+      !GetHelper(pname, params, &num_written)) {
     glGetIntegerv(pname, params);
   }
 }
@@ -8385,7 +8391,8 @@ error::Error GLES2DecoderImpl::HandleGetMultipleIntegervCHROMIUM(
   GLint* start = results;
   for (GLuint ii = 0; ii < count; ++ii) {
     GLsizei num_written = 0;
-    if (!GetHelper(enums[ii], results, &num_written)) {
+    if (!GetStateAsGLint(enums[ii], results, &num_written) &&
+        !GetHelper(enums[ii], results, &num_written)) {
       glGetIntegerv(enums[ii], results);
     }
     results += num_written;
diff --git a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
index 9939b6c..9512a79 100644
--- a/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
+++ b/gpu/command_buffer/service/gles2_cmd_decoder_autogen.h
@@ -1507,6 +1507,10 @@ error::Error GLES2DecoderImpl::HandleScissor(
     SetGLError(GL_INVALID_VALUE, "glScissor", "height < 0");
     return error::kNoError;
   }
+  state_.scissor_x = x;
+  state_.scissor_y = y;
+  state_.scissor_width = width;
+  state_.scissor_height = height;
   glScissor(x, y, width, height);
   return error::kNoError;
 }
@@ -3036,299 +3040,603 @@ bool GLES2DecoderImpl::DoIsEnabled(GLenum cap) {
   }
 }
 
-bool GLES2DecoderImpl::GetState(
+bool GLES2DecoderImpl::GetStateAsGLint(
     GLenum pname, GLint* params, GLsizei* num_written) {
   switch (pname) {
     case GL_VIEWPORT:
       *num_written = 4;
       if (params) {
-        params[0] = state_.viewport_x;
-        params[1] = state_.viewport_y;
-        params[2] = state_.viewport_width;
-        params[3] = state_.viewport_height;
+        params[0] = static_cast<GLint>(state_.viewport_x);
+        params[1] = static_cast<GLint>(state_.viewport_y);
+        params[2] = static_cast<GLint>(state_.viewport_width);
+        params[3] = static_cast<GLint>(state_.viewport_height);
       }
       return true;
     case GL_BLEND_SRC_RGB:
       *num_written = 1;
       if (params) {
-        params[0] = state_.blend_source_rgb;
+        params[0] = static_cast<GLint>(state_.blend_source_rgb);
       }
       return true;
     case GL_BLEND_DST_RGB:
       *num_written = 1;
       if (params) {
-        params[0] = state_.blend_dest_rgb;
+        params[0] = static_cast<GLint>(state_.blend_dest_rgb);
       }
       return true;
     case GL_BLEND_SRC_ALPHA:
       *num_written = 1;
       if (params) {
-        params[0] = state_.blend_source_alpha;
+        params[0] = static_cast<GLint>(state_.blend_source_alpha);
       }
       return true;
     case GL_BLEND_DST_ALPHA:
       *num_written = 1;
       if (params) {
-        params[0] = state_.blend_dest_alpha;
+        params[0] = static_cast<GLint>(state_.blend_dest_alpha);
       }
       return true;
     case GL_LINE_WIDTH:
       *num_written = 1;
       if (params) {
-        params[0] = state_.line_width;
+        params[0] = static_cast<GLint>(state_.line_width);
       }
       return true;
     case GL_BLEND_COLOR:
       *num_written = 4;
       if (params) {
-        params[0] = state_.blend_color_red;
-        params[1] = state_.blend_color_green;
-        params[2] = state_.blend_color_blue;
-        params[3] = state_.blend_color_alpha;
+        params[0] = static_cast<GLint>(state_.blend_color_red);
+        params[1] = static_cast<GLint>(state_.blend_color_green);
+        params[2] = static_cast<GLint>(state_.blend_color_blue);
+        params[3] = static_cast<GLint>(state_.blend_color_alpha);
       }
       return true;
     case GL_STENCIL_CLEAR_VALUE:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_clear;
+        params[0] = static_cast<GLint>(state_.stencil_clear);
       }
       return true;
     case GL_COLOR_WRITEMASK:
       *num_written = 4;
       if (params) {
-        params[0] = state_.color_mask_red;
-        params[1] = state_.color_mask_green;
-        params[2] = state_.color_mask_blue;
-        params[3] = state_.color_mask_alpha;
+        params[0] = static_cast<GLint>(state_.color_mask_red);
+        params[1] = static_cast<GLint>(state_.color_mask_green);
+        params[2] = static_cast<GLint>(state_.color_mask_blue);
+        params[3] = static_cast<GLint>(state_.color_mask_alpha);
       }
       return true;
     case GL_COLOR_CLEAR_VALUE:
       *num_written = 4;
       if (params) {
-        params[0] = state_.color_clear_red;
-        params[1] = state_.color_clear_green;
-        params[2] = state_.color_clear_blue;
-        params[3] = state_.color_clear_alpha;
+        params[0] = static_cast<GLint>(state_.color_clear_red);
+        params[1] = static_cast<GLint>(state_.color_clear_green);
+        params[2] = static_cast<GLint>(state_.color_clear_blue);
+        params[3] = static_cast<GLint>(state_.color_clear_alpha);
       }
       return true;
     case GL_DEPTH_RANGE:
       *num_written = 2;
       if (params) {
-        params[0] = state_.z_near;
-        params[1] = state_.z_far;
+        params[0] = static_cast<GLint>(state_.z_near);
+        params[1] = static_cast<GLint>(state_.z_far);
       }
       return true;
     case GL_DEPTH_CLEAR_VALUE:
       *num_written = 1;
       if (params) {
-        params[0] = state_.depth_clear;
+        params[0] = static_cast<GLint>(state_.depth_clear);
       }
       return true;
     case GL_STENCIL_FAIL:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_front_fail_op;
+        params[0] = static_cast<GLint>(state_.stencil_front_fail_op);
       }
       return true;
     case GL_STENCIL_PASS_DEPTH_FAIL:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_front_z_fail_op;
+        params[0] = static_cast<GLint>(state_.stencil_front_z_fail_op);
       }
       return true;
     case GL_STENCIL_PASS_DEPTH_PASS:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_front_z_pass_op;
+        params[0] = static_cast<GLint>(state_.stencil_front_z_pass_op);
       }
       return true;
     case GL_STENCIL_BACK_FAIL:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_back_fail_op;
+        params[0] = static_cast<GLint>(state_.stencil_back_fail_op);
       }
       return true;
     case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_back_z_fail_op;
+        params[0] = static_cast<GLint>(state_.stencil_back_z_fail_op);
       }
       return true;
     case GL_STENCIL_BACK_PASS_DEPTH_PASS:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_back_z_pass_op;
+        params[0] = static_cast<GLint>(state_.stencil_back_z_pass_op);
       }
       return true;
     case GL_SCISSOR_BOX:
       *num_written = 4;
       if (params) {
-        params[0] = state_.scissor_x;
-        params[1] = state_.scissor_y;
-        params[2] = state_.scissor_width;
-        params[3] = state_.scissor_height;
+        params[0] = static_cast<GLint>(state_.scissor_x);
+        params[1] = static_cast<GLint>(state_.scissor_y);
+        params[2] = static_cast<GLint>(state_.scissor_width);
+        params[3] = static_cast<GLint>(state_.scissor_height);
       }
       return true;
     case GL_FRONT_FACE:
       *num_written = 1;
       if (params) {
-        params[0] = state_.front_face;
+        params[0] = static_cast<GLint>(state_.front_face);
       }
       return true;
     case GL_SAMPLE_COVERAGE_VALUE:
       *num_written = 1;
       if (params) {
-        params[0] = state_.sample_coverage_value;
+        params[0] = static_cast<GLint>(state_.sample_coverage_value);
       }
       return true;
     case GL_SAMPLE_COVERAGE_INVERT:
       *num_written = 1;
       if (params) {
-        params[0] = state_.sample_coverage_invert;
+        params[0] = static_cast<GLint>(state_.sample_coverage_invert);
       }
       return true;
     case GL_POLYGON_OFFSET_FACTOR:
       *num_written = 1;
       if (params) {
-        params[0] = state_.polygon_offset_factor;
+        params[0] = static_cast<GLint>(state_.polygon_offset_factor);
       }
       return true;
     case GL_POLYGON_OFFSET_UNITS:
       *num_written = 1;
       if (params) {
-        params[0] = state_.polygon_offset_units;
+        params[0] = static_cast<GLint>(state_.polygon_offset_units);
       }
       return true;
     case GL_CULL_FACE_MODE:
       *num_written = 1;
       if (params) {
-        params[0] = state_.cull_mode;
+        params[0] = static_cast<GLint>(state_.cull_mode);
       }
       return true;
     case GL_DEPTH_FUNC:
       *num_written = 1;
       if (params) {
-        params[0] = state_.depth_func;
+        params[0] = static_cast<GLint>(state_.depth_func);
       }
       return true;
     case GL_STENCIL_FUNC:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_front_func;
+        params[0] = static_cast<GLint>(state_.stencil_front_func);
       }
       return true;
     case GL_STENCIL_REF:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_front_ref;
+        params[0] = static_cast<GLint>(state_.stencil_front_ref);
       }
       return true;
     case GL_STENCIL_VALUE_MASK:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_front_mask;
+        params[0] = static_cast<GLint>(state_.stencil_front_mask);
       }
       return true;
     case GL_STENCIL_BACK_FUNC:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_back_func;
+        params[0] = static_cast<GLint>(state_.stencil_back_func);
       }
       return true;
     case GL_STENCIL_BACK_REF:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_back_ref;
+        params[0] = static_cast<GLint>(state_.stencil_back_ref);
       }
       return true;
     case GL_STENCIL_BACK_VALUE_MASK:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_back_mask;
+        params[0] = static_cast<GLint>(state_.stencil_back_mask);
       }
       return true;
     case GL_DEPTH_WRITEMASK:
       *num_written = 1;
       if (params) {
-        params[0] = state_.depth_mask;
+        params[0] = static_cast<GLint>(state_.depth_mask);
       }
       return true;
     case GL_BLEND_EQUATION_RGB:
       *num_written = 1;
       if (params) {
-        params[0] = state_.blend_equation_rgb;
+        params[0] = static_cast<GLint>(state_.blend_equation_rgb);
       }
       return true;
     case GL_BLEND_EQUATION_ALPHA:
       *num_written = 1;
       if (params) {
-        params[0] = state_.blend_equation_alpha;
+        params[0] = static_cast<GLint>(state_.blend_equation_alpha);
       }
       return true;
     case GL_STENCIL_WRITEMASK:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_front_writemask;
+        params[0] = static_cast<GLint>(state_.stencil_front_writemask);
       }
       return true;
     case GL_STENCIL_BACK_WRITEMASK:
       *num_written = 1;
       if (params) {
-        params[0] = state_.stencil_back_writemask;
+        params[0] = static_cast<GLint>(state_.stencil_back_writemask);
       }
       return true;
     case GL_BLEND:
       *num_written = 1;
       if (params) {
-        params[0] = state_.enable_flags.blend;
+        params[0] = static_cast<GLint>(state_.enable_flags.blend);
       }
       return true;
     case GL_CULL_FACE:
       *num_written = 1;
       if (params) {
-        params[0] = state_.enable_flags.cull_face;
+        params[0] = static_cast<GLint>(state_.enable_flags.cull_face);
       }
       return true;
     case GL_DEPTH_TEST:
       *num_written = 1;
       if (params) {
-        params[0] = state_.enable_flags.depth_test;
+        params[0] = static_cast<GLint>(state_.enable_flags.depth_test);
       }
       return true;
     case GL_DITHER:
       *num_written = 1;
       if (params) {
-        params[0] = state_.enable_flags.dither;
+        params[0] = static_cast<GLint>(state_.enable_flags.dither);
       }
       return true;
     case GL_POLYGON_OFFSET_FILL:
       *num_written = 1;
       if (params) {
-        params[0] = state_.enable_flags.polygon_offset_fill;
+        params[0] =
+            static_cast<GLint>(state_.enable_flags.polygon_offset_fill);
       }
       return true;
     case GL_SAMPLE_ALPHA_TO_COVERAGE:
       *num_written = 1;
       if (params) {
-        params[0] = state_.enable_flags.sample_alpha_to_coverage;
+        params[0] =
+            static_cast<GLint>(state_.enable_flags.sample_alpha_to_coverage);
       }
       return true;
     case GL_SAMPLE_COVERAGE:
       *num_written = 1;
       if (params) {
-        params[0] = state_.enable_flags.sample_coverage;
+        params[0] = static_cast<GLint>(state_.enable_flags.sample_coverage);
       }
       return true;
     case GL_SCISSOR_TEST:
       *num_written = 1;
       if (params) {
-        params[0] = state_.enable_flags.scissor_test;
+        params[0] = static_cast<GLint>(state_.enable_flags.scissor_test);
       }
       return true;
     case GL_STENCIL_TEST:
       *num_written = 1;
       if (params) {
-        params[0] = state_.enable_flags.stencil_test;
+        params[0] = static_cast<GLint>(state_.enable_flags.stencil_test);
+      }
+      return true;
+    default:
+      return false;
+  }
+}
+
+bool GLES2DecoderImpl::GetStateAsGLfloat(
+    GLenum pname, GLfloat* params, GLsizei* num_written) {
+  switch (pname) {
+    case GL_VIEWPORT:
+      *num_written = 4;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.viewport_x);
+        params[1] = static_cast<GLfloat>(state_.viewport_y);
+        params[2] = static_cast<GLfloat>(state_.viewport_width);
+        params[3] = static_cast<GLfloat>(state_.viewport_height);
+      }
+      return true;
+    case GL_BLEND_SRC_RGB:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.blend_source_rgb);
+      }
+      return true;
+    case GL_BLEND_DST_RGB:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.blend_dest_rgb);
+      }
+      return true;
+    case GL_BLEND_SRC_ALPHA:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.blend_source_alpha);
+      }
+      return true;
+    case GL_BLEND_DST_ALPHA:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.blend_dest_alpha);
+      }
+      return true;
+    case GL_LINE_WIDTH:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.line_width);
+      }
+      return true;
+    case GL_BLEND_COLOR:
+      *num_written = 4;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.blend_color_red);
+        params[1] = static_cast<GLfloat>(state_.blend_color_green);
+        params[2] = static_cast<GLfloat>(state_.blend_color_blue);
+        params[3] = static_cast<GLfloat>(state_.blend_color_alpha);
+      }
+      return true;
+    case GL_STENCIL_CLEAR_VALUE:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_clear);
+      }
+      return true;
+    case GL_COLOR_WRITEMASK:
+      *num_written = 4;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.color_mask_red);
+        params[1] = static_cast<GLfloat>(state_.color_mask_green);
+        params[2] = static_cast<GLfloat>(state_.color_mask_blue);
+        params[3] = static_cast<GLfloat>(state_.color_mask_alpha);
+      }
+      return true;
+    case GL_COLOR_CLEAR_VALUE:
+      *num_written = 4;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.color_clear_red);
+        params[1] = static_cast<GLfloat>(state_.color_clear_green);
+        params[2] = static_cast<GLfloat>(state_.color_clear_blue);
+        params[3] = static_cast<GLfloat>(state_.color_clear_alpha);
+      }
+      return true;
+    case GL_DEPTH_RANGE:
+      *num_written = 2;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.z_near);
+        params[1] = static_cast<GLfloat>(state_.z_far);
+      }
+      return true;
+    case GL_DEPTH_CLEAR_VALUE:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.depth_clear);
+      }
+      return true;
+    case GL_STENCIL_FAIL:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_front_fail_op);
+      }
+      return true;
+    case GL_STENCIL_PASS_DEPTH_FAIL:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_front_z_fail_op);
+      }
+      return true;
+    case GL_STENCIL_PASS_DEPTH_PASS:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_front_z_pass_op);
+      }
+      return true;
+    case GL_STENCIL_BACK_FAIL:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_back_fail_op);
+      }
+      return true;
+    case GL_STENCIL_BACK_PASS_DEPTH_FAIL:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_back_z_fail_op);
+      }
+      return true;
+    case GL_STENCIL_BACK_PASS_DEPTH_PASS:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_back_z_pass_op);
+      }
+      return true;
+    case GL_SCISSOR_BOX:
+      *num_written = 4;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.scissor_x);
+        params[1] = static_cast<GLfloat>(state_.scissor_y);
+        params[2] = static_cast<GLfloat>(state_.scissor_width);
+        params[3] = static_cast<GLfloat>(state_.scissor_height);
+      }
+      return true;
+    case GL_FRONT_FACE:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.front_face);
+      }
+      return true;
+    case GL_SAMPLE_COVERAGE_VALUE:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.sample_coverage_value);
+      }
+      return true;
+    case GL_SAMPLE_COVERAGE_INVERT:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.sample_coverage_invert);
+      }
+      return true;
+    case GL_POLYGON_OFFSET_FACTOR:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.polygon_offset_factor);
+      }
+      return true;
+    case GL_POLYGON_OFFSET_UNITS:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.polygon_offset_units);
+      }
+      return true;
+    case GL_CULL_FACE_MODE:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.cull_mode);
+      }
+      return true;
+    case GL_DEPTH_FUNC:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.depth_func);
+      }
+      return true;
+    case GL_STENCIL_FUNC:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_front_func);
+      }
+      return true;
+    case GL_STENCIL_REF:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_front_ref);
+      }
+      return true;
+    case GL_STENCIL_VALUE_MASK:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_front_mask);
+      }
+      return true;
+    case GL_STENCIL_BACK_FUNC:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_back_func);
+      }
+      return true;
+    case GL_STENCIL_BACK_REF:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_back_ref);
+      }
+      return true;
+    case GL_STENCIL_BACK_VALUE_MASK:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_back_mask);
+      }
+      return true;
+    case GL_DEPTH_WRITEMASK:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.depth_mask);
+      }
+      return true;
+    case GL_BLEND_EQUATION_RGB:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.blend_equation_rgb);
+      }
+      return true;
+    case GL_BLEND_EQUATION_ALPHA:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.blend_equation_alpha);
+      }
+      return true;
+    case GL_STENCIL_WRITEMASK:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_front_writemask);
+      }
+      return true;
+    case GL_STENCIL_BACK_WRITEMASK:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.stencil_back_writemask);
+      }
+      return true;
+    case GL_BLEND:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.enable_flags.blend);
+      }
+      return true;
+    case GL_CULL_FACE:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.enable_flags.cull_face);
+      }
+      return true;
+    case GL_DEPTH_TEST:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.enable_flags.depth_test);
+      }
+      return true;
+    case GL_DITHER:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.enable_flags.dither);
+      }
+      return true;
+    case GL_POLYGON_OFFSET_FILL:
+      *num_written = 1;
+      if (params) {
+        params[0] =
+            static_cast<GLfloat>(state_.enable_flags.polygon_offset_fill);
+      }
+      return true;
+    case GL_SAMPLE_ALPHA_TO_COVERAGE:
+      *num_written = 1;
+      if (params) {
+        params[0] =
+            static_cast<GLfloat>(state_.enable_flags.sample_alpha_to_coverage);
+      }
+      return true;
+    case GL_SAMPLE_COVERAGE:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.enable_flags.sample_coverage);
+      }
+      return true;
+    case GL_SCISSOR_TEST:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.enable_flags.scissor_test);
+      }
+      return true;
+    case GL_STENCIL_TEST:
+      *num_written = 1;
+      if (params) {
+        params[0] = static_cast<GLfloat>(state_.enable_flags.stencil_test);
       }
       return true;
     default: