cc: Defer texture allocation (to allow async allocations).

cc/layer_tree_host_impl_unittest.cc

 // Copyright 2011 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/layer_tree_host_impl.h"
 
 #include <cmath>
 
 #include "base/bind.h"
 #include "base/command_line.h"
@@ skipping 1029 matching lines @@
 
 private:
     MissingTextureAnimatingLayer(LayerTreeImpl* treeImpl, int id, bool tileMissing, bool skipsDraw, bool animating, ResourceProvider* resourceProvider)
         : DidDrawCheckLayer(treeImpl, id)
     {
         scoped_ptr<LayerTilingData> tilingData = LayerTilingData::create(gfx::Size(10, 10), LayerTilingData::NoBorderTexels);
         tilingData->setBounds(bounds());
         setTilingData(*tilingData.get());
         setSkipsDraw(skipsDraw);
         if (!tileMissing) {
-            ResourceProvider::ResourceId resource = resourceProvider->createResource(gfx::Size(), GL_RGBA, ResourceProvider::TextureUsageAny);
+            ResourceProvider::ResourceId resource = resourceProvider->createAllocatedResource(gfx::Size(), GL_RGBA, ResourceProvider::TextureUsageAny);
             pushTileProperties(0, 0, resource, gfx::Rect(), false);
         }
         if (animating)
             addAnimatedTransformToLayer(*this, 10, 3, 0);
     }
 };
 
 TEST_P(LayerTreeHostImplTest, prepareToDrawFailsWhenAnimationUsesCheckerboard)
 {
     // When the texture is not missing, we draw as usual.
@@ skipping 603 matching lines @@
     void setOpaqueContentRect(const gfx::Rect& rect) { m_opaqueContentRect = rect; }
 
 private:
     BlendStateCheckLayer(LayerTreeImpl* treeImpl, int id, ResourceProvider* resourceProvider)
         : LayerImpl(treeImpl, id)
         , m_blend(false)
         , m_hasRenderSurface(false)
         , m_quadsAppended(false)
         , m_quadRect(5, 5, 5, 5)
         , m_quadVisibleRect(5, 5, 5, 5)
-        , m_resourceId(resourceProvider->createResource(gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny))
+        , m_resourceId(resourceProvider->createAllocatedResource(gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny))
     {
         setAnchorPoint(gfx::PointF(0, 0));
         setBounds(gfx::Size(10, 10));
         setContentBounds(gfx::Size(10, 10));
         setDrawsContent(true);
     }
 
     bool m_blend;
     bool m_hasRenderSurface;
     bool m_quadsAppended;
@@ skipping 1055 matching lines @@
     }
 
     void createResources(ResourceProvider* provider)
     {
         DCHECK(provider);
         gfx::Size size(10, 10);
         GLenum format = GL_RGBA;
         ResourceProvider::TextureUsageHint hint = ResourceProvider::TextureUsageAny;
         setScrollbarGeometry(ScrollbarGeometryFixedThumb::create(FakeWebScrollbarThemeGeometryNonEmpty::create()));
 
-        setBackTrackResourceId(provider->createResource(size, format, hint));
-        setForeTrackResourceId(provider->createResource(size, format, hint));
-        setThumbResourceId(provider->createResource(size, format, hint));
+        setBackTrackResourceId(provider->createAllocatedResource(size, format, hint));
+        setForeTrackResourceId(provider->createAllocatedResource(size, format, hint));
+        setThumbResourceId(provider->createAllocatedResource(size, format, hint));
     }
 
 protected:
     FakeScrollbarLayerImpl(LayerTreeImpl* treeImpl, int id)
         : ScrollbarLayerImpl(treeImpl, id)
     {
     }
 };
 
 static inline scoped_ptr<RenderPass> createRenderPassWithResource(ResourceProvider* provider)
 {
-    ResourceProvider::ResourceId resourceId = provider->createResource(gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny);
+    ResourceProvider::ResourceId resourceId = provider->createAllocatedResource(gfx::Size(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny);
 
     scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
     pass->SetNew(RenderPass::Id(1, 1), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), gfx::Transform());
     scoped_ptr<SharedQuadState> sharedState = SharedQuadState::Create();
     sharedState->SetAll(gfx::Transform(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), false, 1);
     const float vertex_opacity[] = {1.0f, 1.0f, 1.0f, 1.0f};
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::Create();
     quad->SetNew(sharedState.get(), gfx::Rect(0, 0, 1, 1), gfx::Rect(0, 0, 1, 1), resourceId, false, gfx::RectF(0, 0, 1, 1), vertex_opacity, false);
 
     pass->AppendSharedQuadState(sharedState.Pass());
@@ skipping 2049 matching lines @@
     gfx::Rect noDamage = gfx::Rect(m_hostImpl->deviceViewportSize());
     drawFrameAndTestDamage(noDamage);
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // namespace
 }  // namespace cc