cc: Switch to Chromium DCHECKs LOGs

cc/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 "config.h"
 
 #include "CCResourceProvider.h"
 
 #include "CCGraphicsContext.h"
 #include "CCSingleThreadProxy.h" // For DebugScopedSetImplThread
 #include "Extensions3DChromium.h"
+#include "base/logging.h"
 #include "cc/scoped_ptr_deque.h"
 #include "cc/scoped_ptr_hash_map.h"
 #include "cc/test/compositor_fake_web_graphics_context_3d.h"
 #include "cc/test/fake_web_compositor_output_surface.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include <public/WebGraphicsContext3D.h>
 
 using namespace cc;
 using namespace WebKit;
 
@@ skipping 31 matching lines @@
     {
         memset(mailbox, 0, sizeof(WGC3Dbyte[64]));
         memcpy(mailbox, &m_nextMailBox, sizeof(m_nextMailBox));
         ++m_nextMailBox;
     }
 
     void produceTexture(const WGC3Dbyte* mailboxName, unsigned syncPoint, scoped_ptr<Texture> texture)
     {
         unsigned mailbox = 0;
         memcpy(&mailbox, mailboxName, sizeof(mailbox));
-        ASSERT(mailbox && mailbox < m_nextMailBox);
+        ASSERT_TRUE(mailbox && mailbox < m_nextMailBox);
         m_textures.set(mailbox, texture.Pass());
-        ASSERT(m_syncPointForMailbox[mailbox] < syncPoint);
+        ASSERT_LT(m_syncPointForMailbox[mailbox], syncPoint);
         m_syncPointForMailbox[mailbox] = syncPoint;
     }
 
     scoped_ptr<Texture> consumeTexture(const WGC3Dbyte* mailboxName, unsigned syncPoint)
     {
         unsigned mailbox = 0;
         memcpy(&mailbox, mailboxName, sizeof(mailbox));
-        ASSERT(mailbox && mailbox < m_nextMailBox);
+        DCHECK(mailbox && mailbox < m_nextMailBox);
 
         // If the latest sync point the context has waited on is before the sync
         // point for when the mailbox was set, pretend we never saw that
         // produceTexture.
         if (m_syncPointForMailbox[mailbox] < syncPoint)
             return scoped_ptr<Texture>();
         return m_textures.take(mailbox);
     }
 
 private:
@@ skipping 24 matching lines @@
         return syncPoint;
     }
 
     virtual void waitSyncPoint(unsigned syncPoint)
     {
         m_lastWaitedSyncPoint = std::max(syncPoint, m_lastWaitedSyncPoint);
     }
 
     virtual void bindTexture(WGC3Denum target, WebGLId texture)
     {
-      ASSERT(target == GraphicsContext3D::TEXTURE_2D);
-      ASSERT(!texture || m_textures.find(texture) != m_textures.end());
+      ASSERT_EQ(target, GraphicsContext3D::TEXTURE_2D);
+      ASSERT_TRUE(!texture || m_textures.find(texture) != m_textures.end());
       m_currentTexture = texture;
     }
 
     virtual WebGLId createTexture()
     {
         WebGLId id = CompositorFakeWebGraphicsContext3D::createTexture();
         m_textures.add(id, scoped_ptr<Texture>());
         return id;
     }
 
     virtual void deleteTexture(WebGLId id)
     {
         TextureMap::iterator it = m_textures.find(id);
-        ASSERT(it != m_textures.end());
+        ASSERT_FALSE(it == m_textures.end());
         m_textures.erase(it);
         if (m_currentTexture == id)
             m_currentTexture = 0;
     }
 
     virtual void texStorage2DEXT(WGC3Denum target, WGC3Dint levels, WGC3Duint internalformat,
                                  WGC3Dint width, WGC3Dint height)
     {
-        ASSERT(m_currentTexture);
-        ASSERT(target == GraphicsContext3D::TEXTURE_2D);
-        ASSERT(levels == 1);
+        ASSERT_TRUE(m_currentTexture);
+        ASSERT_EQ(target, GraphicsContext3D::TEXTURE_2D);
+        ASSERT_EQ(levels, 1);
         WGC3Denum format = GraphicsContext3D::RGBA;
         switch (internalformat) {
         case Extensions3D::RGBA8_OES:
             break;
         case Extensions3DChromium::BGRA8_EXT:
             format = Extensions3D::BGRA_EXT;
             break;
         default:
-            ASSERT_NOT_REACHED();
+            NOTREACHED();
         }
         allocateTexture(IntSize(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)
     {
-        ASSERT(m_currentTexture);
-        ASSERT(target == GraphicsContext3D::TEXTURE_2D);
-        ASSERT(!level);
-        ASSERT(internalformat == format);
-        ASSERT(!border);
-        ASSERT(type == GraphicsContext3D::UNSIGNED_BYTE);
+        ASSERT_TRUE(m_currentTexture);
+        ASSERT_EQ(target, GraphicsContext3D::TEXTURE_2D);
+        ASSERT_FALSE(level);
+        ASSERT_EQ(internalformat, format);
+        ASSERT_FALSE(border);
+        ASSERT_EQ(type, GraphicsContext3D::UNSIGNED_BYTE);
         allocateTexture(IntSize(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)
     {
-        ASSERT(m_currentTexture);
-        ASSERT(target == GraphicsContext3D::TEXTURE_2D);
-        ASSERT(!level);
-        ASSERT(m_textures.get(m_currentTexture));
-        ASSERT(m_textures.get(m_currentTexture)->format == format);
-        ASSERT(type == GraphicsContext3D::UNSIGNED_BYTE);
-        ASSERT(pixels);
+        ASSERT_TRUE(m_currentTexture);
+        ASSERT_EQ(target, GraphicsContext3D::TEXTURE_2D);
+        ASSERT_FALSE(level);
+        ASSERT_TRUE(m_textures.get(m_currentTexture));
+        ASSERT_EQ(m_textures.get(m_currentTexture)->format, format);
+        ASSERT_EQ(type, GraphicsContext3D::UNSIGNED_BYTE);
+        ASSERT_TRUE(pixels);
         setPixels(xoffset, yoffset, width, height, pixels);
     }
 
     virtual void genMailboxCHROMIUM(WGC3Dbyte* mailbox) { return m_sharedData->genMailbox(mailbox); }
     virtual void produceTextureCHROMIUM(WGC3Denum target, const WGC3Dbyte* mailbox)
     {
-        ASSERT(m_currentTexture);
-        ASSERT(target == GraphicsContext3D::TEXTURE_2D);
+        ASSERT_TRUE(m_currentTexture);
+        ASSERT_EQ(target, GraphicsContext3D::TEXTURE_2D);
 
         // 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 = m_textures.take(m_currentTexture);
         m_textures.set(m_currentTexture, scoped_ptr<Texture>());
         m_pendingProduceTextures.append(pending.Pass());
     }
 
     virtual void consumeTextureCHROMIUM(WGC3Denum target, const WGC3Dbyte* mailbox)
     {
-        ASSERT(m_currentTexture);
-        ASSERT(target == GraphicsContext3D::TEXTURE_2D);
+        ASSERT_TRUE(m_currentTexture);
+        ASSERT_EQ(target, GraphicsContext3D::TEXTURE_2D);
         m_textures.set(m_currentTexture, m_sharedData->consumeTexture(mailbox, m_lastWaitedSyncPoint));
     }
 
     void getPixels(const IntSize& size, WGC3Denum format, uint8_t* pixels)
     {
-        ASSERT(m_currentTexture);
+        ASSERT_TRUE(m_currentTexture);
         Texture* texture = m_textures.get(m_currentTexture);
-        ASSERT(texture);
-        ASSERT(texture->size == size);
-        ASSERT(texture->format == format);
+        ASSERT_TRUE(texture);
+        ASSERT_EQ(texture->size, size);
+        ASSERT_EQ(texture->format, format);
         memcpy(pixels, texture->data.get(), textureSize(size, format));
     }
 
     int textureCount()
     {
         return m_textures.size();
     }
 
 protected:
     ResourceProviderContext(const Attributes& attrs, ContextSharedData* sharedData)
         : CompositorFakeWebGraphicsContext3D(attrs)
         , m_sharedData(sharedData)
         , m_currentTexture(0)
         , m_lastWaitedSyncPoint(0)
     { }
 
 private:
     void allocateTexture(const IntSize& size, WGC3Denum format)
     {
-        ASSERT(m_currentTexture);
+        ASSERT_TRUE(m_currentTexture);
         m_textures.set(m_currentTexture, make_scoped_ptr(new Texture(size, format)));
     }
 
     void setPixels(int xoffset, int yoffset, int width, int height, const void* pixels)
     {
-        ASSERT(m_currentTexture);
+        ASSERT_TRUE(m_currentTexture);
         Texture* texture = m_textures.get(m_currentTexture);
-        ASSERT(texture);
-        ASSERT(xoffset >= 0 && xoffset+width <= texture->size.width());
-        ASSERT(yoffset >= 0 && yoffset+height <= texture->size.height());
-        ASSERT(pixels);
+        ASSERT_TRUE(texture);
+        ASSERT_TRUE(xoffset >= 0 && xoffset+width <= texture->size.width());
+        ASSERT_TRUE(yoffset >= 0 && yoffset+height <= texture->size.height());
+        ASSERT_TRUE(pixels);
         size_t inPitch = textureSize(IntSize(width, 1), texture->format);
         size_t outPitch = textureSize(IntSize(texture->size.width(), 1), texture->format);
         uint8_t* dest = texture->data.get() + yoffset * outPitch + textureSize(IntSize(xoffset, 1), texture->format);
         const uint8_t* src = static_cast<const uint8_t*>(pixels);
         for (int i = 0; i < height; ++i) {
             memcpy(dest, src, inPitch);
             dest += outPitch;
             src += inPitch;
         }
     }
@@ skipping 324 matching lines @@
     }
     EXPECT_EQ(0u, childResourceProvider->numResources());
 }
 
 INSTANTIATE_TEST_CASE_P(CCResourceProviderTests,
                         CCResourceProviderTest,
                         ::testing::Values(CCResourceProvider::GLTexture,
                                           CCResourceProvider::Bitmap));
 
 } // namespace