Rolls cc and webkit_compositor up to 127340

cc/CCPrioritizedTextureTest.cpp

 // 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 "CCPrioritizedTexture.h"
 
 #include "CCPrioritizedTextureManager.h"
 #include "CCSingleThreadProxy.h" // For DebugScopedSetImplThread
 #include "CCTexture.h"
 #include "CCTiledLayerTestCommon.h"
 #include "FakeCCGraphicsContext.h"
 #include <gtest/gtest.h>
+#include <public/WebCompositor.h>
 
 using namespace WebCore;
 using namespace WebKitTests;
 using namespace WTF;
 
 namespace {
 
 class CCPrioritizedTextureTest : public testing::Test {
 public:
     CCPrioritizedTextureTest()
         : m_textureSize(256, 256)
         , m_textureFormat(GraphicsContext3D::RGBA)
         , m_context(WebKit::createFakeCCGraphicsContext())
     {
+        WebKit::WebCompositor::initialize(0);
         DebugScopedSetImplThread implThread;
         m_resourceProvider = CCResourceProvider::create(m_context.get());
     }
 
     virtual ~CCPrioritizedTextureTest()
     {
-        DebugScopedSetImplThread implThread;
-        m_resourceProvider.clear();
+        {
+            DebugScopedSetImplThread implThread;
+            m_resourceProvider.clear();
+        }
+        WebKit::WebCompositor::shutdown();
     }
 
     size_t texturesMemorySize(size_t textureCount)
     {
         return CCTexture::memorySizeBytes(m_textureSize, m_textureFormat) * textureCount;
     }
 
     PassOwnPtr<CCPrioritizedTextureManager> createManager(size_t maxTextures)
     {
         return CCPrioritizedTextureManager::create(texturesMemorySize(maxTextures), 1024, 0);
     }
 
     bool validateTexture(OwnPtr<CCPrioritizedTexture>& texture, bool requestLate)
     {
-        DebugScopedSetImplThread implThread;
 #if !ASSERT_DISABLED
         texture->textureManager()->assertInvariants();
 #endif
         if (requestLate)
             texture->requestLate();
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
         bool success = texture->canAcquireBackingTexture();
         if (success)
             texture->acquireBackingTexture(resourceProvider());
         return success;
     }
 
     CCResourceProvider* resourceProvider()
     {
        return m_resourceProvider.get();
     }
@@ skipping 34 matching lines @@
     // Only upper half should be available.
     textureManager->prioritizeTextures();
     EXPECT_FALSE(validateTexture(textures[0], false));
     EXPECT_FALSE(validateTexture(textures[7], false));
     EXPECT_TRUE(validateTexture(textures[8], false));
     EXPECT_TRUE(validateTexture(textures[15], false));
 
     EXPECT_EQ(texturesMemorySize(maxTextures), textureManager->memoryAboveCutoffBytes());
     EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
 
-    DebugScopedSetImplThread implThread;
+    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
     textureManager->clearAllMemory(resourceProvider());
 }
 
 TEST_F(CCPrioritizedTextureTest, changeMemoryLimits)
 {
     const size_t maxTextures = 8;
     OwnPtr<CCPrioritizedTextureManager> textureManager = createManager(maxTextures);
     OwnPtr<CCPrioritizedTexture> textures[maxTextures];
 
     for (size_t i = 0; i < maxTextures; ++i)
         textures[i] = textureManager->createTexture(m_textureSize, m_textureFormat);
     for (size_t i = 0; i < maxTextures; ++i)
         textures[i]->setRequestPriority(100 + i);
 
     // Set max limit to 8 textures
     textureManager->setMaxMemoryLimitBytes(texturesMemorySize(8));
     textureManager->prioritizeTextures();
     for (size_t i = 0; i < maxTextures; ++i)
         validateTexture(textures[i], false);
     {
-        DebugScopedSetImplThread implThread;
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
         textureManager->reduceMemory(resourceProvider());
     }
 
     EXPECT_EQ(texturesMemorySize(8), textureManager->memoryAboveCutoffBytes());
     EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
 
     // Set max limit to 5 textures
     textureManager->setMaxMemoryLimitBytes(texturesMemorySize(5));
     textureManager->prioritizeTextures();
     for (size_t i = 0; i < maxTextures; ++i)
         EXPECT_EQ(validateTexture(textures[i], false), i < 5);
     {
-        DebugScopedSetImplThread implThread;
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
         textureManager->reduceMemory(resourceProvider());
     }
 
     EXPECT_EQ(texturesMemorySize(5), textureManager->memoryAboveCutoffBytes());
     EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
 
     // Set max limit to 4 textures
     textureManager->setMaxMemoryLimitBytes(texturesMemorySize(4));
     textureManager->prioritizeTextures();
     for (size_t i = 0; i < maxTextures; ++i)
         EXPECT_EQ(validateTexture(textures[i], false), i < 4);
     {
-        DebugScopedSetImplThread implThread;
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
         textureManager->reduceMemory(resourceProvider());
     }
 
     EXPECT_EQ(texturesMemorySize(4), textureManager->memoryAboveCutoffBytes());
     EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
 
-    DebugScopedSetImplThread implThread;
+    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
     textureManager->clearAllMemory(resourceProvider());
 }
 
 TEST_F(CCPrioritizedTextureTest, textureManagerPartialUpdateTextures)
 {
     const size_t maxTextures = 4;
     const size_t numTextures = 4;
     OwnPtr<CCPrioritizedTextureManager> textureManager = createManager(maxTextures);
     OwnPtr<CCPrioritizedTexture> textures[numTextures];
     OwnPtr<CCPrioritizedTexture> moreTextures[numTextures];
@@ skipping 39 matching lines @@
     EXPECT_TRUE(validateTexture(moreTextures[1], false));
     EXPECT_TRUE(validateTexture(moreTextures[2], false));
     EXPECT_TRUE(validateTexture(moreTextures[3], false));
 
     // Lower priority have been fully evicted.
     EXPECT_FALSE(textures[0]->haveBackingTexture());
     EXPECT_FALSE(textures[1]->haveBackingTexture());
     EXPECT_FALSE(textures[2]->haveBackingTexture());
     EXPECT_FALSE(textures[3]->haveBackingTexture());
 
-    DebugScopedSetImplThread implThread;
+    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
     textureManager->clearAllMemory(resourceProvider());
 }
 
 TEST_F(CCPrioritizedTextureTest, textureManagerPrioritiesAreEqual)
 {
     const size_t maxTextures = 16;
     OwnPtr<CCPrioritizedTextureManager> textureManager = createManager(maxTextures);
     OwnPtr<CCPrioritizedTexture> textures[maxTextures];
 
     for (size_t i = 0; i < maxTextures; ++i)
@@ skipping 19 matching lines @@
 
     // Manually reserving textures should only succeed on the higher priority textures,
     // and on remaining textures up to the memory limit.
     for (size_t i = 0; i < 8; i++)
         EXPECT_TRUE(validateTexture(textures[i], true));
     for (size_t i = 9; i < maxTextures; i++)
         EXPECT_FALSE(validateTexture(textures[i], true));
     EXPECT_EQ(texturesMemorySize(8), textureManager->memoryAboveCutoffBytes());
     EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
 
-    DebugScopedSetImplThread implThread;
+    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
     textureManager->clearAllMemory(resourceProvider());
 }
 
 TEST_F(CCPrioritizedTextureTest, textureManagerDestroyedFirst)
 {
     OwnPtr<CCPrioritizedTextureManager> textureManager = createManager(1);
     OwnPtr<CCPrioritizedTexture> texture = textureManager->createTexture(m_textureSize, m_textureFormat);
 
     // Texture is initially invalid, but it will become available.
     EXPECT_FALSE(texture->haveBackingTexture());
 
     texture->setRequestPriority(100);
     textureManager->prioritizeTextures();
 
     EXPECT_TRUE(validateTexture(texture, false));
     EXPECT_TRUE(texture->canAcquireBackingTexture());
     EXPECT_TRUE(texture->haveBackingTexture());
 
     {
-        DebugScopedSetImplThread implThread;
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
         textureManager->clearAllMemory(resourceProvider());
     }
     textureManager.clear();
 
     EXPECT_FALSE(texture->canAcquireBackingTexture());
     EXPECT_FALSE(texture->haveBackingTexture());
 }
 
 TEST_F(CCPrioritizedTextureTest, textureMovedToNewManager)
 {
     OwnPtr<CCPrioritizedTextureManager> textureManagerOne = createManager(1);
     OwnPtr<CCPrioritizedTextureManager> textureManagerTwo = createManager(1);
     OwnPtr<CCPrioritizedTexture> texture = textureManagerOne->createTexture(m_textureSize, m_textureFormat);
 
     // Texture is initially invalid, but it will become available.
     EXPECT_FALSE(texture->haveBackingTexture());
 
     texture->setRequestPriority(100);
     textureManagerOne->prioritizeTextures();
 
     EXPECT_TRUE(validateTexture(texture, false));
     EXPECT_TRUE(texture->canAcquireBackingTexture());
     EXPECT_TRUE(texture->haveBackingTexture());
 
     texture->setTextureManager(0);
 
     {
-        DebugScopedSetImplThread implThread;
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
         textureManagerOne->clearAllMemory(resourceProvider());
     }
     textureManagerOne.clear();
 
     EXPECT_FALSE(texture->canAcquireBackingTexture());
     EXPECT_FALSE(texture->haveBackingTexture());
 
     texture->setTextureManager(textureManagerTwo.get());
 
     textureManagerTwo->prioritizeTextures();
 
     EXPECT_TRUE(validateTexture(texture, false));
     EXPECT_TRUE(texture->canAcquireBackingTexture());
     EXPECT_TRUE(texture->haveBackingTexture());
 
-    DebugScopedSetImplThread implThread;
+    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
     textureManagerTwo->clearAllMemory(resourceProvider());
 }
 
 TEST_F(CCPrioritizedTextureTest, renderSurfacesReduceMemoryAvailableOutsideRootSurface)
 {
     const size_t maxTextures = 8;
     OwnPtr<CCPrioritizedTextureManager> textureManager = createManager(maxTextures);
 
     // Half of the memory is taken by surfaces (with high priority place-holder)
     OwnPtr<CCPrioritizedTexture> renderSurfacePlaceHolder = textureManager->createTexture(m_textureSize, m_textureFormat);
@@ skipping 25 matching lines @@
     textureManager->prioritizeTextures();
     EXPECT_FALSE(validateTexture(textures[0], false));
     EXPECT_FALSE(validateTexture(textures[3], false));
     EXPECT_TRUE(validateTexture(textures[4], false));
     EXPECT_TRUE(validateTexture(textures[7], false));
 
     EXPECT_EQ(texturesMemorySize(4), textureManager->memoryAboveCutoffBytes());
     EXPECT_EQ(texturesMemorySize(4), textureManager->memoryForSelfManagedTextures());
     EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
 
-    DebugScopedSetImplThread implThread;
+    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
     textureManager->clearAllMemory(resourceProvider());
 }
 
 TEST_F(CCPrioritizedTextureTest, renderSurfacesReduceMemoryAvailableForRequestLate)
 {
     const size_t maxTextures = 8;
     OwnPtr<CCPrioritizedTextureManager> textureManager = createManager(maxTextures);
 
     // Half of the memory is taken by surfaces (with high priority place-holder)
     OwnPtr<CCPrioritizedTexture> renderSurfacePlaceHolder = textureManager->createTexture(m_textureSize, m_textureFormat);
@@ skipping 16 matching lines @@
         EXPECT_FALSE(validateTexture(textures[i], false));
     for (unsigned i = 0; i < maxTextures; i += 2)
         EXPECT_TRUE(validateTexture(textures[i], true));
     for (unsigned i = 1; i < maxTextures; i += 2)
         EXPECT_FALSE(validateTexture(textures[i], true));
 
     EXPECT_EQ(texturesMemorySize(4), textureManager->memoryAboveCutoffBytes());
     EXPECT_EQ(texturesMemorySize(4), textureManager->memoryForSelfManagedTextures());
     EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
 
-    DebugScopedSetImplThread implThread;
+    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
     textureManager->clearAllMemory(resourceProvider());
 }
 
 TEST_F(CCPrioritizedTextureTest, whenRenderSurfaceNotAvailableTexturesAlsoNotAvailable)
 {
     const size_t maxTextures = 8;
     OwnPtr<CCPrioritizedTextureManager> textureManager = createManager(maxTextures);
 
     // Half of the memory is taken by surfaces (with high priority place-holder)
     OwnPtr<CCPrioritizedTexture> renderSurfacePlaceHolder = textureManager->createTexture(m_textureSize, m_textureFormat);
@@ skipping 19 matching lines @@
     EXPECT_FALSE(validateTexture(textures[7], true));
 
     // Root surface textures are valid.
     for (size_t i = 0; i < 6; ++i)
         EXPECT_TRUE(validateTexture(textures[i], false));
 
     EXPECT_EQ(texturesMemorySize(6), textureManager->memoryAboveCutoffBytes());
     EXPECT_EQ(texturesMemorySize(2), textureManager->memoryForSelfManagedTextures());
     EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
 
-    DebugScopedSetImplThread implThread;
+    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
     textureManager->clearAllMemory(resourceProvider());
 }
 
 } // namespace