RecordingCanvas.cpp revision 339fc0a1d213fed1201443838a9536651ad2ca3b 
1/*
2 * Copyright (C) 2015 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 "RecordingCanvas.h"
18
19#include "DeferredLayerUpdater.h"
20#include "RecordedOp.h"
21#include "RenderNode.h"
22#include "VectorDrawable.h"
23
24namespace android {
25namespace uirenderer {
26
27RecordingCanvas::RecordingCanvas(size_t width, size_t height)
28        : mState(*this)
29        , mResourceCache(ResourceCache::getInstance()) {
30    resetRecording(width, height);
31}
32
33RecordingCanvas::~RecordingCanvas() {
34    LOG_ALWAYS_FATAL_IF(mDisplayList,
35            "Destroyed a RecordingCanvas during a record!");
36}
37
38void RecordingCanvas::resetRecording(int width, int height) {
39    LOG_ALWAYS_FATAL_IF(mDisplayList,
40            "prepareDirty called a second time during a recording!");
41    mDisplayList = new DisplayList();
42
43    mState.initializeRecordingSaveStack(width, height);
44
45    mDeferredBarrierType = DeferredBarrierType::InOrder;
46    mState.setDirtyClip(false);
47}
48
49DisplayList* RecordingCanvas::finishRecording() {
50    restoreToCount(1);
51    mPaintMap.clear();
52    mRegionMap.clear();
53    mPathMap.clear();
54    DisplayList* displayList = mDisplayList;
55    mDisplayList = nullptr;
56    mSkiaCanvasProxy.reset(nullptr);
57    return displayList;
58}
59
60SkCanvas* RecordingCanvas::asSkCanvas() {
61    LOG_ALWAYS_FATAL_IF(!mDisplayList,
62            "attempting to get an SkCanvas when we are not recording!");
63    if (!mSkiaCanvasProxy) {
64        mSkiaCanvasProxy.reset(new SkiaCanvasProxy(this));
65    }
66
67    // SkCanvas instances default to identity transform, but should inherit
68    // the state of this Canvas; if this code was in the SkiaCanvasProxy
69    // constructor, we couldn't cache mSkiaCanvasProxy.
70    SkMatrix parentTransform;
71    getMatrix(&parentTransform);
72    mSkiaCanvasProxy.get()->setMatrix(parentTransform);
73
74    return mSkiaCanvasProxy.get();
75}
76
77// ----------------------------------------------------------------------------
78// CanvasStateClient implementation
79// ----------------------------------------------------------------------------
80
81void RecordingCanvas::onViewportInitialized() {
82}
83
84void RecordingCanvas::onSnapshotRestored(const Snapshot& removed, const Snapshot& restored) {
85    if (removed.flags & Snapshot::kFlagIsFboLayer) {
86        addOp(alloc().create_trivial<EndLayerOp>());
87    } else if (removed.flags & Snapshot::kFlagIsLayer) {
88        addOp(alloc().create_trivial<EndUnclippedLayerOp>());
89    }
90}
91
92// ----------------------------------------------------------------------------
93// android/graphics/Canvas state operations
94// ----------------------------------------------------------------------------
95// Save (layer)
96int RecordingCanvas::save(SaveFlags::Flags flags) {
97    return mState.save((int) flags);
98}
99
100void RecordingCanvas::RecordingCanvas::restore() {
101    mState.restore();
102}
103
104void RecordingCanvas::restoreToCount(int saveCount) {
105    mState.restoreToCount(saveCount);
106}
107
108int RecordingCanvas::saveLayer(float left, float top, float right, float bottom,
109        const SkPaint* paint, SaveFlags::Flags flags) {
110    // force matrix/clip isolation for layer
111    flags |= SaveFlags::MatrixClip;
112    bool clippedLayer = flags & SaveFlags::ClipToLayer;
113
114    const Snapshot& previous = *mState.currentSnapshot();
115
116    // initialize the snapshot as though it almost represents an FBO layer so deferred draw
117    // operations will be able to store and restore the current clip and transform info, and
118    // quick rejection will be correct (for display lists)
119
120    const Rect unmappedBounds(left, top, right, bottom);
121
122    // determine clipped bounds relative to previous viewport.
123    Rect visibleBounds = unmappedBounds;
124    previous.transform->mapRect(visibleBounds);
125
126    if (CC_UNLIKELY(!clippedLayer
127            && previous.transform->rectToRect()
128            && visibleBounds.contains(previous.getRenderTargetClip()))) {
129        // unlikely case where an unclipped savelayer is recorded with a clip it can use,
130        // as none of its unaffected/unclipped area is visible
131        clippedLayer = true;
132        flags |= SaveFlags::ClipToLayer;
133    }
134
135    visibleBounds.doIntersect(previous.getRenderTargetClip());
136    visibleBounds.snapToPixelBoundaries();
137    visibleBounds.doIntersect(Rect(previous.getViewportWidth(), previous.getViewportHeight()));
138
139    // Map visible bounds back to layer space, and intersect with parameter bounds
140    Rect layerBounds = visibleBounds;
141    Matrix4 inverse;
142    inverse.loadInverse(*previous.transform);
143    inverse.mapRect(layerBounds);
144    layerBounds.doIntersect(unmappedBounds);
145
146    int saveValue = mState.save((int) flags);
147    Snapshot& snapshot = *mState.writableSnapshot();
148
149    // layerBounds is in original bounds space, but clipped by current recording clip
150    if (layerBounds.isEmpty() || unmappedBounds.isEmpty()) {
151        // Don't bother recording layer, since it's been rejected
152        if (CC_LIKELY(clippedLayer)) {
153            snapshot.resetClip(0, 0, 0, 0);
154        }
155        return saveValue;
156    }
157
158    if (CC_LIKELY(clippedLayer)) {
159        auto previousClip = getRecordedClip(); // note: done before new snapshot's clip has changed
160
161        snapshot.flags |= Snapshot::kFlagIsLayer | Snapshot::kFlagIsFboLayer;
162        snapshot.initializeViewport(unmappedBounds.getWidth(), unmappedBounds.getHeight());
163        snapshot.transform->loadTranslate(-unmappedBounds.left, -unmappedBounds.top, 0.0f);
164
165        Rect clip = layerBounds;
166        clip.translate(-unmappedBounds.left, -unmappedBounds.top);
167        snapshot.resetClip(clip.left, clip.top, clip.right, clip.bottom);
168        snapshot.roundRectClipState = nullptr;
169
170        addOp(alloc().create_trivial<BeginLayerOp>(
171                unmappedBounds,
172                *previous.transform, // transform to *draw* with
173                previousClip, // clip to *draw* with
174                refPaint(paint)));
175    } else {
176        snapshot.flags |= Snapshot::kFlagIsLayer;
177
178        addOp(alloc().create_trivial<BeginUnclippedLayerOp>(
179                unmappedBounds,
180                *mState.currentSnapshot()->transform,
181                getRecordedClip(),
182                refPaint(paint)));
183    }
184
185    return saveValue;
186}
187
188// Matrix
189void RecordingCanvas::rotate(float degrees) {
190    if (degrees == 0) return;
191
192    mState.rotate(degrees);
193}
194
195void RecordingCanvas::scale(float sx, float sy) {
196    if (sx == 1 && sy == 1) return;
197
198    mState.scale(sx, sy);
199}
200
201void RecordingCanvas::skew(float sx, float sy) {
202    mState.skew(sx, sy);
203}
204
205void RecordingCanvas::translate(float dx, float dy) {
206    if (dx == 0 && dy == 0) return;
207
208    mState.translate(dx, dy, 0);
209}
210
211// Clip
212bool RecordingCanvas::getClipBounds(SkRect* outRect) const {
213    *outRect = mState.getLocalClipBounds().toSkRect();
214    return !(outRect->isEmpty());
215}
216bool RecordingCanvas::quickRejectRect(float left, float top, float right, float bottom) const {
217    return mState.quickRejectConservative(left, top, right, bottom);
218}
219bool RecordingCanvas::quickRejectPath(const SkPath& path) const {
220    SkRect bounds = path.getBounds();
221    return mState.quickRejectConservative(bounds.fLeft, bounds.fTop, bounds.fRight, bounds.fBottom);
222}
223bool RecordingCanvas::clipRect(float left, float top, float right, float bottom, SkRegion::Op op) {
224    return mState.clipRect(left, top, right, bottom, op);
225}
226bool RecordingCanvas::clipPath(const SkPath* path, SkRegion::Op op) {
227    return mState.clipPath(path, op);
228}
229bool RecordingCanvas::clipRegion(const SkRegion* region, SkRegion::Op op) {
230    return mState.clipRegion(region, op);
231}
232
233// ----------------------------------------------------------------------------
234// android/graphics/Canvas draw operations
235// ----------------------------------------------------------------------------
236void RecordingCanvas::drawColor(int color, SkXfermode::Mode mode) {
237    SkPaint paint;
238    paint.setColor(color);
239    paint.setXfermodeMode(mode);
240    drawPaint(paint);
241}
242
243void RecordingCanvas::drawPaint(const SkPaint& paint) {
244    addOp(alloc().create_trivial<RectOp>(
245            mState.getRenderTargetClipBounds(), // OK, since we've not passed transform
246            Matrix4::identity(),
247            getRecordedClip(),
248            refPaint(&paint)));
249}
250
251static Rect calcBoundsOfPoints(const float* points, int floatCount) {
252    Rect unmappedBounds(points[0], points[1], points[0], points[1]);
253    for (int i = 2; i < floatCount; i += 2) {
254        unmappedBounds.expandToCover(points[i], points[i + 1]);
255    }
256    return unmappedBounds;
257}
258
259// Geometry
260void RecordingCanvas::drawPoints(const float* points, int floatCount, const SkPaint& paint) {
261    if (floatCount < 2) return;
262    floatCount &= ~0x1; // round down to nearest two
263
264    addOp(alloc().create_trivial<PointsOp>(
265            calcBoundsOfPoints(points, floatCount),
266            *mState.currentSnapshot()->transform,
267            getRecordedClip(),
268            refPaint(&paint), refBuffer<float>(points, floatCount), floatCount));
269}
270
271void RecordingCanvas::drawLines(const float* points, int floatCount, const SkPaint& paint) {
272    if (floatCount < 4) return;
273    floatCount &= ~0x3; // round down to nearest four
274
275    addOp(alloc().create_trivial<LinesOp>(
276            calcBoundsOfPoints(points, floatCount),
277            *mState.currentSnapshot()->transform,
278            getRecordedClip(),
279            refPaint(&paint), refBuffer<float>(points, floatCount), floatCount));
280}
281
282void RecordingCanvas::drawRect(float left, float top, float right, float bottom, const SkPaint& paint) {
283    addOp(alloc().create_trivial<RectOp>(
284            Rect(left, top, right, bottom),
285            *(mState.currentSnapshot()->transform),
286            getRecordedClip(),
287            refPaint(&paint)));
288}
289
290void RecordingCanvas::drawSimpleRects(const float* rects, int vertexCount, const SkPaint* paint) {
291    if (rects == nullptr) return;
292
293    Vertex* rectData = (Vertex*) mDisplayList->allocator.create_trivial_array<Vertex>(vertexCount);
294    Vertex* vertex = rectData;
295
296    float left = FLT_MAX;
297    float top = FLT_MAX;
298    float right = FLT_MIN;
299    float bottom = FLT_MIN;
300    for (int index = 0; index < vertexCount; index += 4) {
301        float l = rects[index + 0];
302        float t = rects[index + 1];
303        float r = rects[index + 2];
304        float b = rects[index + 3];
305
306        Vertex::set(vertex++, l, t);
307        Vertex::set(vertex++, r, t);
308        Vertex::set(vertex++, l, b);
309        Vertex::set(vertex++, r, b);
310
311        left = std::min(left, l);
312        top = std::min(top, t);
313        right = std::max(right, r);
314        bottom = std::max(bottom, b);
315    }
316    addOp(alloc().create_trivial<SimpleRectsOp>(
317            Rect(left, top, right, bottom),
318            *(mState.currentSnapshot()->transform),
319            getRecordedClip(),
320            refPaint(paint), rectData, vertexCount));
321}
322
323void RecordingCanvas::drawRegion(const SkRegion& region, const SkPaint& paint) {
324    if (paint.getStyle() == SkPaint::kFill_Style
325            && (!paint.isAntiAlias() || mState.currentTransform()->isSimple())) {
326        int count = 0;
327        Vector<float> rects;
328        SkRegion::Iterator it(region);
329        while (!it.done()) {
330            const SkIRect& r = it.rect();
331            rects.push(r.fLeft);
332            rects.push(r.fTop);
333            rects.push(r.fRight);
334            rects.push(r.fBottom);
335            count += 4;
336            it.next();
337        }
338        drawSimpleRects(rects.array(), count, &paint);
339    } else {
340        SkRegion::Iterator it(region);
341        while (!it.done()) {
342            const SkIRect& r = it.rect();
343            drawRect(r.fLeft, r.fTop, r.fRight, r.fBottom, paint);
344            it.next();
345        }
346    }
347}
348void RecordingCanvas::drawRoundRect(float left, float top, float right, float bottom,
349            float rx, float ry, const SkPaint& paint) {
350    addOp(alloc().create_trivial<RoundRectOp>(
351            Rect(left, top, right, bottom),
352            *(mState.currentSnapshot()->transform),
353            getRecordedClip(),
354            refPaint(&paint), rx, ry));
355}
356
357void RecordingCanvas::drawRoundRect(
358        CanvasPropertyPrimitive* left, CanvasPropertyPrimitive* top,
359        CanvasPropertyPrimitive* right, CanvasPropertyPrimitive* bottom,
360        CanvasPropertyPrimitive* rx, CanvasPropertyPrimitive* ry,
361        CanvasPropertyPaint* paint) {
362    mDisplayList->ref(left);
363    mDisplayList->ref(top);
364    mDisplayList->ref(right);
365    mDisplayList->ref(bottom);
366    mDisplayList->ref(rx);
367    mDisplayList->ref(ry);
368    mDisplayList->ref(paint);
369    refBitmapsInShader(paint->value.getShader());
370    addOp(alloc().create_trivial<RoundRectPropsOp>(
371            *(mState.currentSnapshot()->transform),
372            getRecordedClip(),
373            &paint->value,
374            &left->value, &top->value, &right->value, &bottom->value,
375            &rx->value, &ry->value));
376}
377
378void RecordingCanvas::drawCircle(float x, float y, float radius, const SkPaint& paint) {
379    // TODO: move to Canvas.h
380    if (radius <= 0) return;
381    drawOval(x - radius, y - radius, x + radius, y + radius, paint);
382}
383
384void RecordingCanvas::drawCircle(
385        CanvasPropertyPrimitive* x, CanvasPropertyPrimitive* y,
386        CanvasPropertyPrimitive* radius, CanvasPropertyPaint* paint) {
387    mDisplayList->ref(x);
388    mDisplayList->ref(y);
389    mDisplayList->ref(radius);
390    mDisplayList->ref(paint);
391    refBitmapsInShader(paint->value.getShader());
392    addOp(alloc().create_trivial<CirclePropsOp>(
393            *(mState.currentSnapshot()->transform),
394            getRecordedClip(),
395            &paint->value,
396            &x->value, &y->value, &radius->value));
397}
398
399void RecordingCanvas::drawOval(float left, float top, float right, float bottom, const SkPaint& paint) {
400    addOp(alloc().create_trivial<OvalOp>(
401            Rect(left, top, right, bottom),
402            *(mState.currentSnapshot()->transform),
403            getRecordedClip(),
404            refPaint(&paint)));
405}
406
407void RecordingCanvas::drawArc(float left, float top, float right, float bottom,
408        float startAngle, float sweepAngle, bool useCenter, const SkPaint& paint) {
409    if (fabs(sweepAngle) >= 360.0f) {
410        drawOval(left, top, right, bottom, paint);
411    } else {
412        addOp(alloc().create_trivial<ArcOp>(
413                Rect(left, top, right, bottom),
414                *(mState.currentSnapshot()->transform),
415                getRecordedClip(),
416                refPaint(&paint),
417                startAngle, sweepAngle, useCenter));
418    }
419}
420
421void RecordingCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
422    addOp(alloc().create_trivial<PathOp>(
423            Rect(path.getBounds()),
424            *(mState.currentSnapshot()->transform),
425            getRecordedClip(),
426            refPaint(&paint), refPath(&path)));
427}
428
429void RecordingCanvas::drawVectorDrawable(VectorDrawableRoot* tree) {
430    mDisplayList->ref(tree);
431    addOp(alloc().create_trivial<VectorDrawableOp>(
432            tree,
433            Rect(tree->getBounds()),
434            *(mState.currentSnapshot()->transform),
435            getRecordedClip()));
436}
437
438// Bitmap-based
439void RecordingCanvas::drawBitmap(const SkBitmap& bitmap, float left, float top, const SkPaint* paint) {
440    save(SaveFlags::Matrix);
441    translate(left, top);
442    drawBitmap(&bitmap, paint);
443    restore();
444}
445
446void RecordingCanvas::drawBitmap(const SkBitmap& bitmap, const SkMatrix& matrix,
447                            const SkPaint* paint) {
448    if (matrix.isIdentity()) {
449        drawBitmap(&bitmap, paint);
450    } else if (!(matrix.getType() & ~(SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask))
451            && MathUtils::isPositive(matrix.getScaleX())
452            && MathUtils::isPositive(matrix.getScaleY())) {
453        // SkMatrix::isScaleTranslate() not available in L
454        SkRect src;
455        SkRect dst;
456        bitmap.getBounds(&src);
457        matrix.mapRect(&dst, src);
458        drawBitmap(bitmap, src.fLeft, src.fTop, src.fRight, src.fBottom,
459                   dst.fLeft, dst.fTop, dst.fRight, dst.fBottom, paint);
460    } else {
461        save(SaveFlags::Matrix);
462        concat(matrix);
463        drawBitmap(&bitmap, paint);
464        restore();
465    }
466}
467
468void RecordingCanvas::drawBitmap(const SkBitmap& bitmap, float srcLeft, float srcTop,
469            float srcRight, float srcBottom, float dstLeft, float dstTop,
470            float dstRight, float dstBottom, const SkPaint* paint) {
471    if (srcLeft == 0 && srcTop == 0
472            && srcRight == bitmap.width()
473            && srcBottom == bitmap.height()
474            && (srcBottom - srcTop == dstBottom - dstTop)
475            && (srcRight - srcLeft == dstRight - dstLeft)) {
476        // transform simple rect to rect drawing case into position bitmap ops, since they merge
477        save(SaveFlags::Matrix);
478        translate(dstLeft, dstTop);
479        drawBitmap(&bitmap, paint);
480        restore();
481    } else {
482        addOp(alloc().create_trivial<BitmapRectOp>(
483                Rect(dstLeft, dstTop, dstRight, dstBottom),
484                *(mState.currentSnapshot()->transform),
485                getRecordedClip(),
486                refPaint(paint), refBitmap(bitmap),
487                Rect(srcLeft, srcTop, srcRight, srcBottom)));
488    }
489}
490
491void RecordingCanvas::drawBitmapMesh(const SkBitmap& bitmap, int meshWidth, int meshHeight,
492            const float* vertices, const int* colors, const SkPaint* paint) {
493    int vertexCount = (meshWidth + 1) * (meshHeight + 1);
494    addOp(alloc().create_trivial<BitmapMeshOp>(
495            calcBoundsOfPoints(vertices, vertexCount * 2),
496            *(mState.currentSnapshot()->transform),
497            getRecordedClip(),
498            refPaint(paint), refBitmap(bitmap), meshWidth, meshHeight,
499            refBuffer<float>(vertices, vertexCount * 2), // 2 floats per vertex
500            refBuffer<int>(colors, vertexCount))); // 1 color per vertex
501}
502
503void RecordingCanvas::drawNinePatch(const SkBitmap& bitmap, const android::Res_png_9patch& patch,
504            float dstLeft, float dstTop, float dstRight, float dstBottom,
505            const SkPaint* paint) {
506    addOp(alloc().create_trivial<PatchOp>(
507            Rect(dstLeft, dstTop, dstRight, dstBottom),
508            *(mState.currentSnapshot()->transform),
509            getRecordedClip(),
510            refPaint(paint), refBitmap(bitmap), refPatch(&patch)));
511}
512
513// Text
514void RecordingCanvas::drawText(const uint16_t* glyphs, const float* positions, int glyphCount,
515            const SkPaint& paint, float x, float y, float boundsLeft, float boundsTop,
516            float boundsRight, float boundsBottom, float totalAdvance) {
517    if (!glyphs || !positions || glyphCount <= 0 || PaintUtils::paintWillNotDrawText(paint)) return;
518    glyphs = refBuffer<glyph_t>(glyphs, glyphCount);
519    positions = refBuffer<float>(positions, glyphCount * 2);
520
521    // TODO: either must account for text shadow in bounds, or record separate ops for text shadows
522    addOp(alloc().create_trivial<TextOp>(
523            Rect(boundsLeft, boundsTop, boundsRight, boundsBottom),
524            *(mState.currentSnapshot()->transform),
525            getRecordedClip(),
526            refPaint(&paint), glyphs, positions, glyphCount, x, y));
527    drawTextDecorations(x, y, totalAdvance, paint);
528}
529
530void RecordingCanvas::drawTextOnPath(const uint16_t* glyphs, int glyphCount, const SkPath& path,
531            float hOffset, float vOffset, const SkPaint& paint) {
532    if (!glyphs || glyphCount <= 0 || PaintUtils::paintWillNotDrawText(paint)) return;
533    glyphs = refBuffer<glyph_t>(glyphs, glyphCount);
534    addOp(alloc().create_trivial<TextOnPathOp>(
535            mState.getLocalClipBounds(), // TODO: explicitly define bounds
536            *(mState.currentSnapshot()->transform),
537            getRecordedClip(),
538            refPaint(&paint), glyphs, glyphCount, refPath(&path), hOffset, vOffset));
539}
540
541void RecordingCanvas::drawBitmap(const SkBitmap* bitmap, const SkPaint* paint) {
542    addOp(alloc().create_trivial<BitmapOp>(
543            Rect(bitmap->width(), bitmap->height()),
544            *(mState.currentSnapshot()->transform),
545            getRecordedClip(),
546            refPaint(paint), refBitmap(*bitmap)));
547}
548
549void RecordingCanvas::drawRenderNode(RenderNode* renderNode) {
550    auto&& stagingProps = renderNode->stagingProperties();
551    RenderNodeOp* op = alloc().create_trivial<RenderNodeOp>(
552            Rect(stagingProps.getWidth(), stagingProps.getHeight()),
553            *(mState.currentSnapshot()->transform),
554            getRecordedClip(),
555            renderNode);
556    int opIndex = addOp(op);
557    int childIndex = mDisplayList->addChild(op);
558
559    // update the chunk's child indices
560    DisplayList::Chunk& chunk = mDisplayList->chunks.back();
561    chunk.endChildIndex = childIndex + 1;
562
563    if (renderNode->stagingProperties().isProjectionReceiver()) {
564        // use staging property, since recording on UI thread
565        mDisplayList->projectionReceiveIndex = opIndex;
566    }
567}
568
569void RecordingCanvas::drawLayer(DeferredLayerUpdater* layerHandle) {
570    // We ref the DeferredLayerUpdater due to its thread-safe ref-counting semantics.
571    mDisplayList->ref(layerHandle);
572
573    Layer* layer = layerHandle->backingLayer();
574    Matrix4 totalTransform(*(mState.currentSnapshot()->transform));
575    totalTransform.multiply(layer->getTransform());
576
577    addOp(alloc().create_trivial<TextureLayerOp>(
578            Rect(layer->getWidth(), layer->getHeight()),
579            totalTransform,
580            getRecordedClip(),
581            layer));
582}
583
584void RecordingCanvas::callDrawGLFunction(Functor* functor) {
585    mDisplayList->functors.push_back(functor);
586    addOp(alloc().create_trivial<FunctorOp>(
587            mState.getLocalClipBounds(), // TODO: explicitly define bounds
588            *(mState.currentSnapshot()->transform),
589            getRecordedClip(),
590            functor));
591}
592
593size_t RecordingCanvas::addOp(RecordedOp* op) {
594    // TODO: validate if "addDrawOp" quickrejection logic is useful before adding
595    int insertIndex = mDisplayList->ops.size();
596    mDisplayList->ops.push_back(op);
597    if (mDeferredBarrierType != DeferredBarrierType::None) {
598        // op is first in new chunk
599        mDisplayList->chunks.emplace_back();
600        DisplayList::Chunk& newChunk = mDisplayList->chunks.back();
601        newChunk.beginOpIndex = insertIndex;
602        newChunk.endOpIndex = insertIndex + 1;
603        newChunk.reorderChildren = (mDeferredBarrierType == DeferredBarrierType::OutOfOrder);
604
605        int nextChildIndex = mDisplayList->children.size();
606        newChunk.beginChildIndex = newChunk.endChildIndex = nextChildIndex;
607        mDeferredBarrierType = DeferredBarrierType::None;
608    } else {
609        // standard case - append to existing chunk
610        mDisplayList->chunks.back().endOpIndex = insertIndex + 1;
611    }
612    return insertIndex;
613}
614
615void RecordingCanvas::refBitmapsInShader(const SkShader* shader) {
616    if (!shader) return;
617
618    // If this paint has an SkShader that has an SkBitmap add
619    // it to the bitmap pile
620    SkBitmap bitmap;
621    SkShader::TileMode xy[2];
622    if (shader->isABitmap(&bitmap, nullptr, xy)) {
623        refBitmap(bitmap);
624        return;
625    }
626    SkShader::ComposeRec rec;
627    if (shader->asACompose(&rec)) {
628        refBitmapsInShader(rec.fShaderA);
629        refBitmapsInShader(rec.fShaderB);
630        return;
631    }
632}
633
634}; // namespace uirenderer
635}; // namespace android
636