Fixed compile/link errors for gpu unit-tests. I had to mostly fix signed/unsi...

gpu/command_buffer/service/gles2_cmd_decoder_unittest.cc

 // Copyright (c) 2009 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 "gpu/command_buffer/common/gles2_cmd_format.h"
 #include "gpu/command_buffer/service/gl_mock.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
+using ::gles2::MockGLInterface;
 using ::testing::_;
 using ::testing::DoAll;
 using ::testing::InSequence;
 using ::testing::MatcherCast;
 using ::testing::Pointee;
 using ::testing::Return;
 using ::testing::SetArrayArgument;
 using ::testing::SetArgumentPointee;
 using ::testing::StrEq;
 
@@ skipping 55 matching lines @@
   T* GetImmediateAs() {
     return reinterpret_cast<T*>(immediate_buffer_);
   }
 
   template <typename T, typename Command>
   T GetImmediateDataAs(Command* cmd) {
     reinterpret_cast<T>(ImmediateDataAddress(cmd));
   }
 
   virtual void SetUp() {
-    gl_.reset(new ::gles2::MockGLInterface());
+    gl_.reset(new MockGLInterface());
     ::gles2::GLInterface::SetGLInterface(gl_.get());
 
     EXPECT_CALL(*gl_, GetIntegerv(GL_MAX_VERTEX_ATTRIBS, _))
         .WillOnce(SetArgumentPointee<1>(kNumVertexAttribs))
         .RetiresOnSaturation();
     EXPECT_CALL(*gl_, GetError())
         .WillRepeatedly(Return(GL_NO_ERROR));
 
     engine_.reset(new MockCommandBufferEngine());
     Buffer buffer = engine_->GetSharedMemoryBuffer(kSharedMemoryId);
@@ skipping 81 matching lines @@
 
   template <typename T>
   T GetSharedMemoryAs() {
     return reinterpret_cast<T>(shared_memory_address_);
   }
 
   uint32 GetServiceId(uint32 client_id) {
     return decoder_->GetServiceIdForTesting(client_id);
   }
 
-  GLenum GetGLError() {
+  // Note that the error is returned as GLint instead of GLenum.
+  // This is because there is a mismatch in the types of GLenum and
+  // the error values GL_NO_ERROR, GL_INVALID_ENUM, etc. GLenum is
+  // typedef'd as unsigned int while the error values are defined as
+  // integers. This is problematic for template functions such as
+  // EXPECT_EQ that expect both types to be the same.
+  GLint GetGLError() {
     EXPECT_CALL(*gl_, GetError())
         .WillOnce(Return(GL_NO_ERROR))
         .RetiresOnSaturation();
     GetError cmd;
     cmd.Init(shared_memory_id_, shared_memory_offset_);
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
-    return *GetSharedMemoryAs<GLenum*>();
+    return static_cast<GLint>(*GetSharedMemoryAs<GLenum*>());
   }
 
-  scoped_ptr<::gles2::MockGLInterface> gl_;
+  scoped_ptr<MockGLInterface> gl_;
   scoped_ptr<GLES2Decoder> decoder_;
 
   GLuint client_buffer_id_;
   GLuint client_framebuffer_id_;
   GLuint client_program_id_;
   GLuint client_renderbuffer_id_;
   GLuint client_shader_id_;
   GLuint client_texture_id_;
   GLuint client_element_buffer_id_;
 
@@ skipping 38 matching lines @@
 
    private:
     scoped_array<int8> data_;
     Buffer valid_buffer_;
     Buffer invalid_buffer_;
   };
 
   scoped_ptr<MockCommandBufferEngine> engine_;
 };
 
+const GLint GLES2DecoderTest::kNumVertexAttribs;
+const GLuint GLES2DecoderTest::kServiceBufferId;
+const GLuint GLES2DecoderTest::kServiceFramebufferId;
+const GLuint GLES2DecoderTest::kServiceRenderbufferId;
+const GLuint GLES2DecoderTest::kServiceTextureId;
+const GLuint GLES2DecoderTest::kServiceProgramId;
+const GLuint GLES2DecoderTest::kServiceShaderId;
+const GLuint GLES2DecoderTest::kServiceElementBufferId;
+const int32 GLES2DecoderTest::kSharedMemoryId;
+const size_t GLES2DecoderTest::kSharedBufferSize;
+const uint32 GLES2DecoderTest::kSharedMemoryOffset;
+const int32 GLES2DecoderTest::kInvalidSharedMemoryId;
+const uint32 GLES2DecoderTest::kInvalidSharedMemoryOffset;
+const uint32 GLES2DecoderTest::kInitialResult;
+const uint32 GLES2DecoderTest::kNewClientId;
+const uint32 GLES2DecoderTest::kNewServiceId;
+const uint32 GLES2DecoderTest::kInvalidClientId;
+
 template <>
 void GLES2DecoderTest::SpecializedSetup<LinkProgram, 0>() {
   InSequence dummy;
   EXPECT_CALL(*gl_, GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTES, _))
       .WillOnce(SetArgumentPointee<2>(0));
   EXPECT_CALL(
       *gl_,
       GetProgramiv(kServiceProgramId, GL_ACTIVE_ATTRIBUTE_MAX_LENGTH, _))
       .WillOnce(SetArgumentPointee<2>(0));
 };
@@ skipping 182 matching lines @@
 
   void DeleteVertexBuffer() {
     DoDeleteBuffer(client_buffer_id_, kServiceBufferId);
   }
 
   void DeleteIndexBuffer() {
     DoDeleteBuffer(client_element_buffer_id_, kServiceElementBufferId);
   }
 };
 
+const GLint GLES2DecoderWithShaderTest::kNumAttribs;
+const GLint GLES2DecoderWithShaderTest::kMaxAttribLength;
+const GLsizei GLES2DecoderWithShaderTest::kNumVertices;
+const GLsizei GLES2DecoderWithShaderTest::kNumIndices;
+const int GLES2DecoderWithShaderTest::kValidIndexRangeStart;
+const int GLES2DecoderWithShaderTest::kValidIndexRangeCount;
+const int GLES2DecoderWithShaderTest::kInvalidIndexRangeStart;
+const int GLES2DecoderWithShaderTest::kInvalidIndexRangeCount;
+const int GLES2DecoderWithShaderTest::kOutOfRangeIndexRangeEnd;
 const char* GLES2DecoderWithShaderTest::kAttrib1Name = "attrib1";
 const char* GLES2DecoderWithShaderTest::kAttrib2Name = "attrib2";
 const char* GLES2DecoderWithShaderTest::kAttrib3Name = "attrib3";
 
 TEST_F(GLES2DecoderWithShaderTest, DrawArraysNoAttributesSucceeds) {
   EXPECT_CALL(*gl_, DrawArrays(GL_TRIANGLES, 0, kNumVertices))
       .Times(1)
       .RetiresOnSaturation();
   DrawArrays cmd;
   cmd.Init(GL_TRIANGLES, 0, kNumVertices);
@@ skipping 287 matching lines @@
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 
 #include "gpu/command_buffer/service/gles2_cmd_decoder_unittest_autogen.h"
 
 }  // namespace gles2
 }  // namespace gpu