cc: Fix build issues for adding ‘chromium_code’: 1 to cc.gyp and cc_tests.gyp

cc/resources/resource_provider_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/resources/resource_provider.h"
 
 #include <algorithm>
 
 #include "base/bind.h"
 #include "base/logging.h"
@@ skipping 121 matching lines @@
     }
     pending_produce_textures_.clear();
     return sync_point;
   }
 
   virtual void waitSyncPoint(unsigned sync_point) OVERRIDE {
     last_waited_sync_point_ = std::max(sync_point, last_waited_sync_point_);
   }
 
   virtual void bindTexture(WGC3Denum target, WebGLId texture) OVERRIDE {
-    ASSERT_EQ(target, GL_TEXTURE_2D);
+    ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     ASSERT_TRUE(!texture || textures_.find(texture) != textures_.end());
     current_texture_ = texture;
   }
 
   virtual WebGLId createTexture() OVERRIDE {
     WebGLId id = TestWebGraphicsContext3D::createTexture();
     textures_.add(id, make_scoped_ptr(new Texture));
     return id;
   }
 
   virtual void deleteTexture(WebGLId id) OVERRIDE {
     TextureMap::iterator it = textures_.find(id);
     ASSERT_FALSE(it == textures_.end());
     textures_.erase(it);
     if (current_texture_ == id)
       current_texture_ = 0;
   }
 
   virtual void texStorage2DEXT(WGC3Denum target,
                                WGC3Dint levels,
                                WGC3Duint internalformat,
                                WGC3Dint width,
                                WGC3Dint height) OVERRIDE {
     ASSERT_TRUE(current_texture_);
-    ASSERT_EQ(target, GL_TEXTURE_2D);
-    ASSERT_EQ(levels, 1);
+    ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
+    ASSERT_EQ(1, levels);
     WGC3Denum format = GL_RGBA;
     switch (internalformat) {
       case GL_RGBA8_OES:
         break;
       case GL_BGRA8_EXT:
         format = GL_BGRA_EXT;
         break;
       default:
         NOTREACHED();
     }
     AllocateTexture(gfx::Size(width, height), format);
   }
 
   virtual void texImage2D(WGC3Denum target,
                           WGC3Dint level,
                           WGC3Denum internalformat,
                           WGC3Dsizei width,
                           WGC3Dsizei height,
                           WGC3Dint border,
                           WGC3Denum format,
                           WGC3Denum type,
                           const void* pixels) OVERRIDE {
     ASSERT_TRUE(current_texture_);
-    ASSERT_EQ(target, GL_TEXTURE_2D);
+    ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     ASSERT_FALSE(level);
     ASSERT_EQ(internalformat, format);
     ASSERT_FALSE(border);
-    ASSERT_EQ(type, GL_UNSIGNED_BYTE);
+    ASSERT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
     AllocateTexture(gfx::Size(width, height), format);
     if (pixels)
       SetPixels(0, 0, width, height, pixels);
   }
 
   virtual void texSubImage2D(WGC3Denum target,
                              WGC3Dint level,
                              WGC3Dint xoffset,
                              WGC3Dint yoffset,
                              WGC3Dsizei width,
                              WGC3Dsizei height,
                              WGC3Denum format,
                              WGC3Denum type,
                              const void* pixels) OVERRIDE {
     ASSERT_TRUE(current_texture_);
-    ASSERT_EQ(target, GL_TEXTURE_2D);
+    ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     ASSERT_FALSE(level);
     ASSERT_TRUE(textures_.get(current_texture_));
     ASSERT_EQ(textures_.get(current_texture_)->format, format);
-    ASSERT_EQ(type, GL_UNSIGNED_BYTE);
+    ASSERT_EQ(static_cast<unsigned>(GL_UNSIGNED_BYTE), type);
     ASSERT_TRUE(pixels);
     SetPixels(xoffset, yoffset, width, height, pixels);
   }
 
   virtual void texParameteri(WGC3Denum target, WGC3Denum param, WGC3Dint value)
       OVERRIDE {
     ASSERT_TRUE(current_texture_);
-    ASSERT_EQ(target, GL_TEXTURE_2D);
+    ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     Texture* texture = textures_.get(current_texture_);
     ASSERT_TRUE(texture);
     if (param != GL_TEXTURE_MIN_FILTER)
       return;
     texture->filter = value;
   }
 
   virtual void genMailboxCHROMIUM(WGC3Dbyte* mailbox) OVERRIDE {
     return shared_data_->GenMailbox(mailbox);
   }
 
   virtual void produceTextureCHROMIUM(WGC3Denum target,
                                       const WGC3Dbyte* mailbox) OVERRIDE {
     ASSERT_TRUE(current_texture_);
-    ASSERT_EQ(target, GL_TEXTURE_2D);
+    ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
 
     // Delay moving the texture into the mailbox until the next
     // InsertSyncPoint, so that it is not visible to other contexts that
     // haven't waited on that sync point.
     scoped_ptr<PendingProduceTexture> pending(new PendingProduceTexture);
     memcpy(pending->mailbox, mailbox, sizeof(pending->mailbox));
     pending->texture = textures_.take(current_texture_);
     textures_.set(current_texture_, scoped_ptr<Texture>());
     pending_produce_textures_.push_back(pending.Pass());
   }
 
   virtual void consumeTextureCHROMIUM(WGC3Denum target,
                                       const WGC3Dbyte* mailbox) OVERRIDE {
     ASSERT_TRUE(current_texture_);
-    ASSERT_EQ(target, GL_TEXTURE_2D);
+    ASSERT_EQ(static_cast<unsigned>(GL_TEXTURE_2D), target);
     textures_.set(
         current_texture_,
         shared_data_->ConsumeTexture(mailbox, last_waited_sync_point_));
   }
 
   void GetPixels(gfx::Size size, WGC3Denum format, uint8_t* pixels) {
     ASSERT_TRUE(current_texture_);
     Texture* texture = textures_.get(current_texture_);
     ASSERT_TRUE(texture);
     ASSERT_EQ(texture->size, size);
@@ skipping 407 matching lines @@
   gfx::Size size(1, 1);
   WGC3Denum format = GL_RGBA;
   size_t pixel_size = TextureSize(size, format);
   ASSERT_EQ(4U, pixel_size);
 
   ResourceProvider::ResourceId id = child_resource_provider->CreateResource(
       size, format, ResourceProvider::TextureUsageAny);
   uint8_t data[4] = { 1, 2, 3, 4 };
   gfx::Rect rect(size);
   child_resource_provider->SetPixels(id, data, rect, rect, gfx::Vector2d());
-  EXPECT_EQ(GL_LINEAR, GetResourceFilter(child_resource_provider.get(), id));
+  EXPECT_EQ(static_cast<unsigned>(GL_LINEAR),
+            GetResourceFilter(child_resource_provider.get(), id));
   SetResourceFilter(child_resource_provider.get(), id, GL_NEAREST);
-  EXPECT_EQ(GL_NEAREST, GetResourceFilter(child_resource_provider.get(), id));
+  EXPECT_EQ(static_cast<unsigned>(GL_NEAREST),
+            GetResourceFilter(child_resource_provider.get(), id));
 
   int child_id = resource_provider_->CreateChild();
   {
     // Transfer some resource to the parent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(id);
     TransferableResourceArray list;
     child_resource_provider->PrepareSendToParent(resource_ids_to_transfer,
                                                  &list);
     ASSERT_EQ(1u, list.size());
-    EXPECT_EQ(GL_NEAREST, list[0].filter);
+    EXPECT_EQ(static_cast<unsigned>(GL_NEAREST), list[0].filter);
     resource_provider_->ReceiveFromChild(child_id, list);
   }
   ResourceProvider::ResourceIdMap resource_map =
       resource_provider_->GetChildToParentMap(child_id);
   ResourceProvider::ResourceId mapped_id = resource_map[id];
   EXPECT_NE(0u, mapped_id);
-  EXPECT_EQ(GL_NEAREST, GetResourceFilter(resource_provider_.get(), mapped_id));
+  EXPECT_EQ(static_cast<unsigned>(GL_NEAREST),
+            GetResourceFilter(resource_provider_.get(), mapped_id));
   SetResourceFilter(resource_provider_.get(), mapped_id, GL_LINEAR);
-  EXPECT_EQ(GL_LINEAR, GetResourceFilter(resource_provider_.get(), mapped_id));
+  EXPECT_EQ(static_cast<unsigned>(GL_LINEAR),
+            GetResourceFilter(resource_provider_.get(), mapped_id));
   {
     // Transfer resources back from the parent to the child.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(mapped_id);
     TransferableResourceArray list;
     resource_provider_->PrepareSendToChild(
         child_id, resource_ids_to_transfer, &list);
     ASSERT_EQ(1u, list.size());
-    EXPECT_EQ(GL_LINEAR, list[0].filter);
+    EXPECT_EQ(static_cast<unsigned>(GL_LINEAR), list[0].filter);
     child_resource_provider->ReceiveFromParent(list);
   }
-  EXPECT_EQ(GL_LINEAR, GetResourceFilter(child_resource_provider.get(), id));
+  EXPECT_EQ(static_cast<unsigned>(GL_LINEAR),
+            GetResourceFilter(child_resource_provider.get(), id));
   SetResourceFilter(child_resource_provider.get(), id, GL_NEAREST);
-  EXPECT_EQ(GL_NEAREST, GetResourceFilter(child_resource_provider.get(), id));
+  EXPECT_EQ(static_cast<unsigned>(GL_NEAREST),
+            GetResourceFilter(child_resource_provider.get(), id));
 }
 
 void ReleaseTextureMailbox(unsigned* release_sync_point, unsigned sync_point) {
   *release_sync_point = sync_point;
 }
 
 TEST_P(ResourceProviderTest, TransferMailboxResources) {
   // Resource transfer is only supported with GL textures for now.
   if (GetParam() != ResourceProvider::GLTexture)
     return;
   unsigned texture = context()->createTexture();
   context()->bindTexture(GL_TEXTURE_2D, texture);
   uint8_t data[4] = { 1, 2, 3, 4 };
   context()->texImage2D(
       GL_TEXTURE_2D, 0, GL_RGBA, 1, 1, 0, GL_RGBA, GL_UNSIGNED_BYTE, &data);
   gpu::Mailbox mailbox;
   context()->genMailboxCHROMIUM(mailbox.name);
   context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
   unsigned sync_point = context()->insertSyncPoint();
 
   // All the logic below assumes that the sync points are all positive.
   EXPECT_LT(0u, sync_point);
 
   unsigned release_sync_point = 0;
   TextureMailbox::ReleaseCallback callback =
       base::Bind(ReleaseTextureMailbox, &release_sync_point);
   ResourceProvider::ResourceId resource =
       resource_provider_->CreateResourceFromTextureMailbox(
           TextureMailbox(mailbox, callback, sync_point));
-  EXPECT_EQ(1u, context()->texture_count());
+  EXPECT_EQ(1, context()->texture_count());
   EXPECT_EQ(0u, release_sync_point);
   {
     // Transfer the resource, expect the sync points to be consistent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
     ASSERT_EQ(1u, list.size());
     EXPECT_LE(sync_point, list[0].sync_point);
-    EXPECT_EQ(0u,
+    EXPECT_EQ(0,
               memcmp(mailbox.name, list[0].mailbox.name, sizeof(mailbox.name)));
     EXPECT_EQ(0u, release_sync_point);
 
     context()->waitSyncPoint(list[0].sync_point);
     unsigned other_texture = context()->createTexture();
     context()->bindTexture(GL_TEXTURE_2D, other_texture);
     context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
     uint8_t test_data[4] = { 0 };
     context()->GetPixels(gfx::Size(1, 1), GL_RGBA, test_data);
-    EXPECT_EQ(0u, memcmp(data, test_data, sizeof(data)));
+    EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
     context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
     context()->deleteTexture(other_texture);
     list[0].sync_point = context()->insertSyncPoint();
     EXPECT_LT(0u, list[0].sync_point);
 
     // Receive the resource, then delete it, expect the sync points to be
     // consistent.
     resource_provider_->ReceiveFromParent(list);
-    EXPECT_EQ(1u, context()->texture_count());
+    EXPECT_EQ(1, context()->texture_count());
     EXPECT_EQ(0u, release_sync_point);
 
     resource_provider_->DeleteResource(resource);
     EXPECT_LE(list[0].sync_point, release_sync_point);
   }
 
   // We're going to do the same thing as above, but testing the case where we
   // delete the resource before we receive it back.
   sync_point = release_sync_point;
   EXPECT_LT(0u, sync_point);
   release_sync_point = 0;
   resource = resource_provider_->CreateResourceFromTextureMailbox(
       TextureMailbox(mailbox, callback, sync_point));
-  EXPECT_EQ(1u, context()->texture_count());
+  EXPECT_EQ(1, context()->texture_count());
   EXPECT_EQ(0u, release_sync_point);
   {
     // Transfer the resource, expect the sync points to be consistent.
     ResourceProvider::ResourceIdArray resource_ids_to_transfer;
     resource_ids_to_transfer.push_back(resource);
     TransferableResourceArray list;
     resource_provider_->PrepareSendToParent(resource_ids_to_transfer, &list);
     ASSERT_EQ(1u, list.size());
     EXPECT_LE(sync_point, list[0].sync_point);
-    EXPECT_EQ(0u,
+    EXPECT_EQ(0,
               memcmp(mailbox.name, list[0].mailbox.name, sizeof(mailbox.name)));
     EXPECT_EQ(0u, release_sync_point);
 
     context()->waitSyncPoint(list[0].sync_point);
     unsigned other_texture = context()->createTexture();
     context()->bindTexture(GL_TEXTURE_2D, other_texture);
     context()->consumeTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
     uint8_t test_data[4] = { 0 };
     context()->GetPixels(gfx::Size(1, 1), GL_RGBA, test_data);
-    EXPECT_EQ(0u, memcmp(data, test_data, sizeof(data)));
+    EXPECT_EQ(0, memcmp(data, test_data, sizeof(data)));
     context()->produceTextureCHROMIUM(GL_TEXTURE_2D, mailbox.name);
     context()->deleteTexture(other_texture);
     list[0].sync_point = context()->insertSyncPoint();
     EXPECT_LT(0u, list[0].sync_point);
 
     // Delete the resource, which shouldn't do anything.
     resource_provider_->DeleteResource(resource);
-    EXPECT_EQ(1u, context()->texture_count());
+    EXPECT_EQ(1, context()->texture_count());
     EXPECT_EQ(0u, release_sync_point);
 
     // Then receive the resource which should release the mailbox, expect the
     // sync points to be consistent.
     resource_provider_->ReceiveFromParent(list);
     EXPECT_LE(list[0].sync_point, release_sync_point);
   }
 
   context()->waitSyncPoint(release_sync_point);
   context()->bindTexture(GL_TEXTURE_2D, texture);
@@ skipping 112 matching lines @@
       texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE));
   EXPECT_CALL(
       *context,
       texParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE));
   EXPECT_CALL(*context,
               texParameteri(GL_TEXTURE_2D,
                             GL_TEXTURE_POOL_CHROMIUM,
                             GL_TEXTURE_POOL_MANAGED_CHROMIUM));
   ResourceProvider::ResourceId id = resource_provider->CreateManagedResource(
       size, format, ResourceProvider::TextureUsageAny);
+  EXPECT_NE(0u, id);
 
   Mock::VerifyAndClearExpectations(context);
 }
 
 class AllocationTrackingContext3D : public TestWebGraphicsContext3D {
  public:
   MOCK_METHOD0(createTexture, WebGLId());
   MOCK_METHOD1(deleteTexture, void(WebGLId texture_id));
   MOCK_METHOD2(bindTexture, void(WGC3Denum target, WebGLId texture));
   MOCK_METHOD9(texImage2D,
@@ skipping 187 matching lines @@
   Mock::VerifyAndClearExpectations(context);
 }
 
 INSTANTIATE_TEST_CASE_P(
     ResourceProviderTests,
     ResourceProviderTest,
     ::testing::Values(ResourceProvider::GLTexture, ResourceProvider::Bitmap));
 
 }  // namespace
 }  // namespace cc