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

gpu/command_buffer/service/common_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/common_decoder.h"
 #include "gpu/command_buffer/service/cmd_buffer_engine.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace gpu {
 
 TEST(CommonDecoderBucket, Basic) {
   CommonDecoder::Bucket bucket;
-  EXPECT_EQ(0, bucket.size());
+  EXPECT_EQ(0u, bucket.size());
   EXPECT_TRUE(NULL == bucket.GetData(0, 0));
 }
 
 TEST(CommonDecoderBucket, Size) {
   CommonDecoder::Bucket bucket;
   bucket.SetSize(24);
-  EXPECT_EQ(24, bucket.size());
+  EXPECT_EQ(24u, bucket.size());
   bucket.SetSize(12);
-  EXPECT_EQ(12, bucket.size());
+  EXPECT_EQ(12u, bucket.size());
 }
 
 TEST(CommonDecoderBucket, GetData) {
   CommonDecoder::Bucket bucket;
 
   bucket.SetSize(24);
   EXPECT_TRUE(NULL != bucket.GetData(0, 0));
   EXPECT_TRUE(NULL != bucket.GetData(24, 0));
   EXPECT_TRUE(NULL == bucket.GetData(25, 0));
   EXPECT_TRUE(NULL != bucket.GetData(0, 24));
@@ skipping 34 matching lines @@
     return CommonDecoder::GetBucket(id);
   }
 };
 
 class MockCommandBufferEngine : public CommandBufferEngine {
  public:
   static const int32 kStartValidShmId = 1;
   static const int32 kValidShmId = 2;
   static const int32 kInvalidShmId = 3;
   static const size_t kBufferSize = 1024;
-  static const uint32 kValidOffset = kBufferSize / 2;
-  static const uint32 kInvalidOffset = kBufferSize;
+  static const int32 kValidOffset = kBufferSize / 2;
+  static const int32 kInvalidOffset = kBufferSize;
 
   MockCommandBufferEngine()
       : CommandBufferEngine(),
         token_(),
         get_offset_(0) {
   }
 
   // Overridden from CommandBufferEngine.
   virtual Buffer GetSharedMemoryBuffer(int32 shm_id) {
     Buffer buffer;
     if (IsValidSharedMemoryId(shm_id)) {
       buffer.ptr = buffer_;
       buffer.size = kBufferSize;
     }
     return buffer;
   }
 
   template <typename T>
   T GetSharedMemoryAs(uint32 offset) {
     DCHECK(offset < kBufferSize);
     return reinterpret_cast<T>(&buffer_[offset]);
   }
 
-  uint32 GetSharedMemoryOffset(const void* memory) {
+  int32 GetSharedMemoryOffset(const void* memory) {
     ptrdiff_t offset = reinterpret_cast<const int8*>(memory) - &buffer_[0];
     DCHECK_GE(offset, 0);
-    DCHECK(offset < kBufferSize);
-    return static_cast<uint32>(offset);
+    DCHECK(static_cast<size_t>(offset) < kBufferSize);
+    return static_cast<int32>(offset);
   }
 
   // Overridden from CommandBufferEngine.
   virtual void set_token(int32 token) {
     token_ = token;
   }
 
   int32 token() const {
     return token_;
   }
 
   // Overridden from CommandBufferEngine.
   virtual bool SetGetOffset(int32 offset) {
-    if (offset < kBufferSize) {
+    if (static_cast<size_t>(offset) < kBufferSize) {
       get_offset_ = offset;
       return true;
     }
     return false;
   }
 
   // Overridden from CommandBufferEngine.
   virtual int32 GetGetOffset() {
     return get_offset_;
   }
 
  private:
   bool IsValidSharedMemoryId(int32 shm_id) {
     return shm_id == kValidShmId || shm_id == kStartValidShmId;
   }
 
   int8 buffer_[kBufferSize];
   int32 token_;
   int32 get_offset_;
 };
 
+const int32 MockCommandBufferEngine::kStartValidShmId;
+const int32 MockCommandBufferEngine::kValidShmId;
+const int32 MockCommandBufferEngine::kInvalidShmId;
+const size_t MockCommandBufferEngine::kBufferSize;
+const int32 MockCommandBufferEngine::kValidOffset;
+const int32 MockCommandBufferEngine::kInvalidOffset;
+
 class CommonDecoderTest : public testing::Test {
  protected:
   virtual void SetUp() {
     decoder_.set_engine(&engine_);
   }
 
   virtual void TearDown() {
   }
 
   template <typename T>
@@ skipping 10 matching lines @@
     return decoder_.DoCommand(cmd.kCmdId,
                               ComputeNumEntries(sizeof(cmd) + data_size) - 1,
                               &cmd);
   }
 
   MockCommandBufferEngine engine_;
   TestCommonDecoder decoder_;
 };
 
 TEST_F(CommonDecoderTest, Initialize) {
-  EXPECT_EQ(0u, engine_.GetGetOffset());
+  EXPECT_EQ(0, engine_.GetGetOffset());
 }
 
 TEST_F(CommonDecoderTest, HandleNoop) {
   cmd::Noop cmd;
   const uint32 kSkipCount = 5;
   cmd.Init(kSkipCount);
   EXPECT_EQ(error::kNoError,
             ExecuteImmediateCmd(
                 cmd, kSkipCount * kCommandBufferEntrySize));
 }
@@ skipping 23 matching lines @@
 
 // NOTE: The read_pointer checks for relative commands do not take into account
 //     that the actual implementation of CommandBufferEngine uses the parse
 //     which will advance the read pointer to the start of the next command.
 
 TEST_F(CommonDecoderTest, JumpRelative) {
   cmd::JumpRelative cmd;
   // Check valid positive offset succeeds.
   const int32 kPositiveOffset = 16;
   cmd.Init(kPositiveOffset);
-  uint32 read_pointer = engine_.GetGetOffset();
+  int32 read_pointer = engine_.GetGetOffset();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   // See note above.
   EXPECT_EQ(read_pointer + kPositiveOffset, engine_.GetGetOffset());
   // Check valid negative offset succeeds.
   const int32 kNegativeOffset = -8;
   read_pointer = engine_.GetGetOffset();
   cmd.Init(kNegativeOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   // See note above.
   EXPECT_EQ(read_pointer + kNegativeOffset, engine_.GetGetOffset());
@@ skipping 13 matching lines @@
             engine_.GetGetOffset());
   // Check invalid offset fails.
   cmd.Init(MockCommandBufferEngine::kInvalidOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   EXPECT_EQ(MockCommandBufferEngine::kValidOffset,
             engine_.GetGetOffset());
   // Check that the call values are on the stack.
   cmd::Return return_cmd;
   return_cmd.Init();
   EXPECT_EQ(error::kNoError, ExecuteCmd(return_cmd));
-  EXPECT_EQ(0u, engine_.GetGetOffset());
+  EXPECT_EQ(0, engine_.GetGetOffset());
   // Check that stack overflow fails.
   cmd.Init(MockCommandBufferEngine::kValidOffset);
   for (unsigned int ii = 0; ii < CommonDecoder::kMaxStackDepth; ++ii) {
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   }
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_F(CommonDecoderTest, CallRelative) {
   cmd::CallRelative cmd;
   // Check valid positive offset succeeds.
   const int32 kPositiveOffset = 16;
   cmd.Init(kPositiveOffset);
-  uint32 read_pointer_1 = engine_.GetGetOffset();
+  int32 read_pointer_1 = engine_.GetGetOffset();
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   // See note above.
   EXPECT_EQ(read_pointer_1 + kPositiveOffset, engine_.GetGetOffset());
   // Check valid negative offset succeeds.
   const int32 kNegativeOffset = -8;
-  uint32 read_pointer_2 = engine_.GetGetOffset();
+  int32 read_pointer_2 = engine_.GetGetOffset();
   cmd.Init(kNegativeOffset);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   // See note above.
   EXPECT_EQ(read_pointer_2 + kNegativeOffset, engine_.GetGetOffset());
   // Check invalid offset fails.
   cmd.Init(MockCommandBufferEngine::kInvalidOffset);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
   // See note above.
   EXPECT_EQ(read_pointer_2 + kNegativeOffset, engine_.GetGetOffset());
 
   // Check that the call values are on the stack.
   cmd::Return return_cmd;
   return_cmd.Init();
   EXPECT_EQ(error::kNoError, ExecuteCmd(return_cmd));
   // See note above.
   EXPECT_EQ(read_pointer_1 + kPositiveOffset, engine_.GetGetOffset());
 
   EXPECT_EQ(error::kNoError, ExecuteCmd(return_cmd));
   // See note above.
-  EXPECT_EQ(0u, engine_.GetGetOffset());
+  EXPECT_EQ(0, engine_.GetGetOffset());
   // Check that stack overflow fails.
   cmd.Init(kPositiveOffset);
   for (unsigned int ii = 0; ii < CommonDecoder::kMaxStackDepth; ++ii) {
     EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   }
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 TEST_F(CommonDecoderTest, Return) {
   // Success is tested by Call and CallRelative
@@ skipping 20 matching lines @@
   // Check we can change it.
   cmd.Init(kBucketId, kBucketLength2);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   bucket = decoder_.GetBucket(kBucketId);
   EXPECT_TRUE(NULL != bucket);
   EXPECT_EQ(kBucketLength2, bucket->size());
   // Check we can delete it.
   cmd.Init(kBucketId, 0);
   EXPECT_EQ(error::kNoError, ExecuteCmd(cmd));
   bucket = decoder_.GetBucket(kBucketId);
-  EXPECT_EQ(0, bucket->size());
+  EXPECT_EQ(0u, bucket->size());
 }
 
 TEST_F(CommonDecoderTest, SetBucketData) {
   cmd::SetBucketSize size_cmd;
   cmd::SetBucketData cmd;
 
   static const char kData[] = "1234567890123456789";
 
   const uint32 kBucketId = 123;
   const uint32 kInvalidBucketId = 124;
@@ skipping 135 matching lines @@
   cmd::GetBucketData cmd;
 
   static const char kData[] = "1234567890123456789";
   static const char zero[sizeof(kData)] = { 0, };
 
   const uint32 kBucketId = 123;
   const uint32 kInvalidBucketId = 124;
 
   size_cmd.Init(kBucketId, sizeof(kData));
   EXPECT_EQ(error::kNoError, ExecuteCmd(size_cmd));
-  CommonDecoder::Bucket* bucket = decoder_.GetBucket(kBucketId);
   const uint32 kSomeOffsetInSharedMemory = 50;
   uint8* memory = engine_.GetSharedMemoryAs<uint8*>(kSomeOffsetInSharedMemory);
   memcpy(memory, kData, sizeof(kData));
   set_cmd.Init(kBucketId, 0, sizeof(kData),
                MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
   EXPECT_EQ(error::kNoError, ExecuteCmd(set_cmd));
 
   // Check we can get the whole thing.
   memset(memory, 0, sizeof(kData));
   cmd.Init(kBucketId, 0, sizeof(kData),
@@ skipping 26 matching lines @@
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 
   // Check that it fails if the size is invalid
   cmd.Init(kBucketId, 0, sizeof(kData) + 1,
            MockCommandBufferEngine::kValidShmId, kSomeOffsetInSharedMemory);
   EXPECT_NE(error::kNoError, ExecuteCmd(cmd));
 }
 
 }  // namespace gpu