Merge 261120 "gpu: Lose context when BeginQueryEXT fails to allo..."

gpu/command_buffer/service/gles2_cmd_decoder_unittest.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 "base/command_line.h"
 #include "base/strings/string_number_conversions.h"
 #include "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/common/gles2_cmd_utils.h"
@@ skipping 53 matching lines @@
       bool init);
 };
 
 class GLES2DecoderTestWithExtensionsOnGLES2
     : public GLES2DecoderTest,
       public ::testing::WithParamInterface<const char*> {
  public:
   GLES2DecoderTestWithExtensionsOnGLES2() {}
 
   virtual void SetUp() {
-    InitDecoder(GetParam(),       // extensions
-                "opengl es 2.0",  // gl version
-                true,             // has alpha
-                true,             // has depth
-                false,            // has stencil
-                true,             // request alpha
-                true,             // request depth
-                false,            // request stencil
-                false);           // bind generates resource
+    InitState init;
+    init.extensions = GetParam();
+    init.gl_version = "opengl es 2.0";
+    init.has_alpha = true;
+    init.has_depth = true;
+    init.request_alpha = true;
+    init.request_depth = true;
+    InitDecoder(init);
   }
 };
 
 class GLES2DecoderWithShaderTest : public GLES2DecoderWithShaderTestBase {
  public:
   GLES2DecoderWithShaderTest()
       : GLES2DecoderWithShaderTestBase() {
   }
 
   void CheckTextureChangesMarkFBOAsNotComplete(bool bound_fbo);
   void CheckRenderbufferChangesMarkFBOAsNotComplete(bool bound_fbo);
 };
 
 class GLES2DecoderGeometryInstancingTest : public GLES2DecoderWithShaderTest {
  public:
   GLES2DecoderGeometryInstancingTest()
       : GLES2DecoderWithShaderTest() {
   }
 
   virtual void SetUp() {
-    InitDecoder(
-        "GL_ANGLE_instanced_arrays", // extensions
-        "opengl es 2.0",             // gl version
-        true,                        // has alpha
-        true,                        // has depth
-        false,                       // has stencil
-        true,                        // request alpha
-        true,                        // request depth
-        false,                       // request stencil
-        true);                       // bind generates resource
+    InitState init;
+    init.extensions = "GL_ANGLE_instanced_arrays";
+    init.gl_version = "opengl es 2.0";
+    init.has_alpha = true;
+    init.has_depth = true;
+    init.request_alpha = true;
+    init.request_depth = true;
+    init.bind_generates_resource = true;
+    InitDecoder(init);
     SetupDefaultProgram();
   }
 };
 
 class GLES2DecoderRGBBackbufferTest : public GLES2DecoderWithShaderTest {
  public:
   GLES2DecoderRGBBackbufferTest() { }
 
   virtual void SetUp() {
     // Test codepath with workaround clear_alpha_in_readpixels because
     // ReadPixelsEmulator emulates the incorrect driver behavior.
     CommandLine command_line(0, NULL);
     command_line.AppendSwitchASCII(
         switches::kGpuDriverBugWorkarounds,
         base::IntToString(gpu::CLEAR_ALPHA_IN_READPIXELS));
-    InitDecoderWithCommandLine(
-        "",     // extensions
-        "3.0",  // gl version
-        false,  // has alpha
-        false,  // has depth
-        false,  // has stencil
-        false,  // request alpha
-        false,  // request depth
-        false,  // request stencil
-        true,   // bind generates resource
-        &command_line);
+    InitState init;
+    init.gl_version = "3.0";
+    init.bind_generates_resource = true;
+    InitDecoderWithCommandLine(init, &command_line);
     SetupDefaultProgram();
   }
 };
 
 class GLES2DecoderManualInitTest : public GLES2DecoderWithShaderTest {
  public:
   GLES2DecoderManualInitTest() { }
 
   // Override default setup so nothing gets setup.
   virtual void SetUp() {
@@ skipping 59 matching lines @@
 TEST_F(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OverflowFails) {
   const GLsizei kLargeCount = 0x40000000;
   SetupTexture();
   EXPECT_CALL(*gl_, DrawArrays(_, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kLargeCount);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
+  EXPECT_FALSE(GetDecoder()->WasContextLost());
 }
 
 // Tests when the math overflows (0x7FFFFFFF + 1 = 0x8000000 verts)
 TEST_F(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0PosToNegFails) {
   const GLsizei kLargeCount = 0x7FFFFFFF;
   SetupTexture();
   EXPECT_CALL(*gl_, DrawArrays(_, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kLargeCount);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
+  EXPECT_FALSE(GetDecoder()->WasContextLost());
 }
 
 // Tests when the driver returns an error
 TEST_F(GLES2DecoderWithShaderTest, DrawArraysSimulatedAttrib0OOMFails) {
   const GLsizei kFakeLargeCount = 0x1234;
   SetupTexture();
   AddExpectationsForSimulatedAttrib0WithError(
       kFakeLargeCount, 0, GL_OUT_OF_MEMORY);
   EXPECT_CALL(*gl_, DrawArrays(_, _, _))
       .Times(0)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kFakeLargeCount);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
+  EXPECT_FALSE(GetDecoder()->WasContextLost());
+}
+
+// Test that we lose context.
+TEST_F(GLES2DecoderManualInitTest, LoseContextWhenOOM) {
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_alpha = true;
+  init.has_depth = true;
+  init.request_alpha = true;
+  init.request_depth = true;
+  init.bind_generates_resource = true;
+  init.lose_context_when_out_of_memory = true;
+  InitDecoder(init);
+  SetupDefaultProgram();
+
+  const GLsizei kFakeLargeCount = 0x1234;
+  SetupTexture();
+  AddExpectationsForSimulatedAttrib0WithError(
+      kFakeLargeCount, 0, GL_OUT_OF_MEMORY);
+  EXPECT_CALL(*gl_, DrawArrays(_, _, _)).Times(0).RetiresOnSaturation();
+  // Other contexts in the group should be lost also.
+  EXPECT_CALL(*mock_decoder_, LoseContext(GL_UNKNOWN_CONTEXT_RESET_ARB))
+      .Times(1)
+      .RetiresOnSaturation();
+  DrawArrays cmd;
+  cmd.Init(GL_TRIANGLES, 0, kFakeLargeCount);
+  // This context should be lost.
+  EXPECT_EQ(error::kLostContext, ExecuteCmd(cmd));
+  EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
+  EXPECT_TRUE(decoder_->WasContextLost());
 }
 
 TEST_F(GLES2DecoderWithShaderTest, DrawArraysBadTextureUsesBlack) {
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   // This is an NPOT texture. As the default filtering requires mips
   // this should trigger replacing with black textures before rendering.
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 3, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                kSharedMemoryId, kSharedMemoryOffset);
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
   {
@@ skipping 65 matching lines @@
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 // Same as DrawArraysValidAttributesSucceeds, but with workaround
 // |init_vertex_attributes|.
 TEST_F(GLES2DecoderManualInitTest, InitVertexAttributes) {
   CommandLine command_line(0, NULL);
   command_line.AppendSwitchASCII(
       switches::kGpuDriverBugWorkarounds,
       base::IntToString(gpu::INIT_VERTEX_ATTRIBUTES));
-  InitDecoderWithCommandLine(
-      "",     // extensions
-      "3.0",  // gl version
-      true,   // has alpha
-      true,   // has depth
-      false,  // has stencil
-      true,   // request alpha
-      true,   // request depth
-      false,  // request stencil
-      true,   // bind generates resource
-      &command_line);
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_alpha = true;
+  init.has_depth = true;
+  init.request_alpha = true;
+  init.request_depth = true;
+  init.bind_generates_resource = true;
+  InitDecoderWithCommandLine(init, &command_line);
   SetupDefaultProgram();
   SetupTexture();
   SetupVertexBuffer();
   DoEnableVertexAttribArray(1);
   DoVertexAttribPointer(1, 2, GL_FLOAT, 0, 0);
   AddExpectationsForSimulatedAttrib0(kNumVertices, kServiceBufferId);
   SetupExpectationsForApplyingDefaultDirtyState();
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
@@ skipping 1569 matching lines @@
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 // Same as GenerateMipmapClearsUnclearedTexture, but with workaround
 // |set_texture_filters_before_generating_mipmap|.
 TEST_F(GLES2DecoderManualInitTest, SetTextureFiltersBeforeGenerateMipmap) {
   CommandLine command_line(0, NULL);
   command_line.AppendSwitchASCII(
       switches::kGpuDriverBugWorkarounds,
       base::IntToString(gpu::SET_TEXTURE_FILTER_BEFORE_GENERATING_MIPMAP));
-  InitDecoderWithCommandLine(
-      "",     // extensions
-      "3.0",  // gl version
-      false,  // has alpha
-      false,  // has depth
-      false,  // has stencil
-      false,  // request alpha
-      false,  // request depth
-      false,  // request stencil
-      true,   // bind generates resource
-      &command_line);
+  InitState init;
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoderWithCommandLine(init, &command_line);
 
   EXPECT_CALL(*gl_, GenerateMipmapEXT(_))
        .Times(0);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
   SetupClearTextureExpectations(
       kServiceTextureId, kServiceTextureId, GL_TEXTURE_2D, GL_TEXTURE_2D,
       0, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, 2, 2);
   EXPECT_CALL(*gl_, TexParameteri(
@@ skipping 645 matching lines @@
            false);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   cmd.Init(0, 0, 1, 1, GL_RGB, GL_UNSIGNED_BYTE,
            pixels_shm_id, pixels_shm_offset,
            result_shm_id, kInvalidSharedMemoryOffset,
            false);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderManualInitTest, ReadPixelsAsyncError) {
-  InitDecoder(
-      "GL_ARB_sync", // extensions
-      "opengl es 3.0",   // gl version
-      true,    // has alpha
-      false,   // has depth
-      false,   // has stencil
-      true,    // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_ARB_sync";
+  init.gl_version = "opengl es 3.0";
+  init.has_alpha = true;
+  init.request_alpha = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   typedef ReadPixels::Result Result;
   Result* result = GetSharedMemoryAs<Result*>();
 
   const GLsizei kWidth = 4;
   const GLsizei kHeight = 4;
   uint32 result_shm_id = kSharedMemoryId;
   uint32 result_shm_offset = kSharedMemoryOffset;
   uint32 pixels_shm_id = kSharedMemoryId;
   uint32 pixels_shm_offset = kSharedMemoryOffset + sizeof(*result);
@@ skipping 1258 matching lines @@
       false);  // blend_enabled
 
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(draw_cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, ActualAlphaMatchesRequestedAlpha) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      true,    // has alpha
-      false,   // has depth
-      false,   // has stencil
-      true,    // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_alpha = true;
+  init.request_alpha = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_ALPHA_BITS, _))
       .WillOnce(SetArgumentPointee<1>(8))
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_ALPHA_BITS, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_ALPHA_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(8, result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ActualAlphaDoesNotMatchRequestedAlpha) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      true,    // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_alpha = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_ALPHA_BITS, _))
       .WillOnce(SetArgumentPointee<1>(8))
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_ALPHA_BITS, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_ALPHA_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(0, result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ActualDepthMatchesRequestedDepth) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      true,    // has depth
-      false,   // has stencil
-      false,   // request alpha
-      true,    // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_depth = true;
+  init.request_depth = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
       .WillOnce(SetArgumentPointee<1>(24))
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_DEPTH_BITS, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(24, result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ActualDepthDoesNotMatchRequestedDepth) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      true,    // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_depth = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_DEPTH_BITS, _))
       .WillOnce(SetArgumentPointee<1>(24))
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_DEPTH_BITS, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(0, result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ActualStencilMatchesRequestedStencil) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      true,    // has stencil
-      false,   // request alpha
-      false,   // request depth
-      true,    // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_stencil = true;
+  init.request_stencil = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
       .WillOnce(SetArgumentPointee<1>(8))
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_STENCIL_BITS, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(8, result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ActualStencilDoesNotMatchRequestedStencil) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      true,    // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_stencil = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_STENCIL_BITS, _))
       .WillOnce(SetArgumentPointee<1>(8))
       .RetiresOnSaturation();
   result->size = 0;
   GetIntegerv cmd2;
   cmd2.Init(GL_STENCIL_BITS, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(0, result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, DepthEnableWithDepth) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      true,    // has depth
-      false,   // has stencil
-      false,   // request alpha
-      true,    // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_depth = true;
+  init.request_depth = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   Enable cmd;
   cmd.Init(GL_DEPTH_TEST);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   SetupDefaultProgram();
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
   SetupExpectationsForApplyingDirtyState(
@@ skipping 33 matching lines @@
   cmd2.Init(GL_DEPTH_TEST, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_TEST),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(1, result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, DepthEnableWithoutRequestedDepth) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      true,    // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_depth = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   Enable cmd;
   cmd.Init(GL_DEPTH_TEST);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   SetupDefaultProgram();
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
   SetupExpectationsForApplyingDirtyState(
@@ skipping 32 matching lines @@
   cmd2.Init(GL_DEPTH_TEST, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_TEST),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(1, result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, StencilEnableWithStencil) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      true,    // has stencil
-      false,   // request alpha
-      false,   // request depth
-      true,    // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_stencil = true;
+  init.request_stencil = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   Enable cmd;
   cmd.Init(GL_STENCIL_TEST);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   SetupDefaultProgram();
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
   SetupExpectationsForApplyingDirtyState(
@@ skipping 32 matching lines @@
   cmd2.Init(GL_STENCIL_TEST, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_TEST),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(1, result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, StencilEnableWithoutRequestedStencil) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      true,    // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_stencil = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   Enable cmd;
   cmd.Init(GL_STENCIL_TEST);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 
   SetupDefaultProgram();
   SetupTexture();
   AddExpectationsForSimulatedAttrib0(kNumVertices, 0);
   SetupExpectationsForApplyingDirtyState(
@@ skipping 32 matching lines @@
   cmd2.Init(GL_STENCIL_TEST, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_STENCIL_TEST),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(1, result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, PackedDepthStencilReportsCorrectValues) {
-  InitDecoder(
-      "GL_OES_packed_depth_stencil",      // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      true,    // has depth
-      true,    // has stencil
-      false,   // request alpha
-      true,    // request depth
-      true,    // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_packed_depth_stencil";
+  init.gl_version = "opengl es 2.0";
+  init.has_depth = true;
+  init.has_stencil = true;
+  init.request_depth = true;
+  init.request_stencil = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->size = 0;
@@ skipping 15 matching lines @@
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(24, result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, PackedDepthStencilNoRequestedStencil) {
-  InitDecoder(
-      "GL_OES_packed_depth_stencil",      // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      true,    // has depth
-      true,    // has stencil
-      false,   // request alpha
-      true,    // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_packed_depth_stencil";
+  init.gl_version = "opengl es 2.0";
+  init.has_depth = true;
+  init.has_stencil = true;
+  init.request_depth = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   result->size = 0;
@@ skipping 15 matching lines @@
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(24, result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, PackedDepthStencilRenderbufferDepth) {
-  InitDecoder(
-      "GL_OES_packed_depth_stencil",      // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_packed_depth_stencil";
+  init.gl_version = "opengl es 2.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))  // for RenderbufferStoage
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))  // for FramebufferRenderbuffer
       .WillOnce(Return(GL_NO_ERROR))
@@ skipping 42 matching lines @@
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(
       decoder_->GetGLES2Util()->GLGetNumValuesReturned(GL_DEPTH_BITS),
       result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(24, result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, PackedDepthStencilRenderbufferStencil) {
-  InitDecoder(
-      "GL_OES_packed_depth_stencil",      // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_packed_depth_stencil";
+  init.gl_version = "opengl es 2.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   DoBindFramebuffer(GL_FRAMEBUFFER, client_framebuffer_id_,
                     kServiceFramebufferId);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))  // for RenderbufferStoage
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))  // for FramebufferRenderbuffer
       .WillOnce(Return(GL_NO_ERROR))
@@ skipping 374 matching lines @@
   cmd.Init(GL_RENDERBUFFER, GL_RGBA4, TestHelper::kMaxRenderbufferSize + 1, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   cmd.Init(GL_RENDERBUFFER, GL_RGBA4, 1, TestHelper::kMaxRenderbufferSize + 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest,
        RenderbufferStorageMultisampleCHROMIUMGLError) {
-  InitDecoder(
-      "GL_EXT_framebuffer_multisample",  // extensions
-      "2.1",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_EXT_framebuffer_multisample";
+  init.gl_version = "2.1";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_OUT_OF_MEMORY))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, RenderbufferStorageMultisampleEXT(
       GL_RENDERBUFFER, 1, GL_RGBA, 100, 50))
       .Times(1)
       .RetiresOnSaturation();
   RenderbufferStorageMultisampleCHROMIUM cmd;
   cmd.Init(GL_RENDERBUFFER, 1, GL_RGBA4, 100, 50);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest,
        RenderbufferStorageMultisampleCHROMIUMBadArgs) {
-  InitDecoder(
-      "GL_EXT_framebuffer_multisample",  // extensions
-      "2.1",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_EXT_framebuffer_multisample";
+  init.gl_version = "2.1";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   EXPECT_CALL(*gl_, RenderbufferStorageMultisampleEXT(_, _, _, _, _))
       .Times(0)
       .RetiresOnSaturation();
   RenderbufferStorageMultisampleCHROMIUM cmd;
   cmd.Init(GL_RENDERBUFFER, TestHelper::kMaxSamples + 1,
            GL_RGBA4, TestHelper::kMaxRenderbufferSize, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   cmd.Init(GL_RENDERBUFFER, TestHelper::kMaxSamples,
            GL_RGBA4, TestHelper::kMaxRenderbufferSize + 1, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
   cmd.Init(GL_RENDERBUFFER, TestHelper::kMaxSamples,
            GL_RGBA4, 1, TestHelper::kMaxRenderbufferSize + 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, RenderbufferStorageMultisampleCHROMIUM) {
-  InitDecoder(
-      "GL_EXT_framebuffer_multisample",  // extensions
-      "2.1",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      false);  // bind generates resource
+  InitState init;
+  init.extensions = "GL_EXT_framebuffer_multisample";
+  init.gl_version = "2.1";
+  InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   InSequence sequence;
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(
       *gl_,
       RenderbufferStorageMultisampleEXT(GL_RENDERBUFFER,
                                         TestHelper::kMaxSamples,
                                         GL_RGBA,
                                         TestHelper::kMaxRenderbufferSize,
                                         1))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   RenderbufferStorageMultisampleCHROMIUM cmd;
   cmd.Init(GL_RENDERBUFFER, TestHelper::kMaxSamples,
            GL_RGBA4, TestHelper::kMaxRenderbufferSize, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest,
        RenderbufferStorageMultisampleEXTNotSupported) {
-  InitDecoder(
-      "GL_EXT_framebuffer_multisample",  // extensions
-      "2.1",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      false);  // bind generates resource
+  InitState init;
+  init.extensions = "GL_EXT_framebuffer_multisample";
+  init.gl_version = "2.1";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   InSequence sequence;
   // GL_EXT_framebuffer_multisample uses RenderbufferStorageMultisampleCHROMIUM.
   RenderbufferStorageMultisampleEXT cmd;
   cmd.Init(GL_RENDERBUFFER, TestHelper::kMaxSamples,
            GL_RGBA4, TestHelper::kMaxRenderbufferSize, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
@@ skipping 89 matching lines @@
 static bool ValueInArray(GLint value, GLint* array, GLint count) {
   for (GLint ii = 0; ii < count; ++ii) {
     if (array[ii] == value) {
       return true;
     }
   }
   return false;
 }
 
 TEST_F(GLES2DecoderManualInitTest, GetCompressedTextureFormats) {
-  InitDecoder(
-      "GL_EXT_texture_compression_s3tc",  // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_EXT_texture_compression_s3tc";
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
 
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ skipping 28 matching lines @@
       GL_COMPRESSED_RGBA_S3TC_DXT3_EXT,
       result->GetData(), result->GetNumResults()));
   EXPECT_TRUE(ValueInArray(
       GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
       result->GetData(), result->GetNumResults()));
 
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, GetNoCompressedTextureFormats) {
-  InitDecoder(
-      "",  // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
 
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ skipping 15 matching lines @@
   cmd.Init(
       GL_COMPRESSED_TEXTURE_FORMATS,
       shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(num_formats, result->GetNumResults());
 
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, CompressedTexImage2DBucketBadBucket) {
-  InitDecoder(
-      "GL_EXT_texture_compression_s3tc",  // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_EXT_texture_compression_s3tc";
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   const uint32 kBadBucketId = 123;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   CompressedTexImage2DBucket cmd;
   cmd.Init(
       GL_TEXTURE_2D, 0, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT, 4, 4, 0,
       kBadBucketId);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   CompressedTexSubImage2DBucket cmd2;
   cmd2.Init(
       GL_TEXTURE_2D, 0, 0, 0, 4, 4, GL_COMPRESSED_RGBA_S3TC_DXT5_EXT,
       kBadBucketId);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 namespace {
 
 struct S3TCTestData {
   GLenum format;
   size_t block_size;
 };
 
 }  // anonymous namespace.
 
 TEST_F(GLES2DecoderManualInitTest, CompressedTexImage2DS3TC) {
-  InitDecoder(
-      "GL_EXT_texture_compression_s3tc",  // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_EXT_texture_compression_s3tc";
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   const uint32 kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
   static const S3TCTestData test_data[] = {
     { GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 8, },
     { GL_COMPRESSED_RGBA_S3TC_DXT1_EXT, 8, },
     { GL_COMPRESSED_RGBA_S3TC_DXT3_EXT, 16, },
@@ skipping 125 matching lines @@
             EXPECT_EQ(error::kNoError, ExecuteCmd(sub_cmd));
             EXPECT_EQ(GL_NO_ERROR, GetGLError());
           }
         }
       }
     }
   }
 }
 
 TEST_F(GLES2DecoderManualInitTest, CompressedTexImage2DETC1) {
-  InitDecoder(
-      "GL_OES_compressed_ETC1_RGB8_texture",  // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_compressed_ETC1_RGB8_texture";
+  init.gl_version = "opengl es 2.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   const uint32 kBucketId = 123;
   CommonDecoder::Bucket* bucket = decoder_->CreateBucket(kBucketId);
   ASSERT_TRUE(bucket != NULL);
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
   const GLenum kFormat = GL_ETC1_RGB8_OES;
   const size_t kBlockSize = 8;
 
   CompressedTexImage2DBucket cmd;
@@ skipping 43 matching lines @@
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   // Test CopyTexSubImage not allowed for ETC1 compressed texture
   CopyTexSubImage2D copy_cmd;
   copy_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 4, 4);
   EXPECT_EQ(error::kNoError, ExecuteCmd(copy_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, GetCompressedTextureFormatsETC1) {
-  InitDecoder(
-      "GL_OES_compressed_ETC1_RGB8_texture",  // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_compressed_ETC1_RGB8_texture";
+  init.gl_version = "opengl es 2.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
 
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ skipping 46 matching lines @@
   EXPECT_EQ(sizeof(ProgramInfoHeader), bucket->size());
   ProgramInfoHeader* info = bucket->GetDataAs<ProgramInfoHeader*>(
       0, sizeof(ProgramInfoHeader));
   ASSERT_TRUE(info != 0);
   EXPECT_EQ(0u, info->link_status);
   EXPECT_EQ(0u, info->num_attribs);
   EXPECT_EQ(0u, info->num_uniforms);
 }
 
 TEST_F(GLES2DecoderManualInitTest, EGLImageExternalBindTexture) {
-  InitDecoder(
-      "GL_OES_EGL_image_external",  // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_EGL_image_external";
+  init.gl_version = "opengl es 2.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_EXTERNAL_OES, kNewServiceId));
   EXPECT_CALL(*gl_, GenTextures(1, _))
       .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   BindTexture cmd;
   cmd.Init(GL_TEXTURE_EXTERNAL_OES, kNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   TextureRef* texture_ref = GetTexture(kNewClientId);
   EXPECT_TRUE(texture_ref != NULL);
   EXPECT_TRUE(texture_ref->texture()->target() == GL_TEXTURE_EXTERNAL_OES);
 }
 
 TEST_F(GLES2DecoderManualInitTest, EGLImageExternalGetBinding) {
-  InitDecoder(
-      "GL_OES_EGL_image_external",  // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_EGL_image_external";
+  init.gl_version = "opengl es 2.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_TEXTURE_BINDING_EXTERNAL_OES,
                                 result->GetData()))
       .Times(0);
   result->size = 0;
   GetIntegerv cmd;
   cmd.Init(GL_TEXTURE_BINDING_EXTERNAL_OES,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
       GL_TEXTURE_BINDING_EXTERNAL_OES), result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(client_texture_id_, (uint32)result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTextureDefaults) {
-  InitDecoder(
-      "GL_OES_EGL_image_external",  // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_EGL_image_external";
+  init.gl_version = "opengl es 2.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
 
   TextureRef* texture_ref = GetTexture(client_texture_id_);
   EXPECT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTextureParam) {
-  InitDecoder(
-      "GL_OES_EGL_image_external",  // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
-
+  InitState init;
+  init.extensions = "GL_OES_EGL_image_external";
+  init.gl_version = "opengl es 2.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
 
   EXPECT_CALL(*gl_, TexParameteri(GL_TEXTURE_EXTERNAL_OES,
                                   GL_TEXTURE_MIN_FILTER,
                                   GL_NEAREST));
   EXPECT_CALL(*gl_, TexParameteri(GL_TEXTURE_EXTERNAL_OES,
                                   GL_TEXTURE_MIN_FILTER,
                                   GL_LINEAR));
   EXPECT_CALL(*gl_, TexParameteri(GL_TEXTURE_EXTERNAL_OES,
                                   GL_TEXTURE_WRAP_S,
@@ skipping 29 matching lines @@
   TextureRef* texture_ref = GetTexture(client_texture_id_);
   EXPECT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTextureParamInvalid) {
-  InitDecoder(
-      "GL_OES_EGL_image_external",  // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
-
+  InitState init;
+  init.extensions = "GL_OES_EGL_image_external";
+  init.gl_version = "opengl es 2.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
 
   TexParameteri cmd;
   cmd.Init(GL_TEXTURE_EXTERNAL_OES,
            GL_TEXTURE_MIN_FILTER,
            GL_NEAREST_MIPMAP_NEAREST);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 
   cmd.Init(GL_TEXTURE_EXTERNAL_OES,
@@ skipping 11 matching lines @@
   TextureRef* texture_ref = GetTexture(client_texture_id_);
   EXPECT_TRUE(texture_ref != NULL);
   Texture* texture = texture_ref->texture();
   EXPECT_TRUE(texture->target() == GL_TEXTURE_EXTERNAL_OES);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_F(GLES2DecoderManualInitTest, EGLImageExternalTexImage2DError) {
-  InitDecoder(
-      "GL_OES_EGL_image_external",  // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_EGL_image_external";
+  init.gl_version = "opengl es 2.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   GLenum target = GL_TEXTURE_EXTERNAL_OES;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   GLint border = 0;
   GLenum format = GL_RGBA;
   GLenum type = GL_UNSIGNED_BYTE;
   DoBindTexture(GL_TEXTURE_EXTERNAL_OES, client_texture_id_, kServiceTextureId);
   ASSERT_TRUE(GetTexture(client_texture_id_) != NULL);
   TexImage2D cmd;
   cmd.Init(target, level, internal_format, width, height, border, format,
            type, kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 
   // TexImage2D is not allowed with GL_TEXTURE_EXTERNAL_OES targets.
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, BindGeneratesResourceFalse) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      false);  // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  InitDecoder(init);
 
   BindTexture cmd1;
   cmd1.Init(GL_TEXTURE_2D, kInvalidClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd1));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   BindBuffer cmd2;
   cmd2.Init(GL_ARRAY_BUFFER, kInvalidClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd2));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   BindFramebuffer cmd3;
   cmd3.Init(GL_FRAMEBUFFER, kInvalidClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd3));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   BindRenderbuffer cmd4;
   cmd4.Init(GL_RENDERBUFFER, kInvalidClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd4));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleBindTexture) {
-  InitDecoder(
-      "GL_ARB_texture_rectangle",  // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_ARB_texture_rectangle";
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   EXPECT_CALL(*gl_, BindTexture(GL_TEXTURE_RECTANGLE_ARB, kNewServiceId));
   EXPECT_CALL(*gl_, GenTextures(1, _))
      .WillOnce(SetArgumentPointee<1>(kNewServiceId));
   BindTexture cmd;
   cmd.Init(GL_TEXTURE_RECTANGLE_ARB, kNewClientId);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   Texture* texture = GetTexture(kNewClientId)->texture();
   EXPECT_TRUE(texture != NULL);
   EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleGetBinding) {
-  InitDecoder(
-      "GL_ARB_texture_rectangle",  // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_ARB_texture_rectangle";
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
   EXPECT_CALL(*gl_, GetIntegerv(GL_TEXTURE_BINDING_RECTANGLE_ARB,
                                 result->GetData()))
       .Times(0);
   result->size = 0;
   GetIntegerv cmd;
   cmd.Init(GL_TEXTURE_BINDING_RECTANGLE_ARB,
            shared_memory_id_,
            shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(decoder_->GetGLES2Util()->GLGetNumValuesReturned(
       GL_TEXTURE_BINDING_RECTANGLE_ARB), result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   EXPECT_EQ(client_texture_id_, (uint32)result->GetData()[0]);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTextureDefaults) {
-  InitDecoder(
-      "GL_ARB_texture_rectangle",  // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_ARB_texture_rectangle";
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
 
   Texture* texture = GetTexture(client_texture_id_)->texture();
   EXPECT_TRUE(texture != NULL);
   EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParam) {
-  InitDecoder(
-      "GL_ARB_texture_rectangle",  // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_ARB_texture_rectangle";
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
 
   EXPECT_CALL(*gl_, TexParameteri(GL_TEXTURE_RECTANGLE_ARB,
                                   GL_TEXTURE_MIN_FILTER,
                                   GL_NEAREST));
   EXPECT_CALL(*gl_, TexParameteri(GL_TEXTURE_RECTANGLE_ARB,
                                   GL_TEXTURE_MIN_FILTER,
                                   GL_LINEAR));
@@ skipping 30 matching lines @@
 
   Texture* texture = GetTexture(client_texture_id_)->texture();
   EXPECT_TRUE(texture != NULL);
   EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTextureParamInvalid) {
-  InitDecoder(
-      "GL_ARB_texture_rectangle",  // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_ARB_texture_rectangle";
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   DoBindTexture(
       GL_TEXTURE_RECTANGLE_ARB, client_texture_id_, kServiceTextureId);
 
   TexParameteri cmd;
   cmd.Init(GL_TEXTURE_RECTANGLE_ARB,
            GL_TEXTURE_MIN_FILTER,
            GL_NEAREST_MIPMAP_NEAREST);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
@@ skipping 12 matching lines @@
 
   Texture* texture = GetTexture(client_texture_id_)->texture();
   EXPECT_TRUE(texture != NULL);
   EXPECT_TRUE(texture->target() == GL_TEXTURE_RECTANGLE_ARB);
   EXPECT_TRUE(texture->min_filter() == GL_LINEAR);
   EXPECT_TRUE(texture->wrap_s() == GL_CLAMP_TO_EDGE);
   EXPECT_TRUE(texture->wrap_t() == GL_CLAMP_TO_EDGE);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ARBTextureRectangleTexImage2DError) {
-  InitDecoder(
-      "GL_ARB_texture_rectangle",  // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_ARB_texture_rectangle";
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   GLenum target = GL_TEXTURE_RECTANGLE_ARB;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 2;
   GLsizei height = 4;
   GLint border = 0;
   GLenum format = GL_RGBA;
   GLenum type = GL_UNSIGNED_BYTE;
   DoBindTexture(
@@ skipping 74 matching lines @@
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_F(
     GLES2DecoderManualInitTest,
     TexSubImage2DDoesNotClearAfterTexImage2DNULLThenDataWithTexImage2DIsFaster) {
   CommandLine command_line(0, NULL);
   command_line.AppendSwitchASCII(
       switches::kGpuDriverBugWorkarounds,
       base::IntToString(gpu::TEXSUBIMAGE2D_FASTER_THAN_TEXIMAGE2D));
-  InitDecoderWithCommandLine(
-      "",     // extensions
-      "3.0",  // gl version
-      false,  // has alpha
-      false,  // has depth
-      false,  // has stencil
-      false,  // request alpha
-      false,  // request depth
-      false,  // request stencil
-      true,   // bind generates resource
-      &command_line);
+  InitState init;
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoderWithCommandLine(init, &command_line);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 2, 2, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                0, 0);
 
   {
     // Uses texSubimage internally because the above workaround is active and
     // the update is for the full size of the texture.
     EXPECT_CALL(*gl_,
                 TexSubImage2D(
                     GL_TEXTURE_2D, 0, 0, 0, 2, 2, GL_RGBA, GL_UNSIGNED_BYTE, _))
@@ skipping 261 matching lines @@
       0, GL_RGBA, GL_RGBA, GL_UNSIGNED_BYTE, 2, 2);
   EXPECT_CALL(*gl_, CopyTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 1, 1))
       .Times(1)
       .RetiresOnSaturation();
   CopyTexSubImage2D cmd;
   cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 1, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderManualInitTest, CompressedImage2DMarksTextureAsCleared) {
-  InitDecoder(
-      "GL_EXT_texture_compression_s3tc",  // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_EXT_texture_compression_s3tc";
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, CompressedTexImage2D(
       GL_TEXTURE_2D, 0, GL_COMPRESSED_RGB_S3TC_DXT1_EXT, 4, 4, 0, 8, _))
       .Times(1)
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
@@ skipping 110 matching lines @@
   cmd.Init(0, 0, 1, 1, GL_RGBA, GL_UNSIGNED_BYTE,
            pixels_shm_id, pixels_shm_offset,
            result_shm_id, result_shm_offset,
            false);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest,
        UnClearedAttachmentsGetClearedOnReadPixelsAndDrawBufferGetsRestored) {
-  InitDecoder(
-      "GL_EXT_framebuffer_multisample",  // extensions
-      "2.1",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_EXT_framebuffer_multisample";
+  init.gl_version = "2.1";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   const GLuint kFBOClientTextureId = 4100;
   const GLuint kFBOServiceTextureId = 4101;
 
   // Register a texture id.
   EXPECT_CALL(*gl_, GenTextures(_, _))
       .WillOnce(SetArgumentPointee<1>(kFBOServiceTextureId))
       .RetiresOnSaturation();
   GenHelper<GenTexturesImmediate>(kFBOClientTextureId);
 
   // Setup "render from" texture.
@@ skipping 425 matching lines @@
       .RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest, BeginQueryEXTDisabled) {
   // Test something fails if off.
 }
 
 TEST_F(GLES2DecoderManualInitTest, BeginEndQueryEXT) {
-  InitDecoder(
-      "GL_EXT_occlusion_query_boolean",      // extensions
-      "opengl es 2.0",   // gl version
-      true,    // has alpha
-      false,   // has depth
-      false,   // has stencil
-      true,    // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_EXT_occlusion_query_boolean";
+  init.gl_version = "opengl es 2.0";
+  init.has_alpha = true;
+  init.request_alpha = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   // Test end fails if no begin.
   EndQueryEXT end_cmd;
   end_cmd.Init(GL_ANY_SAMPLES_PASSED_EXT, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(end_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   BeginQueryEXT begin_cmd;
 
   // Test id = 0 fails.
@@ skipping 62 matching lines @@
 
 static void CheckBeginEndQueryBadMemoryFails(
     GLES2DecoderTestBase* test,
     GLuint client_id,
     GLuint service_id,
     const QueryType& query_type,
     int32 shm_id,
     uint32 shm_offset) {
   // We need to reset the decoder on each iteration, because we lose the
   // context every time.
-  test->InitDecoder(
-        "GL_EXT_occlusion_query_boolean",      // extensions
-        "opengl es 2.0",   // gl version
-        true,    // has alpha
-        false,   // has depth
-        false,   // has stencil
-        true,    // request alpha
-        false,   // request depth
-        false,   // request stencil
-        true);   // bind generates resource
+  GLES2DecoderTestBase::InitState init;
+  init.extensions = "GL_EXT_occlusion_query_boolean";
+  init.gl_version = "opengl es 2.0";
+  init.has_alpha = true;
+  init.request_alpha = true;
+  init.bind_generates_resource = true;
+  test->InitDecoder(init);
   ::testing::StrictMock< ::gfx::MockGLInterface>* gl = test->GetGLMock();
 
   BeginQueryEXT begin_cmd;
 
   test->GenHelper<GenQueriesEXTImmediate>(client_id);
 
   if (query_type.is_gl) {
     EXPECT_CALL(*gl, GenQueriesARB(1, _))
        .WillOnce(SetArgumentPointee<1>(service_id))
        .RetiresOnSaturation();
@@ skipping 245 matching lines @@
     EXPECT_NE(0u, *result);
     Disable disable_cmd;
     disable_cmd.Init(state);
     EXPECT_EQ(error::kNoError, ExecuteCmd(disable_cmd));
     EXPECT_EQ(error::kNoError, ExecuteCmd(is_enabled_cmd));
     EXPECT_EQ(0u, *result);
   }
 }
 
 TEST_F(GLES2DecoderManualInitTest, DepthTextureBadArgs) {
-  InitDecoder(
-      "GL_ANGLE_depth_texture",      // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      true,    // has depth
-      true,    // has stencil
-      false,   // request alpha
-      true,    // request depth
-      true,    // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_ANGLE_depth_texture";
+  init.gl_version = "opengl es 2.0";
+  init.has_depth = true;
+  init.has_stencil = true;
+  init.request_depth = true;
+  init.request_stencil = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   // Check trying to upload data fails.
   TexImage2D tex_cmd;
   tex_cmd.Init(
       GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT,
       1, 1, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
       kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(tex_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
@@ skipping 23 matching lines @@
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 
   // Check that trying to CopyTexSubImage2D fails
   CopyTexSubImage2D copy_sub_cmd;
   copy_sub_cmd.Init(GL_TEXTURE_2D, 0, 0, 0, 0, 0, 1, 1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(copy_sub_cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, GenerateMipmapDepthTexture) {
-  InitDecoder(
-      "GL_ANGLE_depth_texture",      // extensions
-      "opengl es 2.0",   // gl version
-      false,   // has alpha
-      true,    // has depth
-      true,    // has stencil
-      false,   // request alpha
-      true,    // request depth
-      true,    // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_ANGLE_depth_texture";
+  init.gl_version = "opengl es 2.0";
+  init.has_depth = true;
+  init.has_stencil = true;
+  init.request_depth = true;
+  init.request_stencil = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT,
                2, 2, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT,
                0, 0);
   GenerateMipmap cmd;
   cmd.Init(GL_TEXTURE_2D);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, DrawClearsDepthTexture) {
-  InitDecoder(
-      "GL_ANGLE_depth_texture",      // extensions
-      "opengl es 2.0",   // gl version
-      true,    // has alpha
-      true,    // has depth
-      false,   // has stencil
-      true,    // request alpha
-      true,    // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_ANGLE_depth_texture";
+  init.gl_version = "opengl es 2.0";
+  init.has_alpha = true;
+  init.has_depth = true;
+  init.request_alpha = true;
+  init.request_depth = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   SetupDefaultProgram();
   SetupAllNeededVertexBuffers();
   const GLenum attachment = GL_DEPTH_ATTACHMENT;
   const GLenum target = GL_TEXTURE_2D;
   const GLint level = 0;
   DoBindTexture(target, client_texture_id_, kServiceTextureId);
 
   // Create a depth texture.
   DoTexImage2D(target, level, GL_DEPTH_COMPONENT, 1, 1, 0,
@@ skipping 102 matching lines @@
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 class GLES2DecoderVertexArraysOESTest : public GLES2DecoderWithShaderTest {
  public:
   GLES2DecoderVertexArraysOESTest() { }
 
   bool vertex_array_deleted_manually_;
 
   virtual void SetUp() {
-    InitDecoder(
-        "GL_OES_vertex_array_object",  // extensions
-        "opengl es 2.0",   // gl version
-        false,  // has alpha
-        false,  // has depth
-        false,  // has stencil
-        false,  // request alpha
-        false,  // request depth
-        false,  // request stencil
-        true);  // bind generates resource
+    InitState init;
+    init.extensions = "GL_OES_vertex_array_object";
+    init.gl_version = "opengl es 2.0";
+    init.bind_generates_resource = true;
+    InitDecoder(init);
     SetupDefaultProgram();
 
     AddExpectationsForGenVertexArraysOES();
     GenHelper<GenVertexArraysOESImmediate>(client_vertexarray_id_);
 
     vertex_array_deleted_manually_ = false;
   }
 
   virtual void TearDown() {
     // This should only be set if the test handled deletion of the vertex array
@@ skipping 121 matching lines @@
     EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
   }
 };
 
 class GLES2DecoderEmulatedVertexArraysOESTest
     : public GLES2DecoderVertexArraysOESTest {
  public:
   GLES2DecoderEmulatedVertexArraysOESTest() { }
 
   virtual void SetUp() {
-    InitDecoder(
-        "",     // extensions
-        "3.0",  // gl version
-        false,  // has alpha
-        false,  // has depth
-        false,  // has stencil
-        false,  // request alpha
-        false,  // request depth
-        false,  // request stencil
-        true);  // bind generates resource
+    InitState init;
+    init.gl_version = "3.0";
+    init.bind_generates_resource = true;
+    InitDecoder(init);
     SetupDefaultProgram();
 
     AddExpectationsForGenVertexArraysOES();
     GenHelper<GenVertexArraysOESImmediate>(client_vertexarray_id_);
 
     vertex_array_deleted_manually_ = false;
   }
 };
 
 // Test vertex array objects with native support
@@ skipping 357 matching lines @@
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   FramebufferRenderbuffer fbrb_cmd;
   fbrb_cmd.Init(
       GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER,
       client_renderbuffer_id_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(fbrb_cmd));
 }
 
 TEST_F(GLES2DecoderManualInitTest, DrawWithGLImageExternal) {
-  InitDecoder(
-      "GL_OES_EGL_image_external",  // extensions
-      "opengl es 2.0",              // gl version
-      true,                         // has alpha
-      true,                         // has depth
-      false,                        // has stencil
-      true,                         // request alpha
-      true,                         // request depth
-      false,  // request stencil
-      true);  // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_EGL_image_external";
+  init.gl_version = "opengl es 2.0";
+  init.has_alpha = true;
+  init.has_depth = true;
+  init.request_alpha = true;
+  init.request_depth = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   TextureRef* texture_ref = GetTexture(client_texture_id_);
   scoped_refptr<MockGLImage> image(new MockGLImage);
   group().texture_manager()->SetTarget(texture_ref, GL_TEXTURE_EXTERNAL_OES);
   group().texture_manager()->SetLevelInfo(texture_ref,
                                           GL_TEXTURE_EXTERNAL_OES,
                                           0,
                                           GL_RGBA,
                                           0,
                                           0,
@@ skipping 45 matching lines @@
       .Times(1)
       .RetiresOnSaturation();
   DrawElements cmd;
   cmd.Init(GL_TRIANGLES, kValidIndexRangeCount, GL_UNSIGNED_SHORT,
            kValidIndexRangeStart * 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, GpuMemoryManagerCHROMIUM) {
-  InitDecoder(
-      "GL_ARB_texture_rectangle",  // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_ARB_texture_rectangle";
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   Texture* texture = GetTexture(client_texture_id_)->texture();
   EXPECT_TRUE(texture != NULL);
   EXPECT_TRUE(texture->pool() == GL_TEXTURE_POOL_UNMANAGED_CHROMIUM);
 
   DoBindTexture(
       GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
 
   TexParameteri cmd;
   cmd.Init(GL_TEXTURE_2D,
@@ skipping 11 matching lines @@
   EXPECT_TRUE(texture->pool() == GL_TEXTURE_POOL_MANAGED_CHROMIUM);
 
   cmd.Init(GL_TEXTURE_2D,
            GL_TEXTURE_POOL_CHROMIUM,
            GL_NONE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_ENUM, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransfers) {
-  InitDecoder(
-      "GL_CHROMIUM_async_pixel_transfers",  // extensions
-      "3.0",   // gl version
-      false, false, false,  // has alpha/depth/stencil
-      false, false, false,  // request alpha/depth/stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_CHROMIUM_async_pixel_transfers";
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   // Set up the texture.
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureRef* texture_ref = GetTexture(client_texture_id_);
   Texture* texture = texture_ref->texture();
 
   // Set a mock Async delegate
   StrictMock<gpu::MockAsyncPixelTransferManager>* manager =
       new StrictMock<gpu::MockAsyncPixelTransferManager>;
   manager->Initialize(group().texture_manager());
@@ skipping 165 matching lines @@
     EXPECT_TRUE(texture->IsImmutable());
     // Wait for completion.
     EXPECT_CALL(*delegate, WaitForTransferCompletion());
     EXPECT_CALL(*manager, BindCompletedAsyncTransfers());
     EXPECT_EQ(error::kNoError, ExecuteCmd(wait_cmd));
     EXPECT_EQ(GL_NO_ERROR, GetGLError());
   }
 }
 
 TEST_F(GLES2DecoderManualInitTest, AsyncPixelTransferManager) {
-  InitDecoder(
-      "GL_CHROMIUM_async_pixel_transfers",  // extensions
-      "3.0",   // gl version
-      false, false, false,  // has alpha/depth/stencil
-      false, false, false,  // request alpha/depth/stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_CHROMIUM_async_pixel_transfers";
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   // Set up the texture.
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   TextureRef* texture_ref = GetTexture(client_texture_id_);
 
   // Set a mock Async delegate.
   StrictMock<gpu::MockAsyncPixelTransferManager>* manager =
       new StrictMock<gpu::MockAsyncPixelTransferManager>;
   manager->Initialize(group().texture_manager());
   decoder_->SetAsyncPixelTransferManagerForTest(manager);
@@ skipping 78 matching lines @@
   };
   std::map<Pool, PoolInfo> pool_infos_;
 };
 
 }  // anonymous namespace.
 
 TEST_F(GLES2DecoderManualInitTest, MemoryTrackerInitialSize) {
   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
       new SizeOnlyMemoryTracker();
   set_memory_tracker(memory_tracker.get());
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   // Expect that initial size - size is 0.
   EXPECT_EQ(0u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
   EXPECT_EQ(0u, memory_tracker->GetPoolSize(MemoryTracker::kManaged));
 }
 
 TEST_F(GLES2DecoderManualInitTest, MemoryTrackerTexImage2D) {
   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
       new SizeOnlyMemoryTracker();
   set_memory_tracker(memory_tracker.get());
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
       .WillOnce(Return(true)).RetiresOnSaturation();
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 8, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(64))
       .WillOnce(Return(true)).RetiresOnSaturation();
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE,
                kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(64u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   // Check we get out of memory and no call to glTexImage2D if Ensure fails.
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(64))
       .WillOnce(Return(false)).RetiresOnSaturation();
   TexImage2D cmd;
   cmd.Init(GL_TEXTURE_2D, 0, GL_RGBA, 4, 4, 0, GL_RGBA, GL_UNSIGNED_BYTE,
            kSharedMemoryId, kSharedMemoryOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_EQ(64u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
 }
 
 TEST_F(GLES2DecoderManualInitTest, MemoryTrackerTexStorage2DEXT) {
   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
       new SizeOnlyMemoryTracker();
   set_memory_tracker(memory_tracker.get());
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   // Check we get out of memory and no call to glTexStorage2DEXT
   // if Ensure fails.
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
       .WillOnce(Return(false)).RetiresOnSaturation();
   TexStorage2DEXT cmd;
   cmd.Init(GL_TEXTURE_2D, 1, GL_RGBA8, 8, 4);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(0u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, MemoryTrackerCopyTexImage2D) {
   GLenum target = GL_TEXTURE_2D;
   GLint level = 0;
   GLenum internal_format = GL_RGBA;
   GLsizei width = 4;
   GLsizei height = 8;
   GLint border = 0;
   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
       new SizeOnlyMemoryTracker();
   set_memory_tracker(memory_tracker.get());
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      true,    // has alpha
-      false,   // has depth
-      false,   // has stencil
-      true,    // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_alpha = true;
+  init.request_alpha = true;
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
       .WillOnce(Return(true)).RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, CopyTexImage2D(
       target, level, internal_format, 0, 0, width, height, border))
       .Times(1)
       .RetiresOnSaturation();
   CopyTexImage2D cmd;
   cmd.Init(target, level, internal_format, 0, 0, width, height, border);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   // Check we get out of memory and no call to glCopyTexImage2D if Ensure fails.
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
       .WillOnce(Return(false)).RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
 }
 
 TEST_F(GLES2DecoderManualInitTest, MemoryTrackerRenderbufferStorage) {
   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
       new SizeOnlyMemoryTracker();
   set_memory_tracker(memory_tracker.get());
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindRenderbuffer(GL_RENDERBUFFER, client_renderbuffer_id_,
                     kServiceRenderbufferId);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
       .WillOnce(Return(true)).RetiresOnSaturation();
   EXPECT_CALL(*gl_, RenderbufferStorageEXT(
       GL_RENDERBUFFER, GL_RGBA, 8, 4))
@@ skipping 10 matching lines @@
       .WillOnce(Return(false)).RetiresOnSaturation();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_OUT_OF_MEMORY, GetGLError());
   EXPECT_EQ(128u, memory_tracker->GetPoolSize(MemoryTracker::kUnmanaged));
 }
 
 TEST_F(GLES2DecoderManualInitTest, MemoryTrackerBufferData) {
   scoped_refptr<SizeOnlyMemoryTracker> memory_tracker =
       new SizeOnlyMemoryTracker();
   set_memory_tracker(memory_tracker.get());
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
   DoBindBuffer(GL_ARRAY_BUFFER, client_buffer_id_,
                kServiceBufferId);
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*memory_tracker.get(), EnsureGPUMemoryAvailable(128))
       .WillOnce(Return(true)).RetiresOnSaturation();
   EXPECT_CALL(*gl_, BufferData(GL_ARRAY_BUFFER, 128, _, GL_STREAM_DRAW))
       .Times(1)
@@ skipping 61 matching lines @@
   EXPECT_CALL(*gl_, DrawBuffersARB(count, _))
       .Times(1)
       .RetiresOnSaturation();
 
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(bufs)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, InvalidateFramebufferBinding) {
-  InitDecoder("",                            // extensions
-              "opengl es 3.0",               // gl version
-              false,                         // has alpha
-              false,                         // has depth
-              false,                         // has stencil
-              false,                         // request alpha
-              false,                         // request depth
-              false,                         // request stencil
-              false);                        // bind generates resource
+  InitState init;
+  init.gl_version = "opengl es 3.0";
+  InitDecoder(init);
 
   // EXPECT_EQ can't be used to compare function pointers
   EXPECT_TRUE(
       gfx::MockGLInterface::GetGLProcAddress("glInvalidateFramebuffer") ==
       gfx::g_driver_gl.fn.glDiscardFramebufferEXTFn);
   EXPECT_TRUE(
       gfx::MockGLInterface::GetGLProcAddress("glInvalidateFramebuffer") !=
       gfx::MockGLInterface::GetGLProcAddress("glDiscardFramebufferEXT"));
 }
 
 TEST_F(GLES2DecoderManualInitTest, DiscardFramebufferEXT) {
-  InitDecoder("GL_EXT_discard_framebuffer",  // extensions
-              "opengl es 2.0",               // gl version
-              false,                         // has alpha
-              false,                         // has depth
-              false,                         // has stencil
-              false,                         // request alpha
-              false,                         // request depth
-              false,                         // request stencil
-              false);                        // bind generates resource
+  InitState init;
+  init.extensions = "GL_EXT_discard_framebuffer";
+  init.gl_version = "opengl es 2.0";
+  InitDecoder(init);
 
   // EXPECT_EQ can't be used to compare function pointers
   EXPECT_TRUE(
       gfx::MockGLInterface::GetGLProcAddress("glDiscardFramebufferEXT") ==
       gfx::g_driver_gl.fn.glDiscardFramebufferEXTFn);
 
   const GLenum target = GL_FRAMEBUFFER;
   const GLsizei count = 1;
   const GLenum attachments[] = { GL_COLOR_ATTACHMENT0 };
 
@@ skipping 33 matching lines @@
       *GetImmediateAs<DiscardFramebufferEXTImmediate>();
   cmd.Init(target, count, attachments);
 
   // Should not result into a call into GL.
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(attachments)));
   EXPECT_EQ(GL_INVALID_OPERATION, GetGLError());
 }
 
 TEST_F(GLES2DecoderRestoreStateTest, NullPreviousState) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      false);  // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  InitDecoder(init);
   SetupTexture();
 
   InSequence sequence;
   // Expect to restore texture bindings for unit GL_TEXTURE0.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
   AddExpectationsForBindTexture(GL_TEXTURE_2D, kServiceTextureId);
   AddExpectationsForBindTexture(GL_TEXTURE_CUBE_MAP,
                                 TestHelper::kServiceDefaultTextureCubemapId);
 
   // Expect to restore texture bindings for remaining units.
   for (uint32 i = 1; i < group().max_texture_units() ; ++i) {
     AddExpectationsForActiveTexture(GL_TEXTURE0 + i);
     AddExpectationsForBindTexture(GL_TEXTURE_2D,
                                   TestHelper::kServiceDefaultTexture2dId);
     AddExpectationsForBindTexture(GL_TEXTURE_CUBE_MAP,
                                   TestHelper::kServiceDefaultTextureCubemapId);
   }
 
   // Expect to restore the active texture unit to GL_TEXTURE0.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
 
   GetDecoder()->RestoreAllTextureUnitBindings(NULL);
 }
 
 TEST_F(GLES2DecoderRestoreStateTest, WithPreviousState) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      false);  // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  InitDecoder(init);
   SetupTexture();
 
   // Construct a previous ContextState with all texture bindings
   // set to default textures.
-  ContextState prev_state(NULL, NULL);
+  ContextState prev_state(NULL, NULL, NULL);
   InitializeContextState(&prev_state, std::numeric_limits<uint32>::max(), 0);
 
   InSequence sequence;
   // Expect to restore only GL_TEXTURE_2D binding for GL_TEXTURE0 unit,
   // since the rest of the bindings haven't changed between the current
   // state and the |prev_state|.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
   AddExpectationsForBindTexture(GL_TEXTURE_2D, kServiceTextureId);
 
   // Expect to restore active texture unit to GL_TEXTURE0.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
 
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
 TEST_F(GLES2DecoderRestoreStateTest, ActiveUnit1) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      false);  // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  InitDecoder(init);
 
   // Bind a non-default texture to GL_TEXTURE1 unit.
   EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE1));
   ActiveTexture cmd;
   cmd.Init(GL_TEXTURE1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   SetupTexture();
 
   // Construct a previous ContextState with all texture bindings
   // set to default textures.
-  ContextState prev_state(NULL, NULL);
+  ContextState prev_state(NULL, NULL, NULL);
   InitializeContextState(&prev_state, std::numeric_limits<uint32>::max(), 0);
 
   InSequence sequence;
   // Expect to restore only GL_TEXTURE_2D binding for GL_TEXTURE1 unit,
   // since the rest of the bindings haven't changed between the current
   // state and the |prev_state|.
   AddExpectationsForActiveTexture(GL_TEXTURE1);
   AddExpectationsForBindTexture(GL_TEXTURE_2D, kServiceTextureId);
 
   // Expect to restore active texture unit to GL_TEXTURE1.
   AddExpectationsForActiveTexture(GL_TEXTURE1);
 
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
 TEST_F(GLES2DecoderRestoreStateTest, NonDefaultUnit0) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      false);  // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  InitDecoder(init);
 
   // Bind a non-default texture to GL_TEXTURE1 unit.
   EXPECT_CALL(*gl_, ActiveTexture(GL_TEXTURE1));
   SpecializedSetup<ActiveTexture, 0>(true);
   ActiveTexture cmd;
   cmd.Init(GL_TEXTURE1);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
   SetupTexture();
 
   // Construct a previous ContextState with GL_TEXTURE_2D target in
   // GL_TEXTURE0 unit bound to a non-default texture and the rest
   // set to default textures.
-  ContextState prev_state(NULL, NULL);
+  ContextState prev_state(NULL, NULL, NULL);
   InitializeContextState(&prev_state, 0, kServiceTextureId);
 
   InSequence sequence;
   // Expect to restore GL_TEXTURE_2D binding for GL_TEXTURE0 unit to
   // a default texture.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
   AddExpectationsForBindTexture(GL_TEXTURE_2D,
                                 TestHelper::kServiceDefaultTexture2dId);
 
   // Expect to restore GL_TEXTURE_2D binding for GL_TEXTURE1 unit to
   // non-default.
   AddExpectationsForActiveTexture(GL_TEXTURE1);
   AddExpectationsForBindTexture(GL_TEXTURE_2D, kServiceTextureId);
 
   // Expect to restore active texture unit to GL_TEXTURE1.
   AddExpectationsForActiveTexture(GL_TEXTURE1);
 
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
 TEST_F(GLES2DecoderRestoreStateTest, NonDefaultUnit1) {
-  InitDecoder(
-      "",      // extensions
-      "3.0",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      false);  // bind generates resource
+  InitState init;
+  init.gl_version = "3.0";
+  InitDecoder(init);
 
   // Bind a non-default texture to GL_TEXTURE0 unit.
   SetupTexture();
 
   // Construct a previous ContextState with GL_TEXTURE_2D target in
   // GL_TEXTURE1 unit bound to a non-default texture and the rest
   // set to default textures.
-  ContextState prev_state(NULL, NULL);
+  ContextState prev_state(NULL, NULL, NULL);
   InitializeContextState(&prev_state, 1, kServiceTextureId);
 
   InSequence sequence;
   // Expect to restore GL_TEXTURE_2D binding to the non-default texture
   // for GL_TEXTURE0 unit.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
   AddExpectationsForBindTexture(GL_TEXTURE_2D, kServiceTextureId);
 
   // Expect to restore GL_TEXTURE_2D binding to the default texture
   // for GL_TEXTURE1 unit.
   AddExpectationsForActiveTexture(GL_TEXTURE1);
   AddExpectationsForBindTexture(GL_TEXTURE_2D,
                                 TestHelper::kServiceDefaultTexture2dId);
 
   // Expect to restore active texture unit to GL_TEXTURE0.
   AddExpectationsForActiveTexture(GL_TEXTURE0);
 
   GetDecoder()->RestoreAllTextureUnitBindings(&prev_state);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ClearUniformsBeforeFirstProgramUse) {
   CommandLine command_line(0, NULL);
   command_line.AppendSwitchASCII(
       switches::kGpuDriverBugWorkarounds,
       base::IntToString(gpu::CLEAR_UNIFORMS_BEFORE_FIRST_PROGRAM_USE));
-  InitDecoderWithCommandLine(
-      "",      // extensions
-      "3.0",   // gl version
-      true,    // has alpha
-      false,   // has depth
-      false,   // has stencil
-      true,    // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true,    // bind generates resource
-      &command_line);
+  InitState init;
+  init.gl_version = "3.0";
+  init.has_alpha = true;
+  init.request_alpha = true;
+  init.bind_generates_resource = true;
+  InitDecoderWithCommandLine(init, &command_line);
   {
     static AttribInfo attribs[] = {
       { kAttrib1Name, kAttrib1Size, kAttrib1Type, kAttrib1Location, },
       { kAttrib2Name, kAttrib2Size, kAttrib2Type, kAttrib2Location, },
       { kAttrib3Name, kAttrib3Size, kAttrib3Type, kAttrib3Location, },
     };
     static UniformInfo uniforms[] = {
       { kUniform1Name, kUniform1Size, kUniform1Type,
         kUniform1FakeLocation, kUniform1RealLocation,
         kUniform1DesiredLocation },
@@ skipping 16 matching lines @@
     EXPECT_CALL(*gl_, UseProgram(kServiceProgramId))
         .Times(1)
         .RetiresOnSaturation();
     cmds::UseProgram cmd;
     cmd.Init(client_program_id_);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   }
 }
 
 TEST_F(GLES2DecoderManualInitTest, TexImage2DFloatOnGLES2) {
-  InitDecoder("GL_OES_texture_float",        // extensions
-              "opengl es 2.0",               // gl version
-              false,                         // has alpha
-              false,                         // has depth
-              false,                         // has stencil
-              false,                         // request alpha
-              false,                         // request depth
-              false,                         // request stencil
-              false);                        // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_texture_float";
+  init.gl_version = "opengl es 2.0";
+  InitDecoder(init);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 17, 0, GL_RGBA, GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 16, 17, 0, GL_RGB, GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 16, 17, 0, GL_LUMINANCE,
                GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 16, 17, 0, GL_ALPHA, GL_FLOAT,
                0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 16, 17, 0,
                GL_LUMINANCE_ALPHA, GL_FLOAT, 0, 0);
 }
 
 TEST_F(GLES2DecoderManualInitTest, TexImage2DFloatOnGLES3) {
-  InitDecoder("GL_OES_texture_float GL_EXT_color_buffer_float", // extensions
-              "opengl es 3.0",               // gl version
-              false,                         // has alpha
-              false,                         // has depth
-              false,                         // has stencil
-              false,                         // request alpha
-              false,                         // request depth
-              false,                         // request stencil
-              false);                        // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_texture_float GL_EXT_color_buffer_float";
+  init.gl_version = "opengl es 3.0";
+  InitDecoder(init);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, 16, 17, 0, GL_RGBA, GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, 16, 17, 0, GL_RGB, GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 16, 17, 0, GL_RGBA, GL_FLOAT, 0,
                0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, 16, 17, 0, GL_LUMINANCE,
                GL_FLOAT, 0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_ALPHA, 16, 17, 0, GL_ALPHA, GL_FLOAT,
                0, 0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 16, 17, 0,
                GL_LUMINANCE_ALPHA, GL_FLOAT, 0, 0);
 }
 
 TEST_F(GLES2DecoderManualInitTest, TexSubImage2DFloatOnGLES3) {
-  InitDecoder("GL_OES_texture_float GL_EXT_color_buffer_float", // extensions
-              "opengl es 3.0",               // gl version
-              false,                         // has alpha
-              false,                         // has depth
-              false,                         // has stencil
-              false,                         // request alpha
-              false,                         // request depth
-              false,                         // request stencil
-              false);                        // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_texture_float GL_EXT_color_buffer_float";
+  init.gl_version = "opengl es 3.0";
+  InitDecoder(init);
   const int kWidth = 8;
   const int kHeight = 4;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, kWidth, kHeight, 0, GL_RGBA,
                GL_FLOAT, 0, 0);
   EXPECT_CALL(*gl_, TexImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA32F, kWidth, kHeight, 0, GL_RGBA, GL_FLOAT,
       shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   TexSubImage2D cmd;
   cmd.Init(
       GL_TEXTURE_2D, 0, 0, 0, kWidth, kHeight, GL_RGBA, GL_FLOAT,
       kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, TexSubImage2DFloatDoesClearOnGLES3) {
-  InitDecoder("GL_OES_texture_float GL_EXT_color_buffer_float", // extensions
-              "opengl es 3.0",               // gl version
-              false,                         // has alpha
-              false,                         // has depth
-              false,                         // has stencil
-              false,                         // request alpha
-              false,                         // request depth
-              false,                         // request stencil
-              false);                        // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_texture_float GL_EXT_color_buffer_float";
+  init.gl_version = "opengl es 3.0";
+  InitDecoder(init);
   const int kWidth = 8;
   const int kHeight = 4;
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, kWidth, kHeight, 0, GL_RGBA,
                GL_FLOAT, 0, 0);
   SetupClearTextureExpectations(
       kServiceTextureId, kServiceTextureId, GL_TEXTURE_2D, GL_TEXTURE_2D,
       0, GL_RGBA32F, GL_RGBA, GL_FLOAT, kWidth, kHeight);
   EXPECT_CALL(*gl_, TexSubImage2D(
       GL_TEXTURE_2D, 0, 1, 0, kWidth - 1, kHeight, GL_RGBA, GL_FLOAT,
       shared_memory_address_))
       .Times(1)
       .RetiresOnSaturation();
   TexSubImage2D cmd;
   cmd.Init(
       GL_TEXTURE_2D, 0, 1, 0, kWidth - 1, kHeight, GL_RGBA, GL_FLOAT,
       kSharedMemoryId, kSharedMemoryOffset, GL_FALSE);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, TexImage2DFloatConvertsFormatDesktop) {
-  InitDecoder("GL_ARB_texture_float",        // extensions
-              "2.1",                         // gl version
-              false,                         // has alpha
-              false,                         // has depth
-              false,                         // has stencil
-              false,                         // request alpha
-              false,                         // request depth
-              false,                         // request stencil
-              false);                        // bind generates resource
+  InitState init;
+  init.extensions = "GL_ARB_texture_float";
+  init.gl_version = "2.1";
+  InitDecoder(init);
   DoBindTexture(GL_TEXTURE_2D, client_texture_id_, kServiceTextureId);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, 16, 17, 0, GL_RGBA, GL_FLOAT, 0,
                0);
   DoTexImage2D(GL_TEXTURE_2D, 0, GL_RGB32F, 16, 17, 0, GL_RGB, GL_FLOAT, 0, 0);
   DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D, 0, GL_RGBA, 16, 17, 0,
                                     GL_RGBA, GL_FLOAT, 0, 0, GL_RGBA32F_ARB);
   DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D, 0, GL_RGB, 16, 17, 0,
                                     GL_RGB, GL_FLOAT, 0, 0, GL_RGB32F_ARB);
   DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D, 0, GL_LUMINANCE, 16, 17, 0,
                                     GL_LUMINANCE, GL_FLOAT, 0, 0,
                                     GL_LUMINANCE32F_ARB);
   DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D, 0, GL_ALPHA, 16, 17, 0,
                                     GL_ALPHA, GL_FLOAT, 0, 0, GL_ALPHA32F_ARB);
   DoTexImage2DConvertInternalFormat(GL_TEXTURE_2D, 0, GL_LUMINANCE_ALPHA, 16,
                                     17, 0, GL_LUMINANCE_ALPHA, GL_FLOAT, 0, 0,
                                     GL_LUMINANCE_ALPHA32F_ARB);
 }
 
 TEST_F(GLES2DecoderManualInitTest, ReadFormatExtension) {
-  InitDecoder(
-      "GL_OES_read_format",  // extensions
-      "2.1",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.extensions = "GL_OES_read_format";
+  init.gl_version = "2.1";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
   EXPECT_CALL(*gl_, GetError())
       .Times(6)
       .RetiresOnSaturation();
@@ skipping 37 matching lines @@
       .RetiresOnSaturation();
   cmd.Init(
       GL_IMPLEMENTATION_COLOR_READ_TYPE,
       shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(1, result->GetNumResults());
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderManualInitTest, NoReadFormatExtension) {
-  InitDecoder(
-      "",  // extensions
-      "2.1",   // gl version
-      false,   // has alpha
-      false,   // has depth
-      false,   // has stencil
-      false,   // request alpha
-      false,   // request depth
-      false,   // request stencil
-      true);   // bind generates resource
+  InitState init;
+  init.gl_version = "2.1";
+  init.bind_generates_resource = true;
+  InitDecoder(init);
 
   EXPECT_CALL(*gl_, GetError())
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .WillOnce(Return(GL_NO_ERROR))
       .RetiresOnSaturation();
 
   typedef GetIntegerv::Result Result;
   Result* result = static_cast<Result*>(shared_memory_address_);
@@ skipping 69 matching lines @@
 // TODO(gman): TexImage2DImmediate
 
 // TODO(gman): TexSubImage2DImmediate
 
 // TODO(gman): UseProgram
 
 // TODO(gman): SwapBuffers
 
 }  // namespace gles2
 }  // namespace gpu