Revert 191364 "cc: Add ‘chromium_code’: 1 to cc.gyp and cc_t..."

trunk/src/cc/scheduler/texture_uploader_unittest.cc

 // Copyright 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 "cc/scheduler/texture_uploader.h"
 
 #include "cc/base/util.h"
 #include "cc/resources/prioritized_resource.h"
 #include "cc/test/test_web_graphics_context_3d.h"
 #include "testing/gmock/include/gmock/gmock.h"
@@ skipping 52 matching lines @@
 
   virtual void texSubImage2D(WGC3Denum target,
                              WGC3Dint level,
                              WGC3Dint xoffset,
                              WGC3Dint yoffset,
                              WGC3Dsizei width,
                              WGC3Dsizei height,
                              WGC3Denum format,
                              WGC3Denum type,
                              const void* pixels) OVERRIDE {
-    EXPECT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
+    EXPECT_EQ(GL_TEXTURE_2D, target);
     EXPECT_EQ(0, level);
     EXPECT_LE(0, width);
     EXPECT_LE(0, height);
     EXPECT_LE(0, xoffset);
     EXPECT_LE(0, yoffset);
     EXPECT_LE(0, width);
     EXPECT_LE(0, height);
 
     // Check for allowed format/type combination.
     unsigned int bytes_per_pixel = 0;
     switch (format) {
       case GL_ALPHA:
-        EXPECT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
+        EXPECT_EQ(GL_UNSIGNED_BYTE, type);
         bytes_per_pixel = 1;
         break;
       case GL_RGB:
-        EXPECT_NE(static_cast<unsigned>(GL_UNSIGNED_SHORT_4_4_4_4), type);
-        EXPECT_NE(static_cast<unsigned>(GL_UNSIGNED_SHORT_5_5_5_1), type);
+        EXPECT_NE(GL_UNSIGNED_SHORT_4_4_4_4, type);
+        EXPECT_NE(GL_UNSIGNED_SHORT_5_5_5_1, type);
         switch (type) {
           case GL_UNSIGNED_BYTE:
             bytes_per_pixel = 3;
             break;
           case GL_UNSIGNED_SHORT_5_6_5:
             bytes_per_pixel = 2;
             break;
         }
         break;
       case GL_RGBA:
-        EXPECT_NE(static_cast<unsigned>(GL_UNSIGNED_SHORT_5_6_5), type);
+        EXPECT_NE(GL_UNSIGNED_SHORT_5_6_5, type);
         switch (type) {
           case GL_UNSIGNED_BYTE:
             bytes_per_pixel = 4;
             break;
           case GL_UNSIGNED_SHORT_4_4_4_4:
             bytes_per_pixel = 2;
             break;
           case GL_UNSIGNED_SHORT_5_5_5_1:
             bytes_per_pixel = 2;
             break;
         }
         break;
       case GL_LUMINANCE:
-        EXPECT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
+        EXPECT_EQ(GL_UNSIGNED_BYTE, type);
         bytes_per_pixel = 1;
         break;
       case GL_LUMINANCE_ALPHA:
-        EXPECT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
+        EXPECT_EQ(GL_UNSIGNED_BYTE, type);
         bytes_per_pixel = 2;
         break;
     }
 
     // If NULL, we aren't checking texture contents.
     if (pixels == NULL)
       return;
 
     const uint8* bytes = static_cast<const uint8*>(pixels);
     // We'll expect the first byte of every row to be 0x1, and the last byte to
     // be 0x2.
     const unsigned int stride =
         RoundUp(bytes_per_pixel * width, unpack_alignment_);
     for (WGC3Dsizei row = 0; row < height; ++row) {
       const uint8* row_bytes =
           bytes + (xoffset * bytes_per_pixel + (yoffset + row) * stride);
       EXPECT_EQ(0x1, row_bytes[0]);
       EXPECT_EQ(0x2, row_bytes[width * bytes_per_pixel - 1]);
     }
   }
 
   void SetResultAvailable(unsigned result_available) {
     result_available_ = result_available;
   }
 
  private:
+  unsigned unpack_alignment_;
   unsigned result_available_;
-  unsigned unpack_alignment_;
 
   DISALLOW_COPY_AND_ASSIGN(TestWebGraphicsContext3DTextureUpload);
 };
 
 void UploadTexture(TextureUploader* uploader,
                    WGC3Denum format,
                    gfx::Size size,
                    const uint8* data) {
   uploader->Upload(data,
                    gfx::Rect(size),
                    gfx::Rect(size),
                    gfx::Vector2d(),
                    format,
                    size);
 }
 
 TEST(TextureUploaderTest, NumBlockingUploads) {
   scoped_ptr<TestWebGraphicsContext3DTextureUpload> fake_context(
       new TestWebGraphicsContext3DTextureUpload);
   scoped_ptr<TextureUploader> uploader =
       TextureUploader::Create(fake_context.get(), false, false);
 
   fake_context->SetResultAvailable(0);
-  EXPECT_EQ(0u, uploader->NumBlockingUploads());
+  EXPECT_EQ(0, uploader->NumBlockingUploads());
   UploadTexture(uploader.get(), GL_RGBA, gfx::Size(), NULL);
-  EXPECT_EQ(1u, uploader->NumBlockingUploads());
+  EXPECT_EQ(1, uploader->NumBlockingUploads());
   UploadTexture(uploader.get(), GL_RGBA, gfx::Size(), NULL);
-  EXPECT_EQ(2u, uploader->NumBlockingUploads());
+  EXPECT_EQ(2, uploader->NumBlockingUploads());
 
   fake_context->SetResultAvailable(1);
-  EXPECT_EQ(0u, uploader->NumBlockingUploads());
+  EXPECT_EQ(0, uploader->NumBlockingUploads());
   UploadTexture(uploader.get(), GL_RGBA, gfx::Size(), NULL);
-  EXPECT_EQ(0u, uploader->NumBlockingUploads());
+  EXPECT_EQ(0, uploader->NumBlockingUploads());
   UploadTexture(uploader.get(), GL_RGBA, gfx::Size(), NULL);
   UploadTexture(uploader.get(), GL_RGBA, gfx::Size(), NULL);
-  EXPECT_EQ(0u, uploader->NumBlockingUploads());
+  EXPECT_EQ(0, uploader->NumBlockingUploads());
 }
 
 TEST(TextureUploaderTest, MarkPendingUploadsAsNonBlocking) {
   scoped_ptr<TestWebGraphicsContext3DTextureUpload> fake_context(
       new TestWebGraphicsContext3DTextureUpload);
   scoped_ptr<TextureUploader> uploader =
       TextureUploader::Create(fake_context.get(), false, false);
 
   fake_context->SetResultAvailable(0);
-  EXPECT_EQ(0u, uploader->NumBlockingUploads());
+  EXPECT_EQ(0, uploader->NumBlockingUploads());
   UploadTexture(uploader.get(), GL_RGBA, gfx::Size(), NULL);
   UploadTexture(uploader.get(), GL_RGBA, gfx::Size(), NULL);
-  EXPECT_EQ(2u, uploader->NumBlockingUploads());
+  EXPECT_EQ(2, uploader->NumBlockingUploads());
 
   uploader->MarkPendingUploadsAsNonBlocking();
-  EXPECT_EQ(0u, uploader->NumBlockingUploads());
+  EXPECT_EQ(0, uploader->NumBlockingUploads());
   UploadTexture(uploader.get(), GL_RGBA, gfx::Size(), NULL);
-  EXPECT_EQ(1u, uploader->NumBlockingUploads());
+  EXPECT_EQ(1, uploader->NumBlockingUploads());
 
   fake_context->SetResultAvailable(1);
-  EXPECT_EQ(0u, uploader->NumBlockingUploads());
+  EXPECT_EQ(0, uploader->NumBlockingUploads());
   UploadTexture(uploader.get(), GL_RGBA, gfx::Size(), NULL);
   uploader->MarkPendingUploadsAsNonBlocking();
-  EXPECT_EQ(0u, uploader->NumBlockingUploads());
+  EXPECT_EQ(0, uploader->NumBlockingUploads());
 }
 
 TEST(TextureUploaderTest, UploadContentsTest) {
   scoped_ptr<TestWebGraphicsContext3DTextureUpload> fake_context(
       new TestWebGraphicsContext3DTextureUpload);
   scoped_ptr<TextureUploader> uploader =
       TextureUploader::Create(fake_context.get(), false, false);
   uint8 buffer[256 * 256 * 4];
 
   // Upload a tightly packed 256x256 RGBA texture.
@@ skipping 19 matching lines @@
   for (int i = 0; i < 86; ++i) {
     // Mark the beginning and end of each row, for the test.
     buffer[i * 1 * 82] = 0x1;
     buffer[(i + 1) * 82 - 1] = 0x2;
   }
   UploadTexture(uploader.get(), GL_LUMINANCE, gfx::Size(82, 86), buffer);
 }
 
 }  // namespace
 }  // namespace cc