HWUI: do nothing in case of empty layer

bug:28862058
Change-Id: I8e09a5c33d0eb00a829be4df706dab49cad48b1e

2 files changed, 21 insertions, 30 deletions

diff --git a/libs/hwui/BakedOpDispatcher.cpp b/libs/hwui/BakedOpDispatcher.cpp
index 59c106578cf3..8b3f1722dddf 100644
--- a/libs/hwui/BakedOpDispatcher.cpp
+++ b/libs/hwui/BakedOpDispatcher.cpp
@@ -805,27 +805,21 @@ void BakedOpDispatcher::onLayerOp(BakedOpRenderer& renderer, const LayerOp& op,
     // Note that we don't use op->paint in this function - it's never set on a LayerOp
     OffscreenBuffer* buffer = *op.layerHandle;
 
-    if (CC_UNLIKELY(!buffer)) {
-        // Layer was not allocated, which can occur if there were no draw ops inside. We draw the
-        // equivalent by drawing a rect with the same layer properties (alpha/xfer/filter).
-        int color = SkColorSetA(SK_ColorTRANSPARENT, op.alpha * 255);
-        renderRectForLayer(renderer, op, state,
-                color, op.mode, op.colorFilter);
-    } else {
-        float layerAlpha = op.alpha * state.alpha;
-        Glop glop;
-        GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
-                .setRoundRectClipState(state.roundRectClipState)
-                .setMeshTexturedIndexedVbo(buffer->vbo, buffer->elementCount)
-                .setFillLayer(buffer->texture, op.colorFilter, layerAlpha, op.mode, Blend::ModeOrderSwap::NoSwap)
-                .setTransform(state.computedState.transform, TransformFlags::None)
-                .setModelViewOffsetRectSnap(op.unmappedBounds.left, op.unmappedBounds.top,
-                        Rect(op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight()))
-                .build();
-        renderer.renderGlop(state, glop);
-    }
+    if (CC_UNLIKELY(!buffer)) return;
+
+    float layerAlpha = op.alpha * state.alpha;
+    Glop glop;
+    GlopBuilder(renderer.renderState(), renderer.caches(), &glop)
+            .setRoundRectClipState(state.roundRectClipState)
+            .setMeshTexturedIndexedVbo(buffer->vbo, buffer->elementCount)
+            .setFillLayer(buffer->texture, op.colorFilter, layerAlpha, op.mode, Blend::ModeOrderSwap::NoSwap)
+            .setTransform(state.computedState.transform, TransformFlags::None)
+            .setModelViewOffsetRectSnap(op.unmappedBounds.left, op.unmappedBounds.top,
+                    Rect(op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight()))
+            .build();
+    renderer.renderGlop(state, glop);
 
-    if (buffer && !buffer->hasRenderedSinceRepaint) {
+    if (!buffer->hasRenderedSinceRepaint) {
         buffer->hasRenderedSinceRepaint = true;
         if (CC_UNLIKELY(Properties::debugLayersUpdates)) {
             // render debug layer highlight
diff --git a/libs/hwui/tests/unit/BakedOpDispatcherTests.cpp b/libs/hwui/tests/unit/BakedOpDispatcherTests.cpp
index 01d3d7066ae3..6b7b721eaec6 100644
--- a/libs/hwui/tests/unit/BakedOpDispatcherTests.cpp
+++ b/libs/hwui/tests/unit/BakedOpDispatcherTests.cpp
@@ -53,7 +53,7 @@ private:
 typedef void (*TestBakedOpReceiver)(BakedOpRenderer&, const BakedOpState&);
 
 static void testUnmergedGlopDispatch(renderthread::RenderThread& renderThread, RecordedOp* op,
-        std::function<void(const Glop& glop)> glopVerifier) {
+        std::function<void(const Glop& glop)> glopVerifier, int expectedGlopCount = 1) {
     // Create op, and wrap with basic state.
     LinearAllocator allocator;
     auto snapshot = TestUtils::makeSnapshot(Matrix4::identity(), Rect(100, 100));
@@ -61,8 +61,8 @@ static void testUnmergedGlopDispatch(renderthread::RenderThread& renderThread, R
     ASSERT_NE(nullptr, state);
 
     int glopCount = 0;
-    auto glopReceiver = [&glopVerifier, &glopCount] (const Glop& glop) {
-        ASSERT_EQ(glopCount++, 0) << "Only one Glop expected";
+    auto glopReceiver = [&glopVerifier, &glopCount, &expectedGlopCount] (const Glop& glop) {
+        ASSERT_LE(glopCount++, expectedGlopCount) << expectedGlopCount << "glop(s) expected";
         glopVerifier(glop);
     };
     ValidatingBakedOpRenderer renderer(renderThread.renderState(), glopReceiver);
@@ -75,7 +75,8 @@ static void testUnmergedGlopDispatch(renderthread::RenderThread& renderThread, R
     static TestBakedOpReceiver unmergedReceivers[] = BUILD_RENDERABLE_OP_LUT(X);
 #undef X
     unmergedReceivers[op->opId](renderer, *state);
-    ASSERT_EQ(1, glopCount) << "Exactly one Glop expected";
+    ASSERT_EQ(expectedGlopCount, glopCount) << "Exactly " << expectedGlopCount
+            << "Glop(s) expected";
 }
 
 RENDERTHREAD_TEST(BakedOpDispatcher, pathTexture_positionOvalArc) {
@@ -119,12 +120,8 @@ RENDERTHREAD_TEST(BakedOpDispatcher, onLayerOp_bufferless) {
     OffscreenBuffer* buffer = nullptr; // no providing a buffer, should hit rect fallback case
     LayerOp op(Rect(10, 10), Matrix4::identity(), nullptr, &layerPaint, &buffer);
     testUnmergedGlopDispatch(renderThread, &op, [&renderThread] (const Glop& glop) {
-        // rect glop is dispatched with paint props applied
-        EXPECT_EQ(renderThread.renderState().meshState().getUnitQuadVBO(),
-                glop.mesh.vertices.bufferObject) << "Unit quad should be drawn";
-        EXPECT_EQ(nullptr, glop.fill.texture.texture) << "Should be no texture when layer is null";
-        EXPECT_FLOAT_EQ(128 / 255.0f, glop.fill.color.a) << "Rect quad should use op alpha";
-    });
+        ADD_FAILURE() << "Nothing should happen";
+    }, 0);
 }
 
 static int getGlopTransformFlags(renderthread::RenderThread& renderThread, RecordedOp* op) {