Fix more warnings on linux

Source/core/platform/graphics/chromium/ImageDecodingStoreTest.cpp

 /*
  * Copyright (C) 2012 Google Inc. All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  *
  * 1.  Redistributions of source code must retain the above copyright
  *     notice, this list of conditions and the following disclaimer.
  * 2.  Redistributions in binary form must reproduce the above copyright
@@ skipping 125 matching lines @@
     RefPtr<SharedBuffer> m_data;
     RefPtr<ImageFrameGenerator> m_generator;
     int m_decodersDestroyed;
 };
 
 TEST_F(ImageDecodingStoreTest, evictOneCache)
 {
     insertCache(SkISize::Make(1, 1));
     insertCache(SkISize::Make(2, 2));
     insertCache(SkISize::Make(3, 3));
-    EXPECT_EQ(3u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(3, ImageDecodingStore::instance()->cacheEntries());
 
     evictOneCache();
-    EXPECT_EQ(2u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(2, ImageDecodingStore::instance()->cacheEntries());
 
     evictOneCache();
-    EXPECT_EQ(1u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(1, ImageDecodingStore::instance()->cacheEntries());
 }
 
 TEST_F(ImageDecodingStoreTest, pruneOrderIsLeastRecentlyUsed)
 {
     insertCache(SkISize::Make(1, 1));
     insertCache(SkISize::Make(2, 2));
     insertCache(SkISize::Make(3, 3));
     insertCache(SkISize::Make(4, 4));
     insertCache(SkISize::Make(5, 5));
-    EXPECT_EQ(5u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(5, ImageDecodingStore::instance()->cacheEntries());
 
     // Use cache in the order 3, 2, 4, 1, 5.
     EXPECT_TRUE(isCacheAlive(SkISize::Make(3, 3)));
     EXPECT_TRUE(isCacheAlive(SkISize::Make(2, 2)));
     EXPECT_TRUE(isCacheAlive(SkISize::Make(4, 4)));
     EXPECT_TRUE(isCacheAlive(SkISize::Make(1, 1)));
     EXPECT_TRUE(isCacheAlive(SkISize::Make(5, 5)));
 
     // Evict 3.
     evictOneCache();
     EXPECT_FALSE(isCacheAlive(SkISize::Make(3, 3)));
-    EXPECT_EQ(4u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(4, ImageDecodingStore::instance()->cacheEntries());
 
     // Evict 2.
     evictOneCache();
     EXPECT_FALSE(isCacheAlive(SkISize::Make(2, 2)));
-    EXPECT_EQ(3u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(3, ImageDecodingStore::instance()->cacheEntries());
 
     // Evict 4.
     evictOneCache();
     EXPECT_FALSE(isCacheAlive(SkISize::Make(4, 4)));
-    EXPECT_EQ(2u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(2, ImageDecodingStore::instance()->cacheEntries());
 
     // Evict 1.
     evictOneCache();
     EXPECT_FALSE(isCacheAlive(SkISize::Make(1, 1)));
-    EXPECT_EQ(1u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(1, ImageDecodingStore::instance()->cacheEntries());
 
     // Evict 5.
     evictOneCache();
     EXPECT_FALSE(isCacheAlive(SkISize::Make(5, 5)));
-    EXPECT_EQ(0u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(0, ImageDecodingStore::instance()->cacheEntries());
 }
 
 TEST_F(ImageDecodingStoreTest, pruneCausedByInsertion)
 {
     ImageDecodingStore::instance()->setCacheLimitInBytes(100);
 
     // Insert 100 entries.
     // Cache entries stored should increase and eventually decrease to 1.
     insertCache(SkISize::Make(1, 1));
     insertCache(SkISize::Make(2, 2));
     insertCache(SkISize::Make(3, 3));
-    EXPECT_EQ(3u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(3, ImageDecodingStore::instance()->cacheEntries());
 
     for (int i = 4; i <= 100; ++i)
         insertCache(SkISize::Make(i, i));
 
-    EXPECT_EQ(1u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(1, ImageDecodingStore::instance()->cacheEntries());
     for (int i = 1; i <= 99; ++i)
         EXPECT_FALSE(isCacheAlive(SkISize::Make(i, i)));
     EXPECT_TRUE(isCacheAlive(SkISize::Make(100, 100)));
 }
 
 TEST_F(ImageDecodingStoreTest, cacheInUseNotEvicted)
 {
     insertCache(SkISize::Make(1, 1));
     insertCache(SkISize::Make(2, 2));
     insertCache(SkISize::Make(3, 3));
-    EXPECT_EQ(3u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(3, ImageDecodingStore::instance()->cacheEntries());
 
     const ScaledImageFragment* cachedImage = lockCache(SkISize::Make(1, 1));
     ASSERT_TRUE(cachedImage);
 
     // Cache 2 is evicted because cache 1 is in use.
     evictOneCache();
     EXPECT_TRUE(isCacheAlive(SkISize::Make(1, 1)));
     EXPECT_FALSE(isCacheAlive(SkISize::Make(2, 2)));
     EXPECT_TRUE(isCacheAlive(SkISize::Make(3, 3)));
 
-    EXPECT_EQ(2u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(2, ImageDecodingStore::instance()->cacheEntries());
     unlockCache(cachedImage);
 }
 
 TEST_F(ImageDecodingStoreTest, destroyImageFrameGenerator)
 {
     insertCache(SkISize::Make(1, 1));
     insertCache(SkISize::Make(2, 2));
     insertCache(SkISize::Make(3, 3));
     OwnPtr<ImageDecoder> decoder = MockImageDecoder::create(this);
     decoder->setSize(1, 1);
     ImageDecodingStore::instance()->insertDecoder(m_generator.get(), decoder.release(), false);
-    EXPECT_EQ(4u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(4, ImageDecodingStore::instance()->cacheEntries());
 
     m_generator.clear();
     EXPECT_FALSE(ImageDecodingStore::instance()->cacheEntries());
 }
 
 TEST_F(ImageDecodingStoreTest, insertDecoder)
 {
     const SkISize size = SkISize::Make(1, 1);
     OwnPtr<ImageDecoder> decoder = MockImageDecoder::create(this);
     decoder->setSize(1, 1);
     const ImageDecoder* refDecoder = decoder.get();
     ImageDecodingStore::instance()->insertDecoder(m_generator.get(), decoder.release(), false);
-    EXPECT_EQ(1u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(1, ImageDecodingStore::instance()->cacheEntries());
     EXPECT_EQ(4u, ImageDecodingStore::instance()->memoryUsageInBytes());
 
     ImageDecoder* testDecoder;
     EXPECT_TRUE(ImageDecodingStore::instance()->lockDecoder(m_generator.get(), size, &testDecoder));
     EXPECT_TRUE(testDecoder);
     EXPECT_EQ(refDecoder, testDecoder);
     ImageDecodingStore::instance()->unlockDecoder(m_generator.get(), testDecoder);
-    EXPECT_EQ(1u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(1, ImageDecodingStore::instance()->cacheEntries());
 }
 
 TEST_F(ImageDecodingStoreTest, evictDecoder)
 {
     OwnPtr<ImageDecoder> decoder1 = MockImageDecoder::create(this);
     OwnPtr<ImageDecoder> decoder2 = MockImageDecoder::create(this);
     OwnPtr<ImageDecoder> decoder3 = MockImageDecoder::create(this);
     decoder1->setSize(1, 1);
     decoder2->setSize(2, 2);
     decoder3->setSize(3, 3);
     ImageDecodingStore::instance()->insertDecoder(m_generator.get(), decoder1.release(), false);
     ImageDecodingStore::instance()->insertDecoder(m_generator.get(), decoder2.release(), false);
     ImageDecodingStore::instance()->insertDecoder(m_generator.get(), decoder3.release(), false);
-    EXPECT_EQ(3u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(3, ImageDecodingStore::instance()->cacheEntries());
     EXPECT_EQ(56u, ImageDecodingStore::instance()->memoryUsageInBytes());
 
     evictOneCache();
-    EXPECT_EQ(2u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(2, ImageDecodingStore::instance()->cacheEntries());
     EXPECT_EQ(52u, ImageDecodingStore::instance()->memoryUsageInBytes());
 
     evictOneCache();
-    EXPECT_EQ(1u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(1, ImageDecodingStore::instance()->cacheEntries());
     EXPECT_EQ(36u, ImageDecodingStore::instance()->memoryUsageInBytes());
 
     evictOneCache();
     EXPECT_FALSE(ImageDecodingStore::instance()->cacheEntries());
     EXPECT_FALSE(ImageDecodingStore::instance()->memoryUsageInBytes());
 }
 
 TEST_F(ImageDecodingStoreTest, decoderInUseNotEvicted)
 {
     OwnPtr<ImageDecoder> decoder1 = MockImageDecoder::create(this);
     OwnPtr<ImageDecoder> decoder2 = MockImageDecoder::create(this);
     OwnPtr<ImageDecoder> decoder3 = MockImageDecoder::create(this);
     decoder1->setSize(1, 1);
     decoder2->setSize(2, 2);
     decoder3->setSize(3, 3);
     ImageDecodingStore::instance()->insertDecoder(m_generator.get(), decoder1.release(), false);
     ImageDecodingStore::instance()->insertDecoder(m_generator.get(), decoder2.release(), false);
     ImageDecodingStore::instance()->insertDecoder(m_generator.get(), decoder3.release(), false);
-    EXPECT_EQ(3u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(3, ImageDecodingStore::instance()->cacheEntries());
 
     ImageDecoder* testDecoder;
     EXPECT_TRUE(ImageDecodingStore::instance()->lockDecoder(m_generator.get(), SkISize::Make(2, 2), &testDecoder));
 
     evictOneCache();
     evictOneCache();
     evictOneCache();
-    EXPECT_EQ(1u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(1, ImageDecodingStore::instance()->cacheEntries());
     EXPECT_EQ(16u, ImageDecodingStore::instance()->memoryUsageInBytes());
 
     ImageDecodingStore::instance()->unlockDecoder(m_generator.get(), testDecoder);
     evictOneCache();
     EXPECT_FALSE(ImageDecodingStore::instance()->cacheEntries());
     EXPECT_FALSE(ImageDecodingStore::instance()->memoryUsageInBytes());
 }
 
 TEST_F(ImageDecodingStoreTest, removeDecoder)
 {
     const SkISize size = SkISize::Make(1, 1);
     OwnPtr<ImageDecoder> decoder = MockImageDecoder::create(this);
     decoder->setSize(1, 1);
     const ImageDecoder* refDecoder = decoder.get();
     ImageDecodingStore::instance()->insertDecoder(m_generator.get(), decoder.release(), false);
-    EXPECT_EQ(1u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(1, ImageDecodingStore::instance()->cacheEntries());
     EXPECT_EQ(4u, ImageDecodingStore::instance()->memoryUsageInBytes());
 
     ImageDecoder* testDecoder;
     EXPECT_TRUE(ImageDecodingStore::instance()->lockDecoder(m_generator.get(), size, &testDecoder));
     EXPECT_TRUE(testDecoder);
     EXPECT_EQ(refDecoder, testDecoder);
     ImageDecodingStore::instance()->removeDecoder(m_generator.get(), testDecoder);
     EXPECT_FALSE(ImageDecodingStore::instance()->cacheEntries());
 
     EXPECT_FALSE(ImageDecodingStore::instance()->lockDecoder(m_generator.get(), size, &testDecoder));
 }
 
 TEST_F(ImageDecodingStoreTest, multipleIndex)
 {
     const SkISize size = SkISize::Make(1, 1);
     const ScaledImageFragment* refImage = ImageDecodingStore::instance()->insertAndLockCache(
         m_generator.get(), createCompleteImage(size, false, 0));
     unlockCache(refImage);
     const ScaledImageFragment* testImage = ImageDecodingStore::instance()->insertAndLockCache(
         m_generator.get(), createCompleteImage(size, false, 1));
     unlockCache(testImage);
     EXPECT_NE(refImage, testImage);
-    EXPECT_EQ(2u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(2, ImageDecodingStore::instance()->cacheEntries());
 
     EXPECT_TRUE(ImageDecodingStore::instance()->lockCache(m_generator.get(), size, 1, &refImage));
     EXPECT_EQ(refImage, testImage);
     unlockCache(refImage);
 }
 
 TEST_F(ImageDecodingStoreTest, finalAndPartialImage)
 {
     const SkISize size = SkISize::Make(1, 1);
     const ScaledImageFragment* refImage = ImageDecodingStore::instance()->insertAndLockCache(
         m_generator.get(), createCompleteImage(size, false, 0));
     unlockCache(refImage);
     const ScaledImageFragment* testImage = ImageDecodingStore::instance()->insertAndLockCache(
         m_generator.get(), createIncompleteImage(size, false, 1));
     unlockCache(testImage);
     EXPECT_NE(refImage, testImage);
-    EXPECT_EQ(2u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(2, ImageDecodingStore::instance()->cacheEntries());
 
     EXPECT_TRUE(ImageDecodingStore::instance()->lockCache(m_generator.get(), size, 0, &refImage));
     EXPECT_NE(refImage, testImage);
     unlockCache(refImage);
 }
 
 TEST_F(ImageDecodingStoreTest, insertNoGenerationCollision)
 {
     const SkISize size = SkISize::Make(1, 1);
     const ScaledImageFragment* refImage = ImageDecodingStore::instance()->insertAndLockCache(
         m_generator.get(), createIncompleteImage(size, false, 1));
     unlockCache(refImage);
     const ScaledImageFragment* testImage = ImageDecodingStore::instance()->insertAndLockCache(
         m_generator.get(), createIncompleteImage(size, false, 2));
     unlockCache(testImage);
     EXPECT_NE(refImage, testImage);
-    EXPECT_EQ(2u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(2, ImageDecodingStore::instance()->cacheEntries());
 }
 
 TEST_F(ImageDecodingStoreTest, insertGenerationCollision)
 {
     const SkISize size = SkISize::Make(1, 1);
     const ScaledImageFragment* refImage = ImageDecodingStore::instance()->insertAndLockCache(
         m_generator.get(), createIncompleteImage(size, false, 1));
     unlockCache(refImage);
     const ScaledImageFragment* testImage = ImageDecodingStore::instance()->insertAndLockCache(
         m_generator.get(), createIncompleteImage(size, false, 1));
     unlockCache(testImage);
     EXPECT_EQ(refImage, testImage);
-    EXPECT_EQ(1u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(1, ImageDecodingStore::instance()->cacheEntries());
 }
 
 TEST_F(ImageDecodingStoreTest, insertGenerationCollisionAfterMemoryDiscarded)
 {
     const SkISize size = SkISize::Make(1, 1);
     const ScaledImageFragment* refImage = ImageDecodingStore::instance()->insertAndLockCache(
         m_generator.get(), createIncompleteImage(size, true, 1));
     unlockCache(refImage);
     MockDiscardablePixelRef* pixelRef = static_cast<MockDiscardablePixelRef*>(refImage->bitmap().pixelRef());
     pixelRef->discard();
     const ScaledImageFragment* testImage = ImageDecodingStore::instance()->insertAndLockCache(
         m_generator.get(), createIncompleteImage(size, false, 1));
     unlockCache(testImage);
     EXPECT_NE(refImage, testImage);
-    EXPECT_EQ(1u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(1, ImageDecodingStore::instance()->cacheEntries());
 }
 
 TEST_F(ImageDecodingStoreTest, lockCacheFailedAfterMemoryDiscarded)
 {
     const ScaledImageFragment* cachedImage = ImageDecodingStore::instance()->insertAndLockCache(
         m_generator.get(), createCompleteImage(SkISize::Make(1, 1), true));
     unlockCache(cachedImage);
     MockDiscardablePixelRef* pixelRef = static_cast<MockDiscardablePixelRef*>(cachedImage->bitmap().pixelRef());
     pixelRef->discard();
     EXPECT_EQ(0, lockCache(SkISize::Make(1, 1)));
-    EXPECT_EQ(0u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(0, ImageDecodingStore::instance()->cacheEntries());
 }
 
 TEST_F(ImageDecodingStoreTest, clear)
 {
     insertCache(SkISize::Make(1, 1));
     insertCache(SkISize::Make(2, 2));
-    EXPECT_EQ(2u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(2, ImageDecodingStore::instance()->cacheEntries());
 
     OwnPtr<ImageDecoder> decoder = MockImageDecoder::create(this);
     decoder->setSize(1, 1);
     ImageDecodingStore::instance()->insertDecoder(m_generator.get(), decoder.release(), false);
-    EXPECT_EQ(3u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(3, ImageDecodingStore::instance()->cacheEntries());
 
     ImageDecodingStore::instance()->clear();
-    EXPECT_EQ(0u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(0, ImageDecodingStore::instance()->cacheEntries());
 }
 
 TEST_F(ImageDecodingStoreTest, clearInUse)
 {
     insertCache(SkISize::Make(1, 1));
     insertCache(SkISize::Make(2, 2));
-    EXPECT_EQ(2u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(2, ImageDecodingStore::instance()->cacheEntries());
 
     const ScaledImageFragment* cachedImage = lockCache(SkISize::Make(1, 1));
     ASSERT_TRUE(cachedImage);
     ImageDecodingStore::instance()->clear();
-    EXPECT_EQ(1u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(1, ImageDecodingStore::instance()->cacheEntries());
 
     unlockCache(cachedImage);
-    EXPECT_EQ(1u, ImageDecodingStore::instance()->cacheEntries());
+    EXPECT_EQ(1, ImageDecodingStore::instance()->cacheEntries());
 }
 
 } // namespace