Merge "HWUI: do nothing in case of empty layer" into nyc-dev am: 21a608f27f

am: 6544a0e2e2

* commit '6544a0e2e255b676770d64fa89f4f616a7021e63':
  HWUI: do nothing in case of empty layer

Change-Id: I4bfc8c0210ec97a21fd4ee4cb5ea698324c309f2

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)) {
+    if (CC_UNLIKELY(!buffer)) return;
-        // 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 (buffer && !buffer->hasRenderedSinceRepaint) {
+    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->hasRenderedSinceRepaint) {
         buffer->hasRenderedSinceRepaint = true;
         if (CC_UNLIKELY(Properties::debugLayersUpdates)) {
             // render debug layer highlight

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) {
+    auto glopReceiver = [&glopVerifier, &glopCount, &expectedGlopCount] (const Glop& glop) {
-        ASSERT_EQ(glopCount++, 0) << "Only one Glop expected";
+        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
+        ADD_FAILURE() << "Nothing should happen";
-        EXPECT_EQ(renderThread.renderState().meshState().getUnitQuadVBO(),
+    }, 0);
-                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";
-    });
 }
 
 static int getGlopTransformFlags(renderthread::RenderThread& renderThread, RecordedOp* op) {