libs/hwui/FrameBuilder.cpp

   1 /*
   2  * Copyright (C) 2016 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "FrameBuilder.h"
  18
  19 #include "LayerUpdateQueue.h"
  20 #include "RenderNode.h"
  21 #include "VectorDrawable.h"
  22 #include "renderstate/OffscreenBufferPool.h"
  23 #include "hwui/Canvas.h"
  24 #include "utils/FatVector.h"
  25 #include "utils/PaintUtils.h"
  26 #include "utils/TraceUtils.h"
  27
  28 #include <SkPathOps.h>
  29 #include <utils/TypeHelpers.h>
  30
  31 namespace android {
  32 namespace uirenderer {
  33
  34 FrameBuilder::FrameBuilder(const SkRect& clip,
  35         uint32_t viewportWidth, uint32_t viewportHeight,
  36         const LightGeometry& lightGeometry, Caches& caches)
  37         : mStdAllocator(mAllocator)
  38         , mLayerBuilders(mStdAllocator)
  39         , mLayerStack(mStdAllocator)
  40         , mCanvasState(*this)
  41         , mCaches(caches)
  42         , mLightRadius(lightGeometry.radius)
  43         , mDrawFbo0(true) {
  44
  45     // Prepare to defer Fbo0
  46     auto fbo0 = mAllocator.create<LayerBuilder>(viewportWidth, viewportHeight, Rect(clip));
  47     mLayerBuilders.push_back(fbo0);
  48     mLayerStack.push_back(0);
  49     mCanvasState.initializeSaveStack(viewportWidth, viewportHeight,
  50             clip.fLeft, clip.fTop, clip.fRight, clip.fBottom,
  51             lightGeometry.center);
  52 }
  53
  54 FrameBuilder::FrameBuilder(const LayerUpdateQueue& layers,
  55         const LightGeometry& lightGeometry, Caches& caches)
  56         : mStdAllocator(mAllocator)
  57         , mLayerBuilders(mStdAllocator)
  58         , mLayerStack(mStdAllocator)
  59         , mCanvasState(*this)
  60         , mCaches(caches)
  61         , mLightRadius(lightGeometry.radius)
  62         , mDrawFbo0(false) {
  63     // TODO: remove, with each layer on its own save stack
  64
  65     // Prepare to defer Fbo0 (which will be empty)
  66     auto fbo0 = mAllocator.create<LayerBuilder>(1, 1, Rect(1, 1));
  67     mLayerBuilders.push_back(fbo0);
  68     mLayerStack.push_back(0);
  69     mCanvasState.initializeSaveStack(1, 1,
  70             0, 0, 1, 1,
  71             lightGeometry.center);
  72
  73     deferLayers(layers);
  74 }
  75
  76 void FrameBuilder::deferLayers(const LayerUpdateQueue& layers) {
  77     // Render all layers to be updated, in order. Defer in reverse order, so that they'll be
  78     // updated in the order they're passed in (mLayerBuilders are issued to Renderer in reverse)
  79     for (int i = layers.entries().size() - 1; i >= 0; i--) {
  80         RenderNode* layerNode = layers.entries()[i].renderNode;
  81         // only schedule repaint if node still on layer - possible it may have been
  82         // removed during a dropped frame, but layers may still remain scheduled so
  83         // as not to lose info on what portion is damaged
  84         OffscreenBuffer* layer = layerNode->getLayer();
  85         if (CC_LIKELY(layer)) {
  86             ATRACE_FORMAT("Optimize HW Layer DisplayList %s %ux%u",
  87                     layerNode->getName(), layerNode->getWidth(), layerNode->getHeight());
  88
  89             Rect layerDamage = layers.entries()[i].damage;
  90             // TODO: ensure layer damage can't be larger than layer
  91             layerDamage.doIntersect(0, 0, layer->viewportWidth, layer->viewportHeight);
  92             layerNode->computeOrdering();
  93
  94             // map current light center into RenderNode's coordinate space
  95             Vector3 lightCenter = mCanvasState.currentSnapshot()->getRelativeLightCenter();
  96             layer->inverseTransformInWindow.mapPoint3d(lightCenter);
  97
  98             saveForLayer(layerNode->getWidth(), layerNode->getHeight(), 0, 0,
  99                     layerDamage, lightCenter, nullptr, layerNode);
 100
 101             if (layerNode->getDisplayList()) {
 102                 deferNodeOps(*layerNode);
 103             }
 104             restoreForLayer();
 105         }
 106     }
 107 }
 108
 109 void FrameBuilder::deferRenderNode(RenderNode& renderNode) {
 110     renderNode.computeOrdering();
 111
 112     mCanvasState.save(SaveFlags::MatrixClip);
 113     deferNodePropsAndOps(renderNode);
 114     mCanvasState.restore();
 115 }
 116
 117 void FrameBuilder::deferRenderNode(float tx, float ty, Rect clipRect, RenderNode& renderNode) {
 118     renderNode.computeOrdering();
 119
 120     mCanvasState.save(SaveFlags::MatrixClip);
 121     mCanvasState.translate(tx, ty);
 122     mCanvasState.clipRect(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom,
 123             SkRegion::kIntersect_Op);
 124     deferNodePropsAndOps(renderNode);
 125     mCanvasState.restore();
 126 }
 127
 128 static Rect nodeBounds(RenderNode& node) {
 129     auto& props = node.properties();
 130     return Rect(props.getLeft(), props.getTop(),
 131             props.getRight(), props.getBottom());
 132 }
 133
 134 void FrameBuilder::deferRenderNodeScene(const std::vector< sp<RenderNode> >& nodes,
 135         const Rect& contentDrawBounds) {
 136     if (nodes.size() < 1) return;
 137     if (nodes.size() == 1) {
 138         if (!nodes[0]->nothingToDraw()) {
 139             deferRenderNode(*nodes[0]);
 140         }
 141         return;
 142     }
 143     // It there are multiple render nodes, they are laid out as follows:
 144     // #0 - backdrop (content + caption)
 145     // #1 - content (local bounds are at (0,0), will be translated and clipped to backdrop)
 146     // #2 - additional overlay nodes
 147     // Usually the backdrop cannot be seen since it will be entirely covered by the content. While
 148     // resizing however it might become partially visible. The following render loop will crop the
 149     // backdrop against the content and draw the remaining part of it. It will then draw the content
 150     // cropped to the backdrop (since that indicates a shrinking of the window).
 151     //
 152     // Additional nodes will be drawn on top with no particular clipping semantics.
 153
 154     // Usually the contents bounds should be mContentDrawBounds - however - we will
 155     // move it towards the fixed edge to give it a more stable appearance (for the moment).
 156     // If there is no content bounds we ignore the layering as stated above and start with 2.
 157
 158     // Backdrop bounds in render target space
 159     const Rect backdrop = nodeBounds(*nodes[0]);
 160
 161     // Bounds that content will fill in render target space (note content node bounds may be bigger)
 162     Rect content(contentDrawBounds.getWidth(), contentDrawBounds.getHeight());
 163     content.translate(backdrop.left, backdrop.top);
 164     if (!content.contains(backdrop) && !nodes[0]->nothingToDraw()) {
 165         // Content doesn't entirely overlap backdrop, so fill around content (right/bottom)
 166
 167         // Note: in the future, if content doesn't snap to backdrop's left/top, this may need to
 168         // also fill left/top. Currently, both 2up and freeform position content at the top/left of
 169         // the backdrop, so this isn't necessary.
 170         if (content.right < backdrop.right) {
 171             // draw backdrop to right side of content
 172             deferRenderNode(0, 0, Rect(content.right, backdrop.top,
 173                     backdrop.right, backdrop.bottom), *nodes[0]);
 174         }
 175         if (content.bottom < backdrop.bottom) {
 176             // draw backdrop to bottom of content
 177             // Note: bottom fill uses content left/right, to avoid overdrawing left/right fill
 178             deferRenderNode(0, 0, Rect(content.left, content.bottom,
 179                     content.right, backdrop.bottom), *nodes[0]);
 180         }
 181     }
 182
 183     if (!backdrop.isEmpty()) {
 184         // content node translation to catch up with backdrop
 185         float dx = contentDrawBounds.left - backdrop.left;
 186         float dy = contentDrawBounds.top - backdrop.top;
 187
 188         Rect contentLocalClip = backdrop;
 189         contentLocalClip.translate(dx, dy);
 190         deferRenderNode(-dx, -dy, contentLocalClip, *nodes[1]);
 191     } else {
 192         deferRenderNode(*nodes[1]);
 193     }
 194
 195     // remaining overlay nodes, simply defer
 196     for (size_t index = 2; index < nodes.size(); index++) {
 197         if (!nodes[index]->nothingToDraw()) {
 198             deferRenderNode(*nodes[index]);
 199         }
 200     }
 201 }
 202
 203 void FrameBuilder::onViewportInitialized() {}
 204
 205 void FrameBuilder::onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {}
 206
 207 void FrameBuilder::deferNodePropsAndOps(RenderNode& node) {
 208     const RenderProperties& properties = node.properties();
 209     const Outline& outline = properties.getOutline();
 210     if (properties.getAlpha() <= 0
 211             || (outline.getShouldClip() && outline.isEmpty())
 212             || properties.getScaleX() == 0
 213             || properties.getScaleY() == 0) {
 214         return; // rejected
 215     }
 216
 217     if (properties.getLeft() != 0 || properties.getTop() != 0) {
 218         mCanvasState.translate(properties.getLeft(), properties.getTop());
 219     }
 220     if (properties.getStaticMatrix()) {
 221         mCanvasState.concatMatrix(*properties.getStaticMatrix());
 222     } else if (properties.getAnimationMatrix()) {
 223         mCanvasState.concatMatrix(*properties.getAnimationMatrix());
 224     }
 225     if (properties.hasTransformMatrix()) {
 226         if (properties.isTransformTranslateOnly()) {
 227             mCanvasState.translate(properties.getTranslationX(), properties.getTranslationY());
 228         } else {
 229             mCanvasState.concatMatrix(*properties.getTransformMatrix());
 230         }
 231     }
 232
 233     const int width = properties.getWidth();
 234     const int height = properties.getHeight();
 235
 236     Rect saveLayerBounds; // will be set to non-empty if saveLayer needed
 237     const bool isLayer = properties.effectiveLayerType() != LayerType::None;
 238     int clipFlags = properties.getClippingFlags();
 239     if (properties.getAlpha() < 1) {
 240         if (isLayer) {
 241             clipFlags &= ~CLIP_TO_BOUNDS; // bounds clipping done by layer
 242         }
 243         if (CC_LIKELY(isLayer || !properties.getHasOverlappingRendering())) {
 244             // simply scale rendering content's alpha
 245             mCanvasState.scaleAlpha(properties.getAlpha());
 246         } else {
 247             // schedule saveLayer by initializing saveLayerBounds
 248             saveLayerBounds.set(0, 0, width, height);
 249             if (clipFlags) {
 250                 properties.getClippingRectForFlags(clipFlags, &saveLayerBounds);
 251                 clipFlags = 0; // all clipping done by savelayer
 252             }
 253         }
 254
 255         if (CC_UNLIKELY(ATRACE_ENABLED() && properties.promotedToLayer())) {
 256             // pretend alpha always causes savelayer to warn about
 257             // performance problem affecting old versions
 258             ATRACE_FORMAT("%s alpha caused saveLayer %dx%d", node.getName(), width, height);
 259         }
 260     }
 261     if (clipFlags) {
 262         Rect clipRect;
 263         properties.getClippingRectForFlags(clipFlags, &clipRect);
 264         mCanvasState.clipRect(clipRect.left, clipRect.top, clipRect.right, clipRect.bottom,
 265                 SkRegion::kIntersect_Op);
 266     }
 267
 268     if (properties.getRevealClip().willClip()) {
 269         Rect bounds;
 270         properties.getRevealClip().getBounds(&bounds);
 271         mCanvasState.setClippingRoundRect(mAllocator,
 272                 bounds, properties.getRevealClip().getRadius());
 273     } else if (properties.getOutline().willClip()) {
 274         mCanvasState.setClippingOutline(mAllocator, &(properties.getOutline()));
 275     }
 276
 277     bool quickRejected = mCanvasState.currentSnapshot()->getRenderTargetClip().isEmpty()
 278             || (properties.getClipToBounds()
 279                     && mCanvasState.quickRejectConservative(0, 0, width, height));
 280     if (!quickRejected) {
 281         // not rejected, so defer render as either Layer, or direct (possibly wrapped in saveLayer)
 282         if (node.getLayer()) {
 283             // HW layer
 284             LayerOp* drawLayerOp = mAllocator.create_trivial<LayerOp>(node);
 285             BakedOpState* bakedOpState = tryBakeOpState(*drawLayerOp);
 286             if (bakedOpState) {
 287                 // Node's layer already deferred, schedule it to render into parent layer
 288                 currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Bitmap);
 289             }
 290         } else if (CC_UNLIKELY(!saveLayerBounds.isEmpty())) {
 291             // draw DisplayList contents within temporary, since persisted layer could not be used.
 292             // (temp layers are clipped to viewport, since they don't persist offscreen content)
 293             SkPaint saveLayerPaint;
 294             saveLayerPaint.setAlpha(properties.getAlpha());
 295             deferBeginLayerOp(*mAllocator.create_trivial<BeginLayerOp>(
 296                     saveLayerBounds,
 297                     Matrix4::identity(),
 298                     nullptr, // no record-time clip - need only respect defer-time one
 299                     &saveLayerPaint));
 300             deferNodeOps(node);
 301             deferEndLayerOp(*mAllocator.create_trivial<EndLayerOp>());
 302         } else {
 303             deferNodeOps(node);
 304         }
 305     }
 306 }
 307
 308 typedef key_value_pair_t<float, const RenderNodeOp*> ZRenderNodeOpPair;
 309
 310 template <typename V>
 311 static void buildZSortedChildList(V* zTranslatedNodes,
 312         const DisplayList& displayList, const DisplayList::Chunk& chunk) {
 313     if (chunk.beginChildIndex == chunk.endChildIndex) return;
 314
 315     for (size_t i = chunk.beginChildIndex; i < chunk.endChildIndex; i++) {
 316         RenderNodeOp* childOp = displayList.getChildren()[i];
 317         RenderNode* child = childOp->renderNode;
 318         float childZ = child->properties().getZ();
 319
 320         if (!MathUtils::isZero(childZ) && chunk.reorderChildren) {
 321             zTranslatedNodes->push_back(ZRenderNodeOpPair(childZ, childOp));
 322             childOp->skipInOrderDraw = true;
 323         } else if (!child->properties().getProjectBackwards()) {
 324             // regular, in order drawing DisplayList
 325             childOp->skipInOrderDraw = false;
 326         }
 327     }
 328
 329     // Z sort any 3d children (stable-ness makes z compare fall back to standard drawing order)
 330     std::stable_sort(zTranslatedNodes->begin(), zTranslatedNodes->end());
 331 }
 332
 333 template <typename V>
 334 static size_t findNonNegativeIndex(const V& zTranslatedNodes) {
 335     for (size_t i = 0; i < zTranslatedNodes.size(); i++) {
 336         if (zTranslatedNodes[i].key >= 0.0f) return i;
 337     }
 338     return zTranslatedNodes.size();
 339 }
 340
 341 template <typename V>
 342 void FrameBuilder::defer3dChildren(const ClipBase* reorderClip, ChildrenSelectMode mode,
 343         const V& zTranslatedNodes) {
 344     const int size = zTranslatedNodes.size();
 345     if (size == 0
 346             || (mode == ChildrenSelectMode::Negative&& zTranslatedNodes[0].key > 0.0f)
 347             || (mode == ChildrenSelectMode::Positive && zTranslatedNodes[size - 1].key < 0.0f)) {
 348         // no 3d children to draw
 349         return;
 350     }
 351
 352     /**
 353      * Draw shadows and (potential) casters mostly in order, but allow the shadows of casters
 354      * with very similar Z heights to draw together.
 355      *
 356      * This way, if Views A & B have the same Z height and are both casting shadows, the shadows are
 357      * underneath both, and neither's shadow is drawn on top of the other.
 358      */
 359     const size_t nonNegativeIndex = findNonNegativeIndex(zTranslatedNodes);
 360     size_t drawIndex, shadowIndex, endIndex;
 361     if (mode == ChildrenSelectMode::Negative) {
 362         drawIndex = 0;
 363         endIndex = nonNegativeIndex;
 364         shadowIndex = endIndex; // draw no shadows
 365     } else {
 366         drawIndex = nonNegativeIndex;
 367         endIndex = size;
 368         shadowIndex = drawIndex; // potentially draw shadow for each pos Z child
 369     }
 370
 371     float lastCasterZ = 0.0f;
 372     while (shadowIndex < endIndex || drawIndex < endIndex) {
 373         if (shadowIndex < endIndex) {
 374             const RenderNodeOp* casterNodeOp = zTranslatedNodes[shadowIndex].value;
 375             const float casterZ = zTranslatedNodes[shadowIndex].key;
 376             // attempt to render the shadow if the caster about to be drawn is its caster,
 377             // OR if its caster's Z value is similar to the previous potential caster
 378             if (shadowIndex == drawIndex || casterZ - lastCasterZ < 0.1f) {
 379                 deferShadow(reorderClip, *casterNodeOp);
 380
 381                 lastCasterZ = casterZ; // must do this even if current caster not casting a shadow
 382                 shadowIndex++;
 383                 continue;
 384             }
 385         }
 386
 387         const RenderNodeOp* childOp = zTranslatedNodes[drawIndex].value;
 388         deferRenderNodeOpImpl(*childOp);
 389         drawIndex++;
 390     }
 391 }
 392
 393 void FrameBuilder::deferShadow(const ClipBase* reorderClip, const RenderNodeOp& casterNodeOp) {
 394     auto& node = *casterNodeOp.renderNode;
 395     auto& properties = node.properties();
 396
 397     if (properties.getAlpha() <= 0.0f
 398             || properties.getOutline().getAlpha() <= 0.0f
 399             || !properties.getOutline().getPath()
 400             || properties.getScaleX() == 0
 401             || properties.getScaleY() == 0) {
 402         // no shadow to draw
 403         return;
 404     }
 405
 406     const SkPath* casterOutlinePath = properties.getOutline().getPath();
 407     const SkPath* revealClipPath = properties.getRevealClip().getPath();
 408     if (revealClipPath && revealClipPath->isEmpty()) return;
 409
 410     float casterAlpha = properties.getAlpha() * properties.getOutline().getAlpha();
 411
 412     // holds temporary SkPath to store the result of intersections
 413     SkPath* frameAllocatedPath = nullptr;
 414     const SkPath* casterPath = casterOutlinePath;
 415
 416     // intersect the shadow-casting path with the reveal, if present
 417     if (revealClipPath) {
 418         frameAllocatedPath = createFrameAllocatedPath();
 419
 420         Op(*casterPath, *revealClipPath, kIntersect_SkPathOp, frameAllocatedPath);
 421         casterPath = frameAllocatedPath;
 422     }
 423
 424     // intersect the shadow-casting path with the clipBounds, if present
 425     if (properties.getClippingFlags() & CLIP_TO_CLIP_BOUNDS) {
 426         if (!frameAllocatedPath) {
 427             frameAllocatedPath = createFrameAllocatedPath();
 428         }
 429         Rect clipBounds;
 430         properties.getClippingRectForFlags(CLIP_TO_CLIP_BOUNDS, &clipBounds);
 431         SkPath clipBoundsPath;
 432         clipBoundsPath.addRect(clipBounds.left, clipBounds.top,
 433                 clipBounds.right, clipBounds.bottom);
 434
 435         Op(*casterPath, clipBoundsPath, kIntersect_SkPathOp, frameAllocatedPath);
 436         casterPath = frameAllocatedPath;
 437     }
 438
 439     // apply reorder clip to shadow, so it respects clip at beginning of reorderable chunk
 440     int restoreTo = mCanvasState.save(SaveFlags::MatrixClip);
 441     mCanvasState.writableSnapshot()->applyClip(reorderClip,
 442             *mCanvasState.currentSnapshot()->transform);
 443     if (CC_LIKELY(!mCanvasState.getRenderTargetClipBounds().isEmpty())) {
 444         Matrix4 shadowMatrixXY(casterNodeOp.localMatrix);
 445         Matrix4 shadowMatrixZ(casterNodeOp.localMatrix);
 446         node.applyViewPropertyTransforms(shadowMatrixXY, false);
 447         node.applyViewPropertyTransforms(shadowMatrixZ, true);
 448
 449         sp<TessellationCache::ShadowTask> task = mCaches.tessellationCache.getShadowTask(
 450                 mCanvasState.currentTransform(),
 451                 mCanvasState.getLocalClipBounds(),
 452                 casterAlpha >= 1.0f,
 453                 casterPath,
 454                 &shadowMatrixXY, &shadowMatrixZ,
 455                 mCanvasState.currentSnapshot()->getRelativeLightCenter(),
 456                 mLightRadius);
 457         ShadowOp* shadowOp = mAllocator.create<ShadowOp>(task, casterAlpha);
 458         BakedOpState* bakedOpState = BakedOpState::tryShadowOpConstruct(
 459                 mAllocator, *mCanvasState.writableSnapshot(), shadowOp);
 460         if (CC_LIKELY(bakedOpState)) {
 461             currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Shadow);
 462         }
 463     }
 464     mCanvasState.restoreToCount(restoreTo);
 465 }
 466
 467 void FrameBuilder::deferProjectedChildren(const RenderNode& renderNode) {
 468     int count = mCanvasState.save(SaveFlags::MatrixClip);
 469     const SkPath* projectionReceiverOutline = renderNode.properties().getOutline().getPath();
 470
 471     SkPath transformedMaskPath; // on stack, since BakedOpState makes a deep copy
 472     if (projectionReceiverOutline) {
 473         // transform the mask for this projector into render target space
 474         // TODO: consider combining both transforms by stashing transform instead of applying
 475         SkMatrix skCurrentTransform;
 476         mCanvasState.currentTransform()->copyTo(skCurrentTransform);
 477         projectionReceiverOutline->transform(
 478                 skCurrentTransform,
 479                 &transformedMaskPath);
 480         mCanvasState.setProjectionPathMask(mAllocator, &transformedMaskPath);
 481     }
 482
 483     for (size_t i = 0; i < renderNode.mProjectedNodes.size(); i++) {
 484         RenderNodeOp* childOp = renderNode.mProjectedNodes[i];
 485         RenderNode& childNode = *childOp->renderNode;
 486
 487         // Draw child if it has content, but ignore state in childOp - matrix already applied to
 488         // transformFromCompositingAncestor, and record-time clip is ignored when projecting
 489         if (!childNode.nothingToDraw()) {
 490             int restoreTo = mCanvasState.save(SaveFlags::MatrixClip);
 491
 492             // Apply transform between ancestor and projected descendant
 493             mCanvasState.concatMatrix(childOp->transformFromCompositingAncestor);
 494
 495             deferNodePropsAndOps(childNode);
 496
 497             mCanvasState.restoreToCount(restoreTo);
 498         }
 499     }
 500     mCanvasState.restoreToCount(count);
 501 }
 502
 503 /**
 504  * Used to define a list of lambdas referencing private FrameBuilder::onXX::defer() methods.
 505  *
 506  * This allows opIds embedded in the RecordedOps to be used for dispatching to these lambdas.
 507  * E.g. a BitmapOp op then would be dispatched to FrameBuilder::onBitmapOp(const BitmapOp&)
 508  */
 509 #define OP_RECEIVER(Type) \
 510         [](FrameBuilder& frameBuilder, const RecordedOp& op) { frameBuilder.defer##Type(static_cast<const Type&>(op)); },
 511 void FrameBuilder::deferNodeOps(const RenderNode& renderNode) {
 512     typedef void (*OpDispatcher) (FrameBuilder& frameBuilder, const RecordedOp& op);
 513     static OpDispatcher receivers[] = BUILD_DEFERRABLE_OP_LUT(OP_RECEIVER);
 514
 515     // can't be null, since DL=null node rejection happens before deferNodePropsAndOps
 516     const DisplayList& displayList = *(renderNode.getDisplayList());
 517     for (auto& chunk : displayList.getChunks()) {
 518         FatVector<ZRenderNodeOpPair, 16> zTranslatedNodes;
 519         buildZSortedChildList(&zTranslatedNodes, displayList, chunk);
 520
 521         defer3dChildren(chunk.reorderClip, ChildrenSelectMode::Negative, zTranslatedNodes);
 522         for (size_t opIndex = chunk.beginOpIndex; opIndex < chunk.endOpIndex; opIndex++) {
 523             const RecordedOp* op = displayList.getOps()[opIndex];
 524             receivers[op->opId](*this, *op);
 525
 526             if (CC_UNLIKELY(!renderNode.mProjectedNodes.empty()
 527                     && displayList.projectionReceiveIndex >= 0
 528                     && static_cast<int>(opIndex) == displayList.projectionReceiveIndex)) {
 529                 deferProjectedChildren(renderNode);
 530             }
 531         }
 532         defer3dChildren(chunk.reorderClip, ChildrenSelectMode::Positive, zTranslatedNodes);
 533     }
 534 }
 535
 536 void FrameBuilder::deferRenderNodeOpImpl(const RenderNodeOp& op) {
 537     if (op.renderNode->nothingToDraw()) return;
 538     int count = mCanvasState.save(SaveFlags::MatrixClip);
 539
 540     // apply state from RecordedOp (clip first, since op's clip is transformed by current matrix)
 541     mCanvasState.writableSnapshot()->applyClip(op.localClip,
 542             *mCanvasState.currentSnapshot()->transform);
 543     mCanvasState.concatMatrix(op.localMatrix);
 544
 545     // then apply state from node properties, and defer ops
 546     deferNodePropsAndOps(*op.renderNode);
 547
 548     mCanvasState.restoreToCount(count);
 549 }
 550
 551 void FrameBuilder::deferRenderNodeOp(const RenderNodeOp& op) {
 552     if (!op.skipInOrderDraw) {
 553         deferRenderNodeOpImpl(op);
 554     }
 555 }
 556
 557 /**
 558  * Defers an unmergeable, strokeable op, accounting correctly
 559  * for paint's style on the bounds being computed.
 560  */
 561 BakedOpState* FrameBuilder::deferStrokeableOp(const RecordedOp& op, batchid_t batchId,
 562         BakedOpState::StrokeBehavior strokeBehavior) {
 563     // Note: here we account for stroke when baking the op
 564     BakedOpState* bakedState = BakedOpState::tryStrokeableOpConstruct(
 565             mAllocator, *mCanvasState.writableSnapshot(), op, strokeBehavior);
 566     if (!bakedState) return nullptr; // quick rejected
 567
 568     if (op.opId == RecordedOpId::RectOp && op.paint->getStyle() != SkPaint::kStroke_Style) {
 569         bakedState->setupOpacity(op.paint);
 570     }
 571
 572     currentLayer().deferUnmergeableOp(mAllocator, bakedState, batchId);
 573     return bakedState;
 574 }
 575
 576 /**
 577  * Returns batch id for tessellatable shapes, based on paint. Checks to see if path effect/AA will
 578  * be used, since they trigger significantly different rendering paths.
 579  *
 580  * Note: not used for lines/points, since they don't currently support path effects.
 581  */
 582 static batchid_t tessBatchId(const RecordedOp& op) {
 583     const SkPaint& paint = *(op.paint);
 584     return paint.getPathEffect()
 585             ? OpBatchType::AlphaMaskTexture
 586             : (paint.isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices);
 587 }
 588
 589 void FrameBuilder::deferArcOp(const ArcOp& op) {
 590     deferStrokeableOp(op, tessBatchId(op));
 591 }
 592
 593 static bool hasMergeableClip(const BakedOpState& state) {
 594     return state.computedState.clipState
 595             || state.computedState.clipState->mode == ClipMode::Rectangle;
 596 }
 597
 598 void FrameBuilder::deferBitmapOp(const BitmapOp& op) {
 599     BakedOpState* bakedState = tryBakeOpState(op);
 600     if (!bakedState) return; // quick rejected
 601
 602     if (op.bitmap->isOpaque()) {
 603         bakedState->setupOpacity(op.paint);
 604     }
 605
 606     // Don't merge non-simply transformed or neg scale ops, SET_TEXTURE doesn't handle rotation
 607     // Don't merge A8 bitmaps - the paint's color isn't compared by mergeId, or in
 608     // MergingDrawBatch::canMergeWith()
 609     if (bakedState->computedState.transform.isSimple()
 610             && bakedState->computedState.transform.positiveScale()
 611             && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode
 612             && op.bitmap->colorType() != kAlpha_8_SkColorType
 613             && hasMergeableClip(*bakedState)) {
 614         mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID());
 615         // TODO: AssetAtlas in mergeId
 616         currentLayer().deferMergeableOp(mAllocator, bakedState, OpBatchType::Bitmap, mergeId);
 617     } else {
 618         currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
 619     }
 620 }
 621
 622 void FrameBuilder::deferBitmapMeshOp(const BitmapMeshOp& op) {
 623     BakedOpState* bakedState = tryBakeOpState(op);
 624     if (!bakedState) return; // quick rejected
 625     currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
 626 }
 627
 628 void FrameBuilder::deferBitmapRectOp(const BitmapRectOp& op) {
 629     BakedOpState* bakedState = tryBakeOpState(op);
 630     if (!bakedState) return; // quick rejected
 631     currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
 632 }
 633
 634 void FrameBuilder::deferVectorDrawableOp(const VectorDrawableOp& op) {
 635     const SkBitmap& bitmap = op.vectorDrawable->getBitmapUpdateIfDirty();
 636     SkPaint* paint = op.vectorDrawable->getPaint();
 637     const BitmapRectOp* resolvedOp = mAllocator.create_trivial<BitmapRectOp>(op.unmappedBounds,
 638             op.localMatrix,
 639             op.localClip,
 640             paint,
 641             &bitmap,
 642             Rect(bitmap.width(), bitmap.height()));
 643     deferBitmapRectOp(*resolvedOp);
 644 }
 645
 646 void FrameBuilder::deferCirclePropsOp(const CirclePropsOp& op) {
 647     // allocate a temporary oval op (with mAllocator, so it persists until render), so the
 648     // renderer doesn't have to handle the RoundRectPropsOp type, and so state baking is simple.
 649     float x = *(op.x);
 650     float y = *(op.y);
 651     float radius = *(op.radius);
 652     Rect unmappedBounds(x - radius, y - radius, x + radius, y + radius);
 653     const OvalOp* resolvedOp = mAllocator.create_trivial<OvalOp>(
 654             unmappedBounds,
 655             op.localMatrix,
 656             op.localClip,
 657             op.paint);
 658     deferOvalOp(*resolvedOp);
 659 }
 660
 661 void FrameBuilder::deferColorOp(const ColorOp& op) {
 662     BakedOpState* bakedState = tryBakeUnboundedOpState(op);
 663     if (!bakedState) return; // quick rejected
 664     currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Vertices);
 665 }
 666
 667 void FrameBuilder::deferFunctorOp(const FunctorOp& op) {
 668     BakedOpState* bakedState = tryBakeUnboundedOpState(op);
 669     if (!bakedState) return; // quick rejected
 670     currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Functor);
 671 }
 672
 673 void FrameBuilder::deferLinesOp(const LinesOp& op) {
 674     batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices;
 675     deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced);
 676 }
 677
 678 void FrameBuilder::deferOvalOp(const OvalOp& op) {
 679     deferStrokeableOp(op, tessBatchId(op));
 680 }
 681
 682 void FrameBuilder::deferPatchOp(const PatchOp& op) {
 683     BakedOpState* bakedState = tryBakeOpState(op);
 684     if (!bakedState) return; // quick rejected
 685
 686     if (bakedState->computedState.transform.isPureTranslate()
 687             && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode
 688             && hasMergeableClip(*bakedState)) {
 689         mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.bitmap->getGenerationID());
 690         // TODO: AssetAtlas in mergeId
 691
 692         // Only use the MergedPatch batchId when merged, so Bitmap+Patch don't try to merge together
 693         currentLayer().deferMergeableOp(mAllocator, bakedState, OpBatchType::MergedPatch, mergeId);
 694     } else {
 695         // Use Bitmap batchId since Bitmap+Patch use same shader
 696         currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Bitmap);
 697     }
 698 }
 699
 700 void FrameBuilder::deferPathOp(const PathOp& op) {
 701     auto state = deferStrokeableOp(op, OpBatchType::AlphaMaskTexture);
 702     if (CC_LIKELY(state)) {
 703         mCaches.pathCache.precache(op.path, op.paint);
 704     }
 705 }
 706
 707 void FrameBuilder::deferPointsOp(const PointsOp& op) {
 708     batchid_t batch = op.paint->isAntiAlias() ? OpBatchType::AlphaVertices : OpBatchType::Vertices;
 709     deferStrokeableOp(op, batch, BakedOpState::StrokeBehavior::Forced);
 710 }
 711
 712 void FrameBuilder::deferRectOp(const RectOp& op) {
 713     deferStrokeableOp(op, tessBatchId(op));
 714 }
 715
 716 void FrameBuilder::deferRoundRectOp(const RoundRectOp& op) {
 717     auto state = deferStrokeableOp(op, tessBatchId(op));
 718     if (CC_LIKELY(state && !op.paint->getPathEffect())) {
 719         // TODO: consider storing tessellation task in BakedOpState
 720         mCaches.tessellationCache.precacheRoundRect(state->computedState.transform, *(op.paint),
 721                 op.unmappedBounds.getWidth(), op.unmappedBounds.getHeight(), op.rx, op.ry);
 722     }
 723 }
 724
 725 void FrameBuilder::deferRoundRectPropsOp(const RoundRectPropsOp& op) {
 726     // allocate a temporary round rect op (with mAllocator, so it persists until render), so the
 727     // renderer doesn't have to handle the RoundRectPropsOp type, and so state baking is simple.
 728     const RoundRectOp* resolvedOp = mAllocator.create_trivial<RoundRectOp>(
 729             Rect(*(op.left), *(op.top), *(op.right), *(op.bottom)),
 730             op.localMatrix,
 731             op.localClip,
 732             op.paint, *op.rx, *op.ry);
 733     deferRoundRectOp(*resolvedOp);
 734 }
 735
 736 void FrameBuilder::deferSimpleRectsOp(const SimpleRectsOp& op) {
 737     BakedOpState* bakedState = tryBakeOpState(op);
 738     if (!bakedState) return; // quick rejected
 739     currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::Vertices);
 740 }
 741
 742 static batchid_t textBatchId(const SkPaint& paint) {
 743     // TODO: better handling of shader (since we won't care about color then)
 744     return paint.getColor() == SK_ColorBLACK ? OpBatchType::Text : OpBatchType::ColorText;
 745 }
 746
 747 void FrameBuilder::deferTextOp(const TextOp& op) {
 748     BakedOpState* bakedState = BakedOpState::tryStrokeableOpConstruct(
 749             mAllocator, *mCanvasState.writableSnapshot(), op,
 750             BakedOpState::StrokeBehavior::StyleDefined);
 751     if (!bakedState) return; // quick rejected
 752
 753     batchid_t batchId = textBatchId(*(op.paint));
 754     if (bakedState->computedState.transform.isPureTranslate()
 755             && PaintUtils::getXfermodeDirect(op.paint) == SkXfermode::kSrcOver_Mode
 756             && hasMergeableClip(*bakedState)) {
 757         mergeid_t mergeId = reinterpret_cast<mergeid_t>(op.paint->getColor());
 758         currentLayer().deferMergeableOp(mAllocator, bakedState, batchId, mergeId);
 759     } else {
 760         currentLayer().deferUnmergeableOp(mAllocator, bakedState, batchId);
 761     }
 762
 763     FontRenderer& fontRenderer = mCaches.fontRenderer.getFontRenderer();
 764     auto& totalTransform = bakedState->computedState.transform;
 765     if (totalTransform.isPureTranslate() || totalTransform.isPerspective()) {
 766         fontRenderer.precache(op.paint, op.glyphs, op.glyphCount, SkMatrix::I());
 767     } else {
 768         // Partial transform case, see BakedOpDispatcher::renderTextOp
 769         float sx, sy;
 770         totalTransform.decomposeScale(sx, sy);
 771         fontRenderer.precache(op.paint, op.glyphs, op.glyphCount, SkMatrix::MakeScale(
 772                 roundf(std::max(1.0f, sx)),
 773                 roundf(std::max(1.0f, sy))));
 774     }
 775 }
 776
 777 void FrameBuilder::deferTextOnPathOp(const TextOnPathOp& op) {
 778     BakedOpState* bakedState = tryBakeUnboundedOpState(op);
 779     if (!bakedState) return; // quick rejected
 780     currentLayer().deferUnmergeableOp(mAllocator, bakedState, textBatchId(*(op.paint)));
 781
 782     mCaches.fontRenderer.getFontRenderer().precache(
 783             op.paint, op.glyphs, op.glyphCount, SkMatrix::I());
 784 }
 785
 786 void FrameBuilder::deferTextureLayerOp(const TextureLayerOp& op) {
 787     if (CC_UNLIKELY(!op.layer->isRenderable())) return;
 788
 789     const TextureLayerOp* textureLayerOp = &op;
 790     // Now safe to access transform (which was potentially unready at record time)
 791     if (!op.layer->getTransform().isIdentity()) {
 792         // non-identity transform present, so 'inject it' into op by copying + replacing matrix
 793         Matrix4 combinedMatrix(op.localMatrix);
 794         combinedMatrix.multiply(op.layer->getTransform());
 795         textureLayerOp = mAllocator.create<TextureLayerOp>(op, combinedMatrix);
 796     }
 797     BakedOpState* bakedState = tryBakeOpState(*textureLayerOp);
 798
 799     if (!bakedState) return; // quick rejected
 800     currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::TextureLayer);
 801 }
 802
 803 void FrameBuilder::saveForLayer(uint32_t layerWidth, uint32_t layerHeight,
 804         float contentTranslateX, float contentTranslateY,
 805         const Rect& repaintRect,
 806         const Vector3& lightCenter,
 807         const BeginLayerOp* beginLayerOp, RenderNode* renderNode) {
 808     mCanvasState.save(SaveFlags::MatrixClip);
 809     mCanvasState.writableSnapshot()->initializeViewport(layerWidth, layerHeight);
 810     mCanvasState.writableSnapshot()->roundRectClipState = nullptr;
 811     mCanvasState.writableSnapshot()->setRelativeLightCenter(lightCenter);
 812     mCanvasState.writableSnapshot()->transform->loadTranslate(
 813             contentTranslateX, contentTranslateY, 0);
 814     mCanvasState.writableSnapshot()->setClip(
 815             repaintRect.left, repaintRect.top, repaintRect.right, repaintRect.bottom);
 816
 817     // create a new layer repaint, and push its index on the stack
 818     mLayerStack.push_back(mLayerBuilders.size());
 819     auto newFbo = mAllocator.create<LayerBuilder>(layerWidth, layerHeight,
 820             repaintRect, beginLayerOp, renderNode);
 821     mLayerBuilders.push_back(newFbo);
 822 }
 823
 824 void FrameBuilder::restoreForLayer() {
 825     // restore canvas, and pop finished layer off of the stack
 826     mCanvasState.restore();
 827     mLayerStack.pop_back();
 828 }
 829
 830 // TODO: defer time rejection (when bounds become empty) + tests
 831 // Option - just skip layers with no bounds at playback + defer?
 832 void FrameBuilder::deferBeginLayerOp(const BeginLayerOp& op) {
 833     uint32_t layerWidth = (uint32_t) op.unmappedBounds.getWidth();
 834     uint32_t layerHeight = (uint32_t) op.unmappedBounds.getHeight();
 835
 836     auto previous = mCanvasState.currentSnapshot();
 837     Vector3 lightCenter = previous->getRelativeLightCenter();
 838
 839     // Combine all transforms used to present saveLayer content:
 840     // parent content transform * canvas transform * bounds offset
 841     Matrix4 contentTransform(*(previous->transform));
 842     contentTransform.multiply(op.localMatrix);
 843     contentTransform.translate(op.unmappedBounds.left, op.unmappedBounds.top);
 844
 845     Matrix4 inverseContentTransform;
 846     inverseContentTransform.loadInverse(contentTransform);
 847
 848     // map the light center into layer-relative space
 849     inverseContentTransform.mapPoint3d(lightCenter);
 850
 851     // Clip bounds of temporary layer to parent's clip rect, so:
 852     Rect saveLayerBounds(layerWidth, layerHeight);
 853     //     1) transform Rect(width, height) into parent's space
 854     //        note: left/top offsets put in contentTransform above
 855     contentTransform.mapRect(saveLayerBounds);
 856     //     2) intersect with parent's clip
 857     saveLayerBounds.doIntersect(previous->getRenderTargetClip());
 858     //     3) and transform back
 859     inverseContentTransform.mapRect(saveLayerBounds);
 860     saveLayerBounds.doIntersect(Rect(layerWidth, layerHeight));
 861     saveLayerBounds.roundOut();
 862
 863     // if bounds are reduced, will clip the layer's area by reducing required bounds...
 864     layerWidth = saveLayerBounds.getWidth();
 865     layerHeight = saveLayerBounds.getHeight();
 866     // ...and shifting drawing content to account for left/top side clipping
 867     float contentTranslateX = -saveLayerBounds.left;
 868     float contentTranslateY = -saveLayerBounds.top;
 869
 870     saveForLayer(layerWidth, layerHeight,
 871             contentTranslateX, contentTranslateY,
 872             Rect(layerWidth, layerHeight),
 873             lightCenter,
 874             &op, nullptr);
 875 }
 876
 877 void FrameBuilder::deferEndLayerOp(const EndLayerOp& /* ignored */) {
 878     const BeginLayerOp& beginLayerOp = *currentLayer().beginLayerOp;
 879     int finishedLayerIndex = mLayerStack.back();
 880
 881     restoreForLayer();
 882
 883     // saveLayer will clip & translate the draw contents, so we need
 884     // to translate the drawLayer by how much the contents was translated
 885     // TODO: Unify this with beginLayerOp so we don't have to calculate this
 886     // twice
 887     uint32_t layerWidth = (uint32_t) beginLayerOp.unmappedBounds.getWidth();
 888     uint32_t layerHeight = (uint32_t) beginLayerOp.unmappedBounds.getHeight();
 889
 890     auto previous = mCanvasState.currentSnapshot();
 891     Vector3 lightCenter = previous->getRelativeLightCenter();
 892
 893     // Combine all transforms used to present saveLayer content:
 894     // parent content transform * canvas transform * bounds offset
 895     Matrix4 contentTransform(*(previous->transform));
 896     contentTransform.multiply(beginLayerOp.localMatrix);
 897     contentTransform.translate(beginLayerOp.unmappedBounds.left,
 898             beginLayerOp.unmappedBounds.top);
 899
 900     Matrix4 inverseContentTransform;
 901     inverseContentTransform.loadInverse(contentTransform);
 902
 903     // map the light center into layer-relative space
 904     inverseContentTransform.mapPoint3d(lightCenter);
 905
 906     // Clip bounds of temporary layer to parent's clip rect, so:
 907     Rect saveLayerBounds(layerWidth, layerHeight);
 908     //     1) transform Rect(width, height) into parent's space
 909     //        note: left/top offsets put in contentTransform above
 910     contentTransform.mapRect(saveLayerBounds);
 911     //     2) intersect with parent's clip
 912     saveLayerBounds.doIntersect(previous->getRenderTargetClip());
 913     //     3) and transform back
 914     inverseContentTransform.mapRect(saveLayerBounds);
 915     saveLayerBounds.doIntersect(Rect(layerWidth, layerHeight));
 916     saveLayerBounds.roundOut();
 917
 918     Matrix4 localMatrix(beginLayerOp.localMatrix);
 919     localMatrix.translate(saveLayerBounds.left, saveLayerBounds.top);
 920
 921     // record the draw operation into the previous layer's list of draw commands
 922     // uses state from the associated beginLayerOp, since it has all the state needed for drawing
 923     LayerOp* drawLayerOp = mAllocator.create_trivial<LayerOp>(
 924             beginLayerOp.unmappedBounds,
 925             localMatrix,
 926             beginLayerOp.localClip,
 927             beginLayerOp.paint,
 928             &(mLayerBuilders[finishedLayerIndex]->offscreenBuffer));
 929     BakedOpState* bakedOpState = tryBakeOpState(*drawLayerOp);
 930
 931     if (bakedOpState) {
 932         // Layer will be drawn into parent layer (which is now current, since we popped mLayerStack)
 933         currentLayer().deferUnmergeableOp(mAllocator, bakedOpState, OpBatchType::Bitmap);
 934     } else {
 935         // Layer won't be drawn - delete its drawing batches to prevent it from doing any work
 936         // TODO: need to prevent any render work from being done
 937         // - create layerop earlier for reject purposes?
 938         mLayerBuilders[finishedLayerIndex]->clear();
 939         return;
 940     }
 941 }
 942
 943 void FrameBuilder::deferBeginUnclippedLayerOp(const BeginUnclippedLayerOp& op) {
 944     Matrix4 boundsTransform(*(mCanvasState.currentSnapshot()->transform));
 945     boundsTransform.multiply(op.localMatrix);
 946
 947     Rect dstRect(op.unmappedBounds);
 948     boundsTransform.mapRect(dstRect);
 949     dstRect.roundOut();
 950     dstRect.doIntersect(mCanvasState.currentSnapshot()->getRenderTargetClip());
 951
 952     if (dstRect.isEmpty()) {
 953         // Unclipped layer rejected - push a null op, so next EndUnclippedLayerOp is ignored
 954         currentLayer().activeUnclippedSaveLayers.push_back(nullptr);
 955     } else {
 956         // Allocate a holding position for the layer object (copyTo will produce, copyFrom will consume)
 957         OffscreenBuffer** layerHandle = mAllocator.create<OffscreenBuffer*>(nullptr);
 958
 959         /**
 960          * First, defer an operation to copy out the content from the rendertarget into a layer.
 961          */
 962         auto copyToOp = mAllocator.create_trivial<CopyToLayerOp>(op, layerHandle);
 963         BakedOpState* bakedState = BakedOpState::directConstruct(mAllocator,
 964                 &(currentLayer().repaintClip), dstRect, *copyToOp);
 965         currentLayer().deferUnmergeableOp(mAllocator, bakedState, OpBatchType::CopyToLayer);
 966
 967         /**
 968          * Defer a clear rect, so that clears from multiple unclipped layers can be drawn
 969          * both 1) simultaneously, and 2) as long after the copyToLayer executes as possible
 970          */
 971         currentLayer().deferLayerClear(dstRect);
 972
 973         /**
 974          * And stash an operation to copy that layer back under the rendertarget until
 975          * a balanced EndUnclippedLayerOp is seen
 976          */
 977         auto copyFromOp = mAllocator.create_trivial<CopyFromLayerOp>(op, layerHandle);
 978         bakedState = BakedOpState::directConstruct(mAllocator,
 979                 &(currentLayer().repaintClip), dstRect, *copyFromOp);
 980         currentLayer().activeUnclippedSaveLayers.push_back(bakedState);
 981     }
 982 }
 983
 984 void FrameBuilder::deferEndUnclippedLayerOp(const EndUnclippedLayerOp& /* ignored */) {
 985     LOG_ALWAYS_FATAL_IF(currentLayer().activeUnclippedSaveLayers.empty(), "no layer to end!");
 986
 987     BakedOpState* copyFromLayerOp = currentLayer().activeUnclippedSaveLayers.back();
 988     currentLayer().activeUnclippedSaveLayers.pop_back();
 989     if (copyFromLayerOp) {
 990         currentLayer().deferUnmergeableOp(mAllocator, copyFromLayerOp, OpBatchType::CopyFromLayer);
 991     }
 992 }
 993
 994 void FrameBuilder::finishDefer() {
 995     mCaches.fontRenderer.endPrecaching();
 996 }
 997
 998 } // namespace uirenderer
 999 } // namespace android