Add glBindUniformLocationCHROMIUM

gpu/command_buffer/service/gles2_cmd_decoder_unittest_2_autogen.h

 // 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.
 
 // This file is auto-generated from
 // gpu/command_buffer/build_gles2_cmd_buffer.py
 // DO NOT EDIT!
 
 // It is included by gles2_cmd_decoder_unittest_2.cc
 #ifndef GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_
@@ skipping 682 matching lines @@
 }
 // TODO(gman): TexSubImage2D
 
 // TODO(gman): TexSubImage2DImmediate
 
 
 TEST_F(GLES2DecoderTest2, Uniform1fValidArgs) {
   EXPECT_CALL(*gl_, Uniform1fv(1, 1, _));
   SpecializedSetup<Uniform1f, 0>(true);
   Uniform1f cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2);
+  cmd.Init(1, 2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform1fvValidArgs) {
   EXPECT_CALL(
       *gl_, Uniform1fv(
           1, 2, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<Uniform1fv, 0>(true);
   Uniform1fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform1fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform1fv, 0>(false);
   Uniform1fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), -1, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform1fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform1fv, 0>(false);
   Uniform1fv cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, kInvalidSharedMemoryId, 0);
+  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform1fvInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform1fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform1fv, 0>(false);
   Uniform1fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, kInvalidSharedMemoryOffset);
+  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform1fvValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_, Uniform1fv(
           3, 3, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<Uniform1fv, 0>(true);
   Uniform1fv cmd;
   cmd.Init(
-      GLES2Util::SwizzleLocation(
-          GLES2Util::MakeFakeLocation(
-              1, 1)), 5, shared_memory_id_, shared_memory_offset_);
+      ProgramManager::MakeFakeLocation(
+          1, 1), 5, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform1fvImmediateValidArgs) {
   Uniform1fvImmediate& cmd = *GetImmediateAs<Uniform1fvImmediate>();
   EXPECT_CALL(
       *gl_,
       Uniform1fv(1, 2,
           reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<Uniform1fvImmediate, 0>(true);
   GLfloat temp[1 * 2] = { 0, };
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, &temp[0]);
+  cmd.Init(1, 2, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 // TODO(gman): Uniform1i
 // TODO(gman): Uniform1iv
 // TODO(gman): Uniform1ivImmediate
 
 TEST_F(GLES2DecoderTest2, Uniform2fValidArgs) {
   EXPECT_CALL(*gl_, Uniform2fv(1, 1, _));
   SpecializedSetup<Uniform2f, 0>(true);
   Uniform2f cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, 3);
+  cmd.Init(1, 2, 3);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform2fvValidArgs) {
   EXPECT_CALL(
       *gl_, Uniform2fv(
           1, 2, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<Uniform2fv, 0>(true);
   Uniform2fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform2fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform2fv, 0>(false);
   Uniform2fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), -1, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform2fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform2fv, 0>(false);
   Uniform2fv cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, kInvalidSharedMemoryId, 0);
+  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform2fvInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform2fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform2fv, 0>(false);
   Uniform2fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, kInvalidSharedMemoryOffset);
+  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform2fvValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_, Uniform2fv(
           3, 3, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<Uniform2fv, 0>(true);
   Uniform2fv cmd;
   cmd.Init(
-      GLES2Util::SwizzleLocation(
-          GLES2Util::MakeFakeLocation(
-              1, 1)), 5, shared_memory_id_, shared_memory_offset_);
+      ProgramManager::MakeFakeLocation(
+          1, 1), 5, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform2fvImmediateValidArgs) {
   Uniform2fvImmediate& cmd = *GetImmediateAs<Uniform2fvImmediate>();
   EXPECT_CALL(
       *gl_,
       Uniform2fv(1, 2,
           reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<Uniform2fvImmediate, 0>(true);
   GLfloat temp[2 * 2] = { 0, };
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, &temp[0]);
+  cmd.Init(1, 2, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform2iValidArgs) {
   EXPECT_CALL(*gl_, Uniform2iv(1, 1, _));
   SpecializedSetup<Uniform2i, 0>(true);
   Uniform2i cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, 3);
+  cmd.Init(1, 2, 3);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform2ivValidArgs) {
   EXPECT_CALL(
       *gl_, Uniform2iv(
           1, 2, reinterpret_cast<const GLint*>(shared_memory_address_)));
   SpecializedSetup<Uniform2iv, 0>(true);
   Uniform2iv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform2ivInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
   SpecializedSetup<Uniform2iv, 0>(false);
   Uniform2iv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), -1, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform2ivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
   SpecializedSetup<Uniform2iv, 0>(false);
   Uniform2iv cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, kInvalidSharedMemoryId, 0);
+  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform2ivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform2iv(_, _, _)).Times(0);
   SpecializedSetup<Uniform2iv, 0>(false);
   Uniform2iv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, kInvalidSharedMemoryOffset);
+  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform2ivValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_, Uniform2iv(
           3, 3, reinterpret_cast<const GLint*>(shared_memory_address_)));
   SpecializedSetup<Uniform2iv, 0>(true);
   Uniform2iv cmd;
   cmd.Init(
-      GLES2Util::SwizzleLocation(
-          GLES2Util::MakeFakeLocation(
-              1, 1)), 5, shared_memory_id_, shared_memory_offset_);
+      ProgramManager::MakeFakeLocation(
+          1, 1), 5, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform2ivImmediateValidArgs) {
   Uniform2ivImmediate& cmd = *GetImmediateAs<Uniform2ivImmediate>();
   EXPECT_CALL(
       *gl_,
       Uniform2iv(1, 2,
           reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<Uniform2ivImmediate, 0>(true);
   GLint temp[2 * 2] = { 0, };
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, &temp[0]);
+  cmd.Init(1, 2, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3fValidArgs) {
   EXPECT_CALL(*gl_, Uniform3fv(1, 1, _));
   SpecializedSetup<Uniform3f, 0>(true);
   Uniform3f cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, 3, 4);
+  cmd.Init(1, 2, 3, 4);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3fvValidArgs) {
   EXPECT_CALL(
       *gl_, Uniform3fv(
           1, 2, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<Uniform3fv, 0>(true);
   Uniform3fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform3fv, 0>(false);
   Uniform3fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), -1, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform3fv, 0>(false);
   Uniform3fv cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, kInvalidSharedMemoryId, 0);
+  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3fvInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform3fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform3fv, 0>(false);
   Uniform3fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, kInvalidSharedMemoryOffset);
+  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3fvValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_, Uniform3fv(
           3, 3, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<Uniform3fv, 0>(true);
   Uniform3fv cmd;
   cmd.Init(
-      GLES2Util::SwizzleLocation(
-          GLES2Util::MakeFakeLocation(
-              1, 1)), 5, shared_memory_id_, shared_memory_offset_);
+      ProgramManager::MakeFakeLocation(
+          1, 1), 5, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3fvImmediateValidArgs) {
   Uniform3fvImmediate& cmd = *GetImmediateAs<Uniform3fvImmediate>();
   EXPECT_CALL(
       *gl_,
       Uniform3fv(1, 2,
           reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<Uniform3fvImmediate, 0>(true);
   GLfloat temp[3 * 2] = { 0, };
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, &temp[0]);
+  cmd.Init(1, 2, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3iValidArgs) {
   EXPECT_CALL(*gl_, Uniform3iv(1, 1, _));
   SpecializedSetup<Uniform3i, 0>(true);
   Uniform3i cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, 3, 4);
+  cmd.Init(1, 2, 3, 4);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3ivValidArgs) {
   EXPECT_CALL(
       *gl_, Uniform3iv(
           1, 2, reinterpret_cast<const GLint*>(shared_memory_address_)));
   SpecializedSetup<Uniform3iv, 0>(true);
   Uniform3iv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3ivInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
   SpecializedSetup<Uniform3iv, 0>(false);
   Uniform3iv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), -1, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3ivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
   SpecializedSetup<Uniform3iv, 0>(false);
   Uniform3iv cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, kInvalidSharedMemoryId, 0);
+  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3ivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform3iv(_, _, _)).Times(0);
   SpecializedSetup<Uniform3iv, 0>(false);
   Uniform3iv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, kInvalidSharedMemoryOffset);
+  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3ivValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_, Uniform3iv(
           3, 3, reinterpret_cast<const GLint*>(shared_memory_address_)));
   SpecializedSetup<Uniform3iv, 0>(true);
   Uniform3iv cmd;
   cmd.Init(
-      GLES2Util::SwizzleLocation(
-          GLES2Util::MakeFakeLocation(
-              1, 1)), 5, shared_memory_id_, shared_memory_offset_);
+      ProgramManager::MakeFakeLocation(
+          1, 1), 5, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform3ivImmediateValidArgs) {
   Uniform3ivImmediate& cmd = *GetImmediateAs<Uniform3ivImmediate>();
   EXPECT_CALL(
       *gl_,
       Uniform3iv(1, 2,
           reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<Uniform3ivImmediate, 0>(true);
   GLint temp[3 * 2] = { 0, };
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, &temp[0]);
+  cmd.Init(1, 2, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4fValidArgs) {
   EXPECT_CALL(*gl_, Uniform4fv(1, 1, _));
   SpecializedSetup<Uniform4f, 0>(true);
   Uniform4f cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, 3, 4, 5);
+  cmd.Init(1, 2, 3, 4, 5);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4fvValidArgs) {
   EXPECT_CALL(
       *gl_, Uniform4fv(
           1, 2, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<Uniform4fv, 0>(true);
   Uniform4fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform4fv, 0>(false);
   Uniform4fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), -1, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform4fv, 0>(false);
   Uniform4fv cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, kInvalidSharedMemoryId, 0);
+  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4fvInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform4fv(_, _, _)).Times(0);
   SpecializedSetup<Uniform4fv, 0>(false);
   Uniform4fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, kInvalidSharedMemoryOffset);
+  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4fvValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_, Uniform4fv(
           3, 3, reinterpret_cast<const GLfloat*>(shared_memory_address_)));
   SpecializedSetup<Uniform4fv, 0>(true);
   Uniform4fv cmd;
   cmd.Init(
-      GLES2Util::SwizzleLocation(
-          GLES2Util::MakeFakeLocation(
-              1, 1)), 5, shared_memory_id_, shared_memory_offset_);
+      ProgramManager::MakeFakeLocation(
+          1, 1), 5, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4fvImmediateValidArgs) {
   Uniform4fvImmediate& cmd = *GetImmediateAs<Uniform4fvImmediate>();
   EXPECT_CALL(
       *gl_,
       Uniform4fv(1, 2,
           reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<Uniform4fvImmediate, 0>(true);
   GLfloat temp[4 * 2] = { 0, };
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, &temp[0]);
+  cmd.Init(1, 2, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4iValidArgs) {
   EXPECT_CALL(*gl_, Uniform4iv(1, 1, _));
   SpecializedSetup<Uniform4i, 0>(true);
   Uniform4i cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, 3, 4, 5);
+  cmd.Init(1, 2, 3, 4, 5);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4ivValidArgs) {
   EXPECT_CALL(
       *gl_, Uniform4iv(
           1, 2, reinterpret_cast<const GLint*>(shared_memory_address_)));
   SpecializedSetup<Uniform4iv, 0>(true);
   Uniform4iv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4ivInvalidArgs1_0) {
   EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
   SpecializedSetup<Uniform4iv, 0>(false);
   Uniform4iv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), -1, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, -1, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4ivInvalidArgs2_0) {
   EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
   SpecializedSetup<Uniform4iv, 0>(false);
   Uniform4iv cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, kInvalidSharedMemoryId, 0);
+  cmd.Init(1, 2, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4ivInvalidArgs2_1) {
   EXPECT_CALL(*gl_, Uniform4iv(_, _, _)).Times(0);
   SpecializedSetup<Uniform4iv, 0>(false);
   Uniform4iv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, shared_memory_id_, kInvalidSharedMemoryOffset);
+  cmd.Init(1, 2, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4ivValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_, Uniform4iv(
           3, 3, reinterpret_cast<const GLint*>(shared_memory_address_)));
   SpecializedSetup<Uniform4iv, 0>(true);
   Uniform4iv cmd;
   cmd.Init(
-      GLES2Util::SwizzleLocation(
-          GLES2Util::MakeFakeLocation(
-              1, 1)), 5, shared_memory_id_, shared_memory_offset_);
+      ProgramManager::MakeFakeLocation(
+          1, 1), 5, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, Uniform4ivImmediateValidArgs) {
   Uniform4ivImmediate& cmd = *GetImmediateAs<Uniform4ivImmediate>();
   EXPECT_CALL(
       *gl_,
       Uniform4iv(1, 2,
           reinterpret_cast<GLint*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<Uniform4ivImmediate, 0>(true);
   GLint temp[4 * 2] = { 0, };
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, &temp[0]);
+  cmd.Init(1, 2, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix2fvValidArgs) {
   EXPECT_CALL(
       *gl_, UniformMatrix2fv(
           1, 2, false, reinterpret_cast<const GLfloat*>(
               shared_memory_address_)));
   SpecializedSetup<UniformMatrix2fv, 0>(true);
   UniformMatrix2fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, false, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix2fv, 0>(false);
   UniformMatrix2fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), -1, false, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, -1, false, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix2fv, 0>(false);
   UniformMatrix2fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, true, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, true, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_0) {
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix2fv, 0>(false);
   UniformMatrix2fv cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, false, kInvalidSharedMemoryId, 0);
+  cmd.Init(1, 2, false, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix2fvInvalidArgs3_1) {
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix2fv, 0>(false);
   UniformMatrix2fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, false, shared_memory_id_, kInvalidSharedMemoryOffset);
+  cmd.Init(1, 2, false, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix2fvValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_, UniformMatrix2fv(
           3, 3, false, reinterpret_cast<const GLfloat*>(
               shared_memory_address_)));
   SpecializedSetup<UniformMatrix2fv, 0>(true);
   UniformMatrix2fv cmd;
   cmd.Init(
-      GLES2Util::SwizzleLocation(
-          GLES2Util::MakeFakeLocation(
-              1, 1)), 5, false, shared_memory_id_, shared_memory_offset_);
+      ProgramManager::MakeFakeLocation(
+          1, 1), 5, false, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix2fvImmediateValidArgs) {
   UniformMatrix2fvImmediate& cmd =
       *GetImmediateAs<UniformMatrix2fvImmediate>();
   EXPECT_CALL(
       *gl_,
       UniformMatrix2fv(1, 2, false,
           reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<UniformMatrix2fvImmediate, 0>(true);
   GLfloat temp[4 * 2] = { 0, };
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, false, &temp[0]);
+  cmd.Init(1, 2, false, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix2fvImmediateInvalidArgs2_0) {
   UniformMatrix2fvImmediate& cmd =
       *GetImmediateAs<UniformMatrix2fvImmediate>();
   EXPECT_CALL(*gl_, UniformMatrix2fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix2fvImmediate, 0>(false);
   GLfloat temp[4 * 2] = { 0, };
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, true, &temp[0]);
+  cmd.Init(1, 2, true, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix3fvValidArgs) {
   EXPECT_CALL(
       *gl_, UniformMatrix3fv(
           1, 2, false, reinterpret_cast<const GLfloat*>(
               shared_memory_address_)));
   SpecializedSetup<UniformMatrix3fv, 0>(true);
   UniformMatrix3fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, false, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix3fv, 0>(false);
   UniformMatrix3fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), -1, false, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, -1, false, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix3fv, 0>(false);
   UniformMatrix3fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, true, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, true, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_0) {
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix3fv, 0>(false);
   UniformMatrix3fv cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, false, kInvalidSharedMemoryId, 0);
+  cmd.Init(1, 2, false, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix3fvInvalidArgs3_1) {
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix3fv, 0>(false);
   UniformMatrix3fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, false, shared_memory_id_, kInvalidSharedMemoryOffset);
+  cmd.Init(1, 2, false, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix3fvValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_, UniformMatrix3fv(
           3, 3, false, reinterpret_cast<const GLfloat*>(
               shared_memory_address_)));
   SpecializedSetup<UniformMatrix3fv, 0>(true);
   UniformMatrix3fv cmd;
   cmd.Init(
-      GLES2Util::SwizzleLocation(
-          GLES2Util::MakeFakeLocation(
-              1, 1)), 5, false, shared_memory_id_, shared_memory_offset_);
+      ProgramManager::MakeFakeLocation(
+          1, 1), 5, false, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix3fvImmediateValidArgs) {
   UniformMatrix3fvImmediate& cmd =
       *GetImmediateAs<UniformMatrix3fvImmediate>();
   EXPECT_CALL(
       *gl_,
       UniformMatrix3fv(1, 2, false,
           reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<UniformMatrix3fvImmediate, 0>(true);
   GLfloat temp[9 * 2] = { 0, };
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, false, &temp[0]);
+  cmd.Init(1, 2, false, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix3fvImmediateInvalidArgs2_0) {
   UniformMatrix3fvImmediate& cmd =
       *GetImmediateAs<UniformMatrix3fvImmediate>();
   EXPECT_CALL(*gl_, UniformMatrix3fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix3fvImmediate, 0>(false);
   GLfloat temp[9 * 2] = { 0, };
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, true, &temp[0]);
+  cmd.Init(1, 2, true, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix4fvValidArgs) {
   EXPECT_CALL(
       *gl_, UniformMatrix4fv(
           1, 2, false, reinterpret_cast<const GLfloat*>(
               shared_memory_address_)));
   SpecializedSetup<UniformMatrix4fv, 0>(true);
   UniformMatrix4fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, false, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, false, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs1_0) {
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix4fv, 0>(false);
   UniformMatrix4fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), -1, false, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, -1, false, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs2_0) {
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix4fv, 0>(false);
   UniformMatrix4fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, true, shared_memory_id_, shared_memory_offset_);
+  cmd.Init(1, 2, true, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_0) {
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix4fv, 0>(false);
   UniformMatrix4fv cmd;
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, false, kInvalidSharedMemoryId, 0);
+  cmd.Init(1, 2, false, kInvalidSharedMemoryId, 0);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix4fvInvalidArgs3_1) {
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix4fv, 0>(false);
   UniformMatrix4fv cmd;
-  cmd.Init(
-      GLES2Util::SwizzleLocation(
-          1), 2, false, shared_memory_id_, kInvalidSharedMemoryOffset);
+  cmd.Init(1, 2, false, shared_memory_id_, kInvalidSharedMemoryOffset);
   EXPECT_EQ(error::kOutOfBounds, ExecuteCmd(cmd));
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix4fvValidArgsCountTooLarge) {
   EXPECT_CALL(
       *gl_, UniformMatrix4fv(
           3, 3, false, reinterpret_cast<const GLfloat*>(
               shared_memory_address_)));
   SpecializedSetup<UniformMatrix4fv, 0>(true);
   UniformMatrix4fv cmd;
   cmd.Init(
-      GLES2Util::SwizzleLocation(
-          GLES2Util::MakeFakeLocation(
-              1, 1)), 5, false, shared_memory_id_, shared_memory_offset_);
+      ProgramManager::MakeFakeLocation(
+          1, 1), 5, false, shared_memory_id_, shared_memory_offset_);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix4fvImmediateValidArgs) {
   UniformMatrix4fvImmediate& cmd =
       *GetImmediateAs<UniformMatrix4fvImmediate>();
   EXPECT_CALL(
       *gl_,
       UniformMatrix4fv(1, 2, false,
           reinterpret_cast<GLfloat*>(ImmediateDataAddress(&cmd))));
   SpecializedSetup<UniformMatrix4fvImmediate, 0>(true);
   GLfloat temp[16 * 2] = { 0, };
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, false, &temp[0]);
+  cmd.Init(1, 2, false, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_NO_ERROR, GetGLError());
 }
 
 TEST_F(GLES2DecoderTest2, UniformMatrix4fvImmediateInvalidArgs2_0) {
   UniformMatrix4fvImmediate& cmd =
       *GetImmediateAs<UniformMatrix4fvImmediate>();
   EXPECT_CALL(*gl_, UniformMatrix4fv(_, _, _, _)).Times(0);
   SpecializedSetup<UniformMatrix4fvImmediate, 0>(false);
   GLfloat temp[16 * 2] = { 0, };
-  cmd.Init(GLES2Util::SwizzleLocation(1), 2, true, &temp[0]);
+  cmd.Init(1, 2, true, &temp[0]);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(cmd, sizeof(temp)));
   EXPECT_EQ(GL_INVALID_VALUE, GetGLError());
 }
 // TODO(gman): UseProgram
 
 TEST_F(GLES2DecoderTest2, ValidateProgramValidArgs) {
   EXPECT_CALL(*gl_, ValidateProgram(kServiceProgramId));
   SpecializedSetup<ValidateProgram, 0>(true);
   ValidateProgram cmd;
@@ skipping 254 matching lines @@
 // TODO(gman): EndQueryEXT
 
 // TODO(gman): SwapBuffers
 // TODO(gman): GetMaxValueInBufferCHROMIUM
 // TODO(gman): GenSharedIdsCHROMIUM
 
 // TODO(gman): DeleteSharedIdsCHROMIUM
 
 #endif  // GPU_COMMAND_BUFFER_SERVICE_GLES2_CMD_DECODER_UNITTEST_2_AUTOGEN_H_