Move filters to RenderPassDrawQuad

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 3758 matching lines @@
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive two render passes, each with one quad
         ASSERT_EQ(2U, frame.renderPasses.size());
         EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
         EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
+        RenderPass* targetPass = frame.renderPassesById[quad->render_pass_id];
+        ASSERT_TRUE(targetPass);
         EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // Draw without any change
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive one render pass, as the other one should be culled
         ASSERT_EQ(1U, frame.renderPasses.size());
 
         EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
-        EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
+        EXPECT_TRUE(frame.renderPassesById.find(quad->render_pass_id) == frame.renderPassesById.end());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // Change opacity and draw
     surfaceLayerPtr->setOpacity(0.6f);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive one render pass, as the other one should be culled
         ASSERT_EQ(1U, frame.renderPasses.size());
 
         EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
-        EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
+        EXPECT_TRUE(frame.renderPassesById.find(quad->render_pass_id) == frame.renderPassesById.end());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // Change less benign property and draw - should have contents changed flag
     surfaceLayerPtr->setStackingOrderChanged(true);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive two render passes, each with one quad
         ASSERT_EQ(2U, frame.renderPasses.size());
 
         EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
         EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quad_list[0]->material);
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
+        RenderPass* targetPass = frame.renderPassesById[quad->render_pass_id];
+        ASSERT_TRUE(targetPass);
         EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // Change opacity again, and evict the cached surface texture.
     surfaceLayerPtr->setOpacity(0.5f);
     static_cast<GLRendererWithReleaseTextures*>(myHostImpl->renderer())->releaseRenderPassTextures();
 
     // Change opacity and draw
     surfaceLayerPtr->setOpacity(0.6f);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive two render passes
         ASSERT_EQ(2U, frame.renderPasses.size());
 
         // Even though not enough properties changed, the entire thing must be
         // redrawn as we don't have cached textures
         EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
         EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
+        RenderPass* targetPass = frame.renderPassesById[quad->render_pass_id];
+        ASSERT_TRUE(targetPass);
         EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
 
         // Was our surface evicted?
         EXPECT_FALSE(myHostImpl->renderer()->haveCachedResourcesForRenderPassId(targetPass->id));
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // Draw without any change, to make sure the state is clear
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive one render pass, as the other one should be culled
         ASSERT_EQ(1U, frame.renderPasses.size());
 
         EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
-        EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
+        EXPECT_TRUE(frame.renderPassesById.find(quad->render_pass_id) == frame.renderPassesById.end());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // Change location of the intermediate layer
     gfx::Transform transform = intermediateLayerPtr->transform();
     transform.matrix().setDouble(0, 3, 1.0001);
     intermediateLayerPtr->setTransform(transform);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive one render pass, as the other one should be culled.
         ASSERT_EQ(1U, frame.renderPasses.size());
         EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
-        EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
+        EXPECT_TRUE(frame.renderPassesById.find(quad->render_pass_id) == frame.renderPassesById.end());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, surfaceTextureCachingNoPartialSwap)
 {
     LayerTreeSettings settings;
     settings.minimumOcclusionTrackingSize = gfx::Size();
@@ skipping 10 matching lines @@
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive two render passes, each with one quad
         ASSERT_EQ(2U, frame.renderPasses.size());
         EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
         EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
+        RenderPass* targetPass = frame.renderPassesById[quad->render_pass_id];
         EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
 
         EXPECT_FALSE(frame.renderPasses[0]->damage_rect.IsEmpty());
         EXPECT_FALSE(frame.renderPasses[1]->damage_rect.IsEmpty());
 
         EXPECT_FALSE(frame.renderPasses[0]->has_occlusion_from_outside_target_surface);
         EXPECT_FALSE(frame.renderPasses[1]->has_occlusion_from_outside_target_surface);
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
@@ skipping 21 matching lines @@
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive one render pass, as the other one should be culled
         ASSERT_EQ(1U, frame.renderPasses.size());
 
         EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
-        EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
+        EXPECT_TRUE(frame.renderPassesById.find(quad->render_pass_id) == frame.renderPassesById.end());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // Change less benign property and draw - should have contents changed flag
     surfaceLayerPtr->setStackingOrderChanged(true);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive two render passes, each with one quad
         ASSERT_EQ(2U, frame.renderPasses.size());
 
         EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
         EXPECT_EQ(DrawQuad::SOLID_COLOR, frame.renderPasses[0]->quad_list[0]->material);
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
+        RenderPass* targetPass = frame.renderPassesById[quad->render_pass_id];
+        ASSERT_TRUE(targetPass);
         EXPECT_FALSE(targetPass->damage_rect.IsEmpty());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // Change opacity again, and evict the cached surface texture.
     surfaceLayerPtr->setOpacity(0.5f);
     static_cast<GLRendererWithReleaseTextures*>(myHostImpl->renderer())->releaseRenderPassTextures();
 
     // Change opacity and draw
     surfaceLayerPtr->setOpacity(0.6f);
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive two render passes
         ASSERT_EQ(2U, frame.renderPasses.size());
 
         // Even though not enough properties changed, the entire thing must be
         // redrawn as we don't have cached textures
         EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
         EXPECT_EQ(1U, frame.renderPasses[1]->quad_list.size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[1]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[1]->quad_list[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
+        RenderPass* targetPass = frame.renderPassesById[quad->render_pass_id];
+        ASSERT_TRUE(targetPass);
         EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
 
         // Was our surface evicted?
         EXPECT_FALSE(myHostImpl->renderer()->haveCachedResourcesForRenderPassId(targetPass->id));
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 
     // Draw without any change, to make sure the state is clear
@@ skipping 18 matching lines @@
     {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(myHostImpl->prepareToDraw(frame));
 
         // Must receive one render pass, as the other one should be culled.
         ASSERT_EQ(1U, frame.renderPasses.size());
         EXPECT_EQ(1U, frame.renderPasses[0]->quad_list.size());
 
         EXPECT_EQ(DrawQuad::RENDER_PASS, frame.renderPasses[0]->quad_list[0]->material);
         const RenderPassDrawQuad* quad = RenderPassDrawQuad::MaterialCast(frame.renderPasses[0]->quad_list[0]);
-        RenderPass* targetPass = frame.renderPassesById.get(quad->render_pass_id);
-        EXPECT_TRUE(targetPass->damage_rect.IsEmpty());
+        EXPECT_TRUE(frame.renderPassesById.find(quad->render_pass_id) == frame.renderPassesById.end());
 
         myHostImpl->drawLayers(frame);
         myHostImpl->didDrawAllLayers(frame);
     }
 }
 
 TEST_P(LayerTreeHostImplTest, releaseContentsTextureShouldTriggerCommit)
 {
     setReduceMemoryResult(false);
 
@@ skipping 137 matching lines @@
                         renderer->setHaveCachedResourcesForRenderPassId(newRenderPassId);
 
                     scoped_ptr<TestRenderPass> pass = TestRenderPass::Create();
                     pass->SetNew(newRenderPassId, gfx::Rect(), gfx::Rect(), gfx::Transform());
                     testData.renderPassCache.add(newRenderPassId, pass.Pass());
                 }
 
                 gfx::Rect quadRect = gfx::Rect(0, 0, 1, 1);
                 gfx::Rect contentsChangedRect = contentsChanged ? quadRect : gfx::Rect();
                 scoped_ptr<RenderPassDrawQuad> quad = RenderPassDrawQuad::Create();
-                quad->SetNew(testData.sharedQuadState.get(), quadRect, newRenderPassId, isReplica, 1, contentsChangedRect, gfx::RectF(0, 0, 1, 1));
+                quad->SetNew(testData.sharedQuadState.get(), quadRect, newRenderPassId, isReplica, 1, contentsChangedRect, gfx::RectF(0, 0, 1, 1), WebKit::WebFilterOperations(), skia::RefPtr<SkImageFilter>(), WebKit::WebFilterOperations());
                 renderPass->AppendQuad(quad.PassAs<DrawQuad>());
             }
         }
-        testData.renderPasses.insert(testData.renderPasses.begin(), renderPass.get());
-        testData.renderPassesById.add(renderPassId, renderPass.PassAs<RenderPass>());
+        testData.renderPassesById[renderPassId] = renderPass.get();
+        testData.renderPasses.insert(0, renderPass.PassAs<RenderPass>());
         if (*currentChar)
             currentChar++;
     }
 }
 
 void dumpRenderPassTestData(const RenderPassRemovalTestData& testData, char* buffer)
 {
     char* pos = buffer;
     for (RenderPassList::const_reverse_iterator it = testData.renderPasses.rbegin(); it != testData.renderPasses.rend(); ++it) {
         const RenderPass* currentPass = *it;
@@ skipping 571 matching lines @@
         WebKit::WebGraphicsContext3D::Attributes attrs;
         return FakeOutputSurface::CreateDelegating3d(FakeWebGraphicsContext3D::Create(attrs).PassAs<WebKit::WebGraphicsContext3D>()).PassAs<OutputSurface>();
     }
 
     void drawFrameAndTestDamage(const gfx::RectF& expectedDamage) {
         LayerTreeHostImpl::FrameData frame;
         EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
         ASSERT_EQ(1u, frame.renderPasses.size());
 
         // Verify the damage rect for the root render pass.
-        const RenderPass* rootRenderPass = frame.renderPasses.back();
+        const RenderPass* rootRenderPass = frame.renderPasses.last();
         EXPECT_RECT_EQ(expectedDamage, rootRenderPass->damage_rect);
 
         // Verify the root layer's quad is generated and not being culled.
         ASSERT_EQ(1u, rootRenderPass->quad_list.size());
         gfx::Rect expectedVisibleRect(m_hostImpl->rootLayer()->contentBounds());
         EXPECT_RECT_EQ(expectedVisibleRect, rootRenderPass->quad_list[0]->visible_rect);
 
         m_hostImpl->drawLayers(frame);
         m_hostImpl->didDrawAllLayers(frame);
     }
 };
 
 TEST_P(LayerTreeHostImplTestWithDelegatingRenderer, FrameIncludesDamageRect)
 {
     // Draw a frame. In the first frame, the entire viewport should be damaged.
     gfx::Rect fullFrameDamage = gfx::Rect(m_hostImpl->deviceViewportSize());
     drawFrameAndTestDamage(fullFrameDamage);
 
     // The second frame should have no damage, but the quads should still be generated.
     gfx::Rect noDamage = gfx::Rect(m_hostImpl->deviceViewportSize());
     drawFrameAndTestDamage(noDamage);
 }
 
 INSTANTIATE_TEST_CASE_P(LayerTreeHostImplTests,
                         LayerTreeHostImplTest,
                         ::testing::Values(false, true));
 
 }  // namespace
 }  // namespace cc