Renamed LayerChromium::opaque to LayerChromium::contentsOpaque. Having both opaque and opacity on t…

cc/CCLayerTreeHostImplTest.cpp

 // 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 "config.h"
 
 #include "CCLayerTreeHostImpl.h"
 
 #include "CCAnimationTestCommon.h"
 #include "CCDelegatedRendererLayerImpl.h"
@@ skipping 767 matching lines @@
     DidDrawCheckLayer* root = static_cast<DidDrawCheckLayer*>(m_hostImpl->rootLayer());
 
     root->addChild(DidDrawCheckLayer::create(2));
     DidDrawCheckLayer* occludedLayer = static_cast<DidDrawCheckLayer*>(root->children()[0]);
 
     root->addChild(DidDrawCheckLayer::create(3));
     DidDrawCheckLayer* topLayer = static_cast<DidDrawCheckLayer*>(root->children()[1]);
     // This layer covers the occludedLayer above. Make this layer large so it can occlude.
     topLayer->setBounds(bigSize);
     topLayer->setContentBounds(bigSize);
-    topLayer->setOpaque(true);
+    topLayer->setContentsOpaque(true);
 
     CCLayerTreeHostImpl::FrameData frame;
 
     EXPECT_FALSE(occludedLayer->willDrawCalled());
     EXPECT_FALSE(occludedLayer->didDrawCalled());
     EXPECT_FALSE(topLayer->willDrawCalled());
     EXPECT_FALSE(topLayer->didDrawCalled());
 
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
@@ skipping 597 matching lines @@
 
 class BlendStateCheckLayer : public CCLayerImpl {
 public:
     static PassOwnPtr<BlendStateCheckLayer> create(int id, CCResourceProvider* resourceProvider) { return adoptPtr(new BlendStateCheckLayer(id, resourceProvider)); }
 
     virtual void appendQuads(CCQuadSink& quadSink, CCAppendQuadsData& appendQuadsData) OVERRIDE
     {
         m_quadsAppended = true;
 
         IntRect opaqueRect;
-        if (opaque() || m_opaqueContents)
+        if (contentsOpaque())
             opaqueRect = m_quadRect;
         else
             opaqueRect = m_opaqueContentRect;
 
         CCSharedQuadState* sharedQuadState = quadSink.useSharedQuadState(createSharedQuadState());
         scoped_ptr<CCTileDrawQuad> testBlendingDrawQuad = CCTileDrawQuad::create(sharedQuadState, m_quadRect, opaqueRect, m_resourceId, IntPoint(), IntSize(1, 1), 0, false, false, false, false, false);
         testBlendingDrawQuad->setQuadVisibleRect(m_quadVisibleRect);
         EXPECT_EQ(m_blend, testBlendingDrawQuad->needsBlending());
         EXPECT_EQ(m_hasRenderSurface, !!renderSurface());
         quadSink.append(testBlendingDrawQuad.PassAs<CCDrawQuad>(), appendQuadsData);
     }
 
     void setExpectation(bool blend, bool hasRenderSurface)
     {
         m_blend = blend;
         m_hasRenderSurface = hasRenderSurface;
         m_quadsAppended = false;
     }
 
     bool quadsAppended() const { return m_quadsAppended; }
 
     void setQuadRect(const IntRect& rect) { m_quadRect = rect; }
     void setQuadVisibleRect(const IntRect& rect) { m_quadVisibleRect = rect; }
-    void setOpaqueContents(bool opaque) { m_opaqueContents = opaque; }
     void setOpaqueContentRect(const IntRect& rect) { m_opaqueContentRect = rect; }
 
 private:
     explicit BlendStateCheckLayer(int id, CCResourceProvider* resourceProvider)
         : CCLayerImpl(id)
         , m_blend(false)
         , m_hasRenderSurface(false)
         , m_quadsAppended(false)
-        , m_opaqueContents(false)
         , m_quadRect(5, 5, 5, 5)
         , m_quadVisibleRect(5, 5, 5, 5)
         , m_resourceId(resourceProvider->createResource(CCRenderer::ContentPool, IntSize(1, 1), GraphicsContext3D::RGBA, CCResourceProvider::TextureUsageAny))
     {
         setAnchorPoint(FloatPoint(0, 0));
         setBounds(IntSize(10, 10));
         setContentBounds(IntSize(10, 10));
         setDrawsContent(true);
     }
 
     bool m_blend;
     bool m_hasRenderSurface;
     bool m_quadsAppended;
-    bool m_opaqueContents;
     IntRect m_quadRect;
     IntRect m_opaqueContentRect;
     IntRect m_quadVisibleRect;
     CCResourceProvider::ResourceId m_resourceId;
 };
 
 TEST_F(CCLayerTreeHostImplTest, blendingOffWhenDrawingOpaqueLayers)
 {
     {
         OwnPtr<CCLayerImpl> root = CCLayerImpl::create(1);
         root->setAnchorPoint(FloatPoint(0, 0));
         root->setBounds(IntSize(10, 10));
         root->setContentBounds(root->bounds());
         root->setDrawsContent(false);
         m_hostImpl->setRootLayer(root.release());
     }
     CCLayerImpl* root = m_hostImpl->rootLayer();
 
     root->addChild(BlendStateCheckLayer::create(2, m_hostImpl->resourceProvider()));
     BlendStateCheckLayer* layer1 = static_cast<BlendStateCheckLayer*>(root->children()[0]);
     layer1->setPosition(FloatPoint(2, 2));
 
     CCLayerTreeHostImpl::FrameData frame;
 
     // Opaque layer, drawn without blending.
-    layer1->setOpaque(true);
-    layer1->setOpaqueContents(true);
+    layer1->setContentsOpaque(true);
     layer1->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
-    EXPECT_TRUE(layer1->quadsAppended());
-    m_hostImpl->didDrawAllLayers(frame);
-
-    // Layer with translucent content, but opaque content, so drawn without blending.

[enne (OOO), 2012/10/02 18:06:09]

In retrospect, I have no idea what this was trying to test.

[danakj, 2012/10/02 18:12:08]

Think I wrote this.

It has opaque pixels detected by the opaque paint tracker, but opaque flag
false.

setOpaqueContents here is setting a value on the layer to replicate actual
opaque pixel content, not a hinting flag.

Removing it from all these tests is decreasing what they are testing.

[alokp, 2012/10/02 18:21:50]

CCLayerImpl::setContentsOpaque refers to pixel content being opaque. I could not
tell a difference between setOpaqueContents and setContentsOpaque. I thought it
was added by somebody confused (like me) by the meaning of
CCLayerImpl::setOpaque.

I removed this test because after you remove setOpaqueContents, it becomes
identical to the one above it.

BTW I did not try to understand what the tests were doing. Most of the times
setOpaque and setOpaqueContents were given the same argument. The cases where
they were different, I used true because of the OR operator on line 1406.

[enne (OOO), 2012/10/02 18:25:05]

I disagree.  setOpaqueContents is setting a value on the derived test layer and
so isn't testing anything outside of the test itself.

If BlendStateCheckLayer derived from CCTiledLayerImpl and overrode opaque
regions, that would be testing opaque pixel content.

-    layer1->setOpaque(false);
-    layer1->setOpaqueContents(true);
-    layer1->setExpectation(false, false);
-    EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
-    m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Layer with translucent content and painting, so drawn with blending.
-    layer1->setOpaque(false);
-    layer1->setOpaqueContents(false);
+    layer1->setContentsOpaque(false);
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Layer with translucent opacity, drawn with blending.
-    layer1->setOpaque(true);
-    layer1->setOpaqueContents(true);
+    layer1->setContentsOpaque(true);
     layer1->setOpacity(0.5);
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Layer with translucent opacity and painting, drawn with blending.
-    layer1->setOpaque(true);
-    layer1->setOpaqueContents(false);
+    layer1->setContentsOpaque(true);
     layer1->setOpacity(0.5);
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     layer1->addChild(BlendStateCheckLayer::create(3, m_hostImpl->resourceProvider()));
     BlendStateCheckLayer* layer2 = static_cast<BlendStateCheckLayer*>(layer1->children()[0]);
     layer2->setPosition(FloatPoint(4, 4));
 
     // 2 opaque layers, drawn without blending.
-    layer1->setOpaque(true);
-    layer1->setOpaqueContents(true);
+    layer1->setContentsOpaque(true);
     layer1->setOpacity(1);
     layer1->setExpectation(false, false);
-    layer2->setOpaque(true);
-    layer2->setOpaqueContents(true);
+    layer2->setContentsOpaque(true);
     layer2->setOpacity(1);
     layer2->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Parent layer with translucent content, drawn with blending.
     // Child layer with opaque content, drawn without blending.
-    layer1->setOpaque(false);
-    layer1->setOpaqueContents(false);
+    layer1->setContentsOpaque(false);
     layer1->setExpectation(true, false);
     layer2->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Parent layer with translucent content but opaque painting, drawn without blending.
     // Child layer with opaque content, drawn without blending.
-    layer1->setOpaque(false);
-    layer1->setOpaqueContents(true);
+    layer1->setContentsOpaque(true);
     layer1->setExpectation(false, false);
     layer2->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Parent layer with translucent opacity and opaque content. Since it has a
     // drawing child, it's drawn to a render surface which carries the opacity,
     // so it's itself drawn without blending.
     // Child layer with opaque content, drawn without blending (parent surface
     // carries the inherited opacity).
-    layer1->setOpaque(true);
-    layer1->setOpaqueContents(true);
+    layer1->setContentsOpaque(true);
     layer1->setOpacity(0.5);
     layer1->setExpectation(false, true);
     layer2->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Draw again, but with child non-opaque, to make sure
     // layer1 not culled.
-    layer1->setOpaque(true);
-    layer1->setOpaqueContents(true);
+    layer1->setContentsOpaque(true);
     layer1->setOpacity(1);
     layer1->setExpectation(false, false);
-    layer2->setOpaque(true);
-    layer2->setOpaqueContents(true);
+    layer2->setContentsOpaque(true);
     layer2->setOpacity(0.5);
     layer2->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // A second way of making the child non-opaque.
-    layer1->setOpaque(true);
+    layer1->setContentsOpaque(true);
     layer1->setOpacity(1);
     layer1->setExpectation(false, false);
-    layer2->setOpaque(false);
-    layer2->setOpaqueContents(false);
+    layer2->setContentsOpaque(false);
     layer2->setOpacity(1);
     layer2->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // And when the layer says its not opaque but is painted opaque, it is not blended.
-    layer1->setOpaque(true);
+    layer1->setContentsOpaque(true);
     layer1->setOpacity(1);
     layer1->setExpectation(false, false);
-    layer2->setOpaque(false);
-    layer2->setOpaqueContents(true);
+    layer2->setContentsOpaque(true);
     layer2->setOpacity(1);
     layer2->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     EXPECT_TRUE(layer2->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Layer with partially opaque contents, drawn with blending.
-    layer1->setOpaque(false);
+    layer1->setContentsOpaque(false);
     layer1->setQuadRect(IntRect(5, 5, 5, 5));
     layer1->setQuadVisibleRect(IntRect(5, 5, 5, 5));
-    layer1->setOpaqueContents(false);
     layer1->setOpaqueContentRect(IntRect(5, 5, 2, 5));
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Layer with partially opaque contents partially culled, drawn with blending.
-    layer1->setOpaque(false);
+    layer1->setContentsOpaque(false);
     layer1->setQuadRect(IntRect(5, 5, 5, 5));
     layer1->setQuadVisibleRect(IntRect(5, 5, 5, 2));
-    layer1->setOpaqueContents(false);
     layer1->setOpaqueContentRect(IntRect(5, 5, 2, 5));
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Layer with partially opaque contents culled, drawn with blending.
-    layer1->setOpaque(false);
+    layer1->setContentsOpaque(false);
     layer1->setQuadRect(IntRect(5, 5, 5, 5));
     layer1->setQuadVisibleRect(IntRect(7, 5, 3, 5));
-    layer1->setOpaqueContents(false);
     layer1->setOpaqueContentRect(IntRect(5, 5, 2, 5));
     layer1->setExpectation(true, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
     // Layer with partially opaque contents and translucent contents culled, drawn without blending.
-    layer1->setOpaque(false);
+    layer1->setContentsOpaque(false);
     layer1->setQuadRect(IntRect(5, 5, 5, 5));
     layer1->setQuadVisibleRect(IntRect(5, 5, 2, 5));
-    layer1->setOpaqueContents(false);
     layer1->setOpaqueContentRect(IntRect(5, 5, 2, 5));
     layer1->setExpectation(false, false);
     EXPECT_TRUE(m_hostImpl->prepareToDraw(frame));
     m_hostImpl->drawLayers(frame);
     EXPECT_TRUE(layer1->quadsAppended());
     m_hostImpl->didDrawAllLayers(frame);
 
 }
 
 TEST_F(CCLayerTreeHostImplTest, viewportCovered)
 {
     m_hostImpl->initializeRenderer(createContext());
     m_hostImpl->setBackgroundColor(SK_ColorGRAY);
 
     IntSize viewportSize(1000, 1000);
     m_hostImpl->setViewportSize(viewportSize, viewportSize);
 
     m_hostImpl->setRootLayer(BlendStateCheckLayer::create(1, m_hostImpl->resourceProvider()));
     BlendStateCheckLayer* root = static_cast<BlendStateCheckLayer*>(m_hostImpl->rootLayer());
     root->setExpectation(false, true);
-    root->setOpaque(true);
+    root->setContentsOpaque(true);
 
     // No gutter rects
     {
         IntRect layerRect(0, 0, 1000, 1000);
         root->setPosition(layerRect.location());
         root->setBounds(layerRect.size());
         root->setContentBounds(layerRect.size());
         root->setQuadRect(IntRect(IntPoint(), layerRect.size()));
         root->setQuadVisibleRect(IntRect(IntPoint(), layerRect.size()));
 
@@ skipping 1133 matching lines @@
 
 static void addDrawingLayerTo(CCLayerImpl* parent, int id, const IntRect& layerRect, CCLayerImpl** result)
 {
     OwnPtr<CCLayerImpl> layer = FakeLayerWithQuads::create(id);
     CCLayerImpl* layerPtr = layer.get();
     layerPtr->setAnchorPoint(FloatPoint(0, 0));
     layerPtr->setPosition(FloatPoint(layerRect.location()));
     layerPtr->setBounds(layerRect.size());
     layerPtr->setContentBounds(layerRect.size());
     layerPtr->setDrawsContent(true); // only children draw content
-    layerPtr->setOpaque(true);
+    layerPtr->setContentsOpaque(true);
     parent->addChild(layer.release());
     if (result)
         *result = layerPtr;
 }
 
 static void setupLayersForTextureCaching(CCLayerTreeHostImpl* layerTreeHostImpl, CCLayerImpl*& rootPtr, CCLayerImpl*& intermediateLayerPtr, CCLayerImpl*& surfaceLayerPtr, CCLayerImpl*& childPtr, const IntSize& rootSize)
 {
     OwnPtr<CCGraphicsContext> context = FakeWebCompositorOutputSurface::create(adoptPtr(new PartialSwapContext));
 
     layerTreeHostImpl->initializeRenderer(context.release());
@@ skipping 1390 matching lines @@
     while (removeRenderPassesCases[testCaseIndex].name) {
         RenderPassRemovalTestData testData;
         configureRenderPassTestData(removeRenderPassesCases[testCaseIndex].initScript, testData, renderer.get());
         CCLayerTreeHostImpl::removeRenderPasses(CCLayerTreeHostImpl::CullRenderPassesWithCachedTextures(*renderer), testData);
         verifyRenderPassTestData(removeRenderPassesCases[testCaseIndex], testData);
         testCaseIndex++;
     }
 }
 
 } // namespace