Fix usage of TestRenderPass

It is undefined behavior to cast a RenderPass* into a TestRenderPass* if the
object pointed to is not a TestRenderPass, so remove this pattern.

BUG=None


Review URL: https://chromiumcodereview.appspot.com/11235053

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@163624 0039d316-1c4b-4281-b951-d872f2087c98

cc/delegated_renderer_layer_impl_unittest.cc

@@ -67,10 +67,10 @@ class DelegatedRendererLayerImplTest : public testing::Test, public LayerTreeHos
 
 static TestRenderPass* addRenderPass(ScopedPtrVector<RenderPass>& passList, RenderPass::Id id, IntRect outputRect, WebTransformationMatrix rootTransform)
 {
-    scoped_ptr<RenderPass> pass(RenderPass::create(id, outputRect, rootTransform));
-    TestRenderPass* testPass = static_cast<TestRenderPass*>(pass.get());
-    passList.append(pass.Pass());
-    return testPass;
+    scoped_ptr<TestRenderPass> pass(TestRenderPass::create(id, outputRect, rootTransform));
+    TestRenderPass* saved = pass.get();
+    passList.append(pass.PassAs<RenderPass>());
+    return saved;
 }
 
 static SolidColorDrawQuad* addQuad(TestRenderPass* pass, IntRect rect, SkColor color)

cc/layer_tree_host_impl_unittest.cc

@@ -2639,14 +2639,14 @@ static inline scoped_ptr<RenderPass> createRenderPassWithResource(ResourceProvid
 {
     ResourceProvider::ResourceId resourceId = provider->createResource(0, IntSize(1, 1), GL_RGBA, ResourceProvider::TextureUsageAny);
 
-    scoped_ptr<RenderPass> pass = RenderPass::create(RenderPass::Id(1, 1), IntRect(0, 0, 1, 1), WebTransformationMatrix());
+    scoped_ptr<TestRenderPass> pass = TestRenderPass::create(RenderPass::Id(1, 1), IntRect(0, 0, 1, 1), WebTransformationMatrix());
     scoped_ptr<SharedQuadState> sharedState = SharedQuadState::create(WebTransformationMatrix(), IntRect(0, 0, 1, 1), IntRect(0, 0, 1, 1), 1, false);
     scoped_ptr<TextureDrawQuad> quad = TextureDrawQuad::create(sharedState.get(), IntRect(0, 0, 1, 1), resourceId, false, FloatRect(0, 0, 1, 1), false);
 
-    static_cast<TestRenderPass*>(pass.get())->appendSharedQuadState(sharedState.Pass());
-    static_cast<TestRenderPass*>(pass.get())->appendQuad(quad.PassAs<DrawQuad>());
+    pass->appendSharedQuadState(sharedState.Pass());
+    pass->appendQuad(quad.PassAs<DrawQuad>());
 
-    return pass.Pass();
+    return pass.PassAs<RenderPass>();
 }
 
 TEST_P(LayerTreeHostImplTest, dontUseOldResourcesAfterLostContext)
@@ -4051,7 +4051,7 @@ TEST_P(LayerTreeHostImplTest, releaseContentsTextureShouldTriggerCommit)
 }
 
 struct RenderPassRemovalTestData : public LayerTreeHostImpl::FrameData {
-    ScopedPtrHashMap<RenderPass::Id, RenderPass> renderPassCache;
+    ScopedPtrHashMap<RenderPass::Id, TestRenderPass> renderPassCache;
     scoped_ptr<SharedQuadState> sharedQuadState;
 };
 
@@ -4100,7 +4100,7 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
 
     // Pre-create root pass
     RenderPass::Id rootRenderPassId = RenderPass::Id(testScript[0], testScript[1]);
-    testData.renderPassCache.add(rootRenderPassId, RenderPass::create(rootRenderPassId, IntRect(), WebTransformationMatrix()));
+    testData.renderPassCache.add(rootRenderPassId, TestRenderPass::create(rootRenderPassId, IntRect(), WebTransformationMatrix()));
     while (*currentChar) {
         int layerId = *currentChar;
         currentChar++;
@@ -4114,15 +4114,15 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
         if (!testData.renderPassCache.contains(renderPassId))
             isReplica = true;
 
-        scoped_ptr<RenderPass> renderPass = testData.renderPassCache.take(renderPassId);
+        scoped_ptr<TestRenderPass> renderPass = testData.renderPassCache.take(renderPassId);
 
         // Cycle through quad data and create all quads
         while (*currentChar && *currentChar != '\n') {
             if (*currentChar == 's') {
                 // Solid color draw quad
                 scoped_ptr<SolidColorDrawQuad> quad = SolidColorDrawQuad::create(testData.sharedQuadState.get(), IntRect(0, 0, 10, 10), SK_ColorWHITE);
 
-                static_cast<TestRenderPass*>(renderPass.get())->appendQuad(quad.PassAs<DrawQuad>());
+                renderPass->appendQuad(quad.PassAs<DrawQuad>());
                 currentChar++;
             } else if ((*currentChar >= 'A') && (*currentChar <= 'Z')) {
                 // RenderPass draw quad
@@ -4163,11 +4163,11 @@ static void configureRenderPassTestData(const char* testScript, RenderPassRemova
                 IntRect quadRect = IntRect(0, 0, 1, 1);
                 IntRect contentsChangedRect = contentsChanged ? quadRect : IntRect();
                 scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::create(testData.sharedQuadState.get(), quadRect, newRenderPassId, isReplica, 1, contentsChangedRect, 1, 1, 0, 0);
-                static_cast<TestRenderPass*>(renderPass.get())->appendQuad(quad.PassAs<DrawQuad>());
+                renderPass->appendQuad(quad.PassAs<DrawQuad>());
             }
         }
         testData.renderPasses.insert(testData.renderPasses.begin(), renderPass.get());
-        testData.renderPassesById.add(renderPassId, renderPass.Pass());
+        testData.renderPassesById.add(renderPassId, renderPass.PassAs<RenderPass>());
         if (*currentChar)
             currentChar++;
     }

cc/render_pass_unittest.cc

@@ -8,6 +8,7 @@
 
 #include "CCCheckerboardDrawQuad.h"
 #include "cc/test/geometry_test_utils.h"
+#include "cc/test/render_pass_test_common.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/skia/include/effects/SkBlurImageFilter.h"
 #include <public/WebFilterOperations.h>
@@ -16,17 +17,12 @@
 using WebKit::WebFilterOperation;
 using WebKit::WebFilterOperations;
 using WebKit::WebTransformationMatrix;
+using WebKitTests::TestRenderPass;
 
 using namespace cc;
 
 namespace {
 
-class TestRenderPass : public RenderPass {
-public:
-    QuadList& quadList() { return m_quadList; }
-    SharedQuadStateList& sharedQuadStateList() { return m_sharedQuadStateList; }
-};
-
 struct RenderPassSize {
     // If you add a new field to this class, make sure to add it to the copy() tests.
     RenderPass::Id m_id;
@@ -48,7 +44,7 @@ TEST(RenderPassTest, copyShouldBeIdenticalExceptIdAndQuads)
     gfx::Rect outputRect(45, 22, 120, 13);
     WebTransformationMatrix transformToRoot(1, 0.5, 0.5, -0.5, -1, 0);
 
-    scoped_ptr<RenderPass> pass = RenderPass::create(id, outputRect, transformToRoot);
+    scoped_ptr<TestRenderPass> pass = TestRenderPass::create(id, outputRect, transformToRoot);
 
     gfx::Rect damageRect(56, 123, 19, 43);
     bool hasTransparentBackground = true;
@@ -68,9 +64,8 @@ TEST(RenderPassTest, copyShouldBeIdenticalExceptIdAndQuads)
     pass->setFilter(filter);
 
     // Stick a quad in the pass, this should not get copied.
-    TestRenderPass* testPass = static_cast<TestRenderPass*>(pass.get());
-    testPass->sharedQuadStateList().append(SharedQuadState::create(WebTransformationMatrix(), gfx::Rect(), gfx::Rect(), 1, false));
-    testPass->quadList().append(CheckerboardDrawQuad::create(testPass->sharedQuadStateList().last(), gfx::Rect(), SkColor()).PassAs<DrawQuad>());
+    pass->sharedQuadStateList().append(SharedQuadState::create(WebTransformationMatrix(), gfx::Rect(), gfx::Rect(), 1, false));
+    pass->quadList().append(CheckerboardDrawQuad::create(pass->sharedQuadStateList().last(), gfx::Rect(), SkColor()).PassAs<DrawQuad>());
 
     RenderPass::Id newId(63, 4);
 

cc/software_renderer_unittest.cc

@@ -74,17 +74,16 @@ TEST_F(SoftwareRendererTest, solidColorQuad)
 
     scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::create(WebTransformationMatrix(), outerRect, outerRect, 1.0, true);
     RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
-    scoped_ptr<RenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, outerRect, WebTransformationMatrix());
-    TestRenderPass* testRenderPass = static_cast<TestRenderPass*>(rootRenderPass.get());
+    scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, outerRect, WebTransformationMatrix());
     scoped_ptr<DrawQuad> outerQuad = SolidColorDrawQuad::create(sharedQuadState.get(), outerRect, SK_ColorYELLOW).PassAs<DrawQuad>();
     scoped_ptr<DrawQuad> innerQuad = SolidColorDrawQuad::create(sharedQuadState.get(), innerRect, SK_ColorCYAN).PassAs<DrawQuad>();
-    testRenderPass->appendQuad(innerQuad.Pass());
-    testRenderPass->appendQuad(outerQuad.Pass());
+    rootRenderPass->appendQuad(innerQuad.Pass());
+    rootRenderPass->appendQuad(outerQuad.Pass());
 
     RenderPassList list;
     RenderPassIdHashMap hashmap;
     list.push_back(rootRenderPass.get());
-    hashmap.add(rootRenderPassId, rootRenderPass.Pass());
+    hashmap.add(rootRenderPassId, rootRenderPass.PassAs<RenderPass>());
     renderer()->drawFrame(list, hashmap);
 
     scoped_array<SkColor> pixels(new SkColor[deviceViewportSize().width() * deviceViewportSize().height()]);
@@ -132,17 +131,16 @@ TEST_F(SoftwareRendererTest, tileQuad)
 
     scoped_ptr<SharedQuadState> sharedQuadState = SharedQuadState::create(WebTransformationMatrix(), outerRect, outerRect, 1.0, true);
     RenderPass::Id rootRenderPassId = RenderPass::Id(1, 1);
-    scoped_ptr<RenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, IntRect(IntPoint(), deviceViewportSize()), WebTransformationMatrix());
-    TestRenderPass* testRenderPass = static_cast<TestRenderPass*>(rootRenderPass.get());
+    scoped_ptr<TestRenderPass> rootRenderPass = TestRenderPass::create(rootRenderPassId, IntRect(IntPoint(), deviceViewportSize()), WebTransformationMatrix());
     scoped_ptr<DrawQuad> outerQuad = TileDrawQuad::create(sharedQuadState.get(), outerRect, outerRect, resourceYellow, IntPoint(), outerSize, 0, false, false, false, false, false).PassAs<DrawQuad>();
     scoped_ptr<DrawQuad> innerQuad = TileDrawQuad::create(sharedQuadState.get(), innerRect, innerRect, resourceCyan, IntPoint(), innerSize, 0, false, false, false, false, false).PassAs<DrawQuad>();
-    testRenderPass->appendQuad(innerQuad.Pass());
-    testRenderPass->appendQuad(outerQuad.Pass());
+    rootRenderPass->appendQuad(innerQuad.Pass());
+    rootRenderPass->appendQuad(outerQuad.Pass());
 
     RenderPassList list;
     RenderPassIdHashMap hashmap;
     list.push_back(rootRenderPass.get());
-    hashmap.add(rootRenderPassId, rootRenderPass.Pass());
+    hashmap.add(rootRenderPassId, rootRenderPass.PassAs<RenderPass>());
     renderer()->drawFrame(list, hashmap);
 
     scoped_array<SkColor> pixels(new SkColor[deviceViewportSize().width() * deviceViewportSize().height()]);

cc/test/render_pass_test_common.h

@@ -11,11 +11,19 @@ namespace WebKitTests {
 
 class TestRenderPass : public cc::RenderPass {
 public:
+    static scoped_ptr<TestRenderPass> create(Id id, gfx::Rect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget) {
+        return make_scoped_ptr(new TestRenderPass(id, outputRect, transformToRootTarget));
+    }
+
     cc::QuadList& quadList() { return m_quadList; }
     cc::SharedQuadStateList& sharedQuadStateList() { return m_sharedQuadStateList; }
 
     void appendQuad(scoped_ptr<cc::DrawQuad> quad) { m_quadList.append(quad.Pass()); }
     void appendSharedQuadState(scoped_ptr<cc::SharedQuadState> state) { m_sharedQuadStateList.append(state.Pass()); }
+
+protected:
+    TestRenderPass(Id id, gfx::Rect outputRect, const WebKit::WebTransformationMatrix& transformToRootTarget)
+        : RenderPass(id, outputRect, transformToRootTarget) { }
 };
 
 }  // namespace WebKitTests