Integrate r128344 and r128253 from WebKit

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 "WebCompositorInitializer.h"
 #include <gtest/gtest.h>
 
 using namespace cc;
 using namespace WebKitTests;
 using namespace WTF;
 
-namespace {
+namespace WebCore {

[jamesr, 2012/09/17 18:11:08]

is this change deliberate? normally tests are in an anonymous namespace

[ccameron, 2012/09/17 18:15:59]

Yes -- I made the test base class a friend of the PTM, so that it could call the
otherwise-private functions (assert invariants, prioritize backings), and you
can't make friends across anonymous namespaces.  An alternative scheme would be
to create a testing-helper class in PTM, which would expose a smaller surface
area of the PTM than just making them friends -- would that be preferable?

[jamesr, 2012/09/17 18:24:08]

It seems to not be quite working:

FAILED: clang++ -MMD -MF obj/cc/cc_unittests.CCPrioritizedTextureTest.o.d
-DCHROMIUM_BUILD -DUSE_LIBJPEG_TURBO=1 -DENABLE_ONE_CLICK_SIGNIN
-DENABLE_REMOTING=1 -DENABLE_WEBRTC=1 -DENABLE_CONFIGURATION_POLICY
-DENABLE_INPUT_SPEECH -DENABLE_NOTIFICATIONS -DENABLE_HIDPI=1
-DDCHECK_ALWAYS_ON=1 -DENABLE_GPU=1 -DENABLE_EGLIMAGE=1 -DUSE_SKIA=1
-DENABLE_TASK_MANAGER=1 -DENABLE_WEB_INTENTS=1 -DENABLE_EXTENSIONS=1
-DENABLE_PLUGIN_INSTALLATION=1 -DENABLE_PROTECTOR_SERVICE=1
-DENABLE_SESSION_SERVICE=1 -DENABLE_THEMES=1 -DENABLE_BACKGROUND=1
-DENABLE_AUTOMATION=1 -DENABLE_PRINTING=1 -DENABLE_CAPTIVE_PORTAL_DETECTION=1
-DUSE_LIBCC_FOR_COMPOSITOR -DWTF_USE_ACCELERATED_COMPOSITING=1 -DUNIT_TEST
-DGTEST_HAS_RTTI=0 -DENABLE_3D_PLUGIN=1 -DENABLE_BATTERY_STATUS=0
-DENABLE_BLOB=1 -DENABLE_BLOB_SLICE=1 -DENABLE_CHANNEL_MESSAGING=1
-DENABLE_CSP_NEXT=1 -DENABLE_CSS3_TEXT_DECORATION=0
-DENABLE_CSS_BOX_DECORATION_BREAK=1 -DENABLE_CSS_COMPOSITING=0
-DENABLE_CSS_EXCLUSIONS=1 -DENABLE_CSS_FILTERS=1 -DENABLE_CSS_HIERARCHIES=0
-DENABLE_CSS_IMAGE_SET=1 -DENABLE_CSS_IMAGE_RESOLUTION=0 -DENABLE_CSS_REGIONS=1
-DENABLE_CSS_SHADERS=1 -DENABLE_CSS_VARIABLES=1 -DENABLE_CSS_STICKY_POSITION=1
-DENABLE_CUSTOM_SCHEME_HANDLER=0 -DENABLE_DASHBOARD_SUPPORT=0
-DENABLE_DATA_TRANSFER_ITEMS=1 -DENABLE_DETAILS_ELEMENT=1
-DENABLE_DEVICE_ORIENTATION=1 -DENABLE_DIALOG_ELEMENT=1
-DENABLE_DIRECTORY_UPLOAD=1 -DENABLE_DOWNLOAD_ATTRIBUTE=1
-DENABLE_ENCRYPTED_MEDIA=1 -DENABLE_FILE_SYSTEM=1 -DENABLE_FILTERS=1
-DENABLE_FULLSCREEN_API=1 -DENABLE_GAMEPAD=1 -DENABLE_GEOLOCATION=1
-DENABLE_GESTURE_EVENTS=1 -DENABLE_ICONDATABASE=0 -DENABLE_IFRAME_SEAMLESS=1
-DENABLE_INDEXED_DATABASE=1 -DENABLE_INPUT_TYPE_DATE=1
-DENABLE_INPUT_TYPE_DATETIME=1 -DENABLE_INPUT_TYPE_DATETIMELOCAL=1
-DENABLE_INPUT_TYPE_MONTH=1 -DENABLE_INPUT_TYPE_TIME=1
-DENABLE_INPUT_TYPE_WEEK=1 -DENABLE_JAVASCRIPT_DEBUGGER=1
-DENABLE_LEGACY_CSS_VENDOR_PREFIXES=0 -DENABLE_LEGACY_VIEWPORT_ADAPTION=1
-DENABLE_LEGACY_VENDOR_PREFIXES=1 -DENABLE_LEGACY_WEBKIT_BLOB_BUILDER=1
-DENABLE_LINK_PREFETCH=1 -DENABLE_LINK_PRERENDER=1 -DENABLE_MEDIA_SOURCE=1
-DENABLE_MEDIA_STATISTICS=1 -DENABLE_METER_ELEMENT=1 -DENABLE_MHTML=1
-DENABLE_MICRODATA=0 -DENABLE_MUTATION_OBSERVERS=1
-DENABLE_NAVIGATOR_CONTENT_UTILS=1 -DENABLE_PAGE_VISIBILITY_API=1
-DENABLE_POINTER_LOCK=1 -DENABLE_PROGRESS_ELEMENT=1 -DENABLE_QUOTA=1
-DENABLE_REQUEST_ANIMATION_FRAME=1 -DENABLE_RUBY=1 -DENABLE_SANDBOX=1
-DENABLE_SCRIPTED_SPEECH=1 -DENABLE_SHADOW_DOM=1 -DENABLE_SMOOTH_SCROLLING=1
-DENABLE_SQL_DATABASE=1 -DENABLE_STYLE_SCOPED=1 -DENABLE_SVG=1
-DENABLE_SVG_FONTS=1 -DENABLE_TEXT_AUTOSIZING=1 -DENABLE_TOUCH_ADJUSTMENT=1
-DENABLE_TOUCH_EVENTS=1 -DENABLE_TOUCH_ICON_LOADING=0 -DENABLE_TOUCH_SLIDER=1
-DENABLE_V8_SCRIPT_DEBUG_SERVER=1 -DENABLE_VIDEO=1 -DENABLE_VIDEO_TRACK=1
-DENABLE_VIEWPORT=1 -DENABLE_WEBGL=1 -DENABLE_WEB_SOCKETS=1
-DENABLE_WEB_TIMING=1 -DENABLE_WIDGET_REGION=1 -DENABLE_WORKERS=1
-DENABLE_XHR_RESPONSE_BLOB=1 -DENABLE_XSLT=1 -DWTF_USE_LEVELDB=1
-DWTF_USE_BUILTIN_UTF8_CODEC=1 -DWTF_USE_OPENTYPE_SANITIZER=1
-DWTF_USE_RTL_SCROLLBAR=1 -DWTF_USE_SKIA_TEXT=1 -DWTF_USE_WEBP=1
-DWTF_USE_WEBKIT_IMAGE_DECODERS=1 -DENABLE_ACCELERATED_OVERFLOW_SCROLLING=0
-DENABLE_CALENDAR_PICKER=1 -DENABLE_DATALIST_ELEMENT=1 -DENABLE_INPUT_SPEECH=1
-DENABLE_INPUT_TYPE_COLOR=1 -DENABLE_INPUT_TYPE_TIME_MULTIPLE_FIELDS=1
-DENABLE_JAVASCRIPT_I18N_API=1 -DENABLE_LEGACY_NOTIFICATIONS=1
-DENABLE_MEDIA_CAPTURE=0 -DENABLE_MEDIA_STREAM=1 -DENABLE_NOTIFICATIONS=1
-DENABLE_ORIENTATION_EVENTS=0 -DENABLE_PAGE_POPUP=1 -DENABLE_SHARED_WORKERS=1
-DENABLE_WEB_AUDIO=1 -DENABLE_3D_RENDERING=1 -DENABLE_ACCELERATED_2D_CANVAS=1
-DENABLE_RUBBER_BANDING=1 -DWTF_USE_SKIA_ON_MAC_CHROMIUM=1
-DBUILDING_CHROMIUM__=1 -DUSE_SYSTEM_MALLOC=1 -DWTF_USE_NEW_THEME=1
-DU_USING_ICU_NAMESPACE=0 -DU_STATIC_IMPLEMENTATION -DSK_BUILD_NO_IMAGE_ENCODE
-DSK_DEFERRED_CANVAS_USES_GPIPE=1
'-DGR_GL_CUSTOM_SETUP_HEADER="GrGLConfig_chrome.h"'
-DGR_AGGRESSIVE_SHADER_OPTS=1 -DNDEBUG -DNVALGRIND
-DDYNAMIC_ANNOTATIONS_ENABLED=0 -I../../third_party/icu/public/common
-I../../third_party/icu/public/i18n -I../../cc/stubs -I../../cc/test -I../../cc
-I../../third_party/WebKit/Source/Platform/chromium -I../../third_party/khronos
-I../.. -I../../testing/gtest/include -I../../testing/gmock/include
-I../../third_party/WebKit/Source/WTF
-I../../third_party/WebKit/Source/JavaScriptCore -I../../skia/config
-I../../third_party/skia/src/core -I../../third_party/skia/include/config
-I../../third_party/skia/include/core -I../../third_party/skia/include/effects
-I../../third_party/skia/include/pdf -I../../third_party/skia/include/gpu
-I../../third_party/skia/include/gpu/gl -I../../third_party/skia/include/pipe
-I../../third_party/skia/include/ports -I../../third_party/skia/include/utils
-I../../skia/ext -I../../third_party/skia/include/utils/mac -isysroot
/Developer/SDKs/MacOSX10.6.sdk -O3 -fvisibility=hidden -Werror -Wnewline-eof
-mmacosx-version-min=10.6 -arch i386 -Wendif-labels -Wno-unused-parameter
-Wno-missing-field-initializers -Wheader-hygiene -Wno-char-subscripts
-Wno-unused-function -Wno-unnamed-type-template-args -Wno-c++11-extensions
-Wno-covered-switch-default -Wno-implicit-conversion-floating-point-to-bool
-fno-rtti -fno-exceptions -fvisibility-inlines-hidden -fno-threadsafe-statics
-fno-strict-aliasing -Xclang -load -Xclang
/Volumes/data/b/build/slave/mac/build/src/tools/clang/scripts/../../../third_party/llvm-build/Release+Asserts/lib/libFindBadConstructs.dylib
-Xclang -add-plugin -Xclang find-bad-constructs -Xclang
-plugin-arg-find-bad-constructs -Xclang skip-virtuals-in-implementations
-fcolor-diagnostics  -c ../../cc/CCPrioritizedTextureTest.cpp -o
obj/cc/cc_unittests.CCPrioritizedTextureTest.o
../../cc/CCPrioritizedTextureTest.cpp:73:25:error: 'updateBackingsPriorities' is
a private member of 'cc::CCPrioritizedTextureManager'
        textureManager->updateBackingsPriorities();
                        ^
../../cc/CCPrioritizedTextureManager.h:111:10: note: declared private here
    void updateBackingsPriorities();

I suspect because CCPrioritizedTextureManager is now in namespace 'cc'.

[ccameron, 2012/09/17 18:30:30]

Ack, you're right!

 
 class CCPrioritizedTextureTest : public testing::Test {
 public:
     CCPrioritizedTextureTest()
         : m_textureSize(256, 256)
         , m_textureFormat(GraphicsContext3D::RGBA)
         , m_compositorInitializer(0)
         , m_context(WebKit::createFakeCCGraphicsContext())
     {
         DebugScopedSetImplThread implThread;
@@ skipping 11 matching lines @@
         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)
     {
-#if !ASSERT_DISABLED
-        texture->textureManager()->assertInvariants();
-#endif
+        textureManagerAssertInvariants(texture->textureManager());
         if (requestLate)
             texture->requestLate();
+        textureManagerAssertInvariants(texture->textureManager());
         DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
         bool success = texture->canAcquireBackingTexture();
         if (success)
             texture->acquireBackingTexture(resourceProvider());
         return success;
     }
 
+    void prioritizeTexturesAndBackings(CCPrioritizedTextureManager* textureManager)
+    {
+        textureManager->prioritizeTextures();
+        textureManagerUpdateBackingsPriorities(textureManager);
+    }
+
+    void textureManagerUpdateBackingsPriorities(CCPrioritizedTextureManager* textureManager)
+    {
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
+        textureManager->updateBackingsPriorities();
+    }
+
     CCResourceProvider* resourceProvider()
     {
        return m_resourceProvider.get();
     }
 
+    void textureManagerAssertInvariants(CCPrioritizedTextureManager* textureManager)
+    {
+#if !ASSERT_DISABLED
+        DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
+        textureManager->assertInvariants();
+#endif
+    }
+
+    bool textureBackingIsAbovePriorityCutoff(CCPrioritizedTexture* texture)
+    {
+        return texture->m_backing->wasAbovePriorityCutoffAtLastPriorityUpdate();
+    }
+
 protected:
     const IntSize m_textureSize;
     const GC3Denum m_textureFormat;
     WebCompositorInitializer m_compositorInitializer;
     OwnPtr<CCGraphicsContext> m_context;
     OwnPtr<CCResourceProvider> m_resourceProvider;
 };
 
+}
+
+namespace {
+
 TEST_F(CCPrioritizedTextureTest, requestTextureExceedingMaxLimit)
 {
     const size_t maxTextures = 8;
     OwnPtr<CCPrioritizedTextureManager> textureManager = createManager(maxTextures);
 
     // Create textures for double our memory limit.
     OwnPtr<CCPrioritizedTexture> textures[maxTextures*2];
 
     for (size_t i = 0; i < maxTextures*2; ++i)
         textures[i] = textureManager->createTexture(m_textureSize, m_textureFormat);
 
     // Set decreasing priorities
     for (size_t i = 0; i < maxTextures*2; ++i)
         textures[i]->setRequestPriority(100 + i);
 
     // Only lower half should be available.
-    textureManager->prioritizeTextures();
+    prioritizeTexturesAndBackings(textureManager.get());
     EXPECT_TRUE(validateTexture(textures[0], false));
     EXPECT_TRUE(validateTexture(textures[7], false));
     EXPECT_FALSE(validateTexture(textures[8], false));
     EXPECT_FALSE(validateTexture(textures[15], false));
 
     // Set increasing priorities
     for (size_t i = 0; i < maxTextures*2; ++i)
         textures[i]->setRequestPriority(100 - i);
 
     // Only upper half should be available.
-    textureManager->prioritizeTextures();
+    prioritizeTexturesAndBackings(textureManager.get());
     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());
 
     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();
+    prioritizeTexturesAndBackings(textureManager.get());
     for (size_t i = 0; i < maxTextures; ++i)
         validateTexture(textures[i], false);
     {
         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();
+    prioritizeTexturesAndBackings(textureManager.get());
     for (size_t i = 0; i < maxTextures; ++i)
         EXPECT_EQ(validateTexture(textures[i], false), i < 5);
     {
         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();
+    prioritizeTexturesAndBackings(textureManager.get());
     for (size_t i = 0; i < maxTextures; ++i)
         EXPECT_EQ(validateTexture(textures[i], false), i < 4);
     {
         DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
         textureManager->reduceMemory(resourceProvider());
     }
 
     EXPECT_EQ(texturesMemorySize(4), textureManager->memoryAboveCutoffBytes());
     EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
 
     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];
 
     for (size_t i = 0; i < numTextures; ++i) {
         textures[i] = textureManager->createTexture(m_textureSize, m_textureFormat);
         moreTextures[i] = textureManager->createTexture(m_textureSize, m_textureFormat);
     }
 
     for (size_t i = 0; i < numTextures; ++i)
         textures[i]->setRequestPriority(200 + i);
-    textureManager->prioritizeTextures();
+    prioritizeTexturesAndBackings(textureManager.get());
 
     // Allocate textures which are currently high priority.
     EXPECT_TRUE(validateTexture(textures[0], false));
     EXPECT_TRUE(validateTexture(textures[1], false));
     EXPECT_TRUE(validateTexture(textures[2], false));
     EXPECT_TRUE(validateTexture(textures[3], false));
 
     EXPECT_TRUE(textures[0]->haveBackingTexture());
     EXPECT_TRUE(textures[1]->haveBackingTexture());
     EXPECT_TRUE(textures[2]->haveBackingTexture());
     EXPECT_TRUE(textures[3]->haveBackingTexture());
 
     for (size_t i = 0; i < numTextures; ++i)
         moreTextures[i]->setRequestPriority(100 + i);
-    textureManager->prioritizeTextures();
+    prioritizeTexturesAndBackings(textureManager.get());
 
     // Textures are now below cutoff.
     EXPECT_FALSE(validateTexture(textures[0], false));
     EXPECT_FALSE(validateTexture(textures[1], false));
     EXPECT_FALSE(validateTexture(textures[2], false));
     EXPECT_FALSE(validateTexture(textures[3], false));
 
     // But they are still valid to use.
     EXPECT_TRUE(textures[0]->haveBackingTexture());
     EXPECT_TRUE(textures[1]->haveBackingTexture());
@@ skipping 26 matching lines @@
         textures[i] = textureManager->createTexture(m_textureSize, m_textureFormat);
 
     // All 16 textures have the same priority except 2 higher priority.
     for (size_t i = 0; i < maxTextures; ++i)
         textures[i]->setRequestPriority(100);
     textures[0]->setRequestPriority(99);
     textures[1]->setRequestPriority(99);
 
     // Set max limit to 8 textures
     textureManager->setMaxMemoryLimitBytes(texturesMemorySize(8));
-    textureManager->prioritizeTextures();
+    prioritizeTexturesAndBackings(textureManager.get());
 
     // The two high priority textures should be available, others should not.
     for (size_t i = 0; i < 2; ++i)
         EXPECT_TRUE(validateTexture(textures[i], false));
     for (size_t i = 2; i < maxTextures; ++i)
         EXPECT_FALSE(validateTexture(textures[i], false));
     EXPECT_EQ(texturesMemorySize(2), textureManager->memoryAboveCutoffBytes());
     EXPECT_LE(textureManager->memoryUseBytes(), textureManager->memoryAboveCutoffBytes());
 
     // Manually reserving textures should only succeed on the higher priority textures,
@@ skipping 11 matching lines @@
 
 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();
+    prioritizeTexturesAndBackings(textureManager.get());
 
     EXPECT_TRUE(validateTexture(texture, false));
     EXPECT_TRUE(texture->canAcquireBackingTexture());
     EXPECT_TRUE(texture->haveBackingTexture());
 
     {
         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();
+    prioritizeTexturesAndBackings(textureManagerOne.get());
 
     EXPECT_TRUE(validateTexture(texture, false));
     EXPECT_TRUE(texture->canAcquireBackingTexture());
     EXPECT_TRUE(texture->haveBackingTexture());
 
     texture->setTextureManager(0);
 
     {
         DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
         textureManagerOne->clearAllMemory(resourceProvider());
     }
     textureManagerOne.clear();
 
     EXPECT_FALSE(texture->canAcquireBackingTexture());
     EXPECT_FALSE(texture->haveBackingTexture());
 
     texture->setTextureManager(textureManagerTwo.get());
 
-    textureManagerTwo->prioritizeTextures();
+    prioritizeTexturesAndBackings(textureManagerTwo.get());
 
     EXPECT_TRUE(validateTexture(texture, false));
     EXPECT_TRUE(texture->canAcquireBackingTexture());
     EXPECT_TRUE(texture->haveBackingTexture());
 
     DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
     textureManagerTwo->clearAllMemory(resourceProvider());
 }
 
 TEST_F(CCPrioritizedTextureTest, renderSurfacesReduceMemoryAvailableOutsideRootSurface)
@@ skipping 10 matching lines @@
     OwnPtr<CCPrioritizedTexture> textures[maxTextures];
 
     for (size_t i = 0; i < maxTextures; ++i)
         textures[i] = textureManager->createTexture(m_textureSize, m_textureFormat);
 
     // Set decreasing non-visible priorities outside root surface.
     for (size_t i = 0; i < maxTextures; ++i)
         textures[i]->setRequestPriority(100 + i);
 
     // Only lower half should be available.
-    textureManager->prioritizeTextures();
+    prioritizeTexturesAndBackings(textureManager.get());
     EXPECT_TRUE(validateTexture(textures[0], false));
     EXPECT_TRUE(validateTexture(textures[3], false));
     EXPECT_FALSE(validateTexture(textures[4], false));
     EXPECT_FALSE(validateTexture(textures[7], false));
 
     // Set increasing non-visible priorities outside root surface.
     for (size_t i = 0; i < maxTextures; ++i)
         textures[i]->setRequestPriority(100 - i);
 
     // Only upper half should be available.
-    textureManager->prioritizeTextures();
+    prioritizeTexturesAndBackings(textureManager.get());
     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());
 
     DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
@@ skipping 14 matching lines @@
     OwnPtr<CCPrioritizedTexture> textures[maxTextures];
 
     for (size_t i = 0; i < maxTextures; ++i)
         textures[i] = textureManager->createTexture(m_textureSize, m_textureFormat);
 
     // Set equal priorities.
     for (size_t i = 0; i < maxTextures; ++i)
         textures[i]->setRequestPriority(100);
 
     // The first four to be requested late will be available.
-    textureManager->prioritizeTextures();
+    prioritizeTexturesAndBackings(textureManager.get());
     for (unsigned i = 0; i < maxTextures; ++i)
         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());
@@ skipping 17 matching lines @@
 
     for (size_t i = 0; i < maxTextures; ++i)
         textures[i] = textureManager->createTexture(m_textureSize, m_textureFormat);
 
     // Set 6 visible textures in the root surface, and 2 in a child surface.
     for (size_t i = 0; i < 6; ++i)
         textures[i]->setRequestPriority(CCPriorityCalculator::visiblePriority(true));
     for (size_t i = 6; i < 8; ++i)
         textures[i]->setRequestPriority(CCPriorityCalculator::visiblePriority(false));
 
-    textureManager->prioritizeTextures();
+    prioritizeTexturesAndBackings(textureManager.get());
 
     // Unable to requestLate textures in the child surface.
     EXPECT_FALSE(validateTexture(textures[6], true));
     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());
 
     DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
     textureManager->clearAllMemory(resourceProvider());
 }
 
+TEST_F(CCPrioritizedTextureTest, requestLateBackingsSorting)
+{
+    const size_t maxTextures = 8;
+    OwnPtr<CCPrioritizedTextureManager> textureManager = createManager(maxTextures);
+    textureManager->setMaxMemoryLimitBytes(texturesMemorySize(maxTextures));
+
+    // Create textures to fill our memory limit.
+    OwnPtr<CCPrioritizedTexture> textures[maxTextures];
+    for (size_t i = 0; i < maxTextures; ++i)
+        textures[i] = textureManager->createTexture(m_textureSize, m_textureFormat);
+
+    // Set equal priorities, and allocate backings for all textures.
+    for (size_t i = 0; i < maxTextures; ++i)
+        textures[i]->setRequestPriority(100);
+    prioritizeTexturesAndBackings(textureManager.get());
+    for (unsigned i = 0; i < maxTextures; ++i)
+        EXPECT_TRUE(validateTexture(textures[i], false));
+
+    // Drop the memory limit and prioritize (none will be above the threshold,
+    // but they still have backings because reduceMemory hasn't been called).
+    textureManager->setMaxMemoryLimitBytes(texturesMemorySize(maxTextures / 2));
+    prioritizeTexturesAndBackings(textureManager.get());
+
+    // Push half of them back over the limit.
+    for (size_t i = 0; i < maxTextures; i += 2)
+        EXPECT_TRUE(textures[i]->requestLate());
+
+    // Push the priorities to the backings array and sort the backings array
+    textureManagerUpdateBackingsPriorities(textureManager.get());
+
+    // Assert that the backings list be sorted with the below-limit backings
+    // before the above-limit backings.
+    textureManagerAssertInvariants(textureManager.get());
+
+    // Make sure that we have backings for all of the textures.
+    for (size_t i = 0; i < maxTextures; ++i)
+        EXPECT_TRUE(textures[i]->haveBackingTexture());
+
+    // Make sure that only the requestLate textures are above the priority cutoff
+    for (size_t i = 0; i < maxTextures; i += 2)
+        EXPECT_TRUE(textureBackingIsAbovePriorityCutoff(textures[i].get()));
+    for (size_t i = 1; i < maxTextures; i += 2)
+        EXPECT_FALSE(textureBackingIsAbovePriorityCutoff(textures[i].get()));
+
+    DebugScopedSetImplThreadAndMainThreadBlocked implThreadAndMainThreadBlocked;
+    textureManager->clearAllMemory(resourceProvider());
+}
+
+
 } // namespace