RecordingCanvas.cpp revision 261725fdb2962271c222a049fcdf57bbdc8363c7 
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    const ClipBase* clip = getRecordedClip();
245    // if there's no current clip, draw a big rect and hope we cover the eventual clip bounds
246    Rect bounds = clip ? clip->rect : Rect(-10000, -10000, 10000, 10000);
247    addOp(alloc().create_trivial<RectOp>(
248            bounds,
249            Matrix4::identity(),
250            clip,
251            refPaint(&paint)));
252}
253
254static Rect calcBoundsOfPoints(const float* points, int floatCount) {
255    Rect unmappedBounds(points[0], points[1], points[0], points[1]);
256    for (int i = 2; i < floatCount; i += 2) {
257        unmappedBounds.expandToCover(points[i], points[i + 1]);
258    }
259    return unmappedBounds;
260}
261
262// Geometry
263void RecordingCanvas::drawPoints(const float* points, int floatCount, const SkPaint& paint) {
264    if (floatCount < 2) return;
265    floatCount &= ~0x1; // round down to nearest two
266
267    addOp(alloc().create_trivial<PointsOp>(
268            calcBoundsOfPoints(points, floatCount),
269            *mState.currentSnapshot()->transform,
270            getRecordedClip(),
271            refPaint(&paint), refBuffer<float>(points, floatCount), floatCount));
272}
273
274void RecordingCanvas::drawLines(const float* points, int floatCount, const SkPaint& paint) {
275    if (floatCount < 4) return;
276    floatCount &= ~0x3; // round down to nearest four
277
278    addOp(alloc().create_trivial<LinesOp>(
279            calcBoundsOfPoints(points, floatCount),
280            *mState.currentSnapshot()->transform,
281            getRecordedClip(),
282            refPaint(&paint), refBuffer<float>(points, floatCount), floatCount));
283}
284
285void RecordingCanvas::drawRect(float left, float top, float right, float bottom, const SkPaint& paint) {
286    addOp(alloc().create_trivial<RectOp>(
287            Rect(left, top, right, bottom),
288            *(mState.currentSnapshot()->transform),
289            getRecordedClip(),
290            refPaint(&paint)));
291}
292
293void RecordingCanvas::drawSimpleRects(const float* rects, int vertexCount, const SkPaint* paint) {
294    if (rects == nullptr) return;
295
296    Vertex* rectData = (Vertex*) mDisplayList->allocator.create_trivial_array<Vertex>(vertexCount);
297    Vertex* vertex = rectData;
298
299    float left = FLT_MAX;
300    float top = FLT_MAX;
301    float right = FLT_MIN;
302    float bottom = FLT_MIN;
303    for (int index = 0; index < vertexCount; index += 4) {
304        float l = rects[index + 0];
305        float t = rects[index + 1];
306        float r = rects[index + 2];
307        float b = rects[index + 3];
308
309        Vertex::set(vertex++, l, t);
310        Vertex::set(vertex++, r, t);
311        Vertex::set(vertex++, l, b);
312        Vertex::set(vertex++, r, b);
313
314        left = std::min(left, l);
315        top = std::min(top, t);
316        right = std::max(right, r);
317        bottom = std::max(bottom, b);
318    }
319    addOp(alloc().create_trivial<SimpleRectsOp>(
320            Rect(left, top, right, bottom),
321            *(mState.currentSnapshot()->transform),
322            getRecordedClip(),
323            refPaint(paint), rectData, vertexCount));
324}
325
326void RecordingCanvas::drawRegion(const SkRegion& region, const SkPaint& paint) {
327    if (paint.getStyle() == SkPaint::kFill_Style
328            && (!paint.isAntiAlias() || mState.currentTransform()->isSimple())) {
329        int count = 0;
330        Vector<float> rects;
331        SkRegion::Iterator it(region);
332        while (!it.done()) {
333            const SkIRect& r = it.rect();
334            rects.push(r.fLeft);
335            rects.push(r.fTop);
336            rects.push(r.fRight);
337            rects.push(r.fBottom);
338            count += 4;
339            it.next();
340        }
341        drawSimpleRects(rects.array(), count, &paint);
342    } else {
343        SkRegion::Iterator it(region);
344        while (!it.done()) {
345            const SkIRect& r = it.rect();
346            drawRect(r.fLeft, r.fTop, r.fRight, r.fBottom, paint);
347            it.next();
348        }
349    }
350}
351void RecordingCanvas::drawRoundRect(float left, float top, float right, float bottom,
352            float rx, float ry, const SkPaint& paint) {
353    addOp(alloc().create_trivial<RoundRectOp>(
354            Rect(left, top, right, bottom),
355            *(mState.currentSnapshot()->transform),
356            getRecordedClip(),
357            refPaint(&paint), rx, ry));
358}
359
360void RecordingCanvas::drawRoundRect(
361        CanvasPropertyPrimitive* left, CanvasPropertyPrimitive* top,
362        CanvasPropertyPrimitive* right, CanvasPropertyPrimitive* bottom,
363        CanvasPropertyPrimitive* rx, CanvasPropertyPrimitive* ry,
364        CanvasPropertyPaint* paint) {
365    mDisplayList->ref(left);
366    mDisplayList->ref(top);
367    mDisplayList->ref(right);
368    mDisplayList->ref(bottom);
369    mDisplayList->ref(rx);
370    mDisplayList->ref(ry);
371    mDisplayList->ref(paint);
372    refBitmapsInShader(paint->value.getShader());
373    addOp(alloc().create_trivial<RoundRectPropsOp>(
374            *(mState.currentSnapshot()->transform),
375            getRecordedClip(),
376            &paint->value,
377            &left->value, &top->value, &right->value, &bottom->value,
378            &rx->value, &ry->value));
379}
380
381void RecordingCanvas::drawCircle(float x, float y, float radius, const SkPaint& paint) {
382    // TODO: move to Canvas.h
383    if (radius <= 0) return;
384    drawOval(x - radius, y - radius, x + radius, y + radius, paint);
385}
386
387void RecordingCanvas::drawCircle(
388        CanvasPropertyPrimitive* x, CanvasPropertyPrimitive* y,
389        CanvasPropertyPrimitive* radius, CanvasPropertyPaint* paint) {
390    mDisplayList->ref(x);
391    mDisplayList->ref(y);
392    mDisplayList->ref(radius);
393    mDisplayList->ref(paint);
394    refBitmapsInShader(paint->value.getShader());
395    addOp(alloc().create_trivial<CirclePropsOp>(
396            *(mState.currentSnapshot()->transform),
397            getRecordedClip(),
398            &paint->value,
399            &x->value, &y->value, &radius->value));
400}
401
402void RecordingCanvas::drawOval(float left, float top, float right, float bottom, const SkPaint& paint) {
403    addOp(alloc().create_trivial<OvalOp>(
404            Rect(left, top, right, bottom),
405            *(mState.currentSnapshot()->transform),
406            getRecordedClip(),
407            refPaint(&paint)));
408}
409
410void RecordingCanvas::drawArc(float left, float top, float right, float bottom,
411        float startAngle, float sweepAngle, bool useCenter, const SkPaint& paint) {
412    if (fabs(sweepAngle) >= 360.0f) {
413        drawOval(left, top, right, bottom, paint);
414    } else {
415        addOp(alloc().create_trivial<ArcOp>(
416                Rect(left, top, right, bottom),
417                *(mState.currentSnapshot()->transform),
418                getRecordedClip(),
419                refPaint(&paint),
420                startAngle, sweepAngle, useCenter));
421    }
422}
423
424void RecordingCanvas::drawPath(const SkPath& path, const SkPaint& paint) {
425    addOp(alloc().create_trivial<PathOp>(
426            Rect(path.getBounds()),
427            *(mState.currentSnapshot()->transform),
428            getRecordedClip(),
429            refPaint(&paint), refPath(&path)));
430}
431
432void RecordingCanvas::drawVectorDrawable(VectorDrawableRoot* tree) {
433    mDisplayList->ref(tree);
434    addOp(alloc().create_trivial<VectorDrawableOp>(
435            tree,
436            Rect(tree->getBounds()),
437            *(mState.currentSnapshot()->transform),
438            getRecordedClip()));
439}
440
441// Bitmap-based
442void RecordingCanvas::drawBitmap(const SkBitmap& bitmap, float left, float top, const SkPaint* paint) {
443    save(SaveFlags::Matrix);
444    translate(left, top);
445    drawBitmap(&bitmap, paint);
446    restore();
447}
448
449void RecordingCanvas::drawBitmap(const SkBitmap& bitmap, const SkMatrix& matrix,
450                            const SkPaint* paint) {
451    if (matrix.isIdentity()) {
452        drawBitmap(&bitmap, paint);
453    } else if (!(matrix.getType() & ~(SkMatrix::kScale_Mask | SkMatrix::kTranslate_Mask))
454            && MathUtils::isPositive(matrix.getScaleX())
455            && MathUtils::isPositive(matrix.getScaleY())) {
456        // SkMatrix::isScaleTranslate() not available in L
457        SkRect src;
458        SkRect dst;
459        bitmap.getBounds(&src);
460        matrix.mapRect(&dst, src);
461        drawBitmap(bitmap, src.fLeft, src.fTop, src.fRight, src.fBottom,
462                   dst.fLeft, dst.fTop, dst.fRight, dst.fBottom, paint);
463    } else {
464        save(SaveFlags::Matrix);
465        concat(matrix);
466        drawBitmap(&bitmap, paint);
467        restore();
468    }
469}
470
471void RecordingCanvas::drawBitmap(const SkBitmap& bitmap, float srcLeft, float srcTop,
472            float srcRight, float srcBottom, float dstLeft, float dstTop,
473            float dstRight, float dstBottom, const SkPaint* paint) {
474    if (srcLeft == 0 && srcTop == 0
475            && srcRight == bitmap.width()
476            && srcBottom == bitmap.height()
477            && (srcBottom - srcTop == dstBottom - dstTop)
478            && (srcRight - srcLeft == dstRight - dstLeft)) {
479        // transform simple rect to rect drawing case into position bitmap ops, since they merge
480        save(SaveFlags::Matrix);
481        translate(dstLeft, dstTop);
482        drawBitmap(&bitmap, paint);
483        restore();
484    } else {
485        addOp(alloc().create_trivial<BitmapRectOp>(
486                Rect(dstLeft, dstTop, dstRight, dstBottom),
487                *(mState.currentSnapshot()->transform),
488                getRecordedClip(),
489                refPaint(paint), refBitmap(bitmap),
490                Rect(srcLeft, srcTop, srcRight, srcBottom)));
491    }
492}
493
494void RecordingCanvas::drawBitmapMesh(const SkBitmap& bitmap, int meshWidth, int meshHeight,
495            const float* vertices, const int* colors, const SkPaint* paint) {
496    int vertexCount = (meshWidth + 1) * (meshHeight + 1);
497    addOp(alloc().create_trivial<BitmapMeshOp>(
498            calcBoundsOfPoints(vertices, vertexCount * 2),
499            *(mState.currentSnapshot()->transform),
500            getRecordedClip(),
501            refPaint(paint), refBitmap(bitmap), meshWidth, meshHeight,
502            refBuffer<float>(vertices, vertexCount * 2), // 2 floats per vertex
503            refBuffer<int>(colors, vertexCount))); // 1 color per vertex
504}
505
506void RecordingCanvas::drawNinePatch(const SkBitmap& bitmap, const android::Res_png_9patch& patch,
507            float dstLeft, float dstTop, float dstRight, float dstBottom,
508            const SkPaint* paint) {
509    addOp(alloc().create_trivial<PatchOp>(
510            Rect(dstLeft, dstTop, dstRight, dstBottom),
511            *(mState.currentSnapshot()->transform),
512            getRecordedClip(),
513            refPaint(paint), refBitmap(bitmap), refPatch(&patch)));
514}
515
516// Text
517void RecordingCanvas::drawText(const uint16_t* glyphs, const float* positions, int glyphCount,
518            const SkPaint& paint, float x, float y, float boundsLeft, float boundsTop,
519            float boundsRight, float boundsBottom, float totalAdvance) {
520    if (!glyphs || !positions || glyphCount <= 0 || PaintUtils::paintWillNotDrawText(paint)) return;
521    glyphs = refBuffer<glyph_t>(glyphs, glyphCount);
522    positions = refBuffer<float>(positions, glyphCount * 2);
523
524    // TODO: either must account for text shadow in bounds, or record separate ops for text shadows
525    addOp(alloc().create_trivial<TextOp>(
526            Rect(boundsLeft, boundsTop, boundsRight, boundsBottom),
527            *(mState.currentSnapshot()->transform),
528            getRecordedClip(),
529            refPaint(&paint), glyphs, positions, glyphCount, x, y));
530    drawTextDecorations(x, y, totalAdvance, paint);
531}
532
533void RecordingCanvas::drawTextOnPath(const uint16_t* glyphs, int glyphCount, const SkPath& path,
534            float hOffset, float vOffset, const SkPaint& paint) {
535    if (!glyphs || glyphCount <= 0 || PaintUtils::paintWillNotDrawText(paint)) return;
536    glyphs = refBuffer<glyph_t>(glyphs, glyphCount);
537    addOp(alloc().create_trivial<TextOnPathOp>(
538            mState.getLocalClipBounds(), // TODO: explicitly define bounds
539            *(mState.currentSnapshot()->transform),
540            getRecordedClip(),
541            refPaint(&paint), glyphs, glyphCount, refPath(&path), hOffset, vOffset));
542}
543
544void RecordingCanvas::drawBitmap(const SkBitmap* bitmap, const SkPaint* paint) {
545    addOp(alloc().create_trivial<BitmapOp>(
546            Rect(bitmap->width(), bitmap->height()),
547            *(mState.currentSnapshot()->transform),
548            getRecordedClip(),
549            refPaint(paint), refBitmap(*bitmap)));
550}
551
552void RecordingCanvas::drawRenderNode(RenderNode* renderNode) {
553    auto&& stagingProps = renderNode->stagingProperties();
554    RenderNodeOp* op = alloc().create_trivial<RenderNodeOp>(
555            Rect(stagingProps.getWidth(), stagingProps.getHeight()),
556            *(mState.currentSnapshot()->transform),
557            getRecordedClip(),
558            renderNode);
559    int opIndex = addOp(op);
560    int childIndex = mDisplayList->addChild(op);
561
562    // update the chunk's child indices
563    DisplayList::Chunk& chunk = mDisplayList->chunks.back();
564    chunk.endChildIndex = childIndex + 1;
565
566    if (renderNode->stagingProperties().isProjectionReceiver()) {
567        // use staging property, since recording on UI thread
568        mDisplayList->projectionReceiveIndex = opIndex;
569    }
570}
571
572void RecordingCanvas::drawLayer(DeferredLayerUpdater* layerHandle) {
573    // We ref the DeferredLayerUpdater due to its thread-safe ref-counting semantics.
574    mDisplayList->ref(layerHandle);
575
576    Layer* layer = layerHandle->backingLayer();
577    Matrix4 totalTransform(*(mState.currentSnapshot()->transform));
578    totalTransform.multiply(layer->getTransform());
579
580    addOp(alloc().create_trivial<TextureLayerOp>(
581            Rect(layer->getWidth(), layer->getHeight()),
582            totalTransform,
583            getRecordedClip(),
584            layer));
585}
586
587void RecordingCanvas::callDrawGLFunction(Functor* functor) {
588    mDisplayList->functors.push_back(functor);
589    addOp(alloc().create_trivial<FunctorOp>(
590            mState.getLocalClipBounds(), // TODO: explicitly define bounds
591            *(mState.currentSnapshot()->transform),
592            getRecordedClip(),
593            functor));
594}
595
596size_t RecordingCanvas::addOp(RecordedOp* op) {
597    // skip op with empty clip
598    if (op->localClip && op->localClip->rect.isEmpty()) {
599        // NOTE: this rejection happens after op construction/content ref-ing, so content ref'd
600        // and held by renderthread isn't affected by clip rejection.
601        // Could rewind alloc here if desired, but callers would have to not touch op afterwards.
602        return -1;
603    }
604
605    int insertIndex = mDisplayList->ops.size();
606    mDisplayList->ops.push_back(op);
607    if (mDeferredBarrierType != DeferredBarrierType::None) {
608        // op is first in new chunk
609        mDisplayList->chunks.emplace_back();
610        DisplayList::Chunk& newChunk = mDisplayList->chunks.back();
611        newChunk.beginOpIndex = insertIndex;
612        newChunk.endOpIndex = insertIndex + 1;
613        newChunk.reorderChildren = (mDeferredBarrierType == DeferredBarrierType::OutOfOrder);
614
615        int nextChildIndex = mDisplayList->children.size();
616        newChunk.beginChildIndex = newChunk.endChildIndex = nextChildIndex;
617        mDeferredBarrierType = DeferredBarrierType::None;
618    } else {
619        // standard case - append to existing chunk
620        mDisplayList->chunks.back().endOpIndex = insertIndex + 1;
621    }
622    return insertIndex;
623}
624
625void RecordingCanvas::refBitmapsInShader(const SkShader* shader) {
626    if (!shader) return;
627
628    // If this paint has an SkShader that has an SkBitmap add
629    // it to the bitmap pile
630    SkBitmap bitmap;
631    SkShader::TileMode xy[2];
632    if (shader->isABitmap(&bitmap, nullptr, xy)) {
633        refBitmap(bitmap);
634        return;
635    }
636    SkShader::ComposeRec rec;
637    if (shader->asACompose(&rec)) {
638        refBitmapsInShader(rec.fShaderA);
639        refBitmapsInShader(rec.fShaderB);
640        return;
641    }
642}
643
644}; // namespace uirenderer
645}; // namespace android
646