/src/skia/include/private/SkTArray.h
Line | Count | Source (jump to first uncovered line) |
1 | | /* |
2 | | * Copyright 2011 Google Inc. |
3 | | * |
4 | | * Use of this source code is governed by a BSD-style license that can be |
5 | | * found in the LICENSE file. |
6 | | */ |
7 | | |
8 | | #ifndef SkTArray_DEFINED |
9 | | #define SkTArray_DEFINED |
10 | | |
11 | | #include "include/core/SkMath.h" |
12 | | #include "include/core/SkTypes.h" |
13 | | #include "include/private/SkMalloc.h" |
14 | | #include "include/private/SkSafe32.h" |
15 | | #include "include/private/SkTLogic.h" |
16 | | #include "include/private/SkTemplates.h" |
17 | | #include "include/private/SkTo.h" |
18 | | |
19 | | #include <string.h> |
20 | | #include <initializer_list> |
21 | | #include <memory> |
22 | | #include <new> |
23 | | #include <utility> |
24 | | |
25 | | /** SkTArray<T> implements a typical, mostly std::vector-like array. |
26 | | Each T will be default-initialized on allocation, and ~T will be called on destruction. |
27 | | |
28 | | MEM_MOVE controls the behavior when a T needs to be moved (e.g. when the array is resized) |
29 | | - true: T will be bit-copied via memcpy. |
30 | | - false: T will be moved via move-constructors. |
31 | | |
32 | | Modern implementations of std::vector<T> will generally provide similar performance |
33 | | characteristics when used with appropriate care. Consider using std::vector<T> in new code. |
34 | | */ |
35 | | template <typename T, bool MEM_MOVE = false> class SkTArray { |
36 | | private: |
37 | | enum ReallocType { kExactFit, kGrowing, kShrinking }; |
38 | | |
39 | | public: |
40 | | using value_type = T; |
41 | | |
42 | | /** |
43 | | * Creates an empty array with no initial storage |
44 | | */ |
45 | 2.14M | SkTArray() { this->init(0); } SkTArray<sk_gpu_test::GrContextFactory::Context, true>::SkTArray() Line | Count | Source | 45 | 1.50k | SkTArray() { this->init(0); } |
SkTArray<int, false>::SkTArray() Line | Count | Source | 45 | 456 | SkTArray() { this->init(0); } |
SkTArray<float, false>::SkTArray() Line | Count | Source | 45 | 456 | SkTArray() { this->init(0); } |
SkTArray<SkCanvas::Lattice::RectType, false>::SkTArray() Line | Count | Source | 45 | 228 | SkTArray() { this->init(0); } |
SkTArray<unsigned int, false>::SkTArray() Line | Count | Source | 45 | 228 | SkTArray() { this->init(0); } |
Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::SkTArray() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::SkTArray() SkTArray<SkSL::Parser::Checkpoint::ForwardingErrorReporter::Error, false>::SkTArray() Line | Count | Source | 45 | 73.4k | SkTArray() { this->init(0); } |
Unexecuted instantiation: SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::SkTArray() Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::SkTArray() SkTArray<sk_sp<GrRenderTask>, false>::SkTArray() Line | Count | Source | 45 | 1.32k | SkTArray() { this->init(0); } |
SkTArray<GrOnFlushCallbackObject*, false>::SkTArray() Line | Count | Source | 45 | 1.32k | SkTArray() { this->init(0); } |
SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::SkTArray() Line | Count | Source | 45 | 1.32k | SkTArray() { this->init(0); } |
SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::SkTArray() Line | Count | Source | 45 | 1.32k | SkTArray() { this->init(0); } |
SkTArray<SkString, false>::SkTArray() Line | Count | Source | 45 | 1.34k | SkTArray() { this->init(0); } |
SkTArray<GrTextureProxy*, true>::SkTArray() Line | Count | Source | 45 | 100k | SkTArray() { this->init(0); } |
SkTArray<GrUniqueKeyInvalidatedMessage, false>::SkTArray() Line | Count | Source | 45 | 83.6k | SkTArray() { this->init(0); } |
SkTArray<GrTextureFreedMessage, false>::SkTArray() Line | Count | Source | 45 | 1.32k | SkTArray() { this->init(0); } |
SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::SkTArray() Line | Count | Source | 45 | 1.85k | SkTArray() { this->init(0); } |
Unexecuted instantiation: SkTArray<GrAuditTrail::Op*, false>::SkTArray() Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo::Op, false>::SkTArray() SkTArray<GrSurfaceProxy*, true>::SkTArray() Line | Count | Source | 45 | 89.6k | SkTArray() { this->init(0); } |
SkTArray<int, true>::SkTArray() Line | Count | Source | 45 | 2.46k | SkTArray() { this->init(0); } |
SkTArray<float, true>::SkTArray() Line | Count | Source | 45 | 4.14k | SkTArray() { this->init(0); } |
Unexecuted instantiation: SkTArray<unsigned char, true>::SkTArray() Unexecuted instantiation: SkTArray<SkRSXform, false>::SkTArray() Unexecuted instantiation: SkTArray<SkRect, false>::SkTArray() Unexecuted instantiation: SkTArray<SkPoint, false>::SkTArray() Unexecuted instantiation: SkTArray<unsigned short, false>::SkTArray() Unexecuted instantiation: SkTArray<GrGLProgramDataManager::Uniform, true>::SkTArray() Unexecuted instantiation: SkTArray<GrSwizzle, false>::SkTArray() Unexecuted instantiation: SkTArray<SkSL::String, false>::SkTArray() Unexecuted instantiation: SkTArray<GrRecordingContext::ProgramData, false>::SkTArray() SkTArray<GrUniqueKey, false>::SkTArray() Line | Count | Source | 45 | 103k | SkTArray() { this->init(0); } |
SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::SkTArray() Line | Count | Source | 45 | 7.47k | SkTArray() { this->init(0); } |
SkTArray<SkPaint, false>::SkTArray() Line | Count | Source | 45 | 4.97k | SkTArray() { this->init(0); } |
SkTArray<SkPath, false>::SkTArray() Line | Count | Source | 45 | 1.41M | SkTArray() { this->init(0); } |
SkTArray<sk_sp<SkPicture const>, false>::SkTArray() Line | Count | Source | 45 | 4.97k | SkTArray() { this->init(0); } |
SkTArray<sk_sp<SkDrawable>, false>::SkTArray() Line | Count | Source | 45 | 4.97k | SkTArray() { this->init(0); } |
SkTArray<sk_sp<SkTextBlob const>, false>::SkTArray() Line | Count | Source | 45 | 4.97k | SkTArray() { this->init(0); } |
SkTArray<sk_sp<SkVertices const>, false>::SkTArray() Line | Count | Source | 45 | 4.97k | SkTArray() { this->init(0); } |
SkTArray<sk_sp<SkImage const>, false>::SkTArray() Line | Count | Source | 45 | 4.97k | SkTArray() { this->init(0); } |
SkTArray<SkMatrix, false>::SkTArray() Line | Count | Source | 45 | 1 | SkTArray() { this->init(0); } |
SkTArray<GrBufferAllocPool::BufferBlock, false>::SkTArray() Line | Count | Source | 45 | 61.8k | SkTArray() { this->init(0); } |
SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::SkTArray() Line | Count | Source | 45 | 1.32k | SkTArray() { this->init(0); } |
SkTArray<GrDrawOpAtlas::Plot*, false>::SkTArray() Line | Count | Source | 45 | 863 | SkTArray() { this->init(0); } |
Unexecuted instantiation: SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::SkTArray() SkTArray<GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*, true>::SkTArray() Line | Count | Source | 45 | 76 | SkTArray() { this->init(0); } |
SkTArray<GrProcessorTestFactory<GrGeometryProcessor*>*, true>::SkTArray() Line | Count | Source | 45 | 76 | SkTArray() { this->init(0); } |
SkTArray<GrXPFactoryTestFactory*, true>::SkTArray() Line | Count | Source | 45 | 76 | SkTArray() { this->init(0); } |
Unexecuted instantiation: SkTArray<skgpu::v1::ClipStack::Element, false>::SkTArray() Unexecuted instantiation: SkTArray<GrGLFormat, true>::SkTArray() SkTArray<std::__1::unique_ptr<SkCodec, std::__1::default_delete<SkCodec> >, true>::SkTArray() Line | Count | Source | 45 | 3.38k | SkTArray() { this->init(0); } |
Unexecuted instantiation: SkTArray<dng_exception, false>::SkTArray() Unexecuted instantiation: SkTArray<std::__1::thread, false>::SkTArray() Unexecuted instantiation: SkTArray<std::__1::function<void ()>, false>::SkTArray() SkTArray<sk_sp<SkTypeface_Custom>, false>::SkTArray() Line | Count | Source | 45 | 5 | SkTArray() { this->init(0); } |
SkTArray<sk_sp<SkFontStyleSet_Custom>, false>::SkTArray() Line | Count | Source | 45 | 5 | SkTArray() { this->init(0); } |
Unexecuted instantiation: SkTArray<std::__1::array<unsigned short, 3ul>, false>::SkTArray() Unexecuted instantiation: SkTArray<SkPoint, true>::SkTArray() Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfInfo, false>::SkTArray() Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfLayerInfo, false>::SkTArray() SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::SkTArray() Line | Count | Source | 45 | 19.4k | SkTArray() { this->init(0); } |
SkTArray<skia::textlayout::Block, true>::SkTArray() Line | Count | Source | 45 | 4.02k | SkTArray() { this->init(0); } |
SkTArray<skia::textlayout::Placeholder, true>::SkTArray() Line | Count | Source | 45 | 4.02k | SkTArray() { this->init(0); } |
SkTArray<skia::textlayout::StyleBlock<float>, false>::SkTArray() Line | Count | Source | 45 | 8.05k | SkTArray() { this->init(0); } |
SkTArray<skia::textlayout::StyleBlock<SkPaint>, false>::SkTArray() Line | Count | Source | 45 | 8.05k | SkTArray() { this->init(0); } |
SkTArray<skia::textlayout::StyleBlock<std::__1::vector<skia::textlayout::TextShadow, std::__1::allocator<skia::textlayout::TextShadow> > >, false>::SkTArray() Line | Count | Source | 45 | 4.02k | SkTArray() { this->init(0); } |
SkTArray<skia::textlayout::StyleBlock<skia::textlayout::Decoration>, false>::SkTArray() Line | Count | Source | 45 | 4.02k | SkTArray() { this->init(0); } |
SkTArray<skia::textlayout::Run, false>::SkTArray() Line | Count | Source | 45 | 4.02k | SkTArray() { this->init(0); } |
SkTArray<skia::textlayout::Cluster, true>::SkTArray() Line | Count | Source | 45 | 4.02k | SkTArray() { this->init(0); } |
SkTArray<skia::textlayout::CodeUnitFlags, false>::SkTArray() Line | Count | Source | 45 | 4.02k | SkTArray() { this->init(0); } |
SkTArray<unsigned long, false>::SkTArray() Line | Count | Source | 45 | 4.02k | SkTArray() { this->init(0); } |
SkTArray<unsigned long, true>::SkTArray() Line | Count | Source | 45 | 8.05k | SkTArray() { this->init(0); } |
SkTArray<skia::textlayout::TextLine, false>::SkTArray() Line | Count | Source | 45 | 4.02k | SkTArray() { this->init(0); } |
SkTArray<skia::textlayout::ResolvedFontDescriptor, false>::SkTArray() Line | Count | Source | 45 | 4.02k | SkTArray() { this->init(0); } |
SkTArray<SkShaper::Feature, false>::SkTArray() Line | Count | Source | 45 | 57.6k | SkTArray() { this->init(0); } |
Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo, false>::SkTArray() Unexecuted instantiation: SkTArray<SkTArray<SkPDFTagNode*, false>, false>::SkTArray() Unexecuted instantiation: SkTArray<SkPDFTagNode::MarkedContentInfo, false>::SkTArray() Unexecuted instantiation: SkTArray<SkPDFTagNode*, false>::SkTArray() SkTArray<SkSVGDevice::ClipRec, false>::SkTArray() Line | Count | Source | 45 | 12.9k | SkTArray() { this->init(0); } |
|
46 | | |
47 | | /** |
48 | | * Creates an empty array that will preallocate space for reserveCount |
49 | | * elements. |
50 | | */ |
51 | 65.2k | explicit SkTArray(int reserveCount) : SkTArray() { this->reserve_back(reserveCount); } Unexecuted instantiation: SkTArray<SkRSXform, false>::SkTArray(int) Unexecuted instantiation: SkTArray<SkRect, false>::SkTArray(int) SkTArray<SkMatrix, false>::SkTArray(int) Line | Count | Source | 51 | 1 | explicit SkTArray(int reserveCount) : SkTArray() { this->reserve_back(reserveCount); } |
SkTArray<GrBufferAllocPool::BufferBlock, false>::SkTArray(int) Line | Count | Source | 51 | 61.8k | explicit SkTArray(int reserveCount) : SkTArray() { this->reserve_back(reserveCount); } |
Unexecuted instantiation: SkTArray<skgpu::v1::ClipStack::Element, false>::SkTArray(int) SkTArray<std::__1::unique_ptr<SkCodec, std::__1::default_delete<SkCodec> >, true>::SkTArray(int) Line | Count | Source | 51 | 3.38k | explicit SkTArray(int reserveCount) : SkTArray() { this->reserve_back(reserveCount); } |
Unexecuted instantiation: SkTArray<std::__1::array<unsigned short, 3ul>, false>::SkTArray(int) Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfInfo, false>::SkTArray(int) Unexecuted instantiation: SkTArray<float, false>::SkTArray(int) |
52 | | |
53 | | /** |
54 | | * Copies one array to another. The new array will be heap allocated. |
55 | | */ |
56 | | SkTArray(const SkTArray& that) |
57 | 100k | : SkTArray(that.fItemArray, that.fCount) {} Unexecuted instantiation: SkTArray<unsigned char, true>::SkTArray(SkTArray<unsigned char, true> const&) Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::SkTArray(SkTArray<sk_sp<SkPicture const>, false> const&) Unexecuted instantiation: SkTArray<sk_sp<SkDrawable>, false>::SkTArray(SkTArray<sk_sp<SkDrawable>, false> const&) Unexecuted instantiation: SkTArray<sk_sp<SkTextBlob const>, false>::SkTArray(SkTArray<sk_sp<SkTextBlob const>, false> const&) Unexecuted instantiation: SkTArray<sk_sp<SkVertices const>, false>::SkTArray(SkTArray<sk_sp<SkVertices const>, false> const&) Unexecuted instantiation: SkTArray<sk_sp<SkImage const>, false>::SkTArray(SkTArray<sk_sp<SkImage const>, false> const&) SkTArray<skia::textlayout::Block, true>::SkTArray(SkTArray<skia::textlayout::Block, true> const&) Line | Count | Source | 57 | 16.4k | : SkTArray(that.fItemArray, that.fCount) {} |
SkTArray<skia::textlayout::Placeholder, true>::SkTArray(SkTArray<skia::textlayout::Placeholder, true> const&) Line | Count | Source | 57 | 16.4k | : SkTArray(that.fItemArray, that.fCount) {} |
SkTArray<skia::textlayout::Run, false>::SkTArray(SkTArray<skia::textlayout::Run, false> const&) Line | Count | Source | 57 | 2.40k | : SkTArray(that.fItemArray, that.fCount) {} |
SkTArray<skia::textlayout::CodeUnitFlags, false>::SkTArray(SkTArray<skia::textlayout::CodeUnitFlags, false> const&) Line | Count | Source | 57 | 2.40k | : SkTArray(that.fItemArray, that.fCount) {} |
SkTArray<unsigned long, true>::SkTArray(SkTArray<unsigned long, true> const&) Line | Count | Source | 57 | 4.81k | : SkTArray(that.fItemArray, that.fCount) {} |
SkTArray<SkShaper::Feature, false>::SkTArray(SkTArray<SkShaper::Feature, false> const&) Line | Count | Source | 57 | 57.6k | : SkTArray(that.fItemArray, that.fCount) {} |
|
58 | | |
59 | 87.7k | SkTArray(SkTArray&& that) { |
60 | 87.7k | if (that.fOwnMemory) { |
61 | 65.7k | fItemArray = that.fItemArray; |
62 | 65.7k | fCount = that.fCount; |
63 | 65.7k | fAllocCount = that.fAllocCount; |
64 | 65.7k | fOwnMemory = true; |
65 | 65.7k | fReserved = that.fReserved; |
66 | | |
67 | 65.7k | that.fItemArray = nullptr; |
68 | 65.7k | that.fCount = 0; |
69 | 65.7k | that.fAllocCount = 0; |
70 | 65.7k | that.fOwnMemory = true; |
71 | 65.7k | that.fReserved = false; |
72 | 21.9k | } else { |
73 | 21.9k | this->init(that.fCount); |
74 | 21.9k | that.move(fItemArray); |
75 | 21.9k | that.fCount = 0; |
76 | 21.9k | } |
77 | 87.7k | } Unexecuted instantiation: SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::SkTArray(SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>&&) Unexecuted instantiation: SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::SkTArray(SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>&&) Unexecuted instantiation: SkTArray<SkSL::dsl::DSLField, false>::SkTArray(SkTArray<SkSL::dsl::DSLField, false>&&) Unexecuted instantiation: SkTArray<SkSL::dsl::DSLCase, false>::SkTArray(SkTArray<SkSL::dsl::DSLCase, false>&&) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::SkTArray(SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>&&) Unexecuted instantiation: SkTArray<sk_sp<GrRenderTask>, false>::SkTArray(SkTArray<sk_sp<GrRenderTask>, false>&&) Unexecuted instantiation: SkTArray<GrUniqueKeyInvalidatedMessage, false>::SkTArray(SkTArray<GrUniqueKeyInvalidatedMessage, false>&&) Unexecuted instantiation: SkTArray<GrTextureFreedMessage, false>::SkTArray(SkTArray<GrTextureFreedMessage, false>&&) Unexecuted instantiation: SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::SkTArray(SkTArray<GrTextBlobCache::PurgeBlobMessage, false>&&) Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo::Op, false>::SkTArray(SkTArray<GrAuditTrail::OpInfo::Op, false>&&) Unexecuted instantiation: SkTArray<SkString, false>::SkTArray(SkTArray<SkString, false>&&) Unexecuted instantiation: SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::SkTArray(SkTArray<SkResourceCache::PurgeSharedIDMessage, false>&&) SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::SkTArray(SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>&&) Line | Count | Source | 59 | 21.9k | SkTArray(SkTArray&& that) { | 60 | 21.9k | if (that.fOwnMemory) { | 61 | 0 | fItemArray = that.fItemArray; | 62 | 0 | fCount = that.fCount; | 63 | 0 | fAllocCount = that.fAllocCount; | 64 | 0 | fOwnMemory = true; | 65 | 0 | fReserved = that.fReserved; | 66 | |
| 67 | 0 | that.fItemArray = nullptr; | 68 | 0 | that.fCount = 0; | 69 | 0 | that.fAllocCount = 0; | 70 | 0 | that.fOwnMemory = true; | 71 | 0 | that.fReserved = false; | 72 | 21.9k | } else { | 73 | 21.9k | this->init(that.fCount); | 74 | 21.9k | that.move(fItemArray); | 75 | 21.9k | that.fCount = 0; | 76 | 21.9k | } | 77 | 21.9k | } |
Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfLayerInfo, false>::SkTArray(SkTArray<TestSVGTypeface::GlyfLayerInfo, false>&&) SkTArray<skia::textlayout::Block, true>::SkTArray(SkTArray<skia::textlayout::Block, true>&&) Line | Count | Source | 59 | 4.02k | SkTArray(SkTArray&& that) { | 60 | 4.02k | if (that.fOwnMemory) { | 61 | 4.02k | fItemArray = that.fItemArray; | 62 | 4.02k | fCount = that.fCount; | 63 | 4.02k | fAllocCount = that.fAllocCount; | 64 | 4.02k | fOwnMemory = true; | 65 | 4.02k | fReserved = that.fReserved; | 66 | | | 67 | 4.02k | that.fItemArray = nullptr; | 68 | 4.02k | that.fCount = 0; | 69 | 4.02k | that.fAllocCount = 0; | 70 | 4.02k | that.fOwnMemory = true; | 71 | 4.02k | that.fReserved = false; | 72 | 0 | } else { | 73 | 0 | this->init(that.fCount); | 74 | 0 | that.move(fItemArray); | 75 | 0 | that.fCount = 0; | 76 | 0 | } | 77 | 4.02k | } |
SkTArray<skia::textlayout::Placeholder, true>::SkTArray(SkTArray<skia::textlayout::Placeholder, true>&&) Line | Count | Source | 59 | 4.02k | SkTArray(SkTArray&& that) { | 60 | 4.02k | if (that.fOwnMemory) { | 61 | 4.02k | fItemArray = that.fItemArray; | 62 | 4.02k | fCount = that.fCount; | 63 | 4.02k | fAllocCount = that.fAllocCount; | 64 | 4.02k | fOwnMemory = true; | 65 | 4.02k | fReserved = that.fReserved; | 66 | | | 67 | 4.02k | that.fItemArray = nullptr; | 68 | 4.02k | that.fCount = 0; | 69 | 4.02k | that.fAllocCount = 0; | 70 | 4.02k | that.fOwnMemory = true; | 71 | 4.02k | that.fReserved = false; | 72 | 0 | } else { | 73 | 0 | this->init(that.fCount); | 74 | 0 | that.move(fItemArray); | 75 | 0 | that.fCount = 0; | 76 | 0 | } | 77 | 4.02k | } |
SkTArray<SkShaper::Feature, false>::SkTArray(SkTArray<SkShaper::Feature, false>&&) Line | Count | Source | 59 | 57.6k | SkTArray(SkTArray&& that) { | 60 | 57.6k | if (that.fOwnMemory) { | 61 | 57.6k | fItemArray = that.fItemArray; | 62 | 57.6k | fCount = that.fCount; | 63 | 57.6k | fAllocCount = that.fAllocCount; | 64 | 57.6k | fOwnMemory = true; | 65 | 57.6k | fReserved = that.fReserved; | 66 | | | 67 | 57.6k | that.fItemArray = nullptr; | 68 | 57.6k | that.fCount = 0; | 69 | 57.6k | that.fAllocCount = 0; | 70 | 57.6k | that.fOwnMemory = true; | 71 | 57.6k | that.fReserved = false; | 72 | 0 | } else { | 73 | 0 | this->init(that.fCount); | 74 | 0 | that.move(fItemArray); | 75 | 0 | that.fCount = 0; | 76 | 0 | } | 77 | 57.6k | } |
Unexecuted instantiation: SkTArray<SkPDFTagNode*, false>::SkTArray(SkTArray<SkPDFTagNode*, false>&&) |
78 | | |
79 | | /** |
80 | | * Creates a SkTArray by copying contents of a standard C array. The new |
81 | | * array will be heap allocated. Be careful not to use this constructor |
82 | | * when you really want the (void*, int) version. |
83 | | */ |
84 | 100k | SkTArray(const T* array, int count) { |
85 | 100k | this->init(count); |
86 | 100k | this->copy(array); |
87 | 100k | } Unexecuted instantiation: SkTArray<unsigned char, true>::SkTArray(unsigned char const*, int) Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::SkTArray(sk_sp<SkPicture const> const*, int) Unexecuted instantiation: SkTArray<sk_sp<SkDrawable>, false>::SkTArray(sk_sp<SkDrawable> const*, int) Unexecuted instantiation: SkTArray<sk_sp<SkTextBlob const>, false>::SkTArray(sk_sp<SkTextBlob const> const*, int) Unexecuted instantiation: SkTArray<sk_sp<SkVertices const>, false>::SkTArray(sk_sp<SkVertices const> const*, int) Unexecuted instantiation: SkTArray<sk_sp<SkImage const>, false>::SkTArray(sk_sp<SkImage const> const*, int) SkTArray<skia::textlayout::Block, true>::SkTArray(skia::textlayout::Block const*, int) Line | Count | Source | 84 | 16.4k | SkTArray(const T* array, int count) { | 85 | 16.4k | this->init(count); | 86 | 16.4k | this->copy(array); | 87 | 16.4k | } |
SkTArray<skia::textlayout::Placeholder, true>::SkTArray(skia::textlayout::Placeholder const*, int) Line | Count | Source | 84 | 16.4k | SkTArray(const T* array, int count) { | 85 | 16.4k | this->init(count); | 86 | 16.4k | this->copy(array); | 87 | 16.4k | } |
SkTArray<skia::textlayout::Run, false>::SkTArray(skia::textlayout::Run const*, int) Line | Count | Source | 84 | 2.40k | SkTArray(const T* array, int count) { | 85 | 2.40k | this->init(count); | 86 | 2.40k | this->copy(array); | 87 | 2.40k | } |
SkTArray<skia::textlayout::CodeUnitFlags, false>::SkTArray(skia::textlayout::CodeUnitFlags const*, int) Line | Count | Source | 84 | 2.40k | SkTArray(const T* array, int count) { | 85 | 2.40k | this->init(count); | 86 | 2.40k | this->copy(array); | 87 | 2.40k | } |
SkTArray<unsigned long, true>::SkTArray(unsigned long const*, int) Line | Count | Source | 84 | 4.81k | SkTArray(const T* array, int count) { | 85 | 4.81k | this->init(count); | 86 | 4.81k | this->copy(array); | 87 | 4.81k | } |
SkTArray<SkShaper::Feature, false>::SkTArray(SkShaper::Feature const*, int) Line | Count | Source | 84 | 57.6k | SkTArray(const T* array, int count) { | 85 | 57.6k | this->init(count); | 86 | 57.6k | this->copy(array); | 87 | 57.6k | } |
|
88 | | /** |
89 | | * Creates a SkTArray by copying contents of an initializer list. |
90 | | */ |
91 | | SkTArray(std::initializer_list<T> data) |
92 | | : SkTArray(data.begin(), data.size()) {} |
93 | | |
94 | 24.8M | SkTArray& operator=(const SkTArray& that) { |
95 | 24.8M | if (this == &that) { |
96 | 0 | return *this; |
97 | 0 | } |
98 | 24.8M | for (int i = 0; i < this->count(); ++i) { |
99 | 4.06k | fItemArray[i].~T(); |
100 | 4.06k | } |
101 | 24.8M | fCount = 0; |
102 | 24.8M | this->checkRealloc(that.count(), kExactFit); |
103 | 24.8M | fCount = that.fCount; |
104 | 24.8M | this->copy(that.fItemArray); |
105 | 24.8M | return *this; |
106 | 24.8M | } Unexecuted instantiation: SkTArray<unsigned int, true>::operator=(SkTArray<unsigned int, true> const&) SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::operator=(SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true> const&) Line | Count | Source | 94 | 1.22k | SkTArray& operator=(const SkTArray& that) { | 95 | 1.22k | if (this == &that) { | 96 | 0 | return *this; | 97 | 0 | } | 98 | 1.22k | for (int i = 0; i < this->count(); ++i) { | 99 | 0 | fItemArray[i].~T(); | 100 | 0 | } | 101 | 1.22k | fCount = 0; | 102 | 1.22k | this->checkRealloc(that.count(), kExactFit); | 103 | 1.22k | fCount = that.fCount; | 104 | 1.22k | this->copy(that.fItemArray); | 105 | 1.22k | return *this; | 106 | 1.22k | } |
SkTArray<signed char, false>::operator=(SkTArray<signed char, false> const&) Line | Count | Source | 94 | 22.7M | SkTArray& operator=(const SkTArray& that) { | 95 | 22.7M | if (this == &that) { | 96 | 0 | return *this; | 97 | 0 | } | 98 | 22.7M | for (int i = 0; i < this->count(); ++i) { | 99 | 0 | fItemArray[i].~T(); | 100 | 0 | } | 101 | 22.7M | fCount = 0; | 102 | 22.7M | this->checkRealloc(that.count(), kExactFit); | 103 | 22.7M | fCount = that.fCount; | 104 | 22.7M | this->copy(that.fItemArray); | 105 | 22.7M | return *this; | 106 | 22.7M | } |
SkTArray<int, true>::operator=(SkTArray<int, true> const&) Line | Count | Source | 94 | 2.00M | SkTArray& operator=(const SkTArray& that) { | 95 | 2.00M | if (this == &that) { | 96 | 0 | return *this; | 97 | 0 | } | 98 | 2.00M | for (int i = 0; i < this->count(); ++i) { | 99 | 0 | fItemArray[i].~T(); | 100 | 0 | } | 101 | 2.00M | fCount = 0; | 102 | 2.00M | this->checkRealloc(that.count(), kExactFit); | 103 | 2.00M | fCount = that.fCount; | 104 | 2.00M | this->copy(that.fItemArray); | 105 | 2.00M | return *this; | 106 | 2.00M | } |
Unexecuted instantiation: SkTArray<SkString, false>::operator=(SkTArray<SkString, false> const&) Unexecuted instantiation: SkTArray<SkPaint, false>::operator=(SkTArray<SkPaint, false> const&) SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true>::operator=(SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true> const&) Line | Count | Source | 94 | 2.02k | SkTArray& operator=(const SkTArray& that) { | 95 | 2.02k | if (this == &that) { | 96 | 0 | return *this; | 97 | 0 | } | 98 | 2.02k | for (int i = 0; i < this->count(); ++i) { | 99 | 0 | fItemArray[i].~T(); | 100 | 0 | } | 101 | 2.02k | fCount = 0; | 102 | 2.02k | this->checkRealloc(that.count(), kExactFit); | 103 | 2.02k | fCount = that.fCount; | 104 | 2.02k | this->copy(that.fItemArray); | 105 | 2.02k | return *this; | 106 | 2.02k | } |
Unexecuted instantiation: SkTArray<unsigned short, true>::operator=(SkTArray<unsigned short, true> const&) Unexecuted instantiation: SkTArray<SkPoint, true>::operator=(SkTArray<SkPoint, true> const&) Unexecuted instantiation: SkTArray<SkRect, true>::operator=(SkTArray<SkRect, true> const&) Unexecuted instantiation: SkTArray<float, true>::operator=(SkTArray<float, true> const&) SkTArray<skia::textlayout::Run, false>::operator=(SkTArray<skia::textlayout::Run, false> const&) Line | Count | Source | 94 | 20 | SkTArray& operator=(const SkTArray& that) { | 95 | 20 | if (this == &that) { | 96 | 0 | return *this; | 97 | 0 | } | 98 | 20 | for (int i = 0; i < this->count(); ++i) { | 99 | 0 | fItemArray[i].~T(); | 100 | 0 | } | 101 | 20 | fCount = 0; | 102 | 20 | this->checkRealloc(that.count(), kExactFit); | 103 | 20 | fCount = that.fCount; | 104 | 20 | this->copy(that.fItemArray); | 105 | 20 | return *this; | 106 | 20 | } |
SkTArray<skia::textlayout::CodeUnitFlags, false>::operator=(SkTArray<skia::textlayout::CodeUnitFlags, false> const&) Line | Count | Source | 94 | 20 | SkTArray& operator=(const SkTArray& that) { | 95 | 20 | if (this == &that) { | 96 | 0 | return *this; | 97 | 0 | } | 98 | 4.08k | for (int i = 0; i < this->count(); ++i) { | 99 | 4.06k | fItemArray[i].~T(); | 100 | 4.06k | } | 101 | 20 | fCount = 0; | 102 | 20 | this->checkRealloc(that.count(), kExactFit); | 103 | 20 | fCount = that.fCount; | 104 | 20 | this->copy(that.fItemArray); | 105 | 20 | return *this; | 106 | 20 | } |
SkTArray<unsigned long, true>::operator=(SkTArray<unsigned long, true> const&) Line | Count | Source | 94 | 40 | SkTArray& operator=(const SkTArray& that) { | 95 | 40 | if (this == &that) { | 96 | 0 | return *this; | 97 | 0 | } | 98 | 40 | for (int i = 0; i < this->count(); ++i) { | 99 | 0 | fItemArray[i].~T(); | 100 | 0 | } | 101 | 40 | fCount = 0; | 102 | 40 | this->checkRealloc(that.count(), kExactFit); | 103 | 40 | fCount = that.fCount; | 104 | 40 | this->copy(that.fItemArray); | 105 | 40 | return *this; | 106 | 40 | } |
|
107 | 29.2M | SkTArray& operator=(SkTArray&& that) { |
108 | 29.2M | if (this == &that) { |
109 | 0 | return *this; |
110 | 0 | } |
111 | 29.3M | for (int i = 0; i < this->count(); ++i) { |
112 | 41.3k | fItemArray[i].~T(); |
113 | 41.3k | } |
114 | 29.2M | fCount = 0; |
115 | 29.2M | this->checkRealloc(that.count(), kExactFit); |
116 | 29.2M | fCount = that.fCount; |
117 | 29.2M | that.move(fItemArray); |
118 | 29.2M | that.fCount = 0; |
119 | 29.2M | return *this; |
120 | 29.2M | } Unexecuted instantiation: SkTArray<SkString, false>::operator=(SkTArray<SkString, false>&&) SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::operator=(SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>&&) Line | Count | Source | 107 | 12.1M | SkTArray& operator=(SkTArray&& that) { | 108 | 12.1M | if (this == &that) { | 109 | 0 | return *this; | 110 | 0 | } | 111 | 12.1M | for (int i = 0; i < this->count(); ++i) { | 112 | 0 | fItemArray[i].~T(); | 113 | 0 | } | 114 | 12.1M | fCount = 0; | 115 | 12.1M | this->checkRealloc(that.count(), kExactFit); | 116 | 12.1M | fCount = that.fCount; | 117 | 12.1M | that.move(fItemArray); | 118 | 12.1M | that.fCount = 0; | 119 | 12.1M | return *this; | 120 | 12.1M | } |
Unexecuted instantiation: SkTArray<int, false>::operator=(SkTArray<int, false>&&) SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::operator=(SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>&&) Line | Count | Source | 107 | 14.7M | SkTArray& operator=(SkTArray&& that) { | 108 | 14.7M | if (this == &that) { | 109 | 0 | return *this; | 110 | 0 | } | 111 | 14.8M | for (int i = 0; i < this->count(); ++i) { | 112 | 41.2k | fItemArray[i].~T(); | 113 | 41.2k | } | 114 | 14.7M | fCount = 0; | 115 | 14.7M | this->checkRealloc(that.count(), kExactFit); | 116 | 14.7M | fCount = that.fCount; | 117 | 14.7M | that.move(fItemArray); | 118 | 14.7M | that.fCount = 0; | 119 | 14.7M | return *this; | 120 | 14.7M | } |
SkTArray<int, true>::operator=(SkTArray<int, true>&&) Line | Count | Source | 107 | 1.67M | SkTArray& operator=(SkTArray&& that) { | 108 | 1.67M | if (this == &that) { | 109 | 0 | return *this; | 110 | 0 | } | 111 | 1.67M | for (int i = 0; i < this->count(); ++i) { | 112 | 0 | fItemArray[i].~T(); | 113 | 0 | } | 114 | 1.67M | fCount = 0; | 115 | 1.67M | this->checkRealloc(that.count(), kExactFit); | 116 | 1.67M | fCount = that.fCount; | 117 | 1.67M | that.move(fItemArray); | 118 | 1.67M | that.fCount = 0; | 119 | 1.67M | return *this; | 120 | 1.67M | } |
SkTArray<signed char, false>::operator=(SkTArray<signed char, false>&&) Line | Count | Source | 107 | 626k | SkTArray& operator=(SkTArray&& that) { | 108 | 626k | if (this == &that) { | 109 | 0 | return *this; | 110 | 0 | } | 111 | 626k | for (int i = 0; i < this->count(); ++i) { | 112 | 0 | fItemArray[i].~T(); | 113 | 0 | } | 114 | 626k | fCount = 0; | 115 | 626k | this->checkRealloc(that.count(), kExactFit); | 116 | 626k | fCount = that.fCount; | 117 | 626k | that.move(fItemArray); | 118 | 626k | that.fCount = 0; | 119 | 626k | return *this; | 120 | 626k | } |
Unexecuted instantiation: SkTArray<sk_sp<GrRenderTask>, false>::operator=(SkTArray<sk_sp<GrRenderTask>, false>&&) Unexecuted instantiation: SkTArray<GrUniqueKeyInvalidatedMessage, false>::operator=(SkTArray<GrUniqueKeyInvalidatedMessage, false>&&) Unexecuted instantiation: SkTArray<GrTextureFreedMessage, false>::operator=(SkTArray<GrTextureFreedMessage, false>&&) SkTArray<sk_sp<GrTextBlob>, false>::operator=(SkTArray<sk_sp<GrTextBlob>, false>&&) Line | Count | Source | 107 | 1.22k | SkTArray& operator=(SkTArray&& that) { | 108 | 1.22k | if (this == &that) { | 109 | 0 | return *this; | 110 | 0 | } | 111 | 1.32k | for (int i = 0; i < this->count(); ++i) { | 112 | 96 | fItemArray[i].~T(); | 113 | 96 | } | 114 | 1.22k | fCount = 0; | 115 | 1.22k | this->checkRealloc(that.count(), kExactFit); | 116 | 1.22k | fCount = that.fCount; | 117 | 1.22k | that.move(fItemArray); | 118 | 1.22k | that.fCount = 0; | 119 | 1.22k | return *this; | 120 | 1.22k | } |
Unexecuted instantiation: SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::operator=(SkTArray<GrTextBlobCache::PurgeBlobMessage, false>&&) Unexecuted instantiation: SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::operator=(SkTArray<SkResourceCache::PurgeSharedIDMessage, false>&&) SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::operator=(SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>&&) Line | Count | Source | 107 | 43.9k | SkTArray& operator=(SkTArray&& that) { | 108 | 43.9k | if (this == &that) { | 109 | 0 | return *this; | 110 | 0 | } | 111 | 43.9k | for (int i = 0; i < this->count(); ++i) { | 112 | 0 | fItemArray[i].~T(); | 113 | 0 | } | 114 | 43.9k | fCount = 0; | 115 | 43.9k | this->checkRealloc(that.count(), kExactFit); | 116 | 43.9k | fCount = that.fCount; | 117 | 43.9k | that.move(fItemArray); | 118 | 43.9k | that.fCount = 0; | 119 | 43.9k | return *this; | 120 | 43.9k | } |
Unexecuted instantiation: SkTArray<unsigned short, true>::operator=(SkTArray<unsigned short, true>&&) Unexecuted instantiation: SkTArray<SkPoint, true>::operator=(SkTArray<SkPoint, true>&&) Unexecuted instantiation: SkTArray<unsigned int, true>::operator=(SkTArray<unsigned int, true>&&) Unexecuted instantiation: SkTArray<SkRect, true>::operator=(SkTArray<SkRect, true>&&) Unexecuted instantiation: SkTArray<float, true>::operator=(SkTArray<float, true>&&) Unexecuted instantiation: SkTArray<unsigned long, true>::operator=(SkTArray<unsigned long, true>&&) |
121 | | |
122 | 96.6M | ~SkTArray() { |
123 | 428M | for (int i = 0; i < this->count(); ++i) { |
124 | 332M | fItemArray[i].~T(); |
125 | 332M | } |
126 | 96.6M | if (fOwnMemory) { |
127 | 11.0M | sk_free(fItemArray); |
128 | 11.0M | } |
129 | 96.6M | } SkTArray<sk_gpu_test::GrContextFactory::Context, true>::~SkTArray() Line | Count | Source | 122 | 1.50k | ~SkTArray() { | 123 | 1.50k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 1.50k | if (fOwnMemory) { | 127 | 1.50k | sk_free(fItemArray); | 128 | 1.50k | } | 129 | 1.50k | } |
SkTArray<unsigned int, false>::~SkTArray() Line | Count | Source | 122 | 228 | ~SkTArray() { | 123 | 228 | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 228 | if (fOwnMemory) { | 127 | 228 | sk_free(fItemArray); | 128 | 228 | } | 129 | 228 | } |
SkTArray<SkCanvas::Lattice::RectType, false>::~SkTArray() Line | Count | Source | 122 | 228 | ~SkTArray() { | 123 | 228 | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 228 | if (fOwnMemory) { | 127 | 228 | sk_free(fItemArray); | 128 | 228 | } | 129 | 228 | } |
SkTArray<float, false>::~SkTArray() Line | Count | Source | 122 | 456 | ~SkTArray() { | 123 | 1.82k | for (int i = 0; i < this->count(); ++i) { | 124 | 1.37k | fItemArray[i].~T(); | 125 | 1.37k | } | 126 | 456 | if (fOwnMemory) { | 127 | 456 | sk_free(fItemArray); | 128 | 456 | } | 129 | 456 | } |
SkTArray<int, false>::~SkTArray() Line | Count | Source | 122 | 456 | ~SkTArray() { | 123 | 1.82k | for (int i = 0; i < this->count(); ++i) { | 124 | 1.37k | fItemArray[i].~T(); | 125 | 1.37k | } | 126 | 456 | if (fOwnMemory) { | 127 | 456 | sk_free(fItemArray); | 128 | 456 | } | 129 | 456 | } |
SkTArray<SkNoPixelsDevice::ClipState, false>::~SkTArray() Line | Count | Source | 122 | 327k | ~SkTArray() { | 123 | 655k | for (int i = 0; i < this->count(); ++i) { | 124 | 327k | fItemArray[i].~T(); | 125 | 327k | } | 126 | 327k | if (fOwnMemory) { | 127 | 1.77k | sk_free(fItemArray); | 128 | 1.77k | } | 129 | 327k | } |
SkTArray<sk_sp<SkImageFilter>, true>::~SkTArray() Line | Count | Source | 122 | 20.8k | ~SkTArray() { | 123 | 47.6k | for (int i = 0; i < this->count(); ++i) { | 124 | 26.8k | fItemArray[i].~T(); | 125 | 26.8k | } | 126 | 20.8k | if (fOwnMemory) { | 127 | 185 | sk_free(fItemArray); | 128 | 185 | } | 129 | 20.8k | } |
SkTArray<SkRGBA4f<(SkAlphaType)2>, true>::~SkTArray() Line | Count | Source | 122 | 7.63k | ~SkTArray() { | 123 | 15.2k | for (int i = 0; i < this->count(); ++i) { | 124 | 7.63k | fItemArray[i].~T(); | 125 | 7.63k | } | 126 | 7.63k | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 7.63k | } |
SkTArray<SkRuntimeEffect::ChildPtr, false>::~SkTArray() Line | Count | Source | 122 | 4.04k | ~SkTArray() { | 123 | 12.1k | for (int i = 0; i < this->count(); ++i) { | 124 | 8.09k | fItemArray[i].~T(); | 125 | 8.09k | } | 126 | 4.04k | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 4.04k | } |
SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::~SkTArray() Line | Count | Source | 122 | 203 | ~SkTArray() { | 123 | 203 | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 203 | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 203 | } |
Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::~SkTArray() SkTArray<sk_sp<SkImage const>, false>::~SkTArray() Line | Count | Source | 122 | 4.97k | ~SkTArray() { | 123 | 6.19k | for (int i = 0; i < this->count(); ++i) { | 124 | 1.22k | fItemArray[i].~T(); | 125 | 1.22k | } | 126 | 4.97k | if (fOwnMemory) { | 127 | 4.97k | sk_free(fItemArray); | 128 | 4.97k | } | 129 | 4.97k | } |
SkTArray<sk_sp<SkVertices const>, false>::~SkTArray() Line | Count | Source | 122 | 4.97k | ~SkTArray() { | 123 | 5.10k | for (int i = 0; i < this->count(); ++i) { | 124 | 124 | fItemArray[i].~T(); | 125 | 124 | } | 126 | 4.97k | if (fOwnMemory) { | 127 | 4.97k | sk_free(fItemArray); | 128 | 4.97k | } | 129 | 4.97k | } |
SkTArray<sk_sp<SkTextBlob const>, false>::~SkTArray() Line | Count | Source | 122 | 4.97k | ~SkTArray() { | 123 | 5.21k | for (int i = 0; i < this->count(); ++i) { | 124 | 234 | fItemArray[i].~T(); | 125 | 234 | } | 126 | 4.97k | if (fOwnMemory) { | 127 | 4.97k | sk_free(fItemArray); | 128 | 4.97k | } | 129 | 4.97k | } |
SkTArray<sk_sp<SkDrawable>, false>::~SkTArray() Line | Count | Source | 122 | 4.97k | ~SkTArray() { | 123 | 4.97k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 4.97k | if (fOwnMemory) { | 127 | 4.97k | sk_free(fItemArray); | 128 | 4.97k | } | 129 | 4.97k | } |
SkTArray<sk_sp<SkPicture const>, false>::~SkTArray() Line | Count | Source | 122 | 4.97k | ~SkTArray() { | 123 | 4.97k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 4.97k | if (fOwnMemory) { | 127 | 4.97k | sk_free(fItemArray); | 128 | 4.97k | } | 129 | 4.97k | } |
SkTArray<SkPath, false>::~SkTArray() Line | Count | Source | 122 | 1.41M | ~SkTArray() { | 123 | 1.92M | for (int i = 0; i < this->count(); ++i) { | 124 | 505k | fItemArray[i].~T(); | 125 | 505k | } | 126 | 1.41M | if (fOwnMemory) { | 127 | 1.41M | sk_free(fItemArray); | 128 | 1.41M | } | 129 | 1.41M | } |
SkTArray<SkPaint, false>::~SkTArray() Line | Count | Source | 122 | 4.97k | ~SkTArray() { | 123 | 25.2k | for (int i = 0; i < this->count(); ++i) { | 124 | 20.3k | fItemArray[i].~T(); | 125 | 20.3k | } | 126 | 4.97k | if (fOwnMemory) { | 127 | 4.97k | sk_free(fItemArray); | 128 | 4.97k | } | 129 | 4.97k | } |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::~SkTArray() Line | Count | Source | 122 | 16.5M | ~SkTArray() { | 123 | 24.0M | for (int i = 0; i < this->count(); ++i) { | 124 | 7.52M | fItemArray[i].~T(); | 125 | 7.52M | } | 126 | 16.5M | if (fOwnMemory) { | 127 | 2.67M | sk_free(fItemArray); | 128 | 2.67M | } | 129 | 16.5M | } |
SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::~SkTArray() Line | Count | Source | 122 | 19.9M | ~SkTArray() { | 123 | 29.3M | for (int i = 0; i < this->count(); ++i) { | 124 | 9.46M | fItemArray[i].~T(); | 125 | 9.46M | } | 126 | 19.9M | if (fOwnMemory) { | 127 | 3.19M | sk_free(fItemArray); | 128 | 3.19M | } | 129 | 19.9M | } |
SkTArray<SkSL::Type const*, false>::~SkTArray() Line | Count | Source | 122 | 394k | ~SkTArray() { | 123 | 647k | for (int i = 0; i < this->count(); ++i) { | 124 | 252k | fItemArray[i].~T(); | 125 | 252k | } | 126 | 394k | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 394k | } |
Unexecuted instantiation: SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::~SkTArray() SkTArray<signed char, false>::~SkTArray() Line | Count | Source | 122 | 33.6M | ~SkTArray() { | 123 | 81.8M | for (int i = 0; i < this->count(); ++i) { | 124 | 48.2M | fItemArray[i].~T(); | 125 | 48.2M | } | 126 | 33.6M | if (fOwnMemory) { | 127 | 6.01k | sk_free(fItemArray); | 128 | 6.01k | } | 129 | 33.6M | } |
SkTArray<SkSL::Parser::Checkpoint::ForwardingErrorReporter::Error, false>::~SkTArray() Line | Count | Source | 122 | 73.4k | ~SkTArray() { | 123 | 89.9k | for (int i = 0; i < this->count(); ++i) { | 124 | 16.5k | fItemArray[i].~T(); | 125 | 16.5k | } | 126 | 73.4k | if (fOwnMemory) { | 127 | 73.4k | sk_free(fItemArray); | 128 | 73.4k | } | 129 | 73.4k | } |
SkTArray<int, true>::~SkTArray() Line | Count | Source | 122 | 13.2M | ~SkTArray() { | 123 | 135M | for (int i = 0; i < this->count(); ++i) { | 124 | 121M | fItemArray[i].~T(); | 125 | 121M | } | 126 | 13.2M | if (fOwnMemory) { | 127 | 107k | sk_free(fItemArray); | 128 | 107k | } | 129 | 13.2M | } |
SkTArray<unsigned long, true>::~SkTArray() Line | Count | Source | 122 | 274k | ~SkTArray() { | 123 | 971k | for (int i = 0; i < this->count(); ++i) { | 124 | 697k | fItemArray[i].~T(); | 125 | 697k | } | 126 | 274k | if (fOwnMemory) { | 127 | 12.8k | sk_free(fItemArray); | 128 | 12.8k | } | 129 | 274k | } |
Unexecuted instantiation: SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::~SkTArray() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLField, false>::~SkTArray() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLCase, false>::~SkTArray() SkSLSwizzle.cpp:SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::~SkTArray() Line | Count | Source | 122 | 170k | ~SkTArray() { | 123 | 560k | for (int i = 0; i < this->count(); ++i) { | 124 | 389k | fItemArray[i].~T(); | 125 | 389k | } | 126 | 170k | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 170k | } |
SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::~SkTArray() Line | Count | Source | 122 | 630k | ~SkTArray() { | 123 | 1.18M | for (int i = 0; i < this->count(); ++i) { | 124 | 554k | fItemArray[i].~T(); | 125 | 554k | } | 126 | 630k | if (fOwnMemory) { | 127 | 131k | sk_free(fItemArray); | 128 | 131k | } | 129 | 630k | } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::~SkTArray() SkTArray<sk_sp<GrRenderTask>, false>::~SkTArray() Line | Count | Source | 122 | 2.65k | ~SkTArray() { | 123 | 2.65k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 2.65k | if (fOwnMemory) { | 127 | 1.32k | sk_free(fItemArray); | 128 | 1.32k | } | 129 | 2.65k | } |
SkTArray<unsigned int, true>::~SkTArray() Line | Count | Source | 122 | 1.32k | ~SkTArray() { | 123 | 1.32k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 1.32k | if (fOwnMemory) { | 127 | 535 | sk_free(fItemArray); | 128 | 535 | } | 129 | 1.32k | } |
SkTArray<sk_sp<skgpu::v1::PathRenderer>, false>::~SkTArray() Line | Count | Source | 122 | 673 | ~SkTArray() { | 123 | 5.38k | for (int i = 0; i < this->count(); ++i) { | 124 | 4.71k | fItemArray[i].~T(); | 125 | 4.71k | } | 126 | 673 | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 673 | } |
SkTArray<GrOnFlushCallbackObject*, false>::~SkTArray() Line | Count | Source | 122 | 1.32k | ~SkTArray() { | 123 | 2.69k | for (int i = 0; i < this->count(); ++i) { | 124 | 1.36k | fItemArray[i].~T(); | 125 | 1.36k | } | 126 | 1.32k | if (fOwnMemory) { | 127 | 1.32k | sk_free(fItemArray); | 128 | 1.32k | } | 129 | 1.32k | } |
SkTArray<GrGpu::SubmittedProc, false>::~SkTArray() Line | Count | Source | 122 | 1.32k | ~SkTArray() { | 123 | 1.32k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 1.32k | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 1.32k | } |
SkTArray<SkString, false>::~SkTArray() Line | Count | Source | 122 | 1.32k | ~SkTArray() { | 123 | 1.32k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 1.32k | if (fOwnMemory) { | 127 | 1.32k | sk_free(fItemArray); | 128 | 1.32k | } | 129 | 1.32k | } |
SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::~SkTArray() Line | Count | Source | 122 | 1.32k | ~SkTArray() { | 123 | 1.32k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 1.32k | if (fOwnMemory) { | 127 | 1.32k | sk_free(fItemArray); | 128 | 1.32k | } | 129 | 1.32k | } |
Unexecuted instantiation: SkTArray<GrAuditTrail::Op*, false>::~SkTArray() SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::~SkTArray() Line | Count | Source | 122 | 1.32k | ~SkTArray() { | 123 | 1.32k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 1.32k | if (fOwnMemory) { | 127 | 1.32k | sk_free(fItemArray); | 128 | 1.32k | } | 129 | 1.32k | } |
SkTArray<GrRenderTask*, true>::~SkTArray() Line | Count | Source | 122 | 201k | ~SkTArray() { | 123 | 396k | for (int i = 0; i < this->count(); ++i) { | 124 | 194k | fItemArray[i].~T(); | 125 | 194k | } | 126 | 201k | if (fOwnMemory) { | 127 | 19.9k | sk_free(fItemArray); | 128 | 19.9k | } | 129 | 201k | } |
SkTArray<GrTextureProxy*, true>::~SkTArray() Line | Count | Source | 122 | 100k | ~SkTArray() { | 123 | 100k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 100k | if (fOwnMemory) { | 127 | 100k | sk_free(fItemArray); | 128 | 100k | } | 129 | 100k | } |
SkTArray<sk_sp<GrSurfaceProxy>, false>::~SkTArray() Line | Count | Source | 122 | 100k | ~SkTArray() { | 123 | 201k | for (int i = 0; i < this->count(); ++i) { | 124 | 100k | fItemArray[i].~T(); | 125 | 100k | } | 126 | 100k | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 100k | } |
SkTArray<GrUniqueKeyInvalidatedMessage, false>::~SkTArray() Line | Count | Source | 122 | 83.6k | ~SkTArray() { | 123 | 142k | for (int i = 0; i < this->count(); ++i) { | 124 | 59.0k | fItemArray[i].~T(); | 125 | 59.0k | } | 126 | 83.6k | if (fOwnMemory) { | 127 | 83.6k | sk_free(fItemArray); | 128 | 83.6k | } | 129 | 83.6k | } |
SkTArray<GrTextureFreedMessage, false>::~SkTArray() Line | Count | Source | 122 | 1.32k | ~SkTArray() { | 123 | 1.32k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 1.32k | if (fOwnMemory) { | 127 | 1.32k | sk_free(fItemArray); | 128 | 1.32k | } | 129 | 1.32k | } |
Unexecuted instantiation: SkTArray<GrTextureResolveRenderTask::Resolve, false>::~SkTArray() Unexecuted instantiation: SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::~SkTArray() SkTArray<sk_sp<GrTextBlob>, false>::~SkTArray() Line | Count | Source | 122 | 2.84k | ~SkTArray() { | 123 | 3.28k | for (int i = 0; i < this->count(); ++i) { | 124 | 435 | fItemArray[i].~T(); | 125 | 435 | } | 126 | 2.84k | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 2.84k | } |
SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::~SkTArray() Line | Count | Source | 122 | 1.85k | ~SkTArray() { | 123 | 2.38k | for (int i = 0; i < this->count(); ++i) { | 124 | 531 | fItemArray[i].~T(); | 125 | 531 | } | 126 | 1.85k | if (fOwnMemory) { | 127 | 1.85k | sk_free(fItemArray); | 128 | 1.85k | } | 129 | 1.85k | } |
Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo::Op, false>::~SkTArray() SkTArray<GrOpsTask::OpChain, false>::~SkTArray() Line | Count | Source | 122 | 89.6k | ~SkTArray() { | 123 | 89.6k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 89.6k | if (fOwnMemory) { | 127 | 205 | sk_free(fItemArray); | 128 | 205 | } | 129 | 89.6k | } |
SkTArray<GrSurfaceProxy*, true>::~SkTArray() Line | Count | Source | 122 | 89.6k | ~SkTArray() { | 123 | 275k | for (int i = 0; i < this->count(); ++i) { | 124 | 186k | fItemArray[i].~T(); | 125 | 186k | } | 126 | 89.6k | if (fOwnMemory) { | 127 | 89.6k | sk_free(fItemArray); | 128 | 89.6k | } | 129 | 89.6k | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAConvexPathOp::PathData, true>::~SkTArray() Line | Count | Source | 122 | 646 | ~SkTArray() { | 123 | 1.38k | for (int i = 0; i < this->count(); ++i) { | 124 | 741 | fItemArray[i].~T(); | 125 | 741 | } | 126 | 646 | if (fOwnMemory) { | 127 | 25 | sk_free(fItemArray); | 128 | 25 | } | 129 | 646 | } |
SkTArray<SkPoint, true>::~SkTArray() Line | Count | Source | 122 | 58.2k | ~SkTArray() { | 123 | 1.91M | for (int i = 0; i < this->count(); ++i) { | 124 | 1.85M | fItemArray[i].~T(); | 125 | 1.85M | } | 126 | 58.2k | if (fOwnMemory) { | 127 | 872 | sk_free(fItemArray); | 128 | 872 | } | 129 | 58.2k | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Draw, true>::~SkTArray() Line | Count | Source | 122 | 332 | ~SkTArray() { | 123 | 664 | for (int i = 0; i < this->count(); ++i) { | 124 | 332 | fItemArray[i].~T(); | 125 | 332 | } | 126 | 332 | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 332 | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Segment, true>::~SkTArray() Line | Count | Source | 122 | 461 | ~SkTArray() { | 123 | 19.8k | for (int i = 0; i < this->count(); ++i) { | 124 | 19.3k | fItemArray[i].~T(); | 125 | 19.3k | } | 126 | 461 | if (fOwnMemory) { | 127 | 59 | sk_free(fItemArray); | 128 | 59 | } | 129 | 461 | } |
AAHairLinePathRenderer.cpp:SkTArray<(anonymous namespace)::AAHairlineOp::PathData, true>::~SkTArray() Line | Count | Source | 122 | 3.64k | ~SkTArray() { | 123 | 7.76k | for (int i = 0; i < this->count(); ++i) { | 124 | 4.11k | fItemArray[i].~T(); | 125 | 4.11k | } | 126 | 3.64k | if (fOwnMemory) { | 127 | 21 | sk_free(fItemArray); | 128 | 21 | } | 129 | 3.64k | } |
SkTArray<float, true>::~SkTArray() Line | Count | Source | 122 | 13.1k | ~SkTArray() { | 123 | 277k | for (int i = 0; i < this->count(); ++i) { | 124 | 264k | fItemArray[i].~T(); | 125 | 264k | } | 126 | 13.1k | if (fOwnMemory) { | 127 | 4.69k | sk_free(fItemArray); | 128 | 4.69k | } | 129 | 13.1k | } |
AALinearizingConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::~SkTArray() Line | Count | Source | 122 | 574 | ~SkTArray() { | 123 | 1.17k | for (int i = 0; i < this->count(); ++i) { | 124 | 596 | fItemArray[i].~T(); | 125 | 596 | } | 126 | 574 | if (fOwnMemory) { | 127 | 2 | sk_free(fItemArray); | 128 | 2 | } | 129 | 574 | } |
DefaultPathRenderer.cpp:SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::~SkTArray() Line | Count | Source | 122 | 9.24k | ~SkTArray() { | 123 | 19.4k | for (int i = 0; i < this->count(); ++i) { | 124 | 10.1k | fItemArray[i].~T(); | 125 | 10.1k | } | 126 | 9.24k | if (fOwnMemory) { | 127 | 132 | sk_free(fItemArray); | 128 | 132 | } | 129 | 9.24k | } |
SkTArray<DashOp::LineData, true>::~SkTArray() Line | Count | Source | 122 | 1 | ~SkTArray() { | 123 | 2 | for (int i = 0; i < this->count(); ++i) { | 124 | 1 | fItemArray[i].~T(); | 125 | 1 | } | 126 | 1 | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 1 | } |
SkTArray<DashOp::DashDraw, true>::~SkTArray() Line | Count | Source | 122 | 1 | ~SkTArray() { | 123 | 2 | for (int i = 0; i < this->count(); ++i) { | 124 | 1 | fItemArray[i].~T(); | 125 | 1 | } | 126 | 1 | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 1 | } |
SkTArray<SkRect, true>::~SkTArray() Line | Count | Source | 122 | 1 | ~SkTArray() { | 123 | 4 | for (int i = 0; i < this->count(); ++i) { | 124 | 3 | fItemArray[i].~T(); | 125 | 3 | } | 126 | 1 | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 1 | } |
Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::~SkTArray() Unexecuted instantiation: SkTArray<unsigned char, true>::~SkTArray() Unexecuted instantiation: SkTArray<SkRSXform, false>::~SkTArray() Unexecuted instantiation: SkTArray<SkRect, false>::~SkTArray() GrDrawVerticesOp.cpp:SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::~SkTArray() Line | Count | Source | 122 | 1.85k | ~SkTArray() { | 123 | 3.75k | for (int i = 0; i < this->count(); ++i) { | 124 | 1.89k | fItemArray[i].~T(); | 125 | 1.89k | } | 126 | 1.85k | if (fOwnMemory) { | 127 | 18 | sk_free(fItemArray); | 128 | 18 | } | 129 | 1.85k | } |
SkTArray<SkPoint, false>::~SkTArray() Line | Count | Source | 122 | 386k | ~SkTArray() { | 123 | 386k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 386k | if (fOwnMemory) { | 127 | 19 | sk_free(fItemArray); | 128 | 19 | } | 129 | 386k | } |
SkTArray<unsigned short, false>::~SkTArray() Line | Count | Source | 122 | 386k | ~SkTArray() { | 123 | 386k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 386k | if (fOwnMemory) { | 127 | 19 | sk_free(fItemArray); | 128 | 19 | } | 129 | 386k | } |
Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::~SkTArray() SkTArray<CircularRRectOp::RRect, true>::~SkTArray() Line | Count | Source | 122 | 5 | ~SkTArray() { | 123 | 13 | for (int i = 0; i < this->count(); ++i) { | 124 | 8 | fItemArray[i].~T(); | 125 | 8 | } | 126 | 5 | if (fOwnMemory) { | 127 | 2 | sk_free(fItemArray); | 128 | 2 | } | 129 | 5 | } |
SkTArray<EllipticalRRectOp::RRect, true>::~SkTArray() Line | Count | Source | 122 | 2 | ~SkTArray() { | 123 | 4 | for (int i = 0; i < this->count(); ++i) { | 124 | 2 | fItemArray[i].~T(); | 125 | 2 | } | 126 | 2 | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 2 | } |
Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::~SkTArray() SkTArray<CircleOp::Circle, true>::~SkTArray() Line | Count | Source | 122 | 14 | ~SkTArray() { | 123 | 39 | for (int i = 0; i < this->count(); ++i) { | 124 | 25 | fItemArray[i].~T(); | 125 | 25 | } | 126 | 14 | if (fOwnMemory) { | 127 | 3 | sk_free(fItemArray); | 128 | 3 | } | 129 | 14 | } |
Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::~SkTArray() SkTArray<DIEllipseOp::Ellipse, true>::~SkTArray() Line | Count | Source | 122 | 7 | ~SkTArray() { | 123 | 14 | for (int i = 0; i < this->count(); ++i) { | 124 | 7 | fItemArray[i].~T(); | 125 | 7 | } | 126 | 7 | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 7 | } |
Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::~SkTArray() Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::~SkTArray() GrStrokeRectOp.cpp:SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::~SkTArray() Line | Count | Source | 122 | 208 | ~SkTArray() { | 123 | 477 | for (int i = 0; i < this->count(); ++i) { | 124 | 269 | fItemArray[i].~T(); | 125 | 269 | } | 126 | 208 | if (fOwnMemory) { | 127 | 6 | sk_free(fItemArray); | 128 | 6 | } | 129 | 208 | } |
SmallPathRenderer.cpp:SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::~SkTArray() Line | Count | Source | 122 | 2.96k | ~SkTArray() { | 123 | 6.82k | for (int i = 0; i < this->count(); ++i) { | 124 | 3.85k | fItemArray[i].~T(); | 125 | 3.85k | } | 126 | 2.96k | if (fOwnMemory) { | 127 | 99 | sk_free(fItemArray); | 128 | 99 | } | 129 | 2.96k | } |
SkTArray<SkSL::VariableReference*, false>::~SkTArray() Line | Count | Source | 122 | 38.9k | ~SkTArray() { | 123 | 49.7k | for (int i = 0; i < this->count(); ++i) { | 124 | 10.8k | fItemArray[i].~T(); | 125 | 10.8k | } | 126 | 38.9k | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 38.9k | } |
Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::~SkTArray() Unexecuted instantiation: SkTArray<GrMipLevel, false>::~SkTArray() Unexecuted instantiation: SkTArray<GrGLProgramDataManager::Uniform, true>::~SkTArray() Unexecuted instantiation: SkTArray<GrSwizzle, false>::~SkTArray() Unexecuted instantiation: SkTArray<SkSL::String, false>::~SkTArray() SkTArray<__jmp_buf_tag (*) [1], false>::~SkTArray() Line | Count | Source | 122 | 12.7k | ~SkTArray() { | 123 | 12.7k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 12.7k | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 12.7k | } |
Unexecuted instantiation: SkTArray<GrRecordingContext::ProgramData, false>::~SkTArray() SkTArray<GrUniqueKey, false>::~SkTArray() Line | Count | Source | 122 | 103k | ~SkTArray() { | 123 | 103k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 103k | if (fOwnMemory) { | 127 | 103k | sk_free(fItemArray); | 128 | 103k | } | 129 | 103k | } |
SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::~SkTArray() Line | Count | Source | 122 | 7.47k | ~SkTArray() { | 123 | 9.33k | for (int i = 0; i < this->count(); ++i) { | 124 | 1.86k | fItemArray[i].~T(); | 125 | 1.86k | } | 126 | 7.47k | if (fOwnMemory) { | 127 | 7.47k | sk_free(fItemArray); | 128 | 7.47k | } | 129 | 7.47k | } |
SkTArray<SkMatrix, false>::~SkTArray() Line | Count | Source | 122 | 1 | ~SkTArray() { | 123 | 1 | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 1 | if (fOwnMemory) { | 127 | 1 | sk_free(fItemArray); | 128 | 1 | } | 129 | 1 | } |
SkTArray<OffsetEdge, false>::~SkTArray() Line | Count | Source | 122 | 348 | ~SkTArray() { | 123 | 41.2M | for (int i = 0; i < this->count(); ++i) { | 124 | 41.2M | fItemArray[i].~T(); | 125 | 41.2M | } | 126 | 348 | if (fOwnMemory) { | 127 | 270 | sk_free(fItemArray); | 128 | 270 | } | 129 | 348 | } |
SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::~SkTArray() Line | Count | Source | 122 | 45.9k | ~SkTArray() { | 123 | 318k | for (int i = 0; i < this->count(); ++i) { | 124 | 272k | fItemArray[i].~T(); | 125 | 272k | } | 126 | 45.9k | if (fOwnMemory) { | 127 | 9.74k | sk_free(fItemArray); | 128 | 9.74k | } | 129 | 45.9k | } |
SkTArray<Sk4fGradientInterval, true>::~SkTArray() Line | Count | Source | 122 | 730 | ~SkTArray() { | 123 | 9.20k | for (int i = 0; i < this->count(); ++i) { | 124 | 8.47k | fItemArray[i].~T(); | 125 | 8.47k | } | 126 | 730 | if (fOwnMemory) { | 127 | 77 | sk_free(fItemArray); | 128 | 77 | } | 129 | 730 | } |
SkTArray<GrBufferAllocPool::BufferBlock, false>::~SkTArray() Line | Count | Source | 122 | 61.8k | ~SkTArray() { | 123 | 61.8k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 61.8k | if (fOwnMemory) { | 127 | 61.8k | sk_free(fItemArray); | 128 | 61.8k | } | 129 | 61.8k | } |
SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::~SkTArray() Line | Count | Source | 122 | 45.2k | ~SkTArray() { | 123 | 45.2k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 45.2k | if (fOwnMemory) { | 127 | 23.2k | sk_free(fItemArray); | 128 | 23.2k | } | 129 | 45.2k | } |
Unexecuted instantiation: SkTArray<PathSegment, true>::~SkTArray() SkTArray<GrDrawOpAtlas::Plot*, false>::~SkTArray() Line | Count | Source | 122 | 863 | ~SkTArray() { | 123 | 863 | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 863 | if (fOwnMemory) { | 127 | 863 | sk_free(fItemArray); | 128 | 863 | } | 129 | 863 | } |
Unexecuted instantiation: SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::~SkTArray() Unexecuted instantiation: SkTArray<GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*, true>::~SkTArray() Unexecuted instantiation: SkTArray<GrProcessorTestFactory<GrGeometryProcessor*>*, true>::~SkTArray() Unexecuted instantiation: SkTArray<GrXPFactoryTestFactory*, true>::~SkTArray() SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::~SkTArray() Line | Count | Source | 122 | 1.83k | ~SkTArray() { | 123 | 2.34k | for (int i = 0; i < this->count(); ++i) { | 124 | 516 | fItemArray[i].~T(); | 125 | 516 | } | 126 | 1.83k | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 1.83k | } |
Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::~SkTArray() Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::~SkTArray() SkTArray<skgpu::v1::ClipStack::Element const*, false>::~SkTArray() Line | Count | Source | 122 | 12.8k | ~SkTArray() { | 123 | 23.1k | for (int i = 0; i < this->count(); ++i) { | 124 | 10.3k | fItemArray[i].~T(); | 125 | 10.3k | } | 126 | 12.8k | if (fOwnMemory) { | 127 | 31 | sk_free(fItemArray); | 128 | 31 | } | 129 | 12.8k | } |
Unexecuted instantiation: SkTArray<skgpu::v1::ClipStack::Element, false>::~SkTArray() Unexecuted instantiation: SkTArray<GrGLFormat, true>::~SkTArray() SkTArray<std::__1::unique_ptr<SkCodec, std::__1::default_delete<SkCodec> >, true>::~SkTArray() Line | Count | Source | 122 | 3.38k | ~SkTArray() { | 123 | 6.13k | for (int i = 0; i < this->count(); ++i) { | 124 | 2.74k | fItemArray[i].~T(); | 125 | 2.74k | } | 126 | 3.38k | if (fOwnMemory) { | 127 | 3.38k | sk_free(fItemArray); | 128 | 3.38k | } | 129 | 3.38k | } |
Unexecuted instantiation: SkTArray<dng_exception, false>::~SkTArray() Unexecuted instantiation: SkTArray<std::__1::thread, false>::~SkTArray() Unexecuted instantiation: SkTArray<std::__1::function<void ()>, false>::~SkTArray() SkTArray<SkOpRayHit*, false>::~SkTArray() Line | Count | Source | 122 | 2.60M | ~SkTArray() { | 123 | 36.1M | for (int i = 0; i < this->count(); ++i) { | 124 | 33.5M | fItemArray[i].~T(); | 125 | 33.5M | } | 126 | 2.60M | if (fOwnMemory) { | 127 | 2.47M | sk_free(fItemArray); | 128 | 2.47M | } | 129 | 2.60M | } |
SkTArray<double, true>::~SkTArray() Line | Count | Source | 122 | 94.5k | ~SkTArray() { | 123 | 52.0M | for (int i = 0; i < this->count(); ++i) { | 124 | 51.9M | fItemArray[i].~T(); | 125 | 51.9M | } | 126 | 94.5k | if (fOwnMemory) { | 127 | 52.5k | sk_free(fItemArray); | 128 | 52.5k | } | 129 | 94.5k | } |
Unexecuted instantiation: SkTArray<GrProgramInfo const*, false>::~SkTArray() SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true>::~SkTArray() Line | Count | Source | 122 | 8.66k | ~SkTArray() { | 123 | 8.66k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 8.66k | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 8.66k | } |
SkTArray<sk_sp<SkTypeface_Custom>, false>::~SkTArray() Line | Count | Source | 122 | 5 | ~SkTArray() { | 123 | 10 | for (int i = 0; i < this->count(); ++i) { | 124 | 5 | fItemArray[i].~T(); | 125 | 5 | } | 126 | 5 | if (fOwnMemory) { | 127 | 5 | sk_free(fItemArray); | 128 | 5 | } | 129 | 5 | } |
SkTArray<sk_sp<SkFontStyleSet_Custom>, false>::~SkTArray() Line | Count | Source | 122 | 5 | ~SkTArray() { | 123 | 10 | for (int i = 0; i < this->count(); ++i) { | 124 | 5 | fItemArray[i].~T(); | 125 | 5 | } | 126 | 5 | if (fOwnMemory) { | 127 | 5 | sk_free(fItemArray); | 128 | 5 | } | 129 | 5 | } |
SkTArray<SkClosestRecord const*, true>::~SkTArray() Line | Count | Source | 122 | 2.25M | ~SkTArray() { | 123 | 5.21M | for (int i = 0; i < this->count(); ++i) { | 124 | 2.95M | fItemArray[i].~T(); | 125 | 2.95M | } | 126 | 2.25M | if (fOwnMemory) { | 127 | 976 | sk_free(fItemArray); | 128 | 976 | } | 129 | 2.25M | } |
SkTArray<SkClosestRecord, true>::~SkTArray() Line | Count | Source | 122 | 2.25M | ~SkTArray() { | 123 | 7.46M | for (int i = 0; i < this->count(); ++i) { | 124 | 5.21M | fItemArray[i].~T(); | 125 | 5.21M | } | 126 | 2.25M | if (fOwnMemory) { | 127 | 978 | sk_free(fItemArray); | 128 | 978 | } | 129 | 2.25M | } |
Unexecuted instantiation: SkTArray<GrVertexChunk, false>::~SkTArray() Unexecuted instantiation: SkTArray<std::__1::array<unsigned short, 3ul>, false>::~SkTArray() Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfLayerInfo, false>::~SkTArray() Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfInfo, false>::~SkTArray() Layer.cpp:SkTArray<skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::~SkTArray() Line | Count | Source | 122 | 9.42k | ~SkTArray() { | 123 | 18.0k | for (int i = 0; i < this->count(); ++i) { | 124 | 8.61k | fItemArray[i].~T(); | 125 | 8.61k | } | 126 | 9.42k | if (fOwnMemory) { | 127 | 18 | sk_free(fItemArray); | 128 | 18 | } | 129 | 9.42k | } |
Unexecuted instantiation: SkottieShaper.cpp:SkTArray<skottie::(anonymous namespace)::BlobMaker::RunRec, false>::~SkTArray() SkTArray<sk_sp<SkSVGNode>, true>::~SkTArray() Line | Count | Source | 122 | 76.5k | ~SkTArray() { | 123 | 370k | for (int i = 0; i < this->count(); ++i) { | 124 | 293k | fItemArray[i].~T(); | 125 | 293k | } | 126 | 76.5k | if (fOwnMemory) { | 127 | 29.5k | sk_free(fItemArray); | 128 | 29.5k | } | 129 | 76.5k | } |
SkTArray<SkSVGTextContext::PositionAdjustment, true>::~SkTArray() Line | Count | Source | 122 | 19.7k | ~SkTArray() { | 123 | 19.7k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 19.7k | if (fOwnMemory) { | 127 | 3.59k | sk_free(fItemArray); | 128 | 3.59k | } | 129 | 19.7k | } |
SkTArray<char, true>::~SkTArray() Line | Count | Source | 122 | 19.7k | ~SkTArray() { | 123 | 19.7k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 19.7k | if (fOwnMemory) { | 127 | 3.59k | sk_free(fItemArray); | 128 | 3.59k | } | 129 | 19.7k | } |
SkTArray<hb_feature_t, false>::~SkTArray() Line | Count | Source | 122 | 464k | ~SkTArray() { | 123 | 464k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 464k | if (fOwnMemory) { | 127 | 0 | sk_free(fItemArray); | 128 | 0 | } | 129 | 464k | } |
SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::~SkTArray() Line | Count | Source | 122 | 19.4k | ~SkTArray() { | 123 | 437k | for (int i = 0; i < this->count(); ++i) { | 124 | 418k | fItemArray[i].~T(); | 125 | 418k | } | 126 | 19.4k | if (fOwnMemory) { | 127 | 19.4k | sk_free(fItemArray); | 128 | 19.4k | } | 129 | 19.4k | } |
SkTArray<skia::textlayout::Block, true>::~SkTArray() Line | Count | Source | 122 | 24.4k | ~SkTArray() { | 123 | 44.8k | for (int i = 0; i < this->count(); ++i) { | 124 | 20.4k | fItemArray[i].~T(); | 125 | 20.4k | } | 126 | 24.4k | if (fOwnMemory) { | 127 | 24.4k | sk_free(fItemArray); | 128 | 24.4k | } | 129 | 24.4k | } |
SkTArray<skia::textlayout::Placeholder, true>::~SkTArray() Line | Count | Source | 122 | 24.4k | ~SkTArray() { | 123 | 44.8k | for (int i = 0; i < this->count(); ++i) { | 124 | 20.4k | fItemArray[i].~T(); | 125 | 20.4k | } | 126 | 24.4k | if (fOwnMemory) { | 127 | 24.4k | sk_free(fItemArray); | 128 | 24.4k | } | 129 | 24.4k | } |
Unexecuted instantiation: SkTArray<unsigned short, true>::~SkTArray() SkTArray<skia::textlayout::CodeUnitFlags, false>::~SkTArray() Line | Count | Source | 122 | 6.43k | ~SkTArray() { | 123 | 2.16M | for (int i = 0; i < this->count(); ++i) { | 124 | 2.16M | fItemArray[i].~T(); | 125 | 2.16M | } | 126 | 6.43k | if (fOwnMemory) { | 127 | 6.43k | sk_free(fItemArray); | 128 | 6.43k | } | 129 | 6.43k | } |
SkTArray<skia::textlayout::Run, false>::~SkTArray() Line | Count | Source | 122 | 6.43k | ~SkTArray() { | 123 | 6.43k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 6.43k | if (fOwnMemory) { | 127 | 6.43k | sk_free(fItemArray); | 128 | 6.43k | } | 129 | 6.43k | } |
SkTArray<skia::textlayout::StyleBlock<float>, false>::~SkTArray() Line | Count | Source | 122 | 8.05k | ~SkTArray() { | 123 | 8.05k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 8.05k | if (fOwnMemory) { | 127 | 8.05k | sk_free(fItemArray); | 128 | 8.05k | } | 129 | 8.05k | } |
SkTArray<skia::textlayout::StyleBlock<SkPaint>, false>::~SkTArray() Line | Count | Source | 122 | 8.05k | ~SkTArray() { | 123 | 8.05k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 8.05k | if (fOwnMemory) { | 127 | 8.05k | sk_free(fItemArray); | 128 | 8.05k | } | 129 | 8.05k | } |
SkTArray<skia::textlayout::StyleBlock<std::__1::vector<skia::textlayout::TextShadow, std::__1::allocator<skia::textlayout::TextShadow> > >, false>::~SkTArray() Line | Count | Source | 122 | 4.02k | ~SkTArray() { | 123 | 4.02k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 4.02k | if (fOwnMemory) { | 127 | 4.02k | sk_free(fItemArray); | 128 | 4.02k | } | 129 | 4.02k | } |
SkTArray<skia::textlayout::StyleBlock<skia::textlayout::Decoration>, false>::~SkTArray() Line | Count | Source | 122 | 4.02k | ~SkTArray() { | 123 | 4.02k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 4.02k | if (fOwnMemory) { | 127 | 4.02k | sk_free(fItemArray); | 128 | 4.02k | } | 129 | 4.02k | } |
SkTArray<skia::textlayout::Cluster, true>::~SkTArray() Line | Count | Source | 122 | 4.02k | ~SkTArray() { | 123 | 7.80k | for (int i = 0; i < this->count(); ++i) { | 124 | 3.78k | fItemArray[i].~T(); | 125 | 3.78k | } | 126 | 4.02k | if (fOwnMemory) { | 127 | 4.02k | sk_free(fItemArray); | 128 | 4.02k | } | 129 | 4.02k | } |
SkTArray<unsigned long, false>::~SkTArray() Line | Count | Source | 122 | 4.02k | ~SkTArray() { | 123 | 1.32M | for (int i = 0; i < this->count(); ++i) { | 124 | 1.32M | fItemArray[i].~T(); | 125 | 1.32M | } | 126 | 4.02k | if (fOwnMemory) { | 127 | 4.02k | sk_free(fItemArray); | 128 | 4.02k | } | 129 | 4.02k | } |
SkTArray<skia::textlayout::TextLine, false>::~SkTArray() Line | Count | Source | 122 | 4.02k | ~SkTArray() { | 123 | 4.02k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 4.02k | if (fOwnMemory) { | 127 | 4.02k | sk_free(fItemArray); | 128 | 4.02k | } | 129 | 4.02k | } |
SkTArray<skia::textlayout::ResolvedFontDescriptor, false>::~SkTArray() Line | Count | Source | 122 | 4.02k | ~SkTArray() { | 123 | 4.02k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 4.02k | if (fOwnMemory) { | 127 | 4.02k | sk_free(fItemArray); | 128 | 4.02k | } | 129 | 4.02k | } |
SkTArray<SkShaper::Feature, false>::~SkTArray() Line | Count | Source | 122 | 173k | ~SkTArray() { | 123 | 173k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 173k | if (fOwnMemory) { | 127 | 173k | sk_free(fItemArray); | 128 | 173k | } | 129 | 173k | } |
Unexecuted instantiation: SkTArray<bool, true>::~SkTArray() Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::~SkTArray() Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo, false>::~SkTArray() Unexecuted instantiation: SkTArray<SkTArray<SkPDFTagNode*, false>, false>::~SkTArray() Unexecuted instantiation: SkTArray<SkPDFTagNode*, false>::~SkTArray() Unexecuted instantiation: SkTArray<SkPDFTagNode::MarkedContentInfo, false>::~SkTArray() SkTArray<SkSVGDevice::ClipRec, false>::~SkTArray() Line | Count | Source | 122 | 12.9k | ~SkTArray() { | 123 | 12.9k | for (int i = 0; i < this->count(); ++i) { | 124 | 0 | fItemArray[i].~T(); | 125 | 0 | } | 126 | 12.9k | if (fOwnMemory) { | 127 | 12.9k | sk_free(fItemArray); | 128 | 12.9k | } | 129 | 12.9k | } |
|
130 | | |
131 | | /** |
132 | | * Resets to count() == 0 and resets any reserve count. |
133 | | */ |
134 | 1.53M | void reset() { |
135 | 1.53M | this->pop_back_n(fCount); |
136 | 1.53M | fReserved = false; |
137 | 1.53M | } SkTArray<SkString, false>::reset() Line | Count | Source | 134 | 20 | void reset() { | 135 | 20 | this->pop_back_n(fCount); | 136 | 20 | fReserved = false; | 137 | 20 | } |
SkTArray<SkNoPixelsDevice::ClipState, false>::reset() Line | Count | Source | 134 | 480k | void reset() { | 135 | 480k | this->pop_back_n(fCount); | 136 | 480k | fReserved = false; | 137 | 480k | } |
SkTArray<sk_gpu_test::GrContextFactory::Context, true>::reset() Line | Count | Source | 134 | 1.50k | void reset() { | 135 | 1.50k | this->pop_back_n(fCount); | 136 | 1.50k | fReserved = false; | 137 | 1.50k | } |
SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::reset() Line | Count | Source | 134 | 508 | void reset() { | 135 | 508 | this->pop_back_n(fCount); | 136 | 508 | fReserved = false; | 137 | 508 | } |
Unexecuted instantiation: SkTArray<SkRuntimeEffect::ChildPtr, false>::reset() SkTArray<unsigned int, true>::reset() Line | Count | Source | 134 | 20.6k | void reset() { | 135 | 20.6k | this->pop_back_n(fCount); | 136 | 20.6k | fReserved = false; | 137 | 20.6k | } |
SkTArray<sk_sp<GrRenderTask>, false>::reset() Line | Count | Source | 134 | 64.5k | void reset() { | 135 | 64.5k | this->pop_back_n(fCount); | 136 | 64.5k | fReserved = false; | 137 | 64.5k | } |
SkTArray<GrGpu::SubmittedProc, false>::reset() Line | Count | Source | 134 | 22.6k | void reset() { | 135 | 22.6k | this->pop_back_n(fCount); | 136 | 22.6k | fReserved = false; | 137 | 22.6k | } |
SkTArray<GrUniqueKeyInvalidatedMessage, false>::reset() Line | Count | Source | 134 | 82.3k | void reset() { | 135 | 82.3k | this->pop_back_n(fCount); | 136 | 82.3k | fReserved = false; | 137 | 82.3k | } |
Unexecuted instantiation: SkTArray<GrTextureFreedMessage, false>::reset() SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::reset() Line | Count | Source | 134 | 531 | void reset() { | 135 | 531 | this->pop_back_n(fCount); | 136 | 531 | fReserved = false; | 137 | 531 | } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::reset() Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::reset() SkTArray<GrOpsTask::OpChain, false>::reset() Line | Count | Source | 134 | 126k | void reset() { | 135 | 126k | this->pop_back_n(fCount); | 136 | 126k | fReserved = false; | 137 | 126k | } |
SkTArray<GrTextureProxy*, true>::reset() Line | Count | Source | 134 | 37.3k | void reset() { | 135 | 37.3k | this->pop_back_n(fCount); | 136 | 37.3k | fReserved = false; | 137 | 37.3k | } |
SkTArray<GrSurfaceProxy*, true>::reset() Line | Count | Source | 134 | 37.3k | void reset() { | 135 | 37.3k | this->pop_back_n(fCount); | 136 | 37.3k | fReserved = false; | 137 | 37.3k | } |
SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::reset() Line | Count | Source | 134 | 7.47k | void reset() { | 135 | 7.47k | this->pop_back_n(fCount); | 136 | 7.47k | fReserved = false; | 137 | 7.47k | } |
SkTArray<sk_sp<SkTextBlob const>, false>::reset() Line | Count | Source | 134 | 127 | void reset() { | 135 | 127 | this->pop_back_n(fCount); | 136 | 127 | fReserved = false; | 137 | 127 | } |
SkTArray<sk_sp<SkVertices const>, false>::reset() Line | Count | Source | 134 | 48 | void reset() { | 135 | 48 | this->pop_back_n(fCount); | 136 | 48 | fReserved = false; | 137 | 48 | } |
SkTArray<sk_sp<SkImage const>, false>::reset() Line | Count | Source | 134 | 1.71k | void reset() { | 135 | 1.71k | this->pop_back_n(fCount); | 136 | 1.71k | fReserved = false; | 137 | 1.71k | } |
Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::reset() SkTArray<sk_sp<SkDrawable>, false>::reset() Line | Count | Source | 134 | 7 | void reset() { | 135 | 7 | this->pop_back_n(fCount); | 136 | 7 | fReserved = false; | 137 | 7 | } |
SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::reset() Line | Count | Source | 134 | 21.9k | void reset() { | 135 | 21.9k | this->pop_back_n(fCount); | 136 | 21.9k | fReserved = false; | 137 | 21.9k | } |
Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::reset() SkTArray<unsigned short, false>::reset() Line | Count | Source | 134 | 210k | void reset() { | 135 | 210k | this->pop_back_n(fCount); | 136 | 210k | fReserved = false; | 137 | 210k | } |
SkTArray<SkPoint, false>::reset() Line | Count | Source | 134 | 210k | void reset() { | 135 | 210k | this->pop_back_n(fCount); | 136 | 210k | fReserved = false; | 137 | 210k | } |
SkTArray<Sk4fGradientInterval, true>::reset() Line | Count | Source | 134 | 730 | void reset() { | 135 | 730 | this->pop_back_n(fCount); | 136 | 730 | fReserved = false; | 137 | 730 | } |
Unexecuted instantiation: SkTArray<SkPoint, true>::reset() Unexecuted instantiation: SkottieShaper.cpp:SkTArray<skottie::(anonymous namespace)::BlobMaker::RunRec, false>::reset() SkTArray<char, true>::reset() Line | Count | Source | 134 | 19.4k | void reset() { | 135 | 19.4k | this->pop_back_n(fCount); | 136 | 19.4k | fReserved = false; | 137 | 19.4k | } |
SkTArray<SkSVGTextContext::PositionAdjustment, true>::reset() Line | Count | Source | 134 | 19.4k | void reset() { | 135 | 19.4k | this->pop_back_n(fCount); | 136 | 19.4k | fReserved = false; | 137 | 19.4k | } |
SkTArray<SkPath, false>::reset() Line | Count | Source | 134 | 76.8k | void reset() { | 135 | 76.8k | this->pop_back_n(fCount); | 136 | 76.8k | fReserved = false; | 137 | 76.8k | } |
Unexecuted instantiation: SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::reset() SkTArray<skia::textlayout::Run, false>::reset() Line | Count | Source | 134 | 4.04k | void reset() { | 135 | 4.04k | this->pop_back_n(fCount); | 136 | 4.04k | fReserved = false; | 137 | 4.04k | } |
SkTArray<skia::textlayout::CodeUnitFlags, false>::reset() Line | Count | Source | 134 | 4.02k | void reset() { | 135 | 4.02k | this->pop_back_n(fCount); | 136 | 4.02k | fReserved = false; | 137 | 4.02k | } |
SkTArray<unsigned long, true>::reset() Line | Count | Source | 134 | 8.05k | void reset() { | 135 | 8.05k | this->pop_back_n(fCount); | 136 | 8.05k | fReserved = false; | 137 | 8.05k | } |
SkTArray<skia::textlayout::TextLine, false>::reset() Line | Count | Source | 134 | 4.02k | void reset() { | 135 | 4.02k | this->pop_back_n(fCount); | 136 | 4.02k | fReserved = false; | 137 | 4.02k | } |
SkTArray<skia::textlayout::Cluster, true>::reset() Line | Count | Source | 134 | 3.78k | void reset() { | 135 | 3.78k | this->pop_back_n(fCount); | 136 | 3.78k | fReserved = false; | 137 | 3.78k | } |
SkTArray<unsigned long, false>::reset() Line | Count | Source | 134 | 3.78k | void reset() { | 135 | 3.78k | this->pop_back_n(fCount); | 136 | 3.78k | fReserved = false; | 137 | 3.78k | } |
SkTArray<skia::textlayout::ResolvedFontDescriptor, false>::reset() Line | Count | Source | 134 | 3.76k | void reset() { | 135 | 3.76k | this->pop_back_n(fCount); | 136 | 3.76k | fReserved = false; | 137 | 3.76k | } |
SkTArray<SkShaper::Feature, false>::reset() Line | Count | Source | 134 | 57.6k | void reset() { | 135 | 57.6k | this->pop_back_n(fCount); | 136 | 57.6k | fReserved = false; | 137 | 57.6k | } |
|
138 | | |
139 | | /** |
140 | | * Resets to count() = n newly constructed T objects and resets any reserve count. |
141 | | */ |
142 | 912 | void reset(int n) { |
143 | 912 | SkASSERT(n >= 0); |
144 | 912 | for (int i = 0; i < this->count(); ++i) { |
145 | 0 | fItemArray[i].~T(); |
146 | 0 | } |
147 | | // Set fCount to 0 before calling checkRealloc so that no elements are moved. |
148 | 912 | fCount = 0; |
149 | 912 | this->checkRealloc(n, kExactFit); |
150 | 912 | fCount = n; |
151 | 3.65k | for (int i = 0; i < this->count(); ++i) { |
152 | 2.74k | new (fItemArray + i) T; |
153 | 2.74k | } |
154 | 912 | fReserved = false; |
155 | 912 | } Unexecuted instantiation: SkTArray<unsigned int, true>::reset(int) SkTArray<int, false>::reset(int) Line | Count | Source | 142 | 456 | void reset(int n) { | 143 | 456 | SkASSERT(n >= 0); | 144 | 456 | for (int i = 0; i < this->count(); ++i) { | 145 | 0 | fItemArray[i].~T(); | 146 | 0 | } | 147 | | // Set fCount to 0 before calling checkRealloc so that no elements are moved. | 148 | 456 | fCount = 0; | 149 | 456 | this->checkRealloc(n, kExactFit); | 150 | 456 | fCount = n; | 151 | 1.82k | for (int i = 0; i < this->count(); ++i) { | 152 | 1.37k | new (fItemArray + i) T; | 153 | 1.37k | } | 154 | 456 | fReserved = false; | 155 | 456 | } |
SkTArray<float, false>::reset(int) Line | Count | Source | 142 | 456 | void reset(int n) { | 143 | 456 | SkASSERT(n >= 0); | 144 | 456 | for (int i = 0; i < this->count(); ++i) { | 145 | 0 | fItemArray[i].~T(); | 146 | 0 | } | 147 | | // Set fCount to 0 before calling checkRealloc so that no elements are moved. | 148 | 456 | fCount = 0; | 149 | 456 | this->checkRealloc(n, kExactFit); | 150 | 456 | fCount = n; | 151 | 1.82k | for (int i = 0; i < this->count(); ++i) { | 152 | 1.37k | new (fItemArray + i) T; | 153 | 1.37k | } | 154 | 456 | fReserved = false; | 155 | 456 | } |
Unexecuted instantiation: SkTArray<unsigned char, true>::reset(int) Unexecuted instantiation: SkTArray<SkPath, false>::reset(int) Unexecuted instantiation: SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::reset(int) Unexecuted instantiation: SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true>::reset(int) Unexecuted instantiation: SkTArray<unsigned int, false>::reset(int) Unexecuted instantiation: SkTArray<unsigned int, true>::reset(int) Unexecuted instantiation: SkTArray<unsigned char, true>::reset(int) Unexecuted instantiation: SkTArray<SkPath, false>::reset(int) Unexecuted instantiation: SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::reset(int) Unexecuted instantiation: SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true>::reset(int) |
156 | | |
157 | | /** |
158 | | * Resets to a copy of a C array and resets any reserve count. |
159 | | */ |
160 | 0 | void reset(const T* array, int count) { |
161 | 0 | for (int i = 0; i < this->count(); ++i) { |
162 | 0 | fItemArray[i].~T(); |
163 | 0 | } |
164 | 0 | fCount = 0; |
165 | 0 | this->checkRealloc(count, kExactFit); |
166 | 0 | fCount = count; |
167 | 0 | this->copy(array); |
168 | 0 | fReserved = false; |
169 | 0 | } |
170 | | |
171 | | /** |
172 | | * Ensures there is enough reserved space for n additional elements. The is guaranteed at least |
173 | | * until the array size grows above n and subsequently shrinks below n, any version of reset() |
174 | | * is called, or reserve_back() is called again. |
175 | | */ |
176 | 8.15M | void reserve_back(int n) { |
177 | 8.15M | SkASSERT(n >= 0); |
178 | 8.15M | if (n > 0) { |
179 | 7.32M | this->checkRealloc(n, kExactFit); |
180 | 7.32M | fReserved = fOwnMemory; |
181 | 827k | } else { |
182 | 827k | fReserved = false; |
183 | 827k | } |
184 | 8.15M | } SkTArray<SkRuntimeEffect::ChildPtr, false>::reserve_back(int) Line | Count | Source | 176 | 4.04k | void reserve_back(int n) { | 177 | 4.04k | SkASSERT(n >= 0); | 178 | 4.04k | if (n > 0) { | 179 | 4.04k | this->checkRealloc(n, kExactFit); | 180 | 4.04k | fReserved = fOwnMemory; | 181 | 0 | } else { | 182 | 0 | fReserved = false; | 183 | 0 | } | 184 | 4.04k | } |
SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::reserve_back(int) Line | Count | Source | 176 | 63 | void reserve_back(int n) { | 177 | 63 | SkASSERT(n >= 0); | 178 | 63 | if (n > 0) { | 179 | 63 | this->checkRealloc(n, kExactFit); | 180 | 63 | fReserved = fOwnMemory; | 181 | 0 | } else { | 182 | 0 | fReserved = false; | 183 | 0 | } | 184 | 63 | } |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::reserve_back(int) Line | Count | Source | 176 | 16 | void reserve_back(int n) { | 177 | 16 | SkASSERT(n >= 0); | 178 | 16 | if (n > 0) { | 179 | 16 | this->checkRealloc(n, kExactFit); | 180 | 16 | fReserved = fOwnMemory; | 181 | 0 | } else { | 182 | 0 | fReserved = false; | 183 | 0 | } | 184 | 16 | } |
Unexecuted instantiation: SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::reserve_back(int) Unexecuted instantiation: SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::reserve_back(int) SkTArray<SkSL::Type const*, false>::reserve_back(int) Line | Count | Source | 176 | 453 | void reserve_back(int n) { | 177 | 453 | SkASSERT(n >= 0); | 178 | 453 | if (n > 0) { | 179 | 453 | this->checkRealloc(n, kExactFit); | 180 | 453 | fReserved = fOwnMemory; | 181 | 0 | } else { | 182 | 0 | fReserved = false; | 183 | 0 | } | 184 | 453 | } |
SkTArray<unsigned int, true>::reserve_back(int) Line | Count | Source | 176 | 20.6k | void reserve_back(int n) { | 177 | 20.6k | SkASSERT(n >= 0); | 178 | 20.6k | if (n > 0) { | 179 | 2.48k | this->checkRealloc(n, kExactFit); | 180 | 2.48k | fReserved = fOwnMemory; | 181 | 18.1k | } else { | 182 | 18.1k | fReserved = false; | 183 | 18.1k | } | 184 | 20.6k | } |
SkTArray<GrTextureProxy*, true>::reserve_back(int) Line | Count | Source | 176 | 5.24k | void reserve_back(int n) { | 177 | 5.24k | SkASSERT(n >= 0); | 178 | 5.24k | if (n > 0) { | 179 | 0 | this->checkRealloc(n, kExactFit); | 180 | 0 | fReserved = fOwnMemory; | 181 | 5.24k | } else { | 182 | 5.24k | fReserved = false; | 183 | 5.24k | } | 184 | 5.24k | } |
SkTArray<GrSurfaceProxy*, true>::reserve_back(int) Line | Count | Source | 176 | 5.24k | void reserve_back(int n) { | 177 | 5.24k | SkASSERT(n >= 0); | 178 | 5.24k | if (n > 0) { | 179 | 251 | this->checkRealloc(n, kExactFit); | 180 | 251 | fReserved = fOwnMemory; | 181 | 4.99k | } else { | 182 | 4.99k | fReserved = false; | 183 | 4.99k | } | 184 | 5.24k | } |
SkTArray<GrOpsTask::OpChain, false>::reserve_back(int) Line | Count | Source | 176 | 5.24k | void reserve_back(int n) { | 177 | 5.24k | SkASSERT(n >= 0); | 178 | 5.24k | if (n > 0) { | 179 | 1.08k | this->checkRealloc(n, kExactFit); | 180 | 1.08k | fReserved = fOwnMemory; | 181 | 4.15k | } else { | 182 | 4.15k | fReserved = false; | 183 | 4.15k | } | 184 | 5.24k | } |
Unexecuted instantiation: SkTArray<SkRSXform, false>::reserve_back(int) Unexecuted instantiation: SkTArray<SkRect, false>::reserve_back(int) SkTArray<sk_sp<SkPicture const>, false>::reserve_back(int) Line | Count | Source | 176 | 121 | void reserve_back(int n) { | 177 | 121 | SkASSERT(n >= 0); | 178 | 121 | if (n > 0) { | 179 | 11 | this->checkRealloc(n, kExactFit); | 180 | 11 | fReserved = fOwnMemory; | 181 | 110 | } else { | 182 | 110 | fReserved = false; | 183 | 110 | } | 184 | 121 | } |
SkTArray<SkMatrix, false>::reserve_back(int) Line | Count | Source | 176 | 1 | void reserve_back(int n) { | 177 | 1 | SkASSERT(n >= 0); | 178 | 1 | if (n > 0) { | 179 | 0 | this->checkRealloc(n, kExactFit); | 180 | 0 | fReserved = fOwnMemory; | 181 | 1 | } else { | 182 | 1 | fReserved = false; | 183 | 1 | } | 184 | 1 | } |
SkTArray<OffsetEdge, false>::reserve_back(int) Line | Count | Source | 176 | 348 | void reserve_back(int n) { | 177 | 348 | SkASSERT(n >= 0); | 178 | 348 | if (n > 0) { | 179 | 348 | this->checkRealloc(n, kExactFit); | 180 | 348 | fReserved = fOwnMemory; | 181 | 0 | } else { | 182 | 0 | fReserved = false; | 183 | 0 | } | 184 | 348 | } |
SkTArray<GrBufferAllocPool::BufferBlock, false>::reserve_back(int) Line | Count | Source | 176 | 61.8k | void reserve_back(int n) { | 177 | 61.8k | SkASSERT(n >= 0); | 178 | 61.8k | if (n > 0) { | 179 | 61.8k | this->checkRealloc(n, kExactFit); | 180 | 61.8k | fReserved = fOwnMemory; | 181 | 0 | } else { | 182 | 0 | fReserved = false; | 183 | 0 | } | 184 | 61.8k | } |
SkTArray<float, true>::reserve_back(int) Line | Count | Source | 176 | 8.84k | void reserve_back(int n) { | 177 | 8.84k | SkASSERT(n >= 0); | 178 | 8.84k | if (n > 0) { | 179 | 8.84k | this->checkRealloc(n, kExactFit); | 180 | 8.84k | fReserved = fOwnMemory; | 181 | 0 | } else { | 182 | 0 | fReserved = false; | 183 | 0 | } | 184 | 8.84k | } |
Unexecuted instantiation: SkTArray<skgpu::v1::ClipStack::Element, false>::reserve_back(int) SkTArray<std::__1::unique_ptr<SkCodec, std::__1::default_delete<SkCodec> >, true>::reserve_back(int) Line | Count | Source | 176 | 3.38k | void reserve_back(int n) { | 177 | 3.38k | SkASSERT(n >= 0); | 178 | 3.38k | if (n > 0) { | 179 | 3.38k | this->checkRealloc(n, kExactFit); | 180 | 3.38k | fReserved = fOwnMemory; | 181 | 0 | } else { | 182 | 0 | fReserved = false; | 183 | 0 | } | 184 | 3.38k | } |
SkTArray<double, true>::reserve_back(int) Line | Count | Source | 176 | 94.5k | void reserve_back(int n) { | 177 | 94.5k | SkASSERT(n >= 0); | 178 | 94.5k | if (n > 0) { | 179 | 94.5k | this->checkRealloc(n, kExactFit); | 180 | 94.5k | fReserved = fOwnMemory; | 181 | 0 | } else { | 182 | 0 | fReserved = false; | 183 | 0 | } | 184 | 94.5k | } |
SkTArray<int, true>::reserve_back(int) Line | Count | Source | 176 | 189k | void reserve_back(int n) { | 177 | 189k | SkASSERT(n >= 0); | 178 | 189k | if (n > 0) { | 179 | 189k | this->checkRealloc(n, kExactFit); | 180 | 189k | fReserved = fOwnMemory; | 181 | 0 | } else { | 182 | 0 | fReserved = false; | 183 | 0 | } | 184 | 189k | } |
Unexecuted instantiation: SkTArray<std::__1::array<unsigned short, 3ul>, false>::reserve_back(int) Unexecuted instantiation: SkTArray<sk_sp<ToolUtils::TopoTestNode>, false>::reserve_back(int) Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfInfo, false>::reserve_back(int) SkTArray<char, true>::reserve_back(int) Line | Count | Source | 176 | 17.3k | void reserve_back(int n) { | 177 | 17.3k | SkASSERT(n >= 0); | 178 | 17.3k | if (n > 0) { | 179 | 17.3k | this->checkRealloc(n, kExactFit); | 180 | 17.3k | fReserved = fOwnMemory; | 181 | 0 | } else { | 182 | 0 | fReserved = false; | 183 | 0 | } | 184 | 17.3k | } |
SkTArray<SkSVGTextContext::PositionAdjustment, true>::reserve_back(int) Line | Count | Source | 176 | 17.3k | void reserve_back(int n) { | 177 | 17.3k | SkASSERT(n >= 0); | 178 | 17.3k | if (n > 0) { | 179 | 17.3k | this->checkRealloc(n, kExactFit); | 180 | 17.3k | fReserved = fOwnMemory; | 181 | 0 | } else { | 182 | 0 | fReserved = false; | 183 | 0 | } | 184 | 17.3k | } |
SkTArray<skia::textlayout::Cluster, true>::reserve_back(int) Line | Count | Source | 176 | 3.78k | void reserve_back(int n) { | 177 | 3.78k | SkASSERT(n >= 0); | 178 | 3.78k | if (n > 0) { | 179 | 3.78k | this->checkRealloc(n, kExactFit); | 180 | 3.78k | fReserved = fOwnMemory; | 181 | 0 | } else { | 182 | 0 | fReserved = false; | 183 | 0 | } | 184 | 3.78k | } |
Unexecuted instantiation: SkTArray<float, false>::reserve_back(int) SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::reserve_back(int) Line | Count | Source | 176 | 3.97M | void reserve_back(int n) { | 177 | 3.97M | SkASSERT(n >= 0); | 178 | 3.97M | if (n > 0) { | 179 | 3.92M | this->checkRealloc(n, kExactFit); | 180 | 3.92M | fReserved = fOwnMemory; | 181 | 51.3k | } else { | 182 | 51.3k | fReserved = false; | 183 | 51.3k | } | 184 | 3.97M | } |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::reserve_back(int) Line | Count | Source | 176 | 3.35M | void reserve_back(int n) { | 177 | 3.35M | SkASSERT(n >= 0); | 178 | 3.35M | if (n > 0) { | 179 | 2.81M | this->checkRealloc(n, kExactFit); | 180 | 2.81M | fReserved = fOwnMemory; | 181 | 537k | } else { | 182 | 537k | fReserved = false; | 183 | 537k | } | 184 | 3.35M | } |
Unexecuted instantiation: SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::reserve_back(int) Unexecuted instantiation: SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::reserve_back(int) SkTArray<SkSL::Type const*, false>::reserve_back(int) Line | Count | Source | 176 | 393k | void reserve_back(int n) { | 177 | 393k | SkASSERT(n >= 0); | 178 | 393k | if (n > 0) { | 179 | 187k | this->checkRealloc(n, kExactFit); | 180 | 187k | fReserved = fOwnMemory; | 181 | 205k | } else { | 182 | 205k | fReserved = false; | 183 | 205k | } | 184 | 393k | } |
Unexecuted instantiation: SkTArray<SkRSXform, false>::reserve_back(int) Unexecuted instantiation: SkTArray<SkRect, false>::reserve_back(int) Unexecuted instantiation: SkTArray<skgpu::v1::ClipStack::Element, false>::reserve_back(int) Unexecuted instantiation: SkTArray<std::__1::array<unsigned short, 3ul>, false>::reserve_back(int) |
185 | | |
186 | 0 | void removeShuffle(int n) { |
187 | 0 | SkASSERT(n < this->count()); |
188 | 0 | int newCount = fCount - 1; |
189 | 0 | fCount = newCount; |
190 | 0 | fItemArray[n].~T(); |
191 | 0 | if (n != newCount) { |
192 | 0 | this->move(n, newCount); |
193 | 0 | } |
194 | 0 | } Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::removeShuffle(int) Unexecuted instantiation: SkTArray<GrOnFlushCallbackObject*, false>::removeShuffle(int) Unexecuted instantiation: SkTArray<sk_sp<GrTextBlob>, false>::removeShuffle(int) Unexecuted instantiation: SkTArray<SkString, false>::removeShuffle(int) Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::removeShuffle(int) Unexecuted instantiation: SkTArray<GrOnFlushCallbackObject*, false>::removeShuffle(int) Unexecuted instantiation: SkTArray<sk_sp<GrTextBlob>, false>::removeShuffle(int) Unexecuted instantiation: SkTArray<SkString, false>::removeShuffle(int) |
195 | | |
196 | | /** |
197 | | * Number of elements in the array. |
198 | | */ |
199 | 889M | int count() const { return fCount; } SkTArray<SkString, false>::count() const Line | Count | Source | 199 | 1.34k | int count() const { return fCount; } |
SkTArray<SkNoPixelsDevice::ClipState, false>::count() const Line | Count | Source | 199 | 853k | int count() const { return fCount; } |
SkTArray<GrUniqueKey, false>::count() const Line | Count | Source | 199 | 206k | int count() const { return fCount; } |
SkTArray<unsigned int, true>::count() const Line | Count | Source | 199 | 1.32k | int count() const { return fCount; } |
SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::count() const Line | Count | Source | 199 | 2.14M | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::count() const Unexecuted instantiation: SkTArray<GrFragmentProcessor::ProgramImpl*, true>::count() const SkTArray<sk_gpu_test::GrContextFactory::Context, true>::count() const Line | Count | Source | 199 | 4.52k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::count() const SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::count() const Line | Count | Source | 199 | 6.00k | int count() const { return fCount; } |
SkTArray<unsigned short, false>::count() const Line | Count | Source | 199 | 386k | int count() const { return fCount; } |
SkTArray<SkPoint, false>::count() const Line | Count | Source | 199 | 386k | int count() const { return fCount; } |
SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::count() const Line | Count | Source | 199 | 1.32k | int count() const { return fCount; } |
SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::count() const Line | Count | Source | 199 | 1.32k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<GrAuditTrail::Op*, false>::count() const SkTArray<sk_sp<GrSurfaceProxy>, false>::count() const Line | Count | Source | 199 | 4.88M | int count() const { return fCount; } |
SkTArray<GrRenderTask*, true>::count() const Line | Count | Source | 199 | 4.71M | int count() const { return fCount; } |
SkTArray<GrOpsTask::OpChain, false>::count() const Line | Count | Source | 199 | 660k | int count() const { return fCount; } |
SkTArray<sk_sp<SkImageFilter>, true>::count() const Line | Count | Source | 199 | 48.0k | int count() const { return fCount; } |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::count() const Line | Count | Source | 199 | 109M | int count() const { return fCount; } |
SkTArray<unsigned int, false>::count() const Line | Count | Source | 199 | 228 | int count() const { return fCount; } |
SkTArray<SkCanvas::Lattice::RectType, false>::count() const Line | Count | Source | 199 | 2.06k | int count() const { return fCount; } |
SkTArray<float, false>::count() const Line | Count | Source | 199 | 4.56k | int count() const { return fCount; } |
SkTArray<int, false>::count() const Line | Count | Source | 199 | 6.63k | int count() const { return fCount; } |
SkTArray<SkRGBA4f<(SkAlphaType)2>, true>::count() const Line | Count | Source | 199 | 15.2k | int count() const { return fCount; } |
SkTArray<SkRuntimeEffect::ChildPtr, false>::count() const Line | Count | Source | 199 | 12.1k | int count() const { return fCount; } |
SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::count() const Line | Count | Source | 199 | 203 | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::count() const SkTArray<sk_sp<SkImage const>, false>::count() const Line | Count | Source | 199 | 49.3k | int count() const { return fCount; } |
SkTArray<sk_sp<SkVertices const>, false>::count() const Line | Count | Source | 199 | 8.12k | int count() const { return fCount; } |
SkTArray<sk_sp<SkTextBlob const>, false>::count() const Line | Count | Source | 199 | 6.23k | int count() const { return fCount; } |
SkTArray<sk_sp<SkDrawable>, false>::count() const Line | Count | Source | 199 | 4.98k | int count() const { return fCount; } |
SkTArray<sk_sp<SkPicture const>, false>::count() const Line | Count | Source | 199 | 4.98k | int count() const { return fCount; } |
SkTArray<SkPath, false>::count() const Line | Count | Source | 199 | 3.40M | int count() const { return fCount; } |
SkTArray<SkPaint, false>::count() const Line | Count | Source | 199 | 64.5k | int count() const { return fCount; } |
SkTArray<signed char, false>::count() const Line | Count | Source | 199 | 261M | int count() const { return fCount; } |
SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::count() const Line | Count | Source | 199 | 139M | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<SkSL::dsl::DSLParameter*, false>::count() const SkTArray<SkSL::Type const*, false>::count() const Line | Count | Source | 199 | 1.33M | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::count() const SkTArray<SkSL::Parser::Checkpoint::ForwardingErrorReporter::Error, false>::count() const Line | Count | Source | 199 | 121k | int count() const { return fCount; } |
SkTArray<int, true>::count() const Line | Count | Source | 199 | 157M | int count() const { return fCount; } |
SkTArray<unsigned long, true>::count() const Line | Count | Source | 199 | 1.23M | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<SkSL::dsl::DSLStatement, false>::count() const Unexecuted instantiation: SkTArray<SkSL::dsl::DSLField, false>::count() const Unexecuted instantiation: SkTArray<SkSL::dsl::DSLCase, false>::count() const Unexecuted instantiation: SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::count() const SkSLSwizzle.cpp:SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::count() const Line | Count | Source | 199 | 949k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<bool, true>::count() const Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::count() const SkTArray<sk_sp<GrRenderTask>, false>::count() const Line | Count | Source | 199 | 530k | int count() const { return fCount; } |
SkTArray<sk_sp<skgpu::v1::PathRenderer>, false>::count() const Line | Count | Source | 199 | 5.38k | int count() const { return fCount; } |
SkTArray<GrOnFlushCallbackObject*, false>::count() const Line | Count | Source | 199 | 4.02k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<GrTextureResolveRenderTask::Resolve, false>::count() const SkTArray<GrTextureProxy*, true>::count() const Line | Count | Source | 199 | 320k | int count() const { return fCount; } |
SkTArray<GrGpu::SubmittedProc, false>::count() const Line | Count | Source | 199 | 23.9k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<double, false>::count() const Unexecuted instantiation: SkTArray<SkSL::String, false>::count() const SkTArray<GrUniqueKeyInvalidatedMessage, false>::count() const Line | Count | Source | 199 | 368k | int count() const { return fCount; } |
SkTArray<GrTextureFreedMessage, false>::count() const Line | Count | Source | 199 | 1.32k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::count() const SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::count() const Line | Count | Source | 199 | 198k | int count() const { return fCount; } |
SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::count() const Line | Count | Source | 199 | 2.88k | int count() const { return fCount; } |
SkTArray<sk_sp<GrTextBlob>, false>::count() const Line | Count | Source | 199 | 7.66k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo::Op, false>::count() const Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo, false>::count() const SkTArray<GrSurfaceProxy*, true>::count() const Line | Count | Source | 199 | 297k | int count() const { return fCount; } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAConvexPathOp::PathData, true>::count() const Line | Count | Source | 199 | 1.84k | int count() const { return fCount; } |
SkTArray<SkPoint, true>::count() const Line | Count | Source | 199 | 2.30M | int count() const { return fCount; } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Segment, true>::count() const Line | Count | Source | 199 | 20.8k | int count() const { return fCount; } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Draw, true>::count() const Line | Count | Source | 199 | 1.99k | int count() const { return fCount; } |
AAHairLinePathRenderer.cpp:SkTArray<(anonymous namespace)::AAHairlineOp::PathData, true>::count() const Line | Count | Source | 199 | 10.6k | int count() const { return fCount; } |
SkTArray<float, true>::count() const Line | Count | Source | 199 | 285k | int count() const { return fCount; } |
AALinearizingConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::count() const Line | Count | Source | 199 | 1.32k | int count() const { return fCount; } |
DefaultPathRenderer.cpp:SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::count() const Line | Count | Source | 199 | 35.3k | int count() const { return fCount; } |
SkTArray<DashOp::LineData, true>::count() const Line | Count | Source | 199 | 3 | int count() const { return fCount; } |
SkTArray<DashOp::DashDraw, true>::count() const Line | Count | Source | 199 | 2 | int count() const { return fCount; } |
SkTArray<SkRect, true>::count() const Line | Count | Source | 199 | 4 | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<SkRSXform, false>::count() const Unexecuted instantiation: SkTArray<SkRect, false>::count() const Unexecuted instantiation: SkTArray<unsigned char, true>::count() const Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::count() const GrDrawVerticesOp.cpp:SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::count() const Line | Count | Source | 199 | 3.79k | int count() const { return fCount; } |
Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::count() const SkTArray<CircularRRectOp::RRect, true>::count() const Line | Count | Source | 199 | 16 | int count() const { return fCount; } |
SkTArray<EllipticalRRectOp::RRect, true>::count() const Line | Count | Source | 199 | 6 | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::count() const SkTArray<CircleOp::Circle, true>::count() const Line | Count | Source | 199 | 50 | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::count() const SkTArray<DIEllipseOp::Ellipse, true>::count() const Line | Count | Source | 199 | 19 | int count() const { return fCount; } |
Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::count() const Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::count() const GrStrokeRectOp.cpp:SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::count() const Line | Count | Source | 199 | 653 | int count() const { return fCount; } |
SmallPathRenderer.cpp:SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::count() const Line | Count | Source | 199 | 10.3k | int count() const { return fCount; } |
SkTArray<SkSL::VariableReference*, false>::count() const Line | Count | Source | 199 | 219k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<GrMipLevel, false>::count() const Unexecuted instantiation: SkTArray<GrGLFormat, true>::count() const Unexecuted instantiation: SkTArray<GrSwizzle, false>::count() const Unexecuted instantiation: SkTArray<GrGLProgramDataManager::Uniform, true>::count() const SkTArray<__jmp_buf_tag (*) [1], false>::count() const Line | Count | Source | 199 | 12.7k | int count() const { return fCount; } |
SkTArray<unsigned long, false>::count() const Line | Count | Source | 199 | 1.32M | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<GrRecordingContext::ProgramData, false>::count() const SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::count() const Line | Count | Source | 199 | 20.5k | int count() const { return fCount; } |
SkTArray<SkMatrix, false>::count() const Line | Count | Source | 199 | 1 | int count() const { return fCount; } |
SkTArray<OffsetEdge, false>::count() const Line | Count | Source | 199 | 41.2M | int count() const { return fCount; } |
SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::count() const Line | Count | Source | 199 | 319k | int count() const { return fCount; } |
SkTArray<Sk4fGradientInterval, true>::count() const Line | Count | Source | 199 | 9.20k | int count() const { return fCount; } |
SkTArray<GrBufferAllocPool::BufferBlock, false>::count() const Line | Count | Source | 199 | 311k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<PathSegment, true>::count() const SkTArray<GrDrawOpAtlas::Plot*, false>::count() const Line | Count | Source | 199 | 1.72k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::count() const SkTArray<GrXPFactoryTestFactory*, true>::count() const Line | Count | Source | 199 | 40 | int count() const { return fCount; } |
SkTArray<GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*, true>::count() const Line | Count | Source | 199 | 150 | int count() const { return fCount; } |
SkTArray<GrProcessorTestFactory<GrGeometryProcessor*>*, true>::count() const Line | Count | Source | 199 | 140 | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::count() const Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::count() const Unexecuted instantiation: SkTArray<GrProgramInfo const*, false>::count() const Unexecuted instantiation: SkTArray<skgpu::v1::ClipStack::Element, false>::count() const SkTArray<skgpu::v1::ClipStack::Element const*, false>::count() const Line | Count | Source | 199 | 33.0k | int count() const { return fCount; } |
SkTArray<std::__1::unique_ptr<SkCodec, std::__1::default_delete<SkCodec> >, true>::count() const Line | Count | Source | 199 | 15.9k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<dng_exception, false>::count() const Unexecuted instantiation: SkTArray<std::__1::thread, false>::count() const Unexecuted instantiation: SkTArray<std::__1::function<void ()>, false>::count() const SkTArray<SkOpRayHit*, false>::count() const Line | Count | Source | 199 | 80.2M | int count() const { return fCount; } |
SkTArray<double, true>::count() const Line | Count | Source | 199 | 52.0M | int count() const { return fCount; } |
SkTArray<sk_sp<SkFontStyleSet_Custom>, false>::count() const Line | Count | Source | 199 | 99.4k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<GrVertexChunk, false>::count() const SkTArray<sk_sp<SkTypeface_Custom>, false>::count() const Line | Count | Source | 199 | 50.3k | int count() const { return fCount; } |
SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true>::count() const Line | Count | Source | 199 | 20.7k | int count() const { return fCount; } |
SkTArray<SkClosestRecord const*, true>::count() const Line | Count | Source | 199 | 5.21M | int count() const { return fCount; } |
SkTArray<SkClosestRecord, true>::count() const Line | Count | Source | 199 | 7.46M | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<std::__1::array<unsigned short, 3ul>, false>::count() const Unexecuted instantiation: SkTArray<sk_sp<ToolUtils::TopoTestNode>, false>::count() const Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfLayerInfo, false>::count() const Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfInfo, false>::count() const Layer.cpp:SkTArray<skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::count() const Line | Count | Source | 199 | 26.5k | int count() const { return fCount; } |
Unexecuted instantiation: SkottieShaper.cpp:SkTArray<skottie::(anonymous namespace)::BlobMaker::RunRec, false>::count() const SkTArray<sk_sp<SkSVGNode>, true>::count() const Line | Count | Source | 199 | 895k | int count() const { return fCount; } |
SkTArray<SkSVGTextContext::PositionAdjustment, true>::count() const Line | Count | Source | 199 | 19.7k | int count() const { return fCount; } |
SkTArray<char, true>::count() const Line | Count | Source | 199 | 19.7k | int count() const { return fCount; } |
SkTArray<hb_feature_t, false>::count() const Line | Count | Source | 199 | 464k | int count() const { return fCount; } |
SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::count() const Line | Count | Source | 199 | 1.20M | int count() const { return fCount; } |
SkTArray<skia::textlayout::ResolvedFontDescriptor, false>::count() const Line | Count | Source | 199 | 4.02k | int count() const { return fCount; } |
SkTArray<skia::textlayout::Block, true>::count() const Line | Count | Source | 199 | 77.7k | int count() const { return fCount; } |
SkTArray<skia::textlayout::Placeholder, true>::count() const Line | Count | Source | 199 | 87.8k | int count() const { return fCount; } |
SkTArray<skia::textlayout::Run, false>::count() const Line | Count | Source | 199 | 8.89k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<unsigned short, true>::count() const SkTArray<skia::textlayout::CodeUnitFlags, false>::count() const Line | Count | Source | 199 | 3.01M | int count() const { return fCount; } |
SkTArray<skia::textlayout::StyleBlock<float>, false>::count() const Line | Count | Source | 199 | 8.05k | int count() const { return fCount; } |
SkTArray<skia::textlayout::StyleBlock<SkPaint>, false>::count() const Line | Count | Source | 199 | 8.05k | int count() const { return fCount; } |
SkTArray<skia::textlayout::StyleBlock<std::__1::vector<skia::textlayout::TextShadow, std::__1::allocator<skia::textlayout::TextShadow> > >, false>::count() const Line | Count | Source | 199 | 4.02k | int count() const { return fCount; } |
SkTArray<skia::textlayout::StyleBlock<skia::textlayout::Decoration>, false>::count() const Line | Count | Source | 199 | 4.02k | int count() const { return fCount; } |
SkTArray<skia::textlayout::Cluster, true>::count() const Line | Count | Source | 199 | 7.80k | int count() const { return fCount; } |
SkTArray<skia::textlayout::TextLine, false>::count() const Line | Count | Source | 199 | 4.02k | int count() const { return fCount; } |
SkTArray<SkShaper::Feature, false>::count() const Line | Count | Source | 199 | 230k | int count() const { return fCount; } |
Unexecuted instantiation: SkTArray<SkTArray<SkPDFTagNode*, false>, false>::count() const Unexecuted instantiation: SkTArray<SkPDFTagNode::MarkedContentInfo, false>::count() const Unexecuted instantiation: SkTArray<SkPDFTagNode*, false>::count() const SkTArray<SkSVGDevice::ClipRec, false>::count() const Line | Count | Source | 199 | 31.9k | int count() const { return fCount; } |
|
200 | | |
201 | | /** |
202 | | * Is the array empty. |
203 | | */ |
204 | 7.17M | bool empty() const { return !fCount; } Unexecuted instantiation: SkTArray<unsigned int, true>::empty() const Unexecuted instantiation: SkTArray<GrFragmentProcessor::ProgramImpl*, true>::empty() const SkTArray<GrOpsTask::OpChain, false>::empty() const Line | Count | Source | 204 | 359k | bool empty() const { return !fCount; } |
Unexecuted instantiation: SkTArray<int, false>::empty() const SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::empty() const Line | Count | Source | 204 | 143k | bool empty() const { return !fCount; } |
SkTArray<int, true>::empty() const Line | Count | Source | 204 | 871k | bool empty() const { return !fCount; } |
SkSLSwizzle.cpp:SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::empty() const Line | Count | Source | 204 | 113k | bool empty() const { return !fCount; } |
SkTArray<signed char, false>::empty() const Line | Count | Source | 204 | 425k | bool empty() const { return !fCount; } |
SkTArray<GrOnFlushCallbackObject*, false>::empty() const Line | Count | Source | 204 | 20.6k | bool empty() const { return !fCount; } |
Unexecuted instantiation: SkTArray<sk_sp<GrRenderTask>, false>::empty() const Unexecuted instantiation: SkTArray<sk_sp<GrSurfaceProxy>, false>::empty() const Unexecuted instantiation: SkTArray<sk_sp<GrTextBlob>, false>::empty() const Unexecuted instantiation: SkTArray<SkString, false>::empty() const Unexecuted instantiation: SkTArray<unsigned int, false>::empty() const SkTArray<sk_sp<SkTextBlob const>, false>::empty() const Line | Count | Source | 204 | 129 | bool empty() const { return !fCount; } |
SkTArray<sk_sp<SkVertices const>, false>::empty() const Line | Count | Source | 204 | 51 | bool empty() const { return !fCount; } |
SkTArray<sk_sp<SkImage const>, false>::empty() const Line | Count | Source | 204 | 1.72k | bool empty() const { return !fCount; } |
Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::empty() const SkTArray<sk_sp<SkDrawable>, false>::empty() const Line | Count | Source | 204 | 7 | bool empty() const { return !fCount; } |
SkTArray<GrBufferAllocPool::BufferBlock, false>::empty() const Line | Count | Source | 204 | 213k | bool empty() const { return !fCount; } |
Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::empty() const SkTArray<skgpu::v1::ClipStack::Element const*, false>::empty() const Line | Count | Source | 204 | 14.5k | bool empty() const { return !fCount; } |
SkTArray<__jmp_buf_tag (*) [1], false>::empty() const Line | Count | Source | 204 | 2.43k | bool empty() const { return !fCount; } |
Unexecuted instantiation: SkTArray<dng_exception, false>::empty() const Unexecuted instantiation: SkTArray<GrVertexChunk, false>::empty() const Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfLayerInfo, false>::empty() const Layer.cpp:SkTArray<skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::empty() const Line | Count | Source | 204 | 18.0k | bool empty() const { return !fCount; } |
SkTArray<SkSVGTextContext::PositionAdjustment, true>::empty() const Line | Count | Source | 204 | 4.81M | bool empty() const { return !fCount; } |
SkTArray<sk_sp<SkSVGNode>, true>::empty() const Line | Count | Source | 204 | 94.5k | bool empty() const { return !fCount; } |
SkTArray<float, true>::empty() const Line | Count | Source | 204 | 30 | bool empty() const { return !fCount; } |
Unexecuted instantiation: SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::empty() const SkTArray<skia::textlayout::Block, true>::empty() const Line | Count | Source | 204 | 41.7k | bool empty() const { return !fCount; } |
SkTArray<skia::textlayout::Placeholder, true>::empty() const Line | Count | Source | 204 | 8.05k | bool empty() const { return !fCount; } |
Unexecuted instantiation: SkTArray<SkPoint, true>::empty() const SkTArray<skia::textlayout::TextLine, false>::empty() const Line | Count | Source | 204 | 7.56k | bool empty() const { return !fCount; } |
SkTArray<skia::textlayout::Run, false>::empty() const Line | Count | Source | 204 | 4.02k | bool empty() const { return !fCount; } |
Unexecuted instantiation: SkTArray<unsigned long, true>::empty() const Unexecuted instantiation: SkTArray<float, false>::empty() const Unexecuted instantiation: SkTArray<SkNoPixelsDevice::ClipState, false>::empty() const Unexecuted instantiation: SkTArray<sk_sp<SkImageFilter>, true>::empty() const Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::empty() const Unexecuted instantiation: SkTArray<bool, true>::empty() const SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::empty() const Line | Count | Source | 204 | 5 | bool empty() const { return !fCount; } |
Unexecuted instantiation: SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::empty() const Unexecuted instantiation: SkTArray<std::__1::function<void ()>, false>::empty() const Unexecuted instantiation: SkTArray<Sk4fGradientInterval, true>::empty() const Unexecuted instantiation: SkTArray<GrProgramInfo const*, false>::empty() const Unexecuted instantiation: SkTArray<SkPDFTagNode::MarkedContentInfo, false>::empty() const SkTArray<SkSVGDevice::ClipRec, false>::empty() const Line | Count | Source | 204 | 19.8k | bool empty() const { return !fCount; } |
|
205 | | |
206 | | /** |
207 | | * Adds 1 new default-initialized T value and returns it by reference. Note |
208 | | * the reference only remains valid until the next call that adds or removes |
209 | | * elements. |
210 | | */ |
211 | 5.94M | T& push_back() { |
212 | 5.94M | void* newT = this->push_back_raw(1); |
213 | 5.94M | return *new (newT) T; |
214 | 5.94M | } SkTArray<SkString, false>::push_back() Line | Count | Source | 211 | 20 | T& push_back() { | 212 | 20 | void* newT = this->push_back_raw(1); | 213 | 20 | return *new (newT) T; | 214 | 20 | } |
SkTArray<SkNoPixelsDevice::ClipState, false>::push_back() Line | Count | Source | 211 | 480k | T& push_back() { | 212 | 480k | void* newT = this->push_back_raw(1); | 213 | 480k | return *new (newT) T; | 214 | 480k | } |
SkTArray<sk_gpu_test::GrContextFactory::Context, true>::push_back() Line | Count | Source | 211 | 1.32k | T& push_back() { | 212 | 1.32k | void* newT = this->push_back_raw(1); | 213 | 1.32k | return *new (newT) T; | 214 | 1.32k | } |
Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo::Op, false>::push_back() Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo, false>::push_back() AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Segment, true>::push_back() Line | Count | Source | 211 | 19.3k | T& push_back() { | 212 | 19.3k | void* newT = this->push_back_raw(1); | 213 | 19.3k | return *new (newT) T; | 214 | 19.3k | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Draw, true>::push_back() Line | Count | Source | 211 | 332 | T& push_back() { | 212 | 332 | void* newT = this->push_back_raw(1); | 213 | 332 | return *new (newT) T; | 214 | 332 | } |
SkTArray<float, true>::push_back() Line | Count | Source | 211 | 1.68k | T& push_back() { | 212 | 1.68k | void* newT = this->push_back_raw(1); | 213 | 1.68k | return *new (newT) T; | 214 | 1.68k | } |
SkTArray<int, true>::push_back() Line | Count | Source | 211 | 1.15k | T& push_back() { | 212 | 1.15k | void* newT = this->push_back_raw(1); | 213 | 1.15k | return *new (newT) T; | 214 | 1.15k | } |
Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::push_back() GrDrawVerticesOp.cpp:SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::push_back() Line | Count | Source | 211 | 1.85k | T& push_back() { | 212 | 1.85k | void* newT = this->push_back_raw(1); | 213 | 1.85k | return *new (newT) T; | 214 | 1.85k | } |
Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::push_back() Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::push_back() SkTArray<SkPath, false>::push_back() Line | Count | Source | 211 | 217k | T& push_back() { | 212 | 217k | void* newT = this->push_back_raw(1); | 213 | 217k | return *new (newT) T; | 214 | 217k | } |
Unexecuted instantiation: SkTArray<SkMatrix, false>::push_back() SkTArray<GrBufferAllocPool::BufferBlock, false>::push_back() Line | Count | Source | 211 | 3.30k | T& push_back() { | 212 | 3.30k | void* newT = this->push_back_raw(1); | 213 | 3.30k | return *new (newT) T; | 214 | 3.30k | } |
Unexecuted instantiation: SkTArray<PathSegment, true>::push_back() Unexecuted instantiation: SkTArray<GrDrawOpAtlas::Plot*, false>::push_back() Unexecuted instantiation: SkTArray<GrGLFormat, true>::push_back() SkTArray<std::__1::unique_ptr<SkCodec, std::__1::default_delete<SkCodec> >, true>::push_back() Line | Count | Source | 211 | 2.74k | T& push_back() { | 212 | 2.74k | void* newT = this->push_back_raw(1); | 213 | 2.74k | return *new (newT) T; | 214 | 2.74k | } |
SkTArray<sk_sp<SkFontStyleSet_Custom>, false>::push_back() Line | Count | Source | 211 | 5 | T& push_back() { | 212 | 5 | void* newT = this->push_back_raw(1); | 213 | 5 | return *new (newT) T; | 214 | 5 | } |
SkTArray<SkClosestRecord, true>::push_back() Line | Count | Source | 211 | 5.21M | T& push_back() { | 212 | 5.21M | void* newT = this->push_back_raw(1); | 213 | 5.21M | return *new (newT) T; | 214 | 5.21M | } |
Unexecuted instantiation: SkTArray<GrVertexChunk, false>::push_back() Unexecuted instantiation: SkTArray<SkTArray<SkPDFTagNode*, false>, false>::push_back() |
215 | | |
216 | | /** |
217 | | * Version of above that uses a copy constructor to initialize the new item |
218 | | */ |
219 | 86.8M | T& push_back(const T& t) { |
220 | 86.8M | void* newT = this->push_back_raw(1); |
221 | 86.8M | return *new (newT) T(t); |
222 | 86.8M | } Unexecuted instantiation: SkTArray<GrUniqueKey, false>::push_back(GrUniqueKey const&) SkTArray<unsigned int, true>::push_back(unsigned int const&) Line | Count | Source | 219 | 100k | T& push_back(const T& t) { | 220 | 100k | void* newT = this->push_back_raw(1); | 221 | 100k | return *new (newT) T(t); | 222 | 100k | } |
SkTArray<unsigned short, false>::push_back(unsigned short const&) Line | Count | Source | 219 | 444 | T& push_back(const T& t) { | 220 | 444 | void* newT = this->push_back_raw(1); | 221 | 444 | return *new (newT) T(t); | 222 | 444 | } |
SkTArray<SkPoint, false>::push_back(SkPoint const&) Line | Count | Source | 219 | 444 | T& push_back(const T& t) { | 220 | 444 | void* newT = this->push_back_raw(1); | 221 | 444 | return *new (newT) T(t); | 222 | 444 | } |
SkTArray<GrSurfaceProxy*, true>::push_back(GrSurfaceProxy* const&) Line | Count | Source | 219 | 186k | T& push_back(const T& t) { | 220 | 186k | void* newT = this->push_back_raw(1); | 221 | 186k | return *new (newT) T(t); | 222 | 186k | } |
SkTArray<SkRGBA4f<(SkAlphaType)2>, true>::push_back(SkRGBA4f<(SkAlphaType)2> const&) Line | Count | Source | 219 | 7.63k | T& push_back(const T& t) { | 220 | 7.63k | void* newT = this->push_back_raw(1); | 221 | 7.63k | return *new (newT) T(t); | 222 | 7.63k | } |
Unexecuted instantiation: SkTArray<int, false>::push_back(int const&) SkTArray<SkSL::Type const*, false>::push_back(SkSL::Type const* const&) Line | Count | Source | 219 | 213k | T& push_back(const T& t) { | 220 | 213k | void* newT = this->push_back_raw(1); | 221 | 213k | return *new (newT) T(t); | 222 | 213k | } |
SkTArray<signed char, false>::push_back(signed char const&) Line | Count | Source | 219 | 108k | T& push_back(const T& t) { | 220 | 108k | void* newT = this->push_back_raw(1); | 221 | 108k | return *new (newT) T(t); | 222 | 108k | } |
Unexecuted instantiation: SkTArray<bool, true>::push_back(bool const&) SkTArray<GrOnFlushCallbackObject*, false>::push_back(GrOnFlushCallbackObject* const&) Line | Count | Source | 219 | 1.36k | T& push_back(const T& t) { | 220 | 1.36k | void* newT = this->push_back_raw(1); | 221 | 1.36k | return *new (newT) T(t); | 222 | 1.36k | } |
SkTArray<GrRenderTask*, true>::push_back(GrRenderTask* const&) Line | Count | Source | 219 | 183k | T& push_back(const T& t) { | 220 | 183k | void* newT = this->push_back_raw(1); | 221 | 183k | return *new (newT) T(t); | 222 | 183k | } |
Unexecuted instantiation: SkTArray<GrTextureProxy*, true>::push_back(GrTextureProxy* const&) Unexecuted instantiation: SkTArray<GrAuditTrail::Op*, false>::push_back(GrAuditTrail::Op* const&) SkTArray<DashOp::LineData, true>::push_back(DashOp::LineData const&) Line | Count | Source | 219 | 1 | T& push_back(const T& t) { | 220 | 1 | void* newT = this->push_back_raw(1); | 221 | 1 | return *new (newT) T(t); | 222 | 1 | } |
GrStrokeRectOp.cpp:SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::push_back((anonymous namespace)::AAStrokeRectOp::RectInfo const&) Line | Count | Source | 219 | 70 | T& push_back(const T& t) { | 220 | 70 | void* newT = this->push_back_raw(1); | 221 | 70 | return *new (newT) T(t); | 222 | 70 | } |
Unexecuted instantiation: SkTArray<unsigned long, false>::push_back(unsigned long const&) Unexecuted instantiation: SkTArray<SkPaint, false>::push_back(SkPaint const&) Unexecuted instantiation: SkTArray<skgpu::v1::ClipStack::Element, false>::push_back(skgpu::v1::ClipStack::Element const&) Unexecuted instantiation: SkTArray<GrSwizzle, false>::push_back(GrSwizzle const&) Unexecuted instantiation: SkTArray<dng_exception, false>::push_back(dng_exception const&) SkTArray<SkOpRayHit*, false>::push_back(SkOpRayHit* const&) Line | Count | Source | 219 | 33.5M | T& push_back(const T& t) { | 220 | 33.5M | void* newT = this->push_back_raw(1); | 221 | 33.5M | return *new (newT) T(t); | 222 | 33.5M | } |
SkTArray<SkPath, false>::push_back(SkPath const&) Line | Count | Source | 219 | 498k | T& push_back(const T& t) { | 220 | 498k | void* newT = this->push_back_raw(1); | 221 | 498k | return *new (newT) T(t); | 222 | 498k | } |
SkTArray<double, true>::push_back(double const&) Line | Count | Source | 219 | 51.9M | T& push_back(const T& t) { | 220 | 51.9M | void* newT = this->push_back_raw(1); | 221 | 51.9M | return *new (newT) T(t); | 222 | 51.9M | } |
Unexecuted instantiation: SkTArray<float, true>::push_back(float const&) Unexecuted instantiation: SkTArray<SkString, false>::push_back(SkString const&) Unexecuted instantiation: SkTArray<SkPDFTagNode*, false>::push_back(SkPDFTagNode* const&) |
223 | | |
224 | | /** |
225 | | * Version of above that uses a move constructor to initialize the new item |
226 | | */ |
227 | 140M | T& push_back(T&& t) { |
228 | 140M | void* newT = this->push_back_raw(1); |
229 | 140M | return *new (newT) T(std::move(t)); |
230 | 140M | } Unexecuted instantiation: SkTArray<GrFragmentProcessor::ProgramImpl*, true>::push_back(GrFragmentProcessor::ProgramImpl*&&) SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::push_back(GrDrawOpAtlas::BulkUseTokenUpdater::PlotData&&) Line | Count | Source | 227 | 516 | T& push_back(T&& t) { | 228 | 516 | void* newT = this->push_back_raw(1); | 229 | 516 | return *new (newT) T(std::move(t)); | 230 | 516 | } |
Unexecuted instantiation: SkTArray<SkString, false>::push_back(SkString&&) SkTArray<SkNoPixelsDevice::ClipState, false>::push_back(SkNoPixelsDevice::ClipState&&) Line | Count | Source | 227 | 119k | T& push_back(T&& t) { | 228 | 119k | void* newT = this->push_back_raw(1); | 229 | 119k | return *new (newT) T(std::move(t)); | 230 | 119k | } |
SkTArray<sk_sp<SkImageFilter>, true>::push_back(sk_sp<SkImageFilter>&&) Line | Count | Source | 227 | 26.8k | T& push_back(T&& t) { | 228 | 26.8k | void* newT = this->push_back_raw(1); | 229 | 26.8k | return *new (newT) T(std::move(t)); | 230 | 26.8k | } |
Unexecuted instantiation: SkTArray<SkRGBA4f<(SkAlphaType)2>, true>::push_back(SkRGBA4f<(SkAlphaType)2>&&) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::push_back(std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >&&) SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::push_back(std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >&&) Line | Count | Source | 227 | 9.48M | T& push_back(T&& t) { | 228 | 9.48M | void* newT = this->push_back_raw(1); | 229 | 9.48M | return *new (newT) T(std::move(t)); | 230 | 9.48M | } |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::push_back(std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >&&) Line | Count | Source | 227 | 7.52M | T& push_back(T&& t) { | 228 | 7.52M | void* newT = this->push_back_raw(1); | 229 | 7.52M | return *new (newT) T(std::move(t)); | 230 | 7.52M | } |
SkTArray<SkSL::Parser::Checkpoint::ForwardingErrorReporter::Error, false>::push_back(SkSL::Parser::Checkpoint::ForwardingErrorReporter::Error&&) Line | Count | Source | 227 | 16.5k | T& push_back(T&& t) { | 228 | 16.5k | void* newT = this->push_back_raw(1); | 229 | 16.5k | return *new (newT) T(std::move(t)); | 230 | 16.5k | } |
SkTArray<signed char, false>::push_back(signed char&&) Line | Count | Source | 227 | 14.9M | T& push_back(T&& t) { | 228 | 14.9M | void* newT = this->push_back_raw(1); | 229 | 14.9M | return *new (newT) T(std::move(t)); | 230 | 14.9M | } |
Unexecuted instantiation: SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::push_back(SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>&&) SkTArray<SkSL::Type const*, false>::push_back(SkSL::Type const*&&) Line | Count | Source | 227 | 39.3k | T& push_back(T&& t) { | 228 | 39.3k | void* newT = this->push_back_raw(1); | 229 | 39.3k | return *new (newT) T(std::move(t)); | 230 | 39.3k | } |
SkSLSwizzle.cpp:SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::push_back(SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument&&) Line | Count | Source | 227 | 389k | T& push_back(T&& t) { | 228 | 389k | void* newT = this->push_back_raw(1); | 229 | 389k | return *new (newT) T(std::move(t)); | 230 | 389k | } |
Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::push_back(SkJSONWriter::Scope&&) Unexecuted instantiation: SkTArray<bool, true>::push_back(bool&&) SkTArray<sk_sp<GrRenderTask>, false>::push_back(sk_sp<GrRenderTask>&&) Line | Count | Source | 227 | 100k | T& push_back(T&& t) { | 228 | 100k | void* newT = this->push_back_raw(1); | 229 | 100k | return *new (newT) T(std::move(t)); | 230 | 100k | } |
SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::push_back(std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >&&) Line | Count | Source | 227 | 554k | T& push_back(T&& t) { | 228 | 554k | void* newT = this->push_back_raw(1); | 229 | 554k | return *new (newT) T(std::move(t)); | 230 | 554k | } |
Unexecuted instantiation: SkTArray<double, false>::push_back(double&&) SkTArray<GrRenderTask*, true>::push_back(GrRenderTask*&&) Line | Count | Source | 227 | 10.7k | T& push_back(T&& t) { | 228 | 10.7k | void* newT = this->push_back_raw(1); | 229 | 10.7k | return *new (newT) T(std::move(t)); | 230 | 10.7k | } |
Unexecuted instantiation: SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::push_back(GrClientMappedBufferManager::BufferFinishedMessage&&) SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::push_back(GrTextBlobCache::PurgeBlobMessage&&) Line | Count | Source | 227 | 531 | T& push_back(T&& t) { | 228 | 531 | void* newT = this->push_back_raw(1); | 229 | 531 | return *new (newT) T(std::move(t)); | 230 | 531 | } |
Unexecuted instantiation: SkTArray<int, false>::push_back(int&&) SkTArray<GrUniqueKeyInvalidatedMessage, false>::push_back(GrUniqueKeyInvalidatedMessage&&) Line | Count | Source | 227 | 59.0k | T& push_back(T&& t) { | 228 | 59.0k | void* newT = this->push_back_raw(1); | 229 | 59.0k | return *new (newT) T(std::move(t)); | 230 | 59.0k | } |
Unexecuted instantiation: SkTArray<GrTextureFreedMessage, false>::push_back(GrTextureFreedMessage&&) SkTArray<GrSurfaceProxy*, true>::push_back(GrSurfaceProxy*&&) Line | Count | Source | 227 | 1.87k | T& push_back(T&& t) { | 228 | 1.87k | void* newT = this->push_back_raw(1); | 229 | 1.87k | return *new (newT) T(std::move(t)); | 230 | 1.87k | } |
SkTArray<DashOp::DashDraw, true>::push_back(DashOp::DashDraw&&) Line | Count | Source | 227 | 1 | T& push_back(T&& t) { | 228 | 1 | void* newT = this->push_back_raw(1); | 229 | 1 | return *new (newT) T(std::move(t)); | 230 | 1 | } |
Unexecuted instantiation: SkTArray<SkRSXform, false>::push_back(SkRSXform&&) Unexecuted instantiation: SkTArray<SkRect, false>::push_back(SkRect&&) Unexecuted instantiation: SkTArray<unsigned int, false>::push_back(unsigned int&&) Unexecuted instantiation: SkTArray<SkPoint, false>::push_back(SkPoint&&) Unexecuted instantiation: SkTArray<unsigned short, false>::push_back(unsigned short&&) Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::push_back(ButtCapDashedCircleOp::Circle&&) SkTArray<sk_sp<skgpu::v1::PathRenderer>, false>::push_back(sk_sp<skgpu::v1::PathRenderer>&&) Line | Count | Source | 227 | 4.71k | T& push_back(T&& t) { | 228 | 4.71k | void* newT = this->push_back_raw(1); | 229 | 4.71k | return *new (newT) T(std::move(t)); | 230 | 4.71k | } |
SkTArray<__jmp_buf_tag (*) [1], false>::push_back(__jmp_buf_tag (*&&) [1]) Line | Count | Source | 227 | 104k | T& push_back(T&& t) { | 228 | 104k | void* newT = this->push_back_raw(1); | 229 | 104k | return *new (newT) T(std::move(t)); | 230 | 104k | } |
SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::push_back(SkResourceCache::PurgeSharedIDMessage&&) Line | Count | Source | 227 | 1.86k | T& push_back(T&& t) { | 228 | 1.86k | void* newT = this->push_back_raw(1); | 229 | 1.86k | return *new (newT) T(std::move(t)); | 230 | 1.86k | } |
Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::push_back(sk_sp<SkPicture const>&&) SkTArray<SkPaint, false>::push_back(SkPaint&&) Line | Count | Source | 227 | 20.3k | T& push_back(T&& t) { | 228 | 20.3k | void* newT = this->push_back_raw(1); | 229 | 20.3k | return *new (newT) T(std::move(t)); | 230 | 20.3k | } |
SkTArray<sk_sp<SkTextBlob const>, false>::push_back(sk_sp<SkTextBlob const>&&) Line | Count | Source | 227 | 706 | T& push_back(T&& t) { | 228 | 706 | void* newT = this->push_back_raw(1); | 229 | 706 | return *new (newT) T(std::move(t)); | 230 | 706 | } |
SkTArray<sk_sp<SkVertices const>, false>::push_back(sk_sp<SkVertices const>&&) Line | Count | Source | 227 | 1.64k | T& push_back(T&& t) { | 228 | 1.64k | void* newT = this->push_back_raw(1); | 229 | 1.64k | return *new (newT) T(std::move(t)); | 230 | 1.64k | } |
SkTArray<sk_sp<SkImage const>, false>::push_back(sk_sp<SkImage const>&&) Line | Count | Source | 227 | 21.7k | T& push_back(T&& t) { | 228 | 21.7k | void* newT = this->push_back_raw(1); | 229 | 21.7k | return *new (newT) T(std::move(t)); | 230 | 21.7k | } |
Unexecuted instantiation: SkTArray<sk_sp<SkDrawable>, false>::push_back(sk_sp<SkDrawable>&&) SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::push_back(SkRGBA4f<(SkAlphaType)3>&&) Line | Count | Source | 227 | 270k | T& push_back(T&& t) { | 228 | 270k | void* newT = this->push_back_raw(1); | 229 | 270k | return *new (newT) T(std::move(t)); | 230 | 270k | } |
Unexecuted instantiation: SkTArray<unsigned long, false>::push_back(unsigned long&&) SkTArray<GrXPFactoryTestFactory*, true>::push_back(GrXPFactoryTestFactory*&&) Line | Count | Source | 227 | 304 | T& push_back(T&& t) { | 228 | 304 | void* newT = this->push_back_raw(1); | 229 | 304 | return *new (newT) T(std::move(t)); | 230 | 304 | } |
SkTArray<GrProcessorTestFactory<GrGeometryProcessor*>*, true>::push_back(GrProcessorTestFactory<GrGeometryProcessor*>*&&) Line | Count | Source | 227 | 1.06k | T& push_back(T&& t) { | 228 | 1.06k | void* newT = this->push_back_raw(1); | 229 | 1.06k | return *new (newT) T(std::move(t)); | 230 | 1.06k | } |
SkTArray<GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*, true>::push_back(GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*&&) Line | Count | Source | 227 | 1.14k | T& push_back(T&& t) { | 228 | 1.14k | void* newT = this->push_back_raw(1); | 229 | 1.14k | return *new (newT) T(std::move(t)); | 230 | 1.14k | } |
SkTArray<float, true>::push_back(float&&) Line | Count | Source | 227 | 23.0k | T& push_back(T&& t) { | 228 | 23.0k | void* newT = this->push_back_raw(1); | 229 | 23.0k | return *new (newT) T(std::move(t)); | 230 | 23.0k | } |
Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::push_back(sk_sp<GrAtlasRenderTask>&&) Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::push_back(GrGeometryProcessor::Attribute&&) SkTArray<skgpu::v1::ClipStack::Element const*, false>::push_back(skgpu::v1::ClipStack::Element const*&&) Line | Count | Source | 227 | 10.3k | T& push_back(T&& t) { | 228 | 10.3k | void* newT = this->push_back_raw(1); | 229 | 10.3k | return *new (newT) T(std::move(t)); | 230 | 10.3k | } |
Unexecuted instantiation: SkTArray<dng_exception, false>::push_back(dng_exception&&) SkTArray<int, true>::push_back(int&&) Line | Count | Source | 227 | 103M | T& push_back(T&& t) { | 228 | 103M | void* newT = this->push_back_raw(1); | 229 | 103M | return *new (newT) T(std::move(t)); | 230 | 103M | } |
Unexecuted instantiation: SkTArray<GrProgramInfo const*, false>::push_back(GrProgramInfo const*&&) SkTArray<SkClosestRecord const*, true>::push_back(SkClosestRecord const*&&) Line | Count | Source | 227 | 2.95M | T& push_back(T&& t) { | 228 | 2.95M | void* newT = this->push_back_raw(1); | 229 | 2.95M | return *new (newT) T(std::move(t)); | 230 | 2.95M | } |
Unexecuted instantiation: SkTArray<std::__1::array<unsigned short, 3ul>, false>::push_back(std::__1::array<unsigned short, 3ul>&&) Unexecuted instantiation: SkTArray<sk_sp<ToolUtils::TopoTestNode>, false>::push_back(sk_sp<ToolUtils::TopoTestNode>&&) Layer.cpp:SkTArray<skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::push_back(skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord&&) Line | Count | Source | 227 | 8.61k | T& push_back(T&& t) { | 228 | 8.61k | void* newT = this->push_back_raw(1); | 229 | 8.61k | return *new (newT) T(std::move(t)); | 230 | 8.61k | } |
Unexecuted instantiation: SkottieShaper.cpp:SkTArray<skottie::(anonymous namespace)::BlobMaker::RunRec, false>::push_back(skottie::(anonymous namespace)::BlobMaker::RunRec&&) SkTArray<sk_sp<SkSVGNode>, true>::push_back(sk_sp<SkSVGNode>&&) Line | Count | Source | 227 | 293k | T& push_back(T&& t) { | 228 | 293k | void* newT = this->push_back_raw(1); | 229 | 293k | return *new (newT) T(std::move(t)); | 230 | 293k | } |
Unexecuted instantiation: SkTArray<hb_feature_t, false>::push_back(hb_feature_t&&) Unexecuted instantiation: SkTArray<unsigned long, true>::push_back(unsigned long&&) Unexecuted instantiation: SkTArray<SkPDFTagNode::MarkedContentInfo, false>::push_back(SkPDFTagNode::MarkedContentInfo&&) SkTArray<SkSVGDevice::ClipRec, false>::push_back(SkSVGDevice::ClipRec&&) Line | Count | Source | 227 | 7.86k | T& push_back(T&& t) { | 228 | 7.86k | void* newT = this->push_back_raw(1); | 229 | 7.86k | return *new (newT) T(std::move(t)); | 230 | 7.86k | } |
|
231 | | |
232 | | /** |
233 | | * Construct a new T at the back of this array. |
234 | | */ |
235 | 709k | template<class... Args> T& emplace_back(Args&&... args) { |
236 | 709k | void* newT = this->push_back_raw(1); |
237 | 709k | return *new (newT) T(std::forward<Args>(args)...); |
238 | 709k | } Unexecuted instantiation: SkRuntimeEffect::ChildPtr& SkTArray<SkRuntimeEffect::ChildPtr, false>::emplace_back<sk_sp<SkShader> >(sk_sp<SkShader>&&) Unexecuted instantiation: SkRuntimeEffect::ChildPtr& SkTArray<SkRuntimeEffect::ChildPtr, false>::emplace_back<sk_sp<SkColorFilter> >(sk_sp<SkColorFilter>&&) Unexecuted instantiation: SkRuntimeEffect::ChildPtr& SkTArray<SkRuntimeEffect::ChildPtr, false>::emplace_back<sk_sp<SkBlender> >(sk_sp<SkBlender>&&) Unexecuted instantiation: SkRuntimeEffect::ChildPtr& SkTArray<SkRuntimeEffect::ChildPtr, false>::emplace_back<sk_sp<SkShader>&>(sk_sp<SkShader>&) SkRuntimeEffect::ChildPtr& SkTArray<SkRuntimeEffect::ChildPtr, false>::emplace_back<sk_sp<SkColorFilter>&>(sk_sp<SkColorFilter>&) Line | Count | Source | 235 | 8.09k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 8.09k | void* newT = this->push_back_raw(1); | 237 | 8.09k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 8.09k | } |
Unexecuted instantiation: sk_sp<SkTypeface>& SkTArray<sk_sp<SkTypeface>, false>::emplace_back<sk_sp<SkTypeface> >(sk_sp<SkTypeface>&&) std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >& SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::emplace_back<>() Line | Count | Source | 235 | 15.3k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 15.3k | void* newT = this->push_back_raw(1); | 237 | 15.3k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 15.3k | } |
Unexecuted instantiation: sk_sp<GrRenderTask>& SkTArray<sk_sp<GrRenderTask>, false>::emplace_back<GrRenderTask*>(GrRenderTask*&&) Unexecuted instantiation: GrGpu::SubmittedProc& SkTArray<GrGpu::SubmittedProc, false>::emplace_back<void (* const&)(void*, bool), void* const&>(void (* const&)(void*, bool), void* const&) sk_sp<GrSurfaceProxy>& SkTArray<sk_sp<GrSurfaceProxy>, false>::emplace_back<sk_sp<GrSurfaceProxy> >(sk_sp<GrSurfaceProxy>&&) Line | Count | Source | 235 | 100k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 100k | void* newT = this->push_back_raw(1); | 237 | 100k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 100k | } |
Unexecuted instantiation: GrTextureResolveRenderTask::Resolve& SkTArray<GrTextureResolveRenderTask::Resolve, false>::emplace_back<GrSurfaceProxy::ResolveFlags&>(GrSurfaceProxy::ResolveFlags&) Unexecuted instantiation: skgpu::SurfaceContext::AsyncReadResult::Plane& SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::emplace_back<sk_sp<SkData>, unsigned long&>(sk_sp<SkData>&&, unsigned long&) Unexecuted instantiation: skgpu::SurfaceContext::AsyncReadResult::Plane& SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::emplace_back<sk_sp<GrGpuBuffer>, unsigned long&>(sk_sp<GrGpuBuffer>&&, unsigned long&) sk_sp<GrTextBlob>& SkTArray<sk_sp<GrTextBlob>, false>::emplace_back<sk_sp<GrTextBlob> >(sk_sp<GrTextBlob>&&) Line | Count | Source | 235 | 531 | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 531 | void* newT = this->push_back_raw(1); | 237 | 531 | return *new (newT) T(std::forward<Args>(args)...); | 238 | 531 | } |
Unexecuted instantiation: std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >& SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::emplace_back<GrAuditTrail::Op*&>(GrAuditTrail::Op*&) Unexecuted instantiation: std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >& SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::emplace_back<GrAuditTrail::OpNode*&>(GrAuditTrail::OpNode*&) GrOpsTask::OpChain& SkTArray<GrOpsTask::OpChain, false>::emplace_back<std::__1::unique_ptr<GrOp, std::__1::default_delete<GrOp> >, GrProcessorSet::Analysis&, GrAppliedClip*&, GrDstProxyView const*&>(std::__1::unique_ptr<GrOp, std::__1::default_delete<GrOp> >&&, GrProcessorSet::Analysis&, GrAppliedClip*&, GrDstProxyView const*&) Line | Count | Source | 235 | 119k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 119k | void* newT = this->push_back_raw(1); | 237 | 119k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 119k | } |
AAConvexPathRenderer.cpp:(anonymous namespace)::AAConvexPathOp::PathData& SkTArray<(anonymous namespace)::AAConvexPathOp::PathData, true>::emplace_back<(anonymous namespace)::AAConvexPathOp::PathData>((anonymous namespace)::AAConvexPathOp::PathData&&) Line | Count | Source | 235 | 646 | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 646 | void* newT = this->push_back_raw(1); | 237 | 646 | return *new (newT) T(std::forward<Args>(args)...); | 238 | 646 | } |
AAHairLinePathRenderer.cpp:(anonymous namespace)::AAHairlineOp::PathData& SkTArray<(anonymous namespace)::AAHairlineOp::PathData, true>::emplace_back<(anonymous namespace)::AAHairlineOp::PathData>((anonymous namespace)::AAHairlineOp::PathData&&) Line | Count | Source | 235 | 3.64k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 3.64k | void* newT = this->push_back_raw(1); | 237 | 3.64k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 3.64k | } |
AALinearizingConvexPathRenderer.cpp:(anonymous namespace)::AAFlatteningConvexPathOp::PathData& SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::emplace_back<(anonymous namespace)::AAFlatteningConvexPathOp::PathData>((anonymous namespace)::AAFlatteningConvexPathOp::PathData&&) Line | Count | Source | 235 | 574 | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 574 | void* newT = this->push_back_raw(1); | 237 | 574 | return *new (newT) T(std::forward<Args>(args)...); | 238 | 574 | } |
DefaultPathRenderer.cpp:(anonymous namespace)::DefaultPathOp::PathData& SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::emplace_back<(anonymous namespace)::DefaultPathOp::PathData>((anonymous namespace)::DefaultPathOp::PathData&&) Line | Count | Source | 235 | 9.24k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 9.24k | void* newT = this->push_back_raw(1); | 237 | 9.24k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 9.24k | } |
CircularRRectOp::RRect& SkTArray<CircularRRectOp::RRect, true>::emplace_back<CircularRRectOp::RRect>(CircularRRectOp::RRect&&) Line | Count | Source | 235 | 5 | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 5 | void* newT = this->push_back_raw(1); | 237 | 5 | return *new (newT) T(std::forward<Args>(args)...); | 238 | 5 | } |
EllipticalRRectOp::RRect& SkTArray<EllipticalRRectOp::RRect, true>::emplace_back<EllipticalRRectOp::RRect>(EllipticalRRectOp::RRect&&) Line | Count | Source | 235 | 2 | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 2 | void* newT = this->push_back_raw(1); | 237 | 2 | return *new (newT) T(std::forward<Args>(args)...); | 238 | 2 | } |
CircleOp::Circle& SkTArray<CircleOp::Circle, true>::emplace_back<CircleOp::Circle>(CircleOp::Circle&&) Line | Count | Source | 235 | 14 | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 14 | void* newT = this->push_back_raw(1); | 237 | 14 | return *new (newT) T(std::forward<Args>(args)...); | 238 | 14 | } |
Unexecuted instantiation: EllipseOp::Ellipse& SkTArray<EllipseOp::Ellipse, true>::emplace_back<EllipseOp::Ellipse>(EllipseOp::Ellipse&&) DIEllipseOp::Ellipse& SkTArray<DIEllipseOp::Ellipse, true>::emplace_back<DIEllipseOp::Ellipse>(DIEllipseOp::Ellipse&&) Line | Count | Source | 235 | 7 | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 7 | void* newT = this->push_back_raw(1); | 237 | 7 | return *new (newT) T(std::forward<Args>(args)...); | 238 | 7 | } |
Unexecuted instantiation: GrShadowRRectOp.cpp:(anonymous namespace)::ShadowCircularRRectOp::Geometry& SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::emplace_back<(anonymous namespace)::ShadowCircularRRectOp::Geometry>((anonymous namespace)::ShadowCircularRRectOp::Geometry&&) GrStrokeRectOp.cpp:(anonymous namespace)::AAStrokeRectOp::RectInfo& SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::emplace_back<(anonymous namespace)::AAStrokeRectOp::RectInfo>((anonymous namespace)::AAStrokeRectOp::RectInfo&&) Line | Count | Source | 235 | 138 | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 138 | void* newT = this->push_back_raw(1); | 237 | 138 | return *new (newT) T(std::forward<Args>(args)...); | 238 | 138 | } |
SmallPathRenderer.cpp:(anonymous namespace)::SmallPathOp::Entry& SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::emplace_back<(anonymous namespace)::SmallPathOp::Entry>((anonymous namespace)::SmallPathOp::Entry&&) Line | Count | Source | 235 | 2.96k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 2.96k | void* newT = this->push_back_raw(1); | 237 | 2.96k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 2.96k | } |
Unexecuted instantiation: SkString& SkTArray<SkString, false>::emplace_back<char const*&>(char const*&) Unexecuted instantiation: SkSL::String& SkTArray<SkSL::String, false>::emplace_back<char const*>(char const*&&) Unexecuted instantiation: GrUniqueKeyInvalidatedMessage& SkTArray<GrUniqueKeyInvalidatedMessage, false>::emplace_back<GrUniqueKey const&, unsigned int&, bool>(GrUniqueKey const&, unsigned int&, bool&&) Unexecuted instantiation: GrGeometryProcessor::Attribute& SkTArray<GrGeometryProcessor::Attribute, false>::emplace_back<char const (&) [11], GrVertexAttribType, GrSLType>(char const (&) [11], GrVertexAttribType&&, GrSLType&&) Unexecuted instantiation: GrGeometryProcessor::Attribute& SkTArray<GrGeometryProcessor::Attribute, false>::emplace_back<char const (&) [13], GrVertexAttribType, GrSLType>(char const (&) [13], GrVertexAttribType&&, GrSLType&&) Unexecuted instantiation: GrGeometryProcessor::Attribute& SkTArray<GrGeometryProcessor::Attribute, false>::emplace_back<char const (&) [10], GrVertexAttribType, GrSLType>(char const (&) [10], GrVertexAttribType&&, GrSLType&&) Unexecuted instantiation: GrGeometryProcessor::Attribute& SkTArray<GrGeometryProcessor::Attribute, false>::emplace_back<char const (&) [6], GrVertexAttribType, GrSLType>(char const (&) [6], GrVertexAttribType&&, GrSLType&&) Unexecuted instantiation: GrGeometryProcessor::Attribute& SkTArray<GrGeometryProcessor::Attribute, false>::emplace_back<char const (&) [5], GrVertexAttribType, GrSLType>(char const (&) [5], GrVertexAttribType&&, GrSLType&&) Unexecuted instantiation: GrGeometryProcessor::Attribute& SkTArray<GrGeometryProcessor::Attribute, false>::emplace_back<char const (&) [8], GrVertexAttribType, GrSLType>(char const (&) [8], GrVertexAttribType&&, GrSLType&&) Unexecuted instantiation: std::__1::thread& SkTArray<std::__1::thread, false>::emplace_back<void (*)(void*), SkThreadPool<std::__1::deque<std::__1::function<void ()>, std::__1::allocator<std::__1::function<void ()> > > >*>(void (*&&)(void*), SkThreadPool<std::__1::deque<std::__1::function<void ()>, std::__1::allocator<std::__1::function<void ()> > > >*&&) Unexecuted instantiation: std::__1::thread& SkTArray<std::__1::thread, false>::emplace_back<void (*)(void*), SkThreadPool<SkTArray<std::__1::function<void ()>, false> >*>(void (*&&)(void*), SkThreadPool<SkTArray<std::__1::function<void ()>, false> >*&&) Unexecuted instantiation: std::__1::function<void ()>& SkTArray<std::__1::function<void ()>, false>::emplace_back<std::__1::function<void ()> >(std::__1::function<void ()>&&) Sk4fGradientBase.cpp:Sk4fGradientInterval& SkTArray<Sk4fGradientInterval, true>::emplace_back<(anonymous namespace)::SkNx<4, float>, float const&, (anonymous namespace)::SkNx<4, float>, float const&>((anonymous namespace)::SkNx<4, float>&&, float const&, (anonymous namespace)::SkNx<4, float>&&, float const&) Line | Count | Source | 235 | 2.71k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 2.71k | void* newT = this->push_back_raw(1); | 237 | 2.71k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 2.71k | } |
Sk4fGradientBase.cpp:Sk4fGradientInterval& SkTArray<Sk4fGradientInterval, true>::emplace_back<(anonymous namespace)::SkNx<4, float> const&, float const&, (anonymous namespace)::SkNx<4, float> const&, float const&>((anonymous namespace)::SkNx<4, float> const&, float const&, (anonymous namespace)::SkNx<4, float> const&, float const&) Line | Count | Source | 235 | 630 | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 630 | void* newT = this->push_back_raw(1); | 237 | 630 | return *new (newT) T(std::forward<Args>(args)...); | 238 | 630 | } |
Sk4fGradientBase.cpp:Sk4fGradientInterval& SkTArray<Sk4fGradientInterval, true>::emplace_back<(anonymous namespace)::SkNx<4, float>, float&, (anonymous namespace)::SkNx<4, float>, float&>((anonymous namespace)::SkNx<4, float>&&, float&, (anonymous namespace)::SkNx<4, float>&&, float&) Line | Count | Source | 235 | 5.12k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 5.12k | void* newT = this->push_back_raw(1); | 237 | 5.12k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 5.12k | } |
Unexecuted instantiation: GrGeometryProcessor::Attribute& SkTArray<GrGeometryProcessor::Attribute, false>::emplace_back<char const (&) [12], GrVertexAttribType, GrSLType>(char const (&) [12], GrVertexAttribType&&, GrSLType&&) Unexecuted instantiation: GrGeometryProcessor::Attribute& SkTArray<GrGeometryProcessor::Attribute, false>::emplace_back<char const (&) [4], GrVertexAttribType, GrSLType>(char const (&) [4], GrVertexAttribType&&, GrSLType&&) sk_sp<SkTypeface_Custom>& SkTArray<sk_sp<SkTypeface_Custom>, false>::emplace_back<sk_sp<SkTypeface_Custom> >(sk_sp<SkTypeface_Custom>&&) Line | Count | Source | 235 | 5 | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 5 | void* newT = this->push_back_raw(1); | 237 | 5 | return *new (newT) T(std::forward<Args>(args)...); | 238 | 5 | } |
Unexecuted instantiation: GrGeometryProcessor::Attribute& SkTArray<GrGeometryProcessor::Attribute, false>::emplace_back<char const (&) [9], GrVertexAttribType, GrSLType>(char const (&) [9], GrVertexAttribType&&, GrSLType&&) Unexecuted instantiation: GrGeometryProcessor::Attribute& SkTArray<GrGeometryProcessor::Attribute, false>::emplace_back<char const (&) [15], GrVertexAttribType, GrSLType>(char const (&) [15], GrVertexAttribType&&, GrSLType&&) Unexecuted instantiation: GrGeometryProcessor::Attribute& SkTArray<GrGeometryProcessor::Attribute, false>::emplace_back<char const (&) [14], GrVertexAttribType, GrSLType>(char const (&) [14], GrVertexAttribType&&, GrSLType&&) Unexecuted instantiation: GrGeometryProcessor::Attribute& SkTArray<GrGeometryProcessor::Attribute, false>::emplace_back<char const (&) [18], GrVertexAttribType, GrSLType>(char const (&) [18], GrVertexAttribType&&, GrSLType&&) Unexecuted instantiation: GrGeometryProcessor::Attribute& SkTArray<GrGeometryProcessor::Attribute, false>::emplace_back<char const (&) [17], GrVertexAttribType, GrSLType>(char const (&) [17], GrVertexAttribType&&, GrSLType&&) Unexecuted instantiation: TestSVGTypeface::GlyfLayerInfo& SkTArray<TestSVGTypeface::GlyfLayerInfo, false>::emplace_back<int&, SkIRect&>(int&, SkIRect&) Unexecuted instantiation: int& SkTArray<int, false>::emplace_back<unsigned int&>(unsigned int&) Unexecuted instantiation: TestSVGTypeface::GlyfInfo& SkTArray<TestSVGTypeface::GlyfInfo, false>::emplace_back<>() SkShaper_harfbuzz.cpp:(anonymous namespace)::ShapedRun& SkTArray<(anonymous namespace)::ShapedRun, false>::emplace_back<(anonymous namespace)::ShapedRun>((anonymous namespace)::ShapedRun&&) Line | Count | Source | 235 | 418k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 418k | void* newT = this->push_back_raw(1); | 237 | 418k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 418k | } |
Unexecuted instantiation: GrRecordingContext::ProgramData& SkTArray<GrRecordingContext::ProgramData, false>::emplace_back<std::__1::unique_ptr<GrProgramDesc const, std::__1::default_delete<GrProgramDesc const> >, GrProgramInfo const*&>(std::__1::unique_ptr<GrProgramDesc const, std::__1::default_delete<GrProgramDesc const> >&&, GrProgramInfo const*&) skia::textlayout::Block& SkTArray<skia::textlayout::Block, true>::emplace_back<unsigned long, unsigned long, skia::textlayout::TextStyle const&>(unsigned long&&, unsigned long&&, skia::textlayout::TextStyle const&) Line | Count | Source | 235 | 4.02k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 4.02k | void* newT = this->push_back_raw(1); | 237 | 4.02k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 4.02k | } |
skia::textlayout::Block& SkTArray<skia::textlayout::Block, true>::emplace_back<unsigned long, unsigned long, skia::textlayout::TextStyle&>(unsigned long&&, unsigned long&&, skia::textlayout::TextStyle&) Line | Count | Source | 235 | 8.87k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 8.87k | void* newT = this->push_back_raw(1); | 237 | 8.87k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 8.87k | } |
skia::textlayout::Placeholder& SkTArray<skia::textlayout::Placeholder, true>::emplace_back<unsigned long&, unsigned long&, skia::textlayout::PlaceholderStyle const&, skia::textlayout::TextStyle&, skia::textlayout::SkRange<unsigned long>&, skia::textlayout::SkRange<unsigned long>&>(unsigned long&, unsigned long&, skia::textlayout::PlaceholderStyle const&, skia::textlayout::TextStyle&, skia::textlayout::SkRange<unsigned long>&, skia::textlayout::SkRange<unsigned long>&) Line | Count | Source | 235 | 4.02k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 4.02k | void* newT = this->push_back_raw(1); | 237 | 4.02k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 4.02k | } |
Unexecuted instantiation: skia::textlayout::Cluster& SkTArray<skia::textlayout::Cluster, true>::emplace_back<skia::textlayout::ParagraphImpl*, unsigned long&, unsigned long, unsigned long, SkSpan<char const>, float, float>(skia::textlayout::ParagraphImpl*&&, unsigned long&, unsigned long&&, unsigned long&&, SkSpan<char const>&&, float&&, float&&) Unexecuted instantiation: skia::textlayout::Cluster& SkTArray<skia::textlayout::Cluster, true>::emplace_back<skia::textlayout::ParagraphImpl*, unsigned long const&, unsigned long&, unsigned long&, SkSpan<char const>&, float&, float&>(skia::textlayout::ParagraphImpl*&&, unsigned long const&, unsigned long&, unsigned long&, SkSpan<char const>&, float&, float&) skia::textlayout::Cluster& SkTArray<skia::textlayout::Cluster, true>::emplace_back<skia::textlayout::ParagraphImpl*, unsigned long const&, int, int, SkSpan<char const>, int, int>(skia::textlayout::ParagraphImpl*&&, unsigned long const&, int&&, int&&, SkSpan<char const>&&, int&&, int&&) Line | Count | Source | 235 | 3.78k | template<class... Args> T& emplace_back(Args&&... args) { | 236 | 3.78k | void* newT = this->push_back_raw(1); | 237 | 3.78k | return *new (newT) T(std::forward<Args>(args)...); | 238 | 3.78k | } |
Unexecuted instantiation: skia::textlayout::TextLine& SkTArray<skia::textlayout::TextLine, false>::emplace_back<skia::textlayout::ParagraphImpl*, SkPoint&, SkPoint&, skia::textlayout::SkRange<unsigned long>&, skia::textlayout::SkRange<unsigned long>&, skia::textlayout::SkRange<unsigned long>&, skia::textlayout::SkRange<unsigned long>&, skia::textlayout::SkRange<unsigned long>&, skia::textlayout::SkRange<unsigned long>&, float&, skia::textlayout::InternalLineMetrics&>(skia::textlayout::ParagraphImpl*&&, SkPoint&, SkPoint&, skia::textlayout::SkRange<unsigned long>&, skia::textlayout::SkRange<unsigned long>&, skia::textlayout::SkRange<unsigned long>&, skia::textlayout::SkRange<unsigned long>&, skia::textlayout::SkRange<unsigned long>&, skia::textlayout::SkRange<unsigned long>&, float&, skia::textlayout::InternalLineMetrics&) Unexecuted instantiation: unsigned long& SkTArray<unsigned long, true>::emplace_back<unsigned long>(unsigned long&&) Unexecuted instantiation: unsigned long& SkTArray<unsigned long, true>::emplace_back<unsigned long&>(unsigned long&) Unexecuted instantiation: SkString& SkTArray<SkString, false>::emplace_back<SkString const&>(SkString const&) Unexecuted instantiation: SkShaper::Feature& SkTArray<SkShaper::Feature, false>::emplace_back<SkShaper::Feature&>(SkShaper::Feature&) Unexecuted instantiation: skia::textlayout::ResolvedFontDescriptor& SkTArray<skia::textlayout::ResolvedFontDescriptor, false>::emplace_back<unsigned long&, SkFont&>(unsigned long&, SkFont&) Unexecuted instantiation: skia::textlayout::Run& SkTArray<skia::textlayout::Run, false>::emplace_back<skia::textlayout::Run&>(skia::textlayout::Run&) Unexecuted instantiation: skia::textlayout::Run& SkTArray<skia::textlayout::Run, false>::emplace_back<skia::textlayout::ParagraphImpl*&, SkShaper::RunHandler::RunInfo const&, unsigned long&, float&, bool, int, float&>(skia::textlayout::ParagraphImpl*&, SkShaper::RunHandler::RunInfo const&, unsigned long&, float&, bool&&, int&&, float&) Unexecuted instantiation: skia::textlayout::Run& SkTArray<skia::textlayout::Run, false>::emplace_back<skia::textlayout::ParagraphImpl*&, SkShaper::RunHandler::RunInfo const&, unsigned long&, float, bool, int, float&>(skia::textlayout::ParagraphImpl*&, SkShaper::RunHandler::RunInfo const&, unsigned long&, float&&, bool&&, int&&, float&) |
239 | | |
240 | | /** |
241 | | * Allocates n more default-initialized T values, and returns the address of |
242 | | * the start of that new range. Note: this address is only valid until the |
243 | | * next API call made on the array that might add or remove elements. |
244 | | */ |
245 | 7.82M | T* push_back_n(int n) { |
246 | 7.82M | SkASSERT(n >= 0); |
247 | 7.82M | void* newTs = this->push_back_raw(n); |
248 | 64.8M | for (int i = 0; i < n; ++i) { |
249 | 57.0M | new (static_cast<char*>(newTs) + i * sizeof(T)) T; |
250 | 57.0M | } |
251 | 7.82M | return static_cast<T*>(newTs); |
252 | 7.82M | } Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::push_back_n(int) Unexecuted instantiation: SkTArray<SkCanvas::Lattice::RectType, false>::push_back_n(int) Unexecuted instantiation: SkTArray<unsigned int, false>::push_back_n(int) SkTArray<unsigned long, true>::push_back_n(int) Line | Count | Source | 245 | 261k | T* push_back_n(int n) { | 246 | 261k | SkASSERT(n >= 0); | 247 | 261k | void* newTs = this->push_back_raw(n); | 248 | 958k | for (int i = 0; i < n; ++i) { | 249 | 697k | new (static_cast<char*>(newTs) + i * sizeof(T)) T; | 250 | 697k | } | 251 | 261k | return static_cast<T*>(newTs); | 252 | 261k | } |
SkTArray<int, true>::push_back_n(int) Line | Count | Source | 245 | 6.89M | T* push_back_n(int n) { | 246 | 6.89M | SkASSERT(n >= 0); | 247 | 6.89M | void* newTs = this->push_back_raw(n); | 248 | 19.9M | for (int i = 0; i < n; ++i) { | 249 | 13.0M | new (static_cast<char*>(newTs) + i * sizeof(T)) T; | 250 | 13.0M | } | 251 | 6.89M | return static_cast<T*>(newTs); | 252 | 6.89M | } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::push_back_n(int) Unexecuted instantiation: SkTArray<sk_sp<GrRenderTask>, false>::push_back_n(int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::push_back_n(int) Unexecuted instantiation: SkTArray<SkSL::String, false>::push_back_n(int) SkTArray<SkPoint, true>::push_back_n(int) Line | Count | Source | 245 | 635k | T* push_back_n(int n) { | 246 | 635k | SkASSERT(n >= 0); | 247 | 635k | void* newTs = this->push_back_raw(n); | 248 | 2.48M | for (int i = 0; i < n; ++i) { | 249 | 1.85M | new (static_cast<char*>(newTs) + i * sizeof(T)) T; | 250 | 1.85M | } | 251 | 635k | return static_cast<T*>(newTs); | 252 | 635k | } |
SkTArray<SkRect, true>::push_back_n(int) Line | Count | Source | 245 | 1 | T* push_back_n(int n) { | 246 | 1 | SkASSERT(n >= 0); | 247 | 1 | void* newTs = this->push_back_raw(n); | 248 | 4 | for (int i = 0; i < n; ++i) { | 249 | 3 | new (static_cast<char*>(newTs) + i * sizeof(T)) T; | 250 | 3 | } | 251 | 1 | return static_cast<T*>(newTs); | 252 | 1 | } |
Unexecuted instantiation: SkTArray<SkString, false>::push_back_n(int) Unexecuted instantiation: SkTArray<GrMipLevel, false>::push_back_n(int) Unexecuted instantiation: SkTArray<GrGLProgramDataManager::Uniform, true>::push_back_n(int) SkTArray<OffsetEdge, false>::push_back_n(int) Line | Count | Source | 245 | 21.9k | T* push_back_n(int n) { | 246 | 21.9k | SkASSERT(n >= 0); | 247 | 21.9k | void* newTs = this->push_back_raw(n); | 248 | 41.2M | for (int i = 0; i < n; ++i) { | 249 | 41.2M | new (static_cast<char*>(newTs) + i * sizeof(T)) T; | 250 | 41.2M | } | 251 | 21.9k | return static_cast<T*>(newTs); | 252 | 21.9k | } |
SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::push_back_n(int) Line | Count | Source | 245 | 182 | T* push_back_n(int n) { | 246 | 182 | SkASSERT(n >= 0); | 247 | 182 | void* newTs = this->push_back_raw(n); | 248 | 2.36k | for (int i = 0; i < n; ++i) { | 249 | 2.18k | new (static_cast<char*>(newTs) + i * sizeof(T)) T; | 250 | 2.18k | } | 251 | 182 | return static_cast<T*>(newTs); | 252 | 182 | } |
SkTArray<float, true>::push_back_n(int) Line | Count | Source | 245 | 5.53k | T* push_back_n(int n) { | 246 | 5.53k | SkASSERT(n >= 0); | 247 | 5.53k | void* newTs = this->push_back_raw(n); | 248 | 244k | for (int i = 0; i < n; ++i) { | 249 | 239k | new (static_cast<char*>(newTs) + i * sizeof(T)) T; | 250 | 239k | } | 251 | 5.53k | return static_cast<T*>(newTs); | 252 | 5.53k | } |
Unexecuted instantiation: SkTArray<unsigned short, true>::push_back_n(int) Unexecuted instantiation: SkTArray<unsigned int, true>::push_back_n(int) Unexecuted instantiation: SkTArray<float, false>::push_back_n(int) Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::push_back_n(int) Unexecuted instantiation: SkTArray<SkCanvas::Lattice::RectType, false>::push_back_n(int) Unexecuted instantiation: SkTArray<unsigned int, false>::push_back_n(int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::push_back_n(int) Unexecuted instantiation: SkTArray<sk_sp<GrRenderTask>, false>::push_back_n(int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::push_back_n(int) Unexecuted instantiation: SkTArray<SkSL::String, false>::push_back_n(int) Unexecuted instantiation: SkTArray<SkString, false>::push_back_n(int) Unexecuted instantiation: SkTArray<GrMipLevel, false>::push_back_n(int) Unexecuted instantiation: SkTArray<GrGLProgramDataManager::Uniform, true>::push_back_n(int) |
253 | | |
254 | | /** |
255 | | * Version of above that uses a copy constructor to initialize all n items |
256 | | * to the same T. |
257 | | */ |
258 | 4.86M | T* push_back_n(int n, const T& t) { |
259 | 4.86M | SkASSERT(n >= 0); |
260 | 4.86M | void* newTs = this->push_back_raw(n); |
261 | 12.8M | for (int i = 0; i < n; ++i) { |
262 | 7.99M | new (static_cast<char*>(newTs) + i * sizeof(T)) T(t); |
263 | 7.99M | } |
264 | 4.86M | return static_cast<T*>(newTs); |
265 | 4.86M | } SkTArray<SkSVGTextContext::PositionAdjustment, true>::push_back_n(int, SkSVGTextContext::PositionAdjustment const&) Line | Count | Source | 258 | 4.81M | T* push_back_n(int n, const T& t) { | 259 | 4.81M | SkASSERT(n >= 0); | 260 | 4.81M | void* newTs = this->push_back_raw(n); | 261 | 10.1M | for (int i = 0; i < n; ++i) { | 262 | 5.33M | new (static_cast<char*>(newTs) + i * sizeof(T)) T(t); | 263 | 5.33M | } | 264 | 4.81M | return static_cast<T*>(newTs); | 265 | 4.81M | } |
SkTArray<skia::textlayout::CodeUnitFlags, false>::push_back_n(int, skia::textlayout::CodeUnitFlags const&) Line | Count | Source | 258 | 4.02k | T* push_back_n(int n, const T& t) { | 259 | 4.02k | SkASSERT(n >= 0); | 260 | 4.02k | void* newTs = this->push_back_raw(n); | 261 | 1.33M | for (int i = 0; i < n; ++i) { | 262 | 1.32M | new (static_cast<char*>(newTs) + i * sizeof(T)) T(t); | 263 | 1.32M | } | 264 | 4.02k | return static_cast<T*>(newTs); | 265 | 4.02k | } |
SkTArray<unsigned long, false>::push_back_n(int, unsigned long const&) Line | Count | Source | 258 | 3.78k | T* push_back_n(int n, const T& t) { | 259 | 3.78k | SkASSERT(n >= 0); | 260 | 3.78k | void* newTs = this->push_back_raw(n); | 261 | 1.32M | for (int i = 0; i < n; ++i) { | 262 | 1.32M | new (static_cast<char*>(newTs) + i * sizeof(T)) T(t); | 263 | 1.32M | } | 264 | 3.78k | return static_cast<T*>(newTs); | 265 | 3.78k | } |
Unexecuted instantiation: SkTArray<float, true>::push_back_n(int, float const&) Unexecuted instantiation: SkTArray<SkPoint, true>::push_back_n(int, SkPoint const&) SkTArray<SkSL::VariableReference*, false>::push_back_n(int, SkSL::VariableReference* const&) Line | Count | Source | 258 | 38.9k | T* push_back_n(int n, const T& t) { | 259 | 38.9k | SkASSERT(n >= 0); | 260 | 38.9k | void* newTs = this->push_back_raw(n); | 261 | 49.7k | for (int i = 0; i < n; ++i) { | 262 | 10.8k | new (static_cast<char*>(newTs) + i * sizeof(T)) T(t); | 263 | 10.8k | } | 264 | 38.9k | return static_cast<T*>(newTs); | 265 | 38.9k | } |
|
266 | | |
267 | | /** |
268 | | * Version of above that uses a copy constructor to initialize the n items |
269 | | * to separate T values. |
270 | | */ |
271 | 4.81M | T* push_back_n(int n, const T t[]) { |
272 | 4.81M | SkASSERT(n >= 0); |
273 | 4.81M | this->checkRealloc(n, kGrowing); |
274 | 10.1M | for (int i = 0; i < n; ++i) { |
275 | 5.33M | new (fItemArray + fCount + i) T(t[i]); |
276 | 5.33M | } |
277 | 4.81M | fCount += n; |
278 | 4.81M | return fItemArray + fCount - n; |
279 | 4.81M | } AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAConvexPathOp::PathData, true>::push_back_n(int, (anonymous namespace)::AAConvexPathOp::PathData const*) Line | Count | Source | 271 | 95 | T* push_back_n(int n, const T t[]) { | 272 | 95 | SkASSERT(n >= 0); | 273 | 95 | this->checkRealloc(n, kGrowing); | 274 | 190 | for (int i = 0; i < n; ++i) { | 275 | 95 | new (fItemArray + fCount + i) T(t[i]); | 276 | 95 | } | 277 | 95 | fCount += n; | 278 | 95 | return fItemArray + fCount - n; | 279 | 95 | } |
AAHairLinePathRenderer.cpp:SkTArray<(anonymous namespace)::AAHairlineOp::PathData, true>::push_back_n(int, (anonymous namespace)::AAHairlineOp::PathData const*) Line | Count | Source | 271 | 466 | T* push_back_n(int n, const T t[]) { | 272 | 466 | SkASSERT(n >= 0); | 273 | 466 | this->checkRealloc(n, kGrowing); | 274 | 933 | for (int i = 0; i < n; ++i) { | 275 | 467 | new (fItemArray + fCount + i) T(t[i]); | 276 | 467 | } | 277 | 466 | fCount += n; | 278 | 466 | return fItemArray + fCount - n; | 279 | 466 | } |
AALinearizingConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::push_back_n(int, (anonymous namespace)::AAFlatteningConvexPathOp::PathData const*) Line | Count | Source | 271 | 22 | T* push_back_n(int n, const T t[]) { | 272 | 22 | SkASSERT(n >= 0); | 273 | 22 | this->checkRealloc(n, kGrowing); | 274 | 44 | for (int i = 0; i < n; ++i) { | 275 | 22 | new (fItemArray + fCount + i) T(t[i]); | 276 | 22 | } | 277 | 22 | fCount += n; | 278 | 22 | return fItemArray + fCount - n; | 279 | 22 | } |
DefaultPathRenderer.cpp:SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::push_back_n(int, (anonymous namespace)::DefaultPathOp::PathData const*) Line | Count | Source | 271 | 951 | T* push_back_n(int n, const T t[]) { | 272 | 951 | SkASSERT(n >= 0); | 273 | 951 | this->checkRealloc(n, kGrowing); | 274 | 1.90k | for (int i = 0; i < n; ++i) { | 275 | 951 | new (fItemArray + fCount + i) T(t[i]); | 276 | 951 | } | 277 | 951 | fCount += n; | 278 | 951 | return fItemArray + fCount - n; | 279 | 951 | } |
Unexecuted instantiation: SkTArray<DashOp::LineData, true>::push_back_n(int, DashOp::LineData const*) Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::push_back_n(int, (anonymous namespace)::DrawAtlasOp::Geometry const*) GrDrawVerticesOp.cpp:SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::push_back_n(int, (anonymous namespace)::DrawVerticesOp::Mesh const*) Line | Count | Source | 271 | 42 | T* push_back_n(int n, const T t[]) { | 272 | 42 | SkASSERT(n >= 0); | 273 | 42 | this->checkRealloc(n, kGrowing); | 274 | 84 | for (int i = 0; i < n; ++i) { | 275 | 42 | new (fItemArray + fCount + i) T(t[i]); | 276 | 42 | } | 277 | 42 | fCount += n; | 278 | 42 | return fItemArray + fCount - n; | 279 | 42 | } |
SkTArray<CircularRRectOp::RRect, true>::push_back_n(int, CircularRRectOp::RRect const*) Line | Count | Source | 271 | 3 | T* push_back_n(int n, const T t[]) { | 272 | 3 | SkASSERT(n >= 0); | 273 | 3 | this->checkRealloc(n, kGrowing); | 274 | 6 | for (int i = 0; i < n; ++i) { | 275 | 3 | new (fItemArray + fCount + i) T(t[i]); | 276 | 3 | } | 277 | 3 | fCount += n; | 278 | 3 | return fItemArray + fCount - n; | 279 | 3 | } |
Unexecuted instantiation: SkTArray<EllipticalRRectOp::RRect, true>::push_back_n(int, EllipticalRRectOp::RRect const*) Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::push_back_n(int, ButtCapDashedCircleOp::Circle const*) SkTArray<CircleOp::Circle, true>::push_back_n(int, CircleOp::Circle const*) Line | Count | Source | 271 | 11 | T* push_back_n(int n, const T t[]) { | 272 | 11 | SkASSERT(n >= 0); | 273 | 11 | this->checkRealloc(n, kGrowing); | 274 | 22 | for (int i = 0; i < n; ++i) { | 275 | 11 | new (fItemArray + fCount + i) T(t[i]); | 276 | 11 | } | 277 | 11 | fCount += n; | 278 | 11 | return fItemArray + fCount - n; | 279 | 11 | } |
Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::push_back_n(int, EllipseOp::Ellipse const*) Unexecuted instantiation: SkTArray<DIEllipseOp::Ellipse, true>::push_back_n(int, DIEllipseOp::Ellipse const*) Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::push_back_n(int, (anonymous namespace)::RegionOp::RegionInfo const*) Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::push_back_n(int, (anonymous namespace)::ShadowCircularRRectOp::Geometry const*) GrStrokeRectOp.cpp:SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::push_back_n(int, (anonymous namespace)::AAStrokeRectOp::RectInfo const*) Line | Count | Source | 271 | 61 | T* push_back_n(int n, const T t[]) { | 272 | 61 | SkASSERT(n >= 0); | 273 | 61 | this->checkRealloc(n, kGrowing); | 274 | 122 | for (int i = 0; i < n; ++i) { | 275 | 61 | new (fItemArray + fCount + i) T(t[i]); | 276 | 61 | } | 277 | 61 | fCount += n; | 278 | 61 | return fItemArray + fCount - n; | 279 | 61 | } |
SmallPathRenderer.cpp:SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::push_back_n(int, (anonymous namespace)::SmallPathOp::Entry const*) Line | Count | Source | 271 | 898 | T* push_back_n(int n, const T t[]) { | 272 | 898 | SkASSERT(n >= 0); | 273 | 898 | this->checkRealloc(n, kGrowing); | 274 | 1.79k | for (int i = 0; i < n; ++i) { | 275 | 898 | new (fItemArray + fCount + i) T(t[i]); | 276 | 898 | } | 277 | 898 | fCount += n; | 278 | 898 | return fItemArray + fCount - n; | 279 | 898 | } |
SkTArray<char, true>::push_back_n(int, char const*) Line | Count | Source | 271 | 4.81M | T* push_back_n(int n, const T t[]) { | 272 | 4.81M | SkASSERT(n >= 0); | 273 | 4.81M | this->checkRealloc(n, kGrowing); | 274 | 10.1M | for (int i = 0; i < n; ++i) { | 275 | 5.33M | new (fItemArray + fCount + i) T(t[i]); | 276 | 5.33M | } | 277 | 4.81M | fCount += n; | 278 | 4.81M | return fItemArray + fCount - n; | 279 | 4.81M | } |
Unexecuted instantiation: SkTArray<DashOp::LineData, true>::push_back_n(int, DashOp::LineData const*) Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::push_back_n(int, (anonymous namespace)::DrawAtlasOp::Geometry const*) Unexecuted instantiation: SkTArray<EllipticalRRectOp::RRect, true>::push_back_n(int, EllipticalRRectOp::RRect const*) Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::push_back_n(int, ButtCapDashedCircleOp::Circle const*) Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::push_back_n(int, EllipseOp::Ellipse const*) Unexecuted instantiation: SkTArray<DIEllipseOp::Ellipse, true>::push_back_n(int, DIEllipseOp::Ellipse const*) Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::push_back_n(int, (anonymous namespace)::RegionOp::RegionInfo const*) Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::push_back_n(int, (anonymous namespace)::ShadowCircularRRectOp::Geometry const*) |
280 | | |
281 | | /** |
282 | | * Version of above that uses the move constructor to set n items. |
283 | | */ |
284 | 32.2k | T* move_back_n(int n, T* t) { |
285 | 32.2k | SkASSERT(n >= 0); |
286 | 32.2k | this->checkRealloc(n, kGrowing); |
287 | 52.6k | for (int i = 0; i < n; ++i) { |
288 | 20.3k | new (fItemArray + fCount + i) T(std::move(t[i])); |
289 | 20.3k | } |
290 | 32.2k | fCount += n; |
291 | 32.2k | return fItemArray + fCount - n; |
292 | 32.2k | } SkTArray<GrTextureProxy*, true>::move_back_n(int, GrTextureProxy**) Line | Count | Source | 284 | 10.7k | T* move_back_n(int n, T* t) { | 285 | 10.7k | SkASSERT(n >= 0); | 286 | 10.7k | this->checkRealloc(n, kGrowing); | 287 | 10.7k | for (int i = 0; i < n; ++i) { | 288 | 0 | new (fItemArray + fCount + i) T(std::move(t[i])); | 289 | 0 | } | 290 | 10.7k | fCount += n; | 291 | 10.7k | return fItemArray + fCount - n; | 292 | 10.7k | } |
SkTArray<GrSurfaceProxy*, true>::move_back_n(int, GrSurfaceProxy**) Line | Count | Source | 284 | 10.7k | T* move_back_n(int n, T* t) { | 285 | 10.7k | SkASSERT(n >= 0); | 286 | 10.7k | this->checkRealloc(n, kGrowing); | 287 | 22.9k | for (int i = 0; i < n; ++i) { | 288 | 12.1k | new (fItemArray + fCount + i) T(std::move(t[i])); | 289 | 12.1k | } | 290 | 10.7k | fCount += n; | 291 | 10.7k | return fItemArray + fCount - n; | 292 | 10.7k | } |
SkTArray<GrOpsTask::OpChain, false>::move_back_n(int, GrOpsTask::OpChain*) Line | Count | Source | 284 | 10.7k | T* move_back_n(int n, T* t) { | 285 | 10.7k | SkASSERT(n >= 0); | 286 | 10.7k | this->checkRealloc(n, kGrowing); | 287 | 18.9k | for (int i = 0; i < n; ++i) { | 288 | 8.19k | new (fItemArray + fCount + i) T(std::move(t[i])); | 289 | 8.19k | } | 290 | 10.7k | fCount += n; | 291 | 10.7k | return fItemArray + fCount - n; | 292 | 10.7k | } |
Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::move_back_n(int, (anonymous namespace)::NonAALatticeOp::Patch*) Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::move_back_n(int, (anonymous namespace)::NonAALatticeOp::Patch*) |
293 | | |
294 | | /** |
295 | | * Removes the last element. Not safe to call when count() == 0. |
296 | | */ |
297 | 243k | void pop_back() { |
298 | 243k | SkASSERT(fCount > 0); |
299 | 243k | --fCount; |
300 | 243k | fItemArray[fCount].~T(); |
301 | 243k | this->checkRealloc(0, kShrinking); |
302 | 243k | } Unexecuted instantiation: SkTArray<SkString, false>::pop_back() SkTArray<SkNoPixelsDevice::ClipState, false>::pop_back() Line | Count | Source | 297 | 119k | void pop_back() { | 298 | 119k | SkASSERT(fCount > 0); | 299 | 119k | --fCount; | 300 | 119k | fItemArray[fCount].~T(); | 301 | 119k | this->checkRealloc(0, kShrinking); | 302 | 119k | } |
Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::pop_back() Unexecuted instantiation: SkTArray<bool, true>::pop_back() Unexecuted instantiation: SkTArray<int, false>::pop_back() SkTArray<__jmp_buf_tag (*) [1], false>::pop_back() Line | Count | Source | 297 | 104k | void pop_back() { | 298 | 104k | SkASSERT(fCount > 0); | 299 | 104k | --fCount; | 300 | 104k | fItemArray[fCount].~T(); | 301 | 104k | this->checkRealloc(0, kShrinking); | 302 | 104k | } |
SkTArray<GrBufferAllocPool::BufferBlock, false>::pop_back() Line | Count | Source | 297 | 3.30k | void pop_back() { | 298 | 3.30k | SkASSERT(fCount > 0); | 299 | 3.30k | --fCount; | 300 | 3.30k | fItemArray[fCount].~T(); | 301 | 3.30k | this->checkRealloc(0, kShrinking); | 302 | 3.30k | } |
Unexecuted instantiation: SkTArray<GrDrawOpAtlas::Plot*, false>::pop_back() Unexecuted instantiation: SkTArray<std::__1::function<void ()>, false>::pop_back() Unexecuted instantiation: SkTArray<GrVertexChunk, false>::pop_back() SkTArray<skia::textlayout::Block, true>::pop_back() Line | Count | Source | 297 | 8.87k | void pop_back() { | 298 | 8.87k | SkASSERT(fCount > 0); | 299 | 8.87k | --fCount; | 300 | 8.87k | fItemArray[fCount].~T(); | 301 | 8.87k | this->checkRealloc(0, kShrinking); | 302 | 8.87k | } |
Unexecuted instantiation: SkTArray<SkString, false>::pop_back() Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::pop_back() Unexecuted instantiation: SkTArray<bool, true>::pop_back() Unexecuted instantiation: SkTArray<int, false>::pop_back() Unexecuted instantiation: SkTArray<GrDrawOpAtlas::Plot*, false>::pop_back() Unexecuted instantiation: SkTArray<std::__1::function<void ()>, false>::pop_back() Unexecuted instantiation: SkTArray<GrVertexChunk, false>::pop_back() SkTArray<SkSVGDevice::ClipRec, false>::pop_back() Line | Count | Source | 297 | 7.86k | void pop_back() { | 298 | 7.86k | SkASSERT(fCount > 0); | 299 | 7.86k | --fCount; | 300 | 7.86k | fItemArray[fCount].~T(); | 301 | 7.86k | this->checkRealloc(0, kShrinking); | 302 | 7.86k | } |
|
303 | | |
304 | | /** |
305 | | * Removes the last n elements. Not safe to call when count() < n. |
306 | | */ |
307 | 1.53M | void pop_back_n(int n) { |
308 | 1.53M | SkASSERT(n >= 0); |
309 | 1.53M | SkASSERT(this->count() >= n); |
310 | 1.53M | fCount -= n; |
311 | 12.9M | for (int i = 0; i < n; ++i) { |
312 | 11.3M | fItemArray[fCount + i].~T(); |
313 | 11.3M | } |
314 | 1.53M | this->checkRealloc(0, kShrinking); |
315 | 1.53M | } SkTArray<SkString, false>::pop_back_n(int) Line | Count | Source | 307 | 20 | void pop_back_n(int n) { | 308 | 20 | SkASSERT(n >= 0); | 309 | 20 | SkASSERT(this->count() >= n); | 310 | 20 | fCount -= n; | 311 | 20 | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 20 | this->checkRealloc(0, kShrinking); | 315 | 20 | } |
SkTArray<SkNoPixelsDevice::ClipState, false>::pop_back_n(int) Line | Count | Source | 307 | 480k | void pop_back_n(int n) { | 308 | 480k | SkASSERT(n >= 0); | 309 | 480k | SkASSERT(this->count() >= n); | 310 | 480k | fCount -= n; | 311 | 634k | for (int i = 0; i < n; ++i) { | 312 | 153k | fItemArray[fCount + i].~T(); | 313 | 153k | } | 314 | 480k | this->checkRealloc(0, kShrinking); | 315 | 480k | } |
SkTArray<sk_gpu_test::GrContextFactory::Context, true>::pop_back_n(int) Line | Count | Source | 307 | 1.50k | void pop_back_n(int n) { | 308 | 1.50k | SkASSERT(n >= 0); | 309 | 1.50k | SkASSERT(this->count() >= n); | 310 | 1.50k | fCount -= n; | 311 | 2.83k | for (int i = 0; i < n; ++i) { | 312 | 1.32k | fItemArray[fCount + i].~T(); | 313 | 1.32k | } | 314 | 1.50k | this->checkRealloc(0, kShrinking); | 315 | 1.50k | } |
Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::pop_back_n(int) SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::pop_back_n(int) Line | Count | Source | 307 | 508 | void pop_back_n(int n) { | 308 | 508 | SkASSERT(n >= 0); | 309 | 508 | SkASSERT(this->count() >= n); | 310 | 508 | fCount -= n; | 311 | 508 | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 508 | this->checkRealloc(0, kShrinking); | 315 | 508 | } |
Unexecuted instantiation: SkTArray<SkRuntimeEffect::ChildPtr, false>::pop_back_n(int) SkTArray<unsigned long, true>::pop_back_n(int) Line | Count | Source | 307 | 8.05k | void pop_back_n(int n) { | 308 | 8.05k | SkASSERT(n >= 0); | 309 | 8.05k | SkASSERT(this->count() >= n); | 310 | 8.05k | fCount -= n; | 311 | 8.05k | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 8.05k | this->checkRealloc(0, kShrinking); | 315 | 8.05k | } |
Unexecuted instantiation: SkTArray<int, true>::pop_back_n(int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::pop_back_n(int) SkTArray<unsigned int, true>::pop_back_n(int) Line | Count | Source | 307 | 20.6k | void pop_back_n(int n) { | 308 | 20.6k | SkASSERT(n >= 0); | 309 | 20.6k | SkASSERT(this->count() >= n); | 310 | 20.6k | fCount -= n; | 311 | 121k | for (int i = 0; i < n; ++i) { | 312 | 100k | fItemArray[fCount + i].~T(); | 313 | 100k | } | 314 | 20.6k | this->checkRealloc(0, kShrinking); | 315 | 20.6k | } |
SkTArray<sk_sp<GrRenderTask>, false>::pop_back_n(int) Line | Count | Source | 307 | 65.0k | void pop_back_n(int n) { | 308 | 65.0k | SkASSERT(n >= 0); | 309 | 65.0k | SkASSERT(this->count() >= n); | 310 | 65.0k | fCount -= n; | 311 | 166k | for (int i = 0; i < n; ++i) { | 312 | 100k | fItemArray[fCount + i].~T(); | 313 | 100k | } | 314 | 65.0k | this->checkRealloc(0, kShrinking); | 315 | 65.0k | } |
SkTArray<GrGpu::SubmittedProc, false>::pop_back_n(int) Line | Count | Source | 307 | 22.6k | void pop_back_n(int n) { | 308 | 22.6k | SkASSERT(n >= 0); | 309 | 22.6k | SkASSERT(this->count() >= n); | 310 | 22.6k | fCount -= n; | 311 | 22.6k | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 22.6k | this->checkRealloc(0, kShrinking); | 315 | 22.6k | } |
Unexecuted instantiation: SkTArray<SkSL::String, false>::pop_back_n(int) SkTArray<GrUniqueKeyInvalidatedMessage, false>::pop_back_n(int) Line | Count | Source | 307 | 82.3k | void pop_back_n(int n) { | 308 | 82.3k | SkASSERT(n >= 0); | 309 | 82.3k | SkASSERT(this->count() >= n); | 310 | 82.3k | fCount -= n; | 311 | 82.3k | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 82.3k | this->checkRealloc(0, kShrinking); | 315 | 82.3k | } |
Unexecuted instantiation: SkTArray<GrTextureFreedMessage, false>::pop_back_n(int) SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::pop_back_n(int) Line | Count | Source | 307 | 531 | void pop_back_n(int n) { | 308 | 531 | SkASSERT(n >= 0); | 309 | 531 | SkASSERT(this->count() >= n); | 310 | 531 | fCount -= n; | 311 | 531 | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 531 | this->checkRealloc(0, kShrinking); | 315 | 531 | } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::pop_back_n(int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::pop_back_n(int) SkTArray<GrOpsTask::OpChain, false>::pop_back_n(int) Line | Count | Source | 307 | 126k | void pop_back_n(int n) { | 308 | 126k | SkASSERT(n >= 0); | 309 | 126k | SkASSERT(this->count() >= n); | 310 | 126k | fCount -= n; | 311 | 254k | for (int i = 0; i < n; ++i) { | 312 | 127k | fItemArray[fCount + i].~T(); | 313 | 127k | } | 314 | 126k | this->checkRealloc(0, kShrinking); | 315 | 126k | } |
SkTArray<GrTextureProxy*, true>::pop_back_n(int) Line | Count | Source | 307 | 37.3k | void pop_back_n(int n) { | 308 | 37.3k | SkASSERT(n >= 0); | 309 | 37.3k | SkASSERT(this->count() >= n); | 310 | 37.3k | fCount -= n; | 311 | 37.3k | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 37.3k | this->checkRealloc(0, kShrinking); | 315 | 37.3k | } |
SkTArray<GrSurfaceProxy*, true>::pop_back_n(int) Line | Count | Source | 307 | 37.3k | void pop_back_n(int n) { | 308 | 37.3k | SkASSERT(n >= 0); | 309 | 37.3k | SkASSERT(this->count() >= n); | 310 | 37.3k | fCount -= n; | 311 | 51.4k | for (int i = 0; i < n; ++i) { | 312 | 14.1k | fItemArray[fCount + i].~T(); | 313 | 14.1k | } | 314 | 37.3k | this->checkRealloc(0, kShrinking); | 315 | 37.3k | } |
Unexecuted instantiation: SkTArray<GrMipLevel, false>::pop_back_n(int) SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::pop_back_n(int) Line | Count | Source | 307 | 7.47k | void pop_back_n(int n) { | 308 | 7.47k | SkASSERT(n >= 0); | 309 | 7.47k | SkASSERT(this->count() >= n); | 310 | 7.47k | fCount -= n; | 311 | 7.47k | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 7.47k | this->checkRealloc(0, kShrinking); | 315 | 7.47k | } |
SkTArray<sk_sp<SkTextBlob const>, false>::pop_back_n(int) Line | Count | Source | 307 | 127 | void pop_back_n(int n) { | 308 | 127 | SkASSERT(n >= 0); | 309 | 127 | SkASSERT(this->count() >= n); | 310 | 127 | fCount -= n; | 311 | 599 | for (int i = 0; i < n; ++i) { | 312 | 472 | fItemArray[fCount + i].~T(); | 313 | 472 | } | 314 | 127 | this->checkRealloc(0, kShrinking); | 315 | 127 | } |
SkTArray<sk_sp<SkVertices const>, false>::pop_back_n(int) Line | Count | Source | 307 | 48 | void pop_back_n(int n) { | 308 | 48 | SkASSERT(n >= 0); | 309 | 48 | SkASSERT(this->count() >= n); | 310 | 48 | fCount -= n; | 311 | 1.56k | for (int i = 0; i < n; ++i) { | 312 | 1.51k | fItemArray[fCount + i].~T(); | 313 | 1.51k | } | 314 | 48 | this->checkRealloc(0, kShrinking); | 315 | 48 | } |
SkTArray<sk_sp<SkImage const>, false>::pop_back_n(int) Line | Count | Source | 307 | 1.71k | void pop_back_n(int n) { | 308 | 1.71k | SkASSERT(n >= 0); | 309 | 1.71k | SkASSERT(this->count() >= n); | 310 | 1.71k | fCount -= n; | 311 | 22.2k | for (int i = 0; i < n; ++i) { | 312 | 20.5k | fItemArray[fCount + i].~T(); | 313 | 20.5k | } | 314 | 1.71k | this->checkRealloc(0, kShrinking); | 315 | 1.71k | } |
Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::pop_back_n(int) SkTArray<sk_sp<SkDrawable>, false>::pop_back_n(int) Line | Count | Source | 307 | 7 | void pop_back_n(int n) { | 308 | 7 | SkASSERT(n >= 0); | 309 | 7 | SkASSERT(this->count() >= n); | 310 | 7 | fCount -= n; | 311 | 7 | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 7 | this->checkRealloc(0, kShrinking); | 315 | 7 | } |
Unexecuted instantiation: SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::pop_back_n(int) Unexecuted instantiation: SkTArray<float, true>::pop_back_n(int) SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::pop_back_n(int) Line | Count | Source | 307 | 21.9k | void pop_back_n(int n) { | 308 | 21.9k | SkASSERT(n >= 0); | 309 | 21.9k | SkASSERT(this->count() >= n); | 310 | 21.9k | fCount -= n; | 311 | 21.9k | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 21.9k | this->checkRealloc(0, kShrinking); | 315 | 21.9k | } |
Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::pop_back_n(int) SkTArray<unsigned short, false>::pop_back_n(int) Line | Count | Source | 307 | 210k | void pop_back_n(int n) { | 308 | 210k | SkASSERT(n >= 0); | 309 | 210k | SkASSERT(this->count() >= n); | 310 | 210k | fCount -= n; | 311 | 210k | for (int i = 0; i < n; ++i) { | 312 | 444 | fItemArray[fCount + i].~T(); | 313 | 444 | } | 314 | 210k | this->checkRealloc(0, kShrinking); | 315 | 210k | } |
SkTArray<SkPoint, false>::pop_back_n(int) Line | Count | Source | 307 | 210k | void pop_back_n(int n) { | 308 | 210k | SkASSERT(n >= 0); | 309 | 210k | SkASSERT(this->count() >= n); | 310 | 210k | fCount -= n; | 311 | 210k | for (int i = 0; i < n; ++i) { | 312 | 444 | fItemArray[fCount + i].~T(); | 313 | 444 | } | 314 | 210k | this->checkRealloc(0, kShrinking); | 315 | 210k | } |
SkTArray<Sk4fGradientInterval, true>::pop_back_n(int) Line | Count | Source | 307 | 730 | void pop_back_n(int n) { | 308 | 730 | SkASSERT(n >= 0); | 309 | 730 | SkASSERT(this->count() >= n); | 310 | 730 | fCount -= n; | 311 | 730 | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 730 | this->checkRealloc(0, kShrinking); | 315 | 730 | } |
Unexecuted instantiation: SkTArray<SkPoint, true>::pop_back_n(int) Unexecuted instantiation: SkottieShaper.cpp:SkTArray<skottie::(anonymous namespace)::BlobMaker::RunRec, false>::pop_back_n(int) SkTArray<char, true>::pop_back_n(int) Line | Count | Source | 307 | 19.4k | void pop_back_n(int n) { | 308 | 19.4k | SkASSERT(n >= 0); | 309 | 19.4k | SkASSERT(this->count() >= n); | 310 | 19.4k | fCount -= n; | 311 | 5.35M | for (int i = 0; i < n; ++i) { | 312 | 5.33M | fItemArray[fCount + i].~T(); | 313 | 5.33M | } | 314 | 19.4k | this->checkRealloc(0, kShrinking); | 315 | 19.4k | } |
SkTArray<SkSVGTextContext::PositionAdjustment, true>::pop_back_n(int) Line | Count | Source | 307 | 19.4k | void pop_back_n(int n) { | 308 | 19.4k | SkASSERT(n >= 0); | 309 | 19.4k | SkASSERT(this->count() >= n); | 310 | 19.4k | fCount -= n; | 311 | 5.35M | for (int i = 0; i < n; ++i) { | 312 | 5.33M | fItemArray[fCount + i].~T(); | 313 | 5.33M | } | 314 | 19.4k | this->checkRealloc(0, kShrinking); | 315 | 19.4k | } |
SkTArray<SkPath, false>::pop_back_n(int) Line | Count | Source | 307 | 76.8k | void pop_back_n(int n) { | 308 | 76.8k | SkASSERT(n >= 0); | 309 | 76.8k | SkASSERT(this->count() >= n); | 310 | 76.8k | fCount -= n; | 311 | 287k | for (int i = 0; i < n; ++i) { | 312 | 210k | fItemArray[fCount + i].~T(); | 313 | 210k | } | 314 | 76.8k | this->checkRealloc(0, kShrinking); | 315 | 76.8k | } |
Unexecuted instantiation: SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::pop_back_n(int) SkTArray<skia::textlayout::Run, false>::pop_back_n(int) Line | Count | Source | 307 | 4.04k | void pop_back_n(int n) { | 308 | 4.04k | SkASSERT(n >= 0); | 309 | 4.04k | SkASSERT(this->count() >= n); | 310 | 4.04k | fCount -= n; | 311 | 4.04k | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 4.04k | this->checkRealloc(0, kShrinking); | 315 | 4.04k | } |
SkTArray<skia::textlayout::CodeUnitFlags, false>::pop_back_n(int) Line | Count | Source | 307 | 4.02k | void pop_back_n(int n) { | 308 | 4.02k | SkASSERT(n >= 0); | 309 | 4.02k | SkASSERT(this->count() >= n); | 310 | 4.02k | fCount -= n; | 311 | 4.02k | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 4.02k | this->checkRealloc(0, kShrinking); | 315 | 4.02k | } |
SkTArray<skia::textlayout::TextLine, false>::pop_back_n(int) Line | Count | Source | 307 | 4.02k | void pop_back_n(int n) { | 308 | 4.02k | SkASSERT(n >= 0); | 309 | 4.02k | SkASSERT(this->count() >= n); | 310 | 4.02k | fCount -= n; | 311 | 4.02k | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 4.02k | this->checkRealloc(0, kShrinking); | 315 | 4.02k | } |
SkTArray<skia::textlayout::Cluster, true>::pop_back_n(int) Line | Count | Source | 307 | 3.78k | void pop_back_n(int n) { | 308 | 3.78k | SkASSERT(n >= 0); | 309 | 3.78k | SkASSERT(this->count() >= n); | 310 | 3.78k | fCount -= n; | 311 | 3.78k | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 3.78k | this->checkRealloc(0, kShrinking); | 315 | 3.78k | } |
SkTArray<unsigned long, false>::pop_back_n(int) Line | Count | Source | 307 | 3.78k | void pop_back_n(int n) { | 308 | 3.78k | SkASSERT(n >= 0); | 309 | 3.78k | SkASSERT(this->count() >= n); | 310 | 3.78k | fCount -= n; | 311 | 3.78k | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 3.78k | this->checkRealloc(0, kShrinking); | 315 | 3.78k | } |
SkTArray<skia::textlayout::ResolvedFontDescriptor, false>::pop_back_n(int) Line | Count | Source | 307 | 3.76k | void pop_back_n(int n) { | 308 | 3.76k | SkASSERT(n >= 0); | 309 | 3.76k | SkASSERT(this->count() >= n); | 310 | 3.76k | fCount -= n; | 311 | 3.76k | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 3.76k | this->checkRealloc(0, kShrinking); | 315 | 3.76k | } |
Unexecuted instantiation: SkTArray<float, false>::pop_back_n(int) SkTArray<SkShaper::Feature, false>::pop_back_n(int) Line | Count | Source | 307 | 57.6k | void pop_back_n(int n) { | 308 | 57.6k | SkASSERT(n >= 0); | 309 | 57.6k | SkASSERT(this->count() >= n); | 310 | 57.6k | fCount -= n; | 311 | 57.6k | for (int i = 0; i < n; ++i) { | 312 | 0 | fItemArray[fCount + i].~T(); | 313 | 0 | } | 314 | 57.6k | this->checkRealloc(0, kShrinking); | 315 | 57.6k | } |
Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::pop_back_n(int) Unexecuted instantiation: SkTArray<SkRuntimeEffect::ChildPtr, false>::pop_back_n(int) Unexecuted instantiation: SkTArray<int, true>::pop_back_n(int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::pop_back_n(int) Unexecuted instantiation: SkTArray<SkSL::String, false>::pop_back_n(int) Unexecuted instantiation: SkTArray<GrTextureFreedMessage, false>::pop_back_n(int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::pop_back_n(int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::pop_back_n(int) Unexecuted instantiation: SkTArray<GrMipLevel, false>::pop_back_n(int) Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::pop_back_n(int) Unexecuted instantiation: SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::pop_back_n(int) Unexecuted instantiation: SkTArray<float, true>::pop_back_n(int) Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::pop_back_n(int) |
316 | | |
317 | | /** |
318 | | * Pushes or pops from the back to resize. Pushes will be default |
319 | | * initialized. |
320 | | */ |
321 | 7.16M | void resize_back(int newCount) { |
322 | 7.16M | SkASSERT(newCount >= 0); |
323 | | |
324 | 7.16M | if (newCount > this->count()) { |
325 | 7.16M | this->push_back_n(newCount - fCount); |
326 | 647 | } else if (newCount < this->count()) { |
327 | 548 | this->pop_back_n(fCount - newCount); |
328 | 548 | } |
329 | 7.16M | } Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::resize_back(int) SkTArray<unsigned long, true>::resize_back(int) Line | Count | Source | 321 | 261k | void resize_back(int newCount) { | 322 | 261k | SkASSERT(newCount >= 0); | 323 | | | 324 | 261k | if (newCount > this->count()) { | 325 | 261k | this->push_back_n(newCount - fCount); | 326 | 0 | } else if (newCount < this->count()) { | 327 | 0 | this->pop_back_n(fCount - newCount); | 328 | 0 | } | 329 | 261k | } |
SkTArray<int, true>::resize_back(int) Line | Count | Source | 321 | 6.89M | void resize_back(int newCount) { | 322 | 6.89M | SkASSERT(newCount >= 0); | 323 | | | 324 | 6.89M | if (newCount > this->count()) { | 325 | 6.89M | this->push_back_n(newCount - fCount); | 326 | 0 | } else if (newCount < this->count()) { | 327 | 0 | this->pop_back_n(fCount - newCount); | 328 | 0 | } | 329 | 6.89M | } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::resize_back(int) SkTArray<sk_sp<GrRenderTask>, false>::resize_back(int) Line | Count | Source | 321 | 634 | void resize_back(int newCount) { | 322 | 634 | SkASSERT(newCount >= 0); | 323 | | | 324 | 634 | if (newCount > this->count()) { | 325 | 0 | this->push_back_n(newCount - fCount); | 326 | 634 | } else if (newCount < this->count()) { | 327 | 548 | this->pop_back_n(fCount - newCount); | 328 | 548 | } | 329 | 634 | } |
Unexecuted instantiation: SkTArray<SkSL::String, false>::resize_back(int) Unexecuted instantiation: SkTArray<GrMipLevel, false>::resize_back(int) SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::resize_back(int) Line | Count | Source | 321 | 193 | void resize_back(int newCount) { | 322 | 193 | SkASSERT(newCount >= 0); | 323 | | | 324 | 193 | if (newCount > this->count()) { | 325 | 182 | this->push_back_n(newCount - fCount); | 326 | 11 | } else if (newCount < this->count()) { | 327 | 0 | this->pop_back_n(fCount - newCount); | 328 | 0 | } | 329 | 193 | } |
SkTArray<float, true>::resize_back(int) Line | Count | Source | 321 | 736 | void resize_back(int newCount) { | 322 | 736 | SkASSERT(newCount >= 0); | 323 | | | 324 | 736 | if (newCount > this->count()) { | 325 | 734 | this->push_back_n(newCount - fCount); | 326 | 2 | } else if (newCount < this->count()) { | 327 | 0 | this->pop_back_n(fCount - newCount); | 328 | 0 | } | 329 | 736 | } |
Unexecuted instantiation: SkTArray<float, false>::resize_back(int) Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::resize_back(int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::resize_back(int) Unexecuted instantiation: SkTArray<SkSL::String, false>::resize_back(int) Unexecuted instantiation: SkTArray<GrMipLevel, false>::resize_back(int) |
330 | | |
331 | | /** Swaps the contents of this array with that array. Does a pointer swap if possible, |
332 | | otherwise copies the T values. */ |
333 | 112k | void swap(SkTArray& that) { |
334 | 112k | using std::swap; |
335 | 112k | if (this == &that) { |
336 | 0 | return; |
337 | 0 | } |
338 | 112k | if (fOwnMemory && that.fOwnMemory) { |
339 | 90.3k | swap(fItemArray, that.fItemArray); |
340 | | |
341 | 90.3k | auto count = fCount; |
342 | 90.3k | fCount = that.fCount; |
343 | 90.3k | that.fCount = count; |
344 | | |
345 | 90.3k | auto allocCount = fAllocCount; |
346 | 90.3k | fAllocCount = that.fAllocCount; |
347 | 90.3k | that.fAllocCount = allocCount; |
348 | 21.9k | } else { |
349 | | // This could be more optimal... |
350 | 21.9k | SkTArray copy(std::move(that)); |
351 | 21.9k | that = std::move(*this); |
352 | 21.9k | *this = std::move(copy); |
353 | 21.9k | } |
354 | 112k | } Unexecuted instantiation: SkTArray<SkString, false>::swap(SkTArray<SkString, false>&) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::swap(SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>&) Unexecuted instantiation: SkTArray<sk_sp<GrRenderTask>, false>::swap(SkTArray<sk_sp<GrRenderTask>, false>&) SkTArray<GrUniqueKeyInvalidatedMessage, false>::swap(SkTArray<GrUniqueKeyInvalidatedMessage, false>&) Line | Count | Source | 333 | 82.3k | void swap(SkTArray& that) { | 334 | 82.3k | using std::swap; | 335 | 82.3k | if (this == &that) { | 336 | 0 | return; | 337 | 0 | } | 338 | 82.3k | if (fOwnMemory && that.fOwnMemory) { | 339 | 82.3k | swap(fItemArray, that.fItemArray); | 340 | | | 341 | 82.3k | auto count = fCount; | 342 | 82.3k | fCount = that.fCount; | 343 | 82.3k | that.fCount = count; | 344 | | | 345 | 82.3k | auto allocCount = fAllocCount; | 346 | 82.3k | fAllocCount = that.fAllocCount; | 347 | 82.3k | that.fAllocCount = allocCount; | 348 | 0 | } else { | 349 | | // This could be more optimal... | 350 | 0 | SkTArray copy(std::move(that)); | 351 | 0 | that = std::move(*this); | 352 | 0 | *this = std::move(copy); | 353 | 0 | } | 354 | 82.3k | } |
Unexecuted instantiation: SkTArray<GrTextureFreedMessage, false>::swap(SkTArray<GrTextureFreedMessage, false>&) SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::swap(SkTArray<GrTextBlobCache::PurgeBlobMessage, false>&) Line | Count | Source | 333 | 531 | void swap(SkTArray& that) { | 334 | 531 | using std::swap; | 335 | 531 | if (this == &that) { | 336 | 0 | return; | 337 | 0 | } | 338 | 531 | if (fOwnMemory && that.fOwnMemory) { | 339 | 531 | swap(fItemArray, that.fItemArray); | 340 | | | 341 | 531 | auto count = fCount; | 342 | 531 | fCount = that.fCount; | 343 | 531 | that.fCount = count; | 344 | | | 345 | 531 | auto allocCount = fAllocCount; | 346 | 531 | fAllocCount = that.fAllocCount; | 347 | 531 | that.fAllocCount = allocCount; | 348 | 0 | } else { | 349 | | // This could be more optimal... | 350 | 0 | SkTArray copy(std::move(that)); | 351 | 0 | that = std::move(*this); | 352 | 0 | *this = std::move(copy); | 353 | 0 | } | 354 | 531 | } |
SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::swap(SkTArray<SkResourceCache::PurgeSharedIDMessage, false>&) Line | Count | Source | 333 | 7.47k | void swap(SkTArray& that) { | 334 | 7.47k | using std::swap; | 335 | 7.47k | if (this == &that) { | 336 | 0 | return; | 337 | 0 | } | 338 | 7.47k | if (fOwnMemory && that.fOwnMemory) { | 339 | 7.47k | swap(fItemArray, that.fItemArray); | 340 | | | 341 | 7.47k | auto count = fCount; | 342 | 7.47k | fCount = that.fCount; | 343 | 7.47k | that.fCount = count; | 344 | | | 345 | 7.47k | auto allocCount = fAllocCount; | 346 | 7.47k | fAllocCount = that.fAllocCount; | 347 | 7.47k | that.fAllocCount = allocCount; | 348 | 0 | } else { | 349 | | // This could be more optimal... | 350 | 0 | SkTArray copy(std::move(that)); | 351 | 0 | that = std::move(*this); | 352 | 0 | *this = std::move(copy); | 353 | 0 | } | 354 | 7.47k | } |
SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::swap(SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>&) Line | Count | Source | 333 | 21.9k | void swap(SkTArray& that) { | 334 | 21.9k | using std::swap; | 335 | 21.9k | if (this == &that) { | 336 | 0 | return; | 337 | 0 | } | 338 | 21.9k | if (fOwnMemory && that.fOwnMemory) { | 339 | 0 | swap(fItemArray, that.fItemArray); | 340 | |
| 341 | 0 | auto count = fCount; | 342 | 0 | fCount = that.fCount; | 343 | 0 | that.fCount = count; | 344 | |
| 345 | 0 | auto allocCount = fAllocCount; | 346 | 0 | fAllocCount = that.fAllocCount; | 347 | 0 | that.fAllocCount = allocCount; | 348 | 21.9k | } else { | 349 | | // This could be more optimal... | 350 | 21.9k | SkTArray copy(std::move(that)); | 351 | 21.9k | that = std::move(*this); | 352 | 21.9k | *this = std::move(copy); | 353 | 21.9k | } | 354 | 21.9k | } |
|
355 | | |
356 | 32.2M | T* begin() { |
357 | 32.2M | return fItemArray; |
358 | 32.2M | } Unexecuted instantiation: SkTArray<unsigned int, true>::begin() SkTArray<sk_sp<SkImageFilter>, true>::begin() Line | Count | Source | 356 | 354 | T* begin() { | 357 | 354 | return fItemArray; | 358 | 354 | } |
SkTArray<float, false>::begin() Line | Count | Source | 356 | 456 | T* begin() { | 357 | 456 | return fItemArray; | 358 | 456 | } |
SkTArray<int, false>::begin() Line | Count | Source | 356 | 456 | T* begin() { | 357 | 456 | return fItemArray; | 358 | 456 | } |
SkTArray<SkRGBA4f<(SkAlphaType)2>, true>::begin() Line | Count | Source | 356 | 7.63k | T* begin() { | 357 | 7.63k | return fItemArray; | 358 | 7.63k | } |
SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::begin() Line | Count | Source | 356 | 8.32M | T* begin() { | 357 | 8.32M | return fItemArray; | 358 | 8.32M | } |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::begin() Line | Count | Source | 356 | 6.73M | T* begin() { | 357 | 6.73M | return fItemArray; | 358 | 6.73M | } |
SkTArray<SkSL::Parser::Checkpoint::ForwardingErrorReporter::Error, false>::begin() Line | Count | Source | 356 | 58.2k | T* begin() { | 357 | 58.2k | return fItemArray; | 358 | 58.2k | } |
SkTArray<unsigned long, true>::begin() Line | Count | Source | 356 | 261k | T* begin() { | 357 | 261k | return fItemArray; | 358 | 261k | } |
Unexecuted instantiation: SkTArray<SkSL::dsl::DSLStatement, false>::begin() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLVar, false>::begin() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLGlobalVar, false>::begin() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLField, false>::begin() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLCase, false>::begin() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::begin() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLParameter*, false>::begin() SkSLSwizzle.cpp:SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::begin() Line | Count | Source | 356 | 170k | T* begin() { | 357 | 170k | return fItemArray; | 358 | 170k | } |
SkTArray<signed char, false>::begin() Line | Count | Source | 356 | 10.8M | T* begin() { | 357 | 10.8M | return fItemArray; | 358 | 10.8M | } |
SkTArray<sk_sp<GrRenderTask>, false>::begin() Line | Count | Source | 356 | 188k | T* begin() { | 357 | 188k | return fItemArray; | 358 | 188k | } |
SkTArray<GrOnFlushCallbackObject*, false>::begin() Line | Count | Source | 356 | 41.2k | T* begin() { | 357 | 41.2k | return fItemArray; | 358 | 41.2k | } |
Unexecuted instantiation: SkTArray<SkSL::String, false>::begin() SkTArray<sk_sp<GrSurfaceProxy>, false>::begin() Line | Count | Source | 356 | 100k | T* begin() { | 357 | 100k | return fItemArray; | 358 | 100k | } |
SkTArray<GrRenderTask*, true>::begin() Line | Count | Source | 356 | 10.7k | T* begin() { | 357 | 10.7k | return fItemArray; | 358 | 10.7k | } |
SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::begin() Line | Count | Source | 356 | 531 | T* begin() { | 357 | 531 | return fItemArray; | 358 | 531 | } |
SkTArray<sk_sp<GrTextBlob>, false>::begin() Line | Count | Source | 356 | 96 | T* begin() { | 357 | 96 | return fItemArray; | 358 | 96 | } |
SkTArray<GrOpsTask::OpChain, false>::begin() Line | Count | Source | 356 | 273k | T* begin() { | 357 | 273k | return fItemArray; | 358 | 273k | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAConvexPathOp::PathData, true>::begin() Line | Count | Source | 356 | 95 | T* begin() { | 357 | 95 | return fItemArray; | 358 | 95 | } |
AAHairLinePathRenderer.cpp:SkTArray<(anonymous namespace)::AAHairlineOp::PathData, true>::begin() Line | Count | Source | 356 | 466 | T* begin() { | 357 | 466 | return fItemArray; | 358 | 466 | } |
AALinearizingConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::begin() Line | Count | Source | 356 | 22 | T* begin() { | 357 | 22 | return fItemArray; | 358 | 22 | } |
DefaultPathRenderer.cpp:SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::begin() Line | Count | Source | 356 | 951 | T* begin() { | 357 | 951 | return fItemArray; | 358 | 951 | } |
Unexecuted instantiation: SkTArray<DashOp::LineData, true>::begin() Unexecuted instantiation: SkTArray<unsigned char, true>::begin() Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::begin() Unexecuted instantiation: SkTArray<SkRSXform, false>::begin() Unexecuted instantiation: SkTArray<SkRect, false>::begin() Unexecuted instantiation: SkTArray<unsigned int, false>::begin() GrDrawVerticesOp.cpp:SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::begin() Line | Count | Source | 356 | 628 | T* begin() { | 357 | 628 | return fItemArray; | 358 | 628 | } |
Unexecuted instantiation: SkTArray<SkPoint, false>::begin() Unexecuted instantiation: SkTArray<unsigned short, false>::begin() Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::begin() SkTArray<CircularRRectOp::RRect, true>::begin() Line | Count | Source | 356 | 5 | T* begin() { | 357 | 5 | return fItemArray; | 358 | 5 | } |
SkTArray<EllipticalRRectOp::RRect, true>::begin() Line | Count | Source | 356 | 2 | T* begin() { | 357 | 2 | return fItemArray; | 358 | 2 | } |
Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::begin() SkTArray<CircleOp::Circle, true>::begin() Line | Count | Source | 356 | 14 | T* begin() { | 357 | 14 | return fItemArray; | 358 | 14 | } |
Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::begin() SkTArray<DIEllipseOp::Ellipse, true>::begin() Line | Count | Source | 356 | 5 | T* begin() { | 357 | 5 | return fItemArray; | 358 | 5 | } |
Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::begin() Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::begin() GrStrokeRectOp.cpp:SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::begin() Line | Count | Source | 356 | 61 | T* begin() { | 357 | 61 | return fItemArray; | 358 | 61 | } |
SmallPathRenderer.cpp:SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::begin() Line | Count | Source | 356 | 898 | T* begin() { | 357 | 898 | return fItemArray; | 358 | 898 | } |
SkTArray<sk_sp<skgpu::v1::PathRenderer>, false>::begin() Line | Count | Source | 356 | 50.1k | T* begin() { | 357 | 50.1k | return fItemArray; | 358 | 50.1k | } |
Unexecuted instantiation: SkTArray<SkString, false>::begin() Unexecuted instantiation: SkTArray<GrMipLevel, false>::begin() Unexecuted instantiation: SkTArray<GrUniqueKeyInvalidatedMessage, false>::begin() SkTArray<SkMatrix, false>::begin() Line | Count | Source | 356 | 1 | T* begin() { | 357 | 1 | return fItemArray; | 358 | 1 | } |
SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::begin() Line | Count | Source | 356 | 20.0k | T* begin() { | 357 | 20.0k | return fItemArray; | 358 | 20.0k | } |
SkTArray<float, true>::begin() Line | Count | Source | 356 | 19.9k | T* begin() { | 357 | 19.9k | return fItemArray; | 358 | 19.9k | } |
SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::begin() Line | Count | Source | 356 | 21.9k | T* begin() { | 357 | 21.9k | return fItemArray; | 358 | 21.9k | } |
Unexecuted instantiation: SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::begin() Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::begin() SkTArray<skgpu::v1::ClipStack::Element const*, false>::begin() Line | Count | Source | 356 | 9.76k | T* begin() { | 357 | 9.76k | return fItemArray; | 358 | 9.76k | } |
SkTArray<SkOpRayHit*, false>::begin() Line | Count | Source | 356 | 2.60M | T* begin() { | 357 | 2.60M | return fItemArray; | 358 | 2.60M | } |
SkTArray<int, true>::begin() Line | Count | Source | 356 | 94.5k | T* begin() { | 357 | 94.5k | return fItemArray; | 358 | 94.5k | } |
SkTArray<double, true>::begin() Line | Count | Source | 356 | 94.5k | T* begin() { | 357 | 94.5k | return fItemArray; | 358 | 94.5k | } |
Unexecuted instantiation: SkTArray<GrProgramInfo const*, false>::begin() SkTArray<SkClosestRecord const*, true>::begin() Line | Count | Source | 356 | 2.25M | T* begin() { | 357 | 2.25M | return fItemArray; | 358 | 2.25M | } |
Layer.cpp:SkTArray<skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::begin() Line | Count | Source | 356 | 33 | T* begin() { | 357 | 33 | return fItemArray; | 358 | 33 | } |
Unexecuted instantiation: SkottieShaper.cpp:SkTArray<skottie::(anonymous namespace)::BlobMaker::RunRec, false>::begin() Unexecuted instantiation: SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::begin() SkTArray<skia::textlayout::Cluster, true>::begin() Line | Count | Source | 356 | 3.78k | T* begin() { | 357 | 3.78k | return fItemArray; | 358 | 3.78k | } |
SkTArray<skia::textlayout::Run, false>::begin() Line | Count | Source | 356 | 18.9k | T* begin() { | 357 | 18.9k | return fItemArray; | 358 | 18.9k | } |
Unexecuted instantiation: SkTArray<skia::textlayout::Block, true>::begin() SkTArray<skia::textlayout::TextLine, false>::begin() Line | Count | Source | 356 | 7.80k | T* begin() { | 357 | 7.80k | return fItemArray; | 358 | 7.80k | } |
SkTArray<skia::textlayout::Placeholder, true>::begin() Line | Count | Source | 356 | 3.76k | T* begin() { | 357 | 3.76k | return fItemArray; | 358 | 3.76k | } |
Unexecuted instantiation: SkTArray<SkPDFTagNode::MarkedContentInfo, false>::begin() |
359 | 32.8M | const T* begin() const { |
360 | 32.8M | return fItemArray; |
361 | 32.8M | } Unexecuted instantiation: SkTArray<SkString, false>::begin() const SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::begin() const Line | Count | Source | 359 | 901k | const T* begin() const { | 360 | 901k | return fItemArray; | 361 | 901k | } |
SkTArray<sk_sp<GrSurfaceProxy>, false>::begin() const Line | Count | Source | 359 | 2.23M | const T* begin() const { | 360 | 2.23M | return fItemArray; | 361 | 2.23M | } |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::begin() const Line | Count | Source | 359 | 18.7M | const T* begin() const { | 360 | 18.7M | return fItemArray; | 361 | 18.7M | } |
Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::begin() const SkTArray<signed char, false>::begin() const Line | Count | Source | 359 | 169k | const T* begin() const { | 360 | 169k | return fItemArray; | 361 | 169k | } |
SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::begin() const Line | Count | Source | 359 | 8.33M | const T* begin() const { | 360 | 8.33M | return fItemArray; | 361 | 8.33M | } |
Unexecuted instantiation: SkTArray<SkSL::String, false>::begin() const SkTArray<GrSurfaceProxy*, true>::begin() const Line | Count | Source | 359 | 2.05M | const T* begin() const { | 360 | 2.05M | return fItemArray; | 361 | 2.05M | } |
SkTArray<GrOpsTask::OpChain, false>::begin() const Line | Count | Source | 359 | 107k | const T* begin() const { | 360 | 107k | return fItemArray; | 361 | 107k | } |
Unexecuted instantiation: AALinearizingConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::begin() const Unexecuted instantiation: DefaultPathRenderer.cpp:SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::begin() const Unexecuted instantiation: SkTArray<DashOp::LineData, true>::begin() const Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::begin() const Unexecuted instantiation: SkTArray<unsigned char, true>::begin() const Unexecuted instantiation: SkTArray<EllipticalRRectOp::RRect, true>::begin() const Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::begin() const Unexecuted instantiation: SkTArray<DIEllipseOp::Ellipse, true>::begin() const Unexecuted instantiation: GrStrokeRectOp.cpp:SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::begin() const Unexecuted instantiation: SmallPathRenderer.cpp:SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::begin() const Unexecuted instantiation: SkTArray<GrUniqueKeyInvalidatedMessage, false>::begin() const Unexecuted instantiation: SkTArray<SkPaint, false>::begin() const Unexecuted instantiation: SkTArray<SkPath, false>::begin() const Unexecuted instantiation: SkTArray<sk_sp<SkTextBlob const>, false>::begin() const Unexecuted instantiation: SkTArray<sk_sp<SkVertices const>, false>::begin() const Unexecuted instantiation: SkTArray<sk_sp<SkImage const>, false>::begin() const Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::begin() const Unexecuted instantiation: SkTArray<sk_sp<SkDrawable>, false>::begin() const Unexecuted instantiation: SkTArray<sk_sp<GrRenderTask>, false>::begin() const SkTArray<Sk4fGradientInterval, true>::begin() const Line | Count | Source | 359 | 190k | const T* begin() const { | 360 | 190k | return fItemArray; | 361 | 190k | } |
Unexecuted instantiation: SkTArray<GrVertexChunk, false>::begin() const SkTArray<sk_sp<SkSVGNode>, true>::begin() const Line | Count | Source | 359 | 2.20k | const T* begin() const { | 360 | 2.20k | return fItemArray; | 361 | 2.20k | } |
Unexecuted instantiation: SkTArray<unsigned short, true>::begin() const Unexecuted instantiation: SkTArray<SkPoint, true>::begin() const Unexecuted instantiation: SkTArray<unsigned int, true>::begin() const Unexecuted instantiation: SkTArray<float, true>::begin() const SkTArray<skia::textlayout::Placeholder, true>::begin() const Line | Count | Source | 359 | 14.7k | const T* begin() const { | 360 | 14.7k | return fItemArray; | 361 | 14.7k | } |
SkTArray<skia::textlayout::Block, true>::begin() const Line | Count | Source | 359 | 14.7k | const T* begin() const { | 360 | 14.7k | return fItemArray; | 361 | 14.7k | } |
Unexecuted instantiation: SkTArray<unsigned long, true>::begin() const Unexecuted instantiation: SkTArray<SkPDFTagNode*, false>::begin() const |
362 | 32.1M | T* end() { |
363 | 32.0M | return fItemArray ? fItemArray + fCount : nullptr; |
364 | 32.1M | } Unexecuted instantiation: SkTArray<int, false>::end() SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::end() Line | Count | Source | 362 | 8.32M | T* end() { | 363 | 8.32M | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 8.32M | } |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::end() Line | Count | Source | 362 | 6.73M | T* end() { | 363 | 6.73M | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 6.73M | } |
SkTArray<SkSL::Parser::Checkpoint::ForwardingErrorReporter::Error, false>::end() Line | Count | Source | 362 | 58.2k | T* end() { | 363 | 58.1k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 58.2k | } |
SkTArray<unsigned long, true>::end() Line | Count | Source | 362 | 261k | T* end() { | 363 | 261k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 261k | } |
Unexecuted instantiation: SkTArray<SkSL::dsl::DSLStatement, false>::end() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLVar, false>::end() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLGlobalVar, false>::end() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLField, false>::end() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLCase, false>::end() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::end() Unexecuted instantiation: SkTArray<SkSL::dsl::DSLParameter*, false>::end() SkSLSwizzle.cpp:SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::end() Line | Count | Source | 362 | 170k | T* end() { | 363 | 170k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 170k | } |
SkTArray<signed char, false>::end() Line | Count | Source | 362 | 10.8M | T* end() { | 363 | 10.8M | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 10.8M | } |
SkTArray<sk_sp<GrRenderTask>, false>::end() Line | Count | Source | 362 | 234k | T* end() { | 363 | 234k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 234k | } |
SkTArray<GrOnFlushCallbackObject*, false>::end() Line | Count | Source | 362 | 41.2k | T* end() { | 363 | 41.2k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 41.2k | } |
Unexecuted instantiation: SkTArray<SkSL::String, false>::end() SkTArray<sk_sp<GrSurfaceProxy>, false>::end() Line | Count | Source | 362 | 100k | T* end() { | 363 | 100k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 100k | } |
SkTArray<GrRenderTask*, true>::end() Line | Count | Source | 362 | 10.7k | T* end() { | 363 | 10.7k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 10.7k | } |
SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::end() Line | Count | Source | 362 | 531 | T* end() { | 363 | 435 | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 531 | } |
SkTArray<sk_sp<GrTextBlob>, false>::end() Line | Count | Source | 362 | 96 | T* end() { | 363 | 96 | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 96 | } |
SkTArray<GrOpsTask::OpChain, false>::end() Line | Count | Source | 362 | 273k | T* end() { | 363 | 273k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 273k | } |
GrDrawVerticesOp.cpp:SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::end() Line | Count | Source | 362 | 586 | T* end() { | 363 | 586 | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 586 | } |
SkTArray<CircularRRectOp::RRect, true>::end() Line | Count | Source | 362 | 2 | T* end() { | 363 | 2 | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 2 | } |
SkTArray<EllipticalRRectOp::RRect, true>::end() Line | Count | Source | 362 | 2 | T* end() { | 363 | 2 | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 2 | } |
Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::end() SkTArray<CircleOp::Circle, true>::end() Line | Count | Source | 362 | 3 | T* end() { | 363 | 3 | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 3 | } |
Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::end() SkTArray<DIEllipseOp::Ellipse, true>::end() Line | Count | Source | 362 | 5 | T* end() { | 363 | 5 | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 5 | } |
SkTArray<sk_sp<skgpu::v1::PathRenderer>, false>::end() Line | Count | Source | 362 | 50.1k | T* end() { | 363 | 50.1k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 50.1k | } |
Unexecuted instantiation: SkTArray<SkString, false>::end() Unexecuted instantiation: SkTArray<GrUniqueKeyInvalidatedMessage, false>::end() SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::end() Line | Count | Source | 362 | 21.9k | T* end() { | 363 | 21.9k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 21.9k | } |
Unexecuted instantiation: SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::end() SkTArray<SkOpRayHit*, false>::end() Line | Count | Source | 362 | 2.60M | T* end() { | 363 | 2.60M | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 2.60M | } |
SkTArray<int, true>::end() Line | Count | Source | 362 | 94.5k | T* end() { | 363 | 94.5k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 94.5k | } |
Unexecuted instantiation: SkTArray<GrProgramInfo const*, false>::end() SkTArray<SkClosestRecord const*, true>::end() Line | Count | Source | 362 | 2.25M | T* end() { | 363 | 2.25M | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 2.25M | } |
Layer.cpp:SkTArray<skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::end() Line | Count | Source | 362 | 33 | T* end() { | 363 | 33 | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 33 | } |
Unexecuted instantiation: SkottieShaper.cpp:SkTArray<skottie::(anonymous namespace)::BlobMaker::RunRec, false>::end() Unexecuted instantiation: SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::end() Unexecuted instantiation: SkTArray<float, true>::end() SkTArray<skia::textlayout::Run, false>::end() Line | Count | Source | 362 | 18.9k | T* end() { | 363 | 18.9k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 18.9k | } |
SkTArray<skia::textlayout::TextLine, false>::end() Line | Count | Source | 362 | 7.80k | T* end() { | 363 | 7.80k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 7.80k | } |
Unexecuted instantiation: SkTArray<skia::textlayout::Block, true>::end() SkTArray<skia::textlayout::Placeholder, true>::end() Line | Count | Source | 362 | 3.76k | T* end() { | 363 | 3.76k | return fItemArray ? fItemArray + fCount : nullptr; | 364 | 3.76k | } |
Unexecuted instantiation: SkTArray<std::__1::array<unsigned short, 3ul>, false>::end() Unexecuted instantiation: SkTArray<SkPDFTagNode::MarkedContentInfo, false>::end() |
365 | 32.7M | const T* end() const { |
366 | 32.6M | return fItemArray ? fItemArray + fCount : nullptr; |
367 | 32.7M | } Unexecuted instantiation: SkTArray<SkString, false>::end() const SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::end() const Line | Count | Source | 365 | 901k | const T* end() const { | 366 | 901k | return fItemArray ? fItemArray + fCount : nullptr; | 367 | 901k | } |
SkTArray<sk_sp<GrSurfaceProxy>, false>::end() const Line | Count | Source | 365 | 2.23M | const T* end() const { | 366 | 2.23M | return fItemArray ? fItemArray + fCount : nullptr; | 367 | 2.23M | } |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::end() const Line | Count | Source | 365 | 18.7M | const T* end() const { | 366 | 18.7M | return fItemArray ? fItemArray + fCount : nullptr; | 367 | 18.7M | } |
Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::end() const SkTArray<signed char, false>::end() const Line | Count | Source | 365 | 169k | const T* end() const { | 366 | 169k | return fItemArray ? fItemArray + fCount : nullptr; | 367 | 169k | } |
SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::end() const Line | Count | Source | 365 | 8.25M | const T* end() const { | 366 | 8.25M | return fItemArray ? fItemArray + fCount : nullptr; | 367 | 8.25M | } |
Unexecuted instantiation: SkTArray<SkSL::String, false>::end() const SkTArray<GrSurfaceProxy*, true>::end() const Line | Count | Source | 365 | 2.05M | const T* end() const { | 366 | 1.97M | return fItemArray ? fItemArray + fCount : nullptr; | 367 | 2.05M | } |
SkTArray<GrOpsTask::OpChain, false>::end() const Line | Count | Source | 365 | 107k | const T* end() const { | 366 | 107k | return fItemArray ? fItemArray + fCount : nullptr; | 367 | 107k | } |
Unexecuted instantiation: AALinearizingConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::end() const Unexecuted instantiation: DefaultPathRenderer.cpp:SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::end() const Unexecuted instantiation: SkTArray<DashOp::LineData, true>::end() const Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::end() const Unexecuted instantiation: SkTArray<EllipticalRRectOp::RRect, true>::end() const Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::end() const Unexecuted instantiation: SkTArray<DIEllipseOp::Ellipse, true>::end() const Unexecuted instantiation: GrStrokeRectOp.cpp:SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::end() const Unexecuted instantiation: SmallPathRenderer.cpp:SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::end() const Unexecuted instantiation: SkTArray<GrUniqueKeyInvalidatedMessage, false>::end() const Unexecuted instantiation: SkTArray<SkPaint, false>::end() const Unexecuted instantiation: SkTArray<SkPath, false>::end() const Unexecuted instantiation: SkTArray<sk_sp<SkTextBlob const>, false>::end() const Unexecuted instantiation: SkTArray<sk_sp<SkVertices const>, false>::end() const Unexecuted instantiation: SkTArray<sk_sp<SkImage const>, false>::end() const Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::end() const Unexecuted instantiation: SkTArray<sk_sp<SkDrawable>, false>::end() const Unexecuted instantiation: SkTArray<sk_sp<GrRenderTask>, false>::end() const SkTArray<Sk4fGradientInterval, true>::end() const Line | Count | Source | 365 | 192k | const T* end() const { | 366 | 192k | return fItemArray ? fItemArray + fCount : nullptr; | 367 | 192k | } |
Unexecuted instantiation: SkTArray<GrVertexChunk, false>::end() const SkTArray<sk_sp<SkSVGNode>, true>::end() const Line | Count | Source | 365 | 2.20k | const T* end() const { | 366 | 2.20k | return fItemArray ? fItemArray + fCount : nullptr; | 367 | 2.20k | } |
SkTArray<skia::textlayout::Placeholder, true>::end() const Line | Count | Source | 365 | 14.7k | const T* end() const { | 366 | 14.7k | return fItemArray ? fItemArray + fCount : nullptr; | 367 | 14.7k | } |
SkTArray<skia::textlayout::Block, true>::end() const Line | Count | Source | 365 | 14.7k | const T* end() const { | 366 | 14.7k | return fItemArray ? fItemArray + fCount : nullptr; | 367 | 14.7k | } |
Unexecuted instantiation: SkTArray<unsigned long, true>::end() const Unexecuted instantiation: SkTArray<SkPDFTagNode*, false>::end() const |
368 | 1.13M | T* data() { return fItemArray; } SkTArray<unsigned short, false>::data() Line | Count | Source | 368 | 213k | T* data() { return fItemArray; } |
SkTArray<SkPoint, false>::data() Line | Count | Source | 368 | 213k | T* data() { return fItemArray; } |
SkTArray<GrRenderTask*, true>::data() Line | Count | Source | 368 | 21.5k | T* data() { return fItemArray; } |
SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::data() Line | Count | Source | 368 | 203 | T* data() { return fItemArray; } |
SkTArray<SkRuntimeEffect::ChildPtr, false>::data() Line | Count | Source | 368 | 4.04k | T* data() { return fItemArray; } |
SkTArray<int, true>::data() Line | Count | Source | 368 | 87.1k | T* data() { return fItemArray; } |
SkTArray<unsigned int, true>::data() Line | Count | Source | 368 | 45.6k | T* data() { return fItemArray; } |
SkTArray<sk_sp<GrRenderTask>, false>::data() Line | Count | Source | 368 | 20.6k | T* data() { return fItemArray; } |
SkTArray<GrTextureProxy*, true>::data() Line | Count | Source | 368 | 10.7k | T* data() { return fItemArray; } |
SkTArray<GrSurfaceProxy*, true>::data() Line | Count | Source | 368 | 10.7k | T* data() { return fItemArray; } |
SkTArray<GrOpsTask::OpChain, false>::data() Line | Count | Source | 368 | 10.7k | T* data() { return fItemArray; } |
Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::data() Unexecuted instantiation: SkTArray<std::__1::array<unsigned short, 3ul>, false>::data() SkTArray<float, true>::data() Line | Count | Source | 368 | 714 | T* data() { return fItemArray; } |
SkTArray<char, true>::data() Line | Count | Source | 368 | 19.4k | T* data() { return fItemArray; } |
SkTArray<hb_feature_t, false>::data() Line | Count | Source | 368 | 464k | T* data() { return fItemArray; } |
SkTArray<skia::textlayout::Run, false>::data() Line | Count | Source | 368 | 3.78k | T* data() { return fItemArray; } |
Unexecuted instantiation: SkTArray<skia::textlayout::Block, true>::data() Unexecuted instantiation: SkTArray<skia::textlayout::Placeholder, true>::data() SkTArray<skia::textlayout::TextLine, false>::data() Line | Count | Source | 368 | 3.78k | T* data() { return fItemArray; } |
Unexecuted instantiation: SkTArray<unsigned short, true>::data() Unexecuted instantiation: SkTArray<SkPoint, true>::data() Unexecuted instantiation: SkTArray<SkRect, true>::data() Unexecuted instantiation: SkTArray<float, false>::data() Unexecuted instantiation: SkTArray<SkShaper::Feature, false>::data() |
369 | 444 | const T* data() const { return fItemArray; } Unexecuted instantiation: SkTArray<unsigned int, true>::data() const SkTArray<unsigned short, false>::data() const Line | Count | Source | 369 | 444 | const T* data() const { return fItemArray; } |
Unexecuted instantiation: SkTArray<unsigned short, true>::data() const Unexecuted instantiation: SkTArray<SkPoint, true>::data() const Unexecuted instantiation: SkTArray<unsigned long, true>::data() const |
370 | 82.0M | size_t size() const { return (size_t)fCount; } SkTArray<unsigned int, true>::size() const Line | Count | Source | 370 | 45.6k | size_t size() const { return (size_t)fCount; } |
SkTArray<unsigned short, false>::size() const Line | Count | Source | 370 | 213k | size_t size() const { return (size_t)fCount; } |
SkTArray<GrRenderTask*, true>::size() const Line | Count | Source | 370 | 21.5k | size_t size() const { return (size_t)fCount; } |
SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::size() const Line | Count | Source | 370 | 203 | size_t size() const { return (size_t)fCount; } |
SkTArray<SkRuntimeEffect::ChildPtr, false>::size() const Line | Count | Source | 370 | 4.04k | size_t size() const { return (size_t)fCount; } |
SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::size() const Line | Count | Source | 370 | 14.1M | size_t size() const { return (size_t)fCount; } |
SkTArray<signed char, false>::size() const Line | Count | Source | 370 | 39.7M | size_t size() const { return (size_t)fCount; } |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::size() const Line | Count | Source | 370 | 4.07M | size_t size() const { return (size_t)fCount; } |
SkTArray<unsigned long, true>::size() const Line | Count | Source | 370 | 958k | size_t size() const { return (size_t)fCount; } |
SkTArray<int, true>::size() const Line | Count | Source | 370 | 22.0M | size_t size() const { return (size_t)fCount; } |
Unexecuted instantiation: SkTArray<SkSL::dsl::DSLParameter*, false>::size() const Unexecuted instantiation: SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::size() const SkTArray<SkSL::Type const*, false>::size() const Line | Count | Source | 370 | 477 | size_t size() const { return (size_t)fCount; } |
SkTArray<sk_sp<GrRenderTask>, false>::size() const Line | Count | Source | 370 | 65.8k | size_t size() const { return (size_t)fCount; } |
Unexecuted instantiation: SkTArray<SkString, false>::size() const Unexecuted instantiation: SkTArray<GrRecordingContext::ProgramData, false>::size() const Unexecuted instantiation: SkTArray<int, false>::size() const SkTArray<char, true>::size() const Line | Count | Source | 370 | 19.4k | size_t size() const { return (size_t)fCount; } |
SkTArray<hb_feature_t, false>::size() const Line | Count | Source | 370 | 464k | size_t size() const { return (size_t)fCount; } |
SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::size() const Line | Count | Source | 370 | 19.4k | size_t size() const { return (size_t)fCount; } |
Unexecuted instantiation: SkTArray<unsigned short, true>::size() const Unexecuted instantiation: SkTArray<SkPoint, true>::size() const Unexecuted instantiation: SkTArray<float, true>::size() const SkTArray<skia::textlayout::TextLine, false>::size() const Line | Count | Source | 370 | 3.78k | size_t size() const { return (size_t)fCount; } |
SkTArray<skia::textlayout::Run, false>::size() const Line | Count | Source | 370 | 7.54k | size_t size() const { return (size_t)fCount; } |
SkTArray<skia::textlayout::Block, true>::size() const Line | Count | Source | 370 | 138k | size_t size() const { return (size_t)fCount; } |
SkTArray<skia::textlayout::Placeholder, true>::size() const Line | Count | Source | 370 | 9.15k | size_t size() const { return (size_t)fCount; } |
SkTArray<skia::textlayout::Cluster, true>::size() const Line | Count | Source | 370 | 7.56k | size_t size() const { return (size_t)fCount; } |
Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::size() const Unexecuted instantiation: SkTArray<SkShaper::Feature, false>::size() const Unexecuted instantiation: SkTArray<SkPoint, false>::size() const SkTArray<SkSL::VariableReference*, false>::size() const Line | Count | Source | 370 | 18.3k | size_t size() const { return (size_t)fCount; } |
Unexecuted instantiation: SkTArray<SkTArray<SkPDFTagNode*, false>, false>::size() const SkTArray<SkSVGDevice::ClipRec, false>::size() const Line | Count | Source | 370 | 67.7k | size_t size() const { return (size_t)fCount; } |
|
371 | 7.15M | void resize(size_t count) { this->resize_back((int)count); } SkTArray<unsigned long, true>::resize(unsigned long) Line | Count | Source | 371 | 261k | void resize(size_t count) { this->resize_back((int)count); } |
SkTArray<int, true>::resize(unsigned long) Line | Count | Source | 371 | 6.89M | void resize(size_t count) { this->resize_back((int)count); } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::resize(unsigned long) Unexecuted instantiation: SkTArray<SkSL::String, false>::resize(unsigned long) Unexecuted instantiation: SkTArray<GrMipLevel, false>::resize(unsigned long) SkTArray<float, true>::resize(unsigned long) Line | Count | Source | 371 | 714 | void resize(size_t count) { this->resize_back((int)count); } |
Unexecuted instantiation: SkTArray<float, false>::resize(unsigned long) |
372 | | |
373 | | /** |
374 | | * Get the i^th element. |
375 | | */ |
376 | 256M | T& operator[] (int i) { |
377 | 256M | SkASSERT(i < this->count()); |
378 | 256M | SkASSERT(i >= 0); |
379 | 256M | return fItemArray[i]; |
380 | 256M | } Unexecuted instantiation: SkTArray<SkString, false>::operator[](int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::operator[](int) SkTArray<sk_gpu_test::GrContextFactory::Context, true>::operator[](int) Line | Count | Source | 376 | 1.32k | T& operator[] (int i) { | 377 | 1.32k | SkASSERT(i < this->count()); | 378 | 1.32k | SkASSERT(i >= 0); | 379 | 1.32k | return fItemArray[i]; | 380 | 1.32k | } |
Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::operator[](int) SkTArray<GrRenderTask*, true>::operator[](int) Line | Count | Source | 376 | 91.7k | T& operator[] (int i) { | 377 | 91.7k | SkASSERT(i < this->count()); | 378 | 91.7k | SkASSERT(i >= 0); | 379 | 91.7k | return fItemArray[i]; | 380 | 91.7k | } |
SkTArray<sk_sp<SkImageFilter>, true>::operator[](int) Line | Count | Source | 376 | 5.61k | T& operator[] (int i) { | 377 | 5.61k | SkASSERT(i < this->count()); | 378 | 5.61k | SkASSERT(i >= 0); | 379 | 5.61k | return fItemArray[i]; | 380 | 5.61k | } |
Unexecuted instantiation: SkTArray<SkCanvas::Lattice::RectType, false>::operator[](int) Unexecuted instantiation: SkTArray<unsigned int, false>::operator[](int) SkTArray<int, false>::operator[](int) Line | Count | Source | 376 | 3.68k | T& operator[] (int i) { | 377 | 3.68k | SkASSERT(i < this->count()); | 378 | 3.68k | SkASSERT(i >= 0); | 379 | 3.68k | return fItemArray[i]; | 380 | 3.68k | } |
SkTArray<float, false>::operator[](int) Line | Count | Source | 376 | 3.68k | T& operator[] (int i) { | 377 | 3.68k | SkASSERT(i < this->count()); | 378 | 3.68k | SkASSERT(i >= 0); | 379 | 3.68k | return fItemArray[i]; | 380 | 3.68k | } |
Unexecuted instantiation: SkTArray<SkRGBA4f<(SkAlphaType)2>, true>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::operator[](int) SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::operator[](int) Line | Count | Source | 376 | 1.20k | T& operator[] (int i) { | 377 | 1.20k | SkASSERT(i < this->count()); | 378 | 1.20k | SkASSERT(i >= 0); | 379 | 1.20k | return fItemArray[i]; | 380 | 1.20k | } |
SkTArray<SkSL::Type const*, false>::operator[](int) Line | Count | Source | 376 | 820 | T& operator[] (int i) { | 377 | 820 | SkASSERT(i < this->count()); | 378 | 820 | SkASSERT(i >= 0); | 379 | 820 | return fItemArray[i]; | 380 | 820 | } |
SkTArray<int, true>::operator[](int) Line | Count | Source | 376 | 115M | T& operator[] (int i) { | 377 | 115M | SkASSERT(i < this->count()); | 378 | 115M | SkASSERT(i >= 0); | 379 | 115M | return fItemArray[i]; | 380 | 115M | } |
SkTArray<unsigned long, true>::operator[](int) Line | Count | Source | 376 | 2.09M | T& operator[] (int i) { | 377 | 2.09M | SkASSERT(i < this->count()); | 378 | 2.09M | SkASSERT(i >= 0); | 379 | 2.09M | return fItemArray[i]; | 380 | 2.09M | } |
Unexecuted instantiation: SkTArray<SkSL::dsl::DSLParameter*, false>::operator[](int) Unexecuted instantiation: SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::operator[](int) SkTArray<signed char, false>::operator[](int) Line | Count | Source | 376 | 560 | T& operator[] (int i) { | 377 | 560 | SkASSERT(i < this->count()); | 378 | 560 | SkASSERT(i >= 0); | 379 | 560 | return fItemArray[i]; | 380 | 560 | } |
Unexecuted instantiation: SkTArray<GrOnFlushCallbackObject*, false>::operator[](int) SkTArray<sk_sp<GrRenderTask>, false>::operator[](int) Line | Count | Source | 376 | 527k | T& operator[] (int i) { | 377 | 527k | SkASSERT(i < this->count()); | 378 | 527k | SkASSERT(i >= 0); | 379 | 527k | return fItemArray[i]; | 380 | 527k | } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::operator[](int) Unexecuted instantiation: SkTArray<GrGpu::SubmittedProc, false>::operator[](int) Unexecuted instantiation: SkTArray<GrTextureProxy*, true>::operator[](int) SkTArray<GrUniqueKeyInvalidatedMessage, false>::operator[](int) Line | Count | Source | 376 | 118k | T& operator[] (int i) { | 377 | 118k | SkASSERT(i < this->count()); | 378 | 118k | SkASSERT(i >= 0); | 379 | 118k | return fItemArray[i]; | 380 | 118k | } |
Unexecuted instantiation: SkTArray<GrTextureFreedMessage, false>::operator[](int) Unexecuted instantiation: SkTArray<GrTextureResolveRenderTask::Resolve, false>::operator[](int) Unexecuted instantiation: SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::operator[](int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::operator[](int) Unexecuted instantiation: SkTArray<GrAuditTrail::Op*, false>::operator[](int) SkTArray<GrOpsTask::OpChain, false>::operator[](int) Line | Count | Source | 376 | 98.3k | T& operator[] (int i) { | 377 | 98.3k | SkASSERT(i < this->count()); | 378 | 98.3k | SkASSERT(i >= 0); | 379 | 98.3k | return fItemArray[i]; | 380 | 98.3k | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAConvexPathOp::PathData, true>::operator[](int) Line | Count | Source | 376 | 461 | T& operator[] (int i) { | 377 | 461 | SkASSERT(i < this->count()); | 378 | 461 | SkASSERT(i >= 0); | 379 | 461 | return fItemArray[i]; | 380 | 461 | } |
SkTArray<SkPoint, true>::operator[](int) Line | Count | Source | 376 | 751k | T& operator[] (int i) { | 377 | 751k | SkASSERT(i < this->count()); | 378 | 751k | SkASSERT(i >= 0); | 379 | 751k | return fItemArray[i]; | 380 | 751k | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Segment, true>::operator[](int) Line | Count | Source | 376 | 49.6k | T& operator[] (int i) { | 377 | 49.6k | SkASSERT(i < this->count()); | 378 | 49.6k | SkASSERT(i >= 0); | 379 | 49.6k | return fItemArray[i]; | 380 | 49.6k | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Draw, true>::operator[](int) Line | Count | Source | 376 | 332 | T& operator[] (int i) { | 377 | 332 | SkASSERT(i < this->count()); | 378 | 332 | SkASSERT(i >= 0); | 379 | 332 | return fItemArray[i]; | 380 | 332 | } |
AAHairLinePathRenderer.cpp:SkTArray<(anonymous namespace)::AAHairlineOp::PathData, true>::operator[](int) Line | Count | Source | 376 | 2.90k | T& operator[] (int i) { | 377 | 2.90k | SkASSERT(i < this->count()); | 378 | 2.90k | SkASSERT(i >= 0); | 379 | 2.90k | return fItemArray[i]; | 380 | 2.90k | } |
SkTArray<float, true>::operator[](int) Line | Count | Source | 376 | 1.68k | T& operator[] (int i) { | 377 | 1.68k | SkASSERT(i < this->count()); | 378 | 1.68k | SkASSERT(i >= 0); | 379 | 1.68k | return fItemArray[i]; | 380 | 1.68k | } |
AALinearizingConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::operator[](int) Line | Count | Source | 376 | 157 | T& operator[] (int i) { | 377 | 157 | SkASSERT(i < this->count()); | 378 | 157 | SkASSERT(i >= 0); | 379 | 157 | return fItemArray[i]; | 380 | 157 | } |
DefaultPathRenderer.cpp:SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::operator[](int) Line | Count | Source | 376 | 6.76k | T& operator[] (int i) { | 377 | 6.76k | SkASSERT(i < this->count()); | 378 | 6.76k | SkASSERT(i >= 0); | 379 | 6.76k | return fItemArray[i]; | 380 | 6.76k | } |
SkTArray<DashOp::LineData, true>::operator[](int) Line | Count | Source | 376 | 3 | T& operator[] (int i) { | 377 | 3 | SkASSERT(i < this->count()); | 378 | 3 | SkASSERT(i >= 0); | 379 | 3 | return fItemArray[i]; | 380 | 3 | } |
SkTArray<SkRect, true>::operator[](int) Line | Count | Source | 376 | 4 | T& operator[] (int i) { | 377 | 4 | SkASSERT(i < this->count()); | 378 | 4 | SkASSERT(i >= 0); | 379 | 4 | return fItemArray[i]; | 380 | 4 | } |
SkTArray<DashOp::DashDraw, true>::operator[](int) Line | Count | Source | 376 | 10 | T& operator[] (int i) { | 377 | 10 | SkASSERT(i < this->count()); | 378 | 10 | SkASSERT(i >= 0); | 379 | 10 | return fItemArray[i]; | 380 | 10 | } |
Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::operator[](int) GrDrawVerticesOp.cpp:SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::operator[](int) Line | Count | Source | 376 | 1.25k | T& operator[] (int i) { | 377 | 1.25k | SkASSERT(i < this->count()); | 378 | 1.25k | SkASSERT(i >= 0); | 379 | 1.25k | return fItemArray[i]; | 380 | 1.25k | } |
Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::operator[](int) SkTArray<DIEllipseOp::Ellipse, true>::operator[](int) Line | Count | Source | 376 | 7 | T& operator[] (int i) { | 377 | 7 | SkASSERT(i < this->count()); | 378 | 7 | SkASSERT(i >= 0); | 379 | 7 | return fItemArray[i]; | 380 | 7 | } |
Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::operator[](int) Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::operator[](int) GrStrokeRectOp.cpp:SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::operator[](int) Line | Count | Source | 376 | 176 | T& operator[] (int i) { | 377 | 176 | SkASSERT(i < this->count()); | 378 | 176 | SkASSERT(i >= 0); | 379 | 176 | return fItemArray[i]; | 380 | 176 | } |
SmallPathRenderer.cpp:SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::operator[](int) Line | Count | Source | 376 | 13.2k | T& operator[] (int i) { | 377 | 13.2k | SkASSERT(i < this->count()); | 378 | 13.2k | SkASSERT(i >= 0); | 379 | 13.2k | return fItemArray[i]; | 380 | 13.2k | } |
Unexecuted instantiation: SkTArray<GrMipLevel, false>::operator[](int) Unexecuted instantiation: SkTArray<GrGLProgramDataManager::Uniform, true>::operator[](int) Unexecuted instantiation: SkTArray<SkSL::String, false>::operator[](int) SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::operator[](int) Line | Count | Source | 376 | 1.86k | T& operator[] (int i) { | 377 | 1.86k | SkASSERT(i < this->count()); | 378 | 1.86k | SkASSERT(i >= 0); | 379 | 1.86k | return fItemArray[i]; | 380 | 1.86k | } |
SkTArray<SkPath, false>::operator[](int) Line | Count | Source | 376 | 1.07M | T& operator[] (int i) { | 377 | 1.07M | SkASSERT(i < this->count()); | 378 | 1.07M | SkASSERT(i >= 0); | 379 | 1.07M | return fItemArray[i]; | 380 | 1.07M | } |
Unexecuted instantiation: SkTArray<sk_sp<SkImage const>, false>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<SkDrawable>, false>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<SkTextBlob const>, false>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<SkVertices const>, false>::operator[](int) SkTArray<OffsetEdge, false>::operator[](int) Line | Count | Source | 376 | 1.04k | T& operator[] (int i) { | 377 | 1.04k | SkASSERT(i < this->count()); | 378 | 1.04k | SkASSERT(i >= 0); | 379 | 1.04k | return fItemArray[i]; | 380 | 1.04k | } |
Unexecuted instantiation: SkTArray<PathSegment, true>::operator[](int) Unexecuted instantiation: SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::operator[](int) Unexecuted instantiation: SkTArray<GrXPFactoryTestFactory*, true>::operator[](int) Unexecuted instantiation: SkTArray<GrProcessorTestFactory<GrGeometryProcessor*>*, true>::operator[](int) Unexecuted instantiation: SkTArray<GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*, true>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::operator[](int) Unexecuted instantiation: SkTArray<skgpu::v1::ClipStack::Element, false>::operator[](int) SkTArray<std::__1::unique_ptr<SkCodec, std::__1::default_delete<SkCodec> >, true>::operator[](int) Line | Count | Source | 376 | 8.26k | T& operator[] (int i) { | 377 | 8.26k | SkASSERT(i < this->count()); | 378 | 8.26k | SkASSERT(i >= 0); | 379 | 8.26k | return fItemArray[i]; | 380 | 8.26k | } |
Unexecuted instantiation: SkTArray<std::__1::thread, false>::operator[](int) SkTArray<SkOpRayHit*, false>::operator[](int) Line | Count | Source | 376 | 11.4M | T& operator[] (int i) { | 377 | 11.4M | SkASSERT(i < this->count()); | 378 | 11.4M | SkASSERT(i >= 0); | 379 | 11.4M | return fItemArray[i]; | 380 | 11.4M | } |
SkTArray<sk_sp<SkTypeface_Custom>, false>::operator[](int) Line | Count | Source | 376 | 99.7k | T& operator[] (int i) { | 377 | 99.7k | SkASSERT(i < this->count()); | 378 | 99.7k | SkASSERT(i >= 0); | 379 | 99.7k | return fItemArray[i]; | 380 | 99.7k | } |
Unexecuted instantiation: SkTArray<sk_sp<SkFontStyleSet_Custom>, false>::operator[](int) SkTArray<SkClosestRecord, true>::operator[](int) Line | Count | Source | 376 | 109M | T& operator[] (int i) { | 377 | 109M | SkASSERT(i < this->count()); | 378 | 109M | SkASSERT(i >= 0); | 379 | 109M | return fItemArray[i]; | 380 | 109M | } |
SkTArray<SkClosestRecord const*, true>::operator[](int) Line | Count | Source | 376 | 2.95M | T& operator[] (int i) { | 377 | 2.95M | SkASSERT(i < this->count()); | 378 | 2.95M | SkASSERT(i >= 0); | 379 | 2.95M | return fItemArray[i]; | 380 | 2.95M | } |
Unexecuted instantiation: SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<ToolUtils::TopoTestNode>, false>::operator[](int) Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfInfo, false>::operator[](int) Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfLayerInfo, false>::operator[](int) SkTArray<SkSVGTextContext::PositionAdjustment, true>::operator[](int) Line | Count | Source | 376 | 4.76M | T& operator[] (int i) { | 377 | 4.76M | SkASSERT(i < this->count()); | 378 | 4.76M | SkASSERT(i >= 0); | 379 | 4.76M | return fItemArray[i]; | 380 | 4.76M | } |
Unexecuted instantiation: SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::operator[](int) SkTArray<unsigned long, false>::operator[](int) Line | Count | Source | 376 | 3.78k | T& operator[] (int i) { | 377 | 3.78k | SkASSERT(i < this->count()); | 378 | 3.78k | SkASSERT(i >= 0); | 379 | 3.78k | return fItemArray[i]; | 380 | 3.78k | } |
Unexecuted instantiation: SkTArray<skia::textlayout::Run, false>::operator[](int) SkTArray<skia::textlayout::CodeUnitFlags, false>::operator[](int) Line | Count | Source | 376 | 739k | T& operator[] (int i) { | 377 | 739k | SkASSERT(i < this->count()); | 378 | 739k | SkASSERT(i >= 0); | 379 | 739k | return fItemArray[i]; | 380 | 739k | } |
SkTArray<skia::textlayout::Block, true>::operator[](int) Line | Count | Source | 376 | 115k | T& operator[] (int i) { | 377 | 115k | SkASSERT(i < this->count()); | 378 | 115k | SkASSERT(i >= 0); | 379 | 115k | return fItemArray[i]; | 380 | 115k | } |
Unexecuted instantiation: SkTArray<skia::textlayout::Cluster, true>::operator[](int) Unexecuted instantiation: SkTArray<unsigned int, true>::operator[](int) Unexecuted instantiation: SkTArray<unsigned short, true>::operator[](int) Unexecuted instantiation: SkTArray<SkString, false>::operator[](int) Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::operator[](int) Unexecuted instantiation: SkTArray<SkCanvas::Lattice::RectType, false>::operator[](int) Unexecuted instantiation: SkTArray<unsigned int, false>::operator[](int) Unexecuted instantiation: SkTArray<SkRGBA4f<(SkAlphaType)2>, true>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::operator[](int) SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::operator[](int) Line | Count | Source | 376 | 4.05M | T& operator[] (int i) { | 377 | 4.05M | SkASSERT(i < this->count()); | 378 | 4.05M | SkASSERT(i >= 0); | 379 | 4.05M | return fItemArray[i]; | 380 | 4.05M | } |
SkTArray<SkSL::Type const*, false>::operator[](int) Line | Count | Source | 376 | 251k | T& operator[] (int i) { | 377 | 251k | SkASSERT(i < this->count()); | 378 | 251k | SkASSERT(i >= 0); | 379 | 251k | return fItemArray[i]; | 380 | 251k | } |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::operator[](int) Line | Count | Source | 376 | 13.6k | T& operator[] (int i) { | 377 | 13.6k | SkASSERT(i < this->count()); | 378 | 13.6k | SkASSERT(i >= 0); | 379 | 13.6k | return fItemArray[i]; | 380 | 13.6k | } |
Unexecuted instantiation: SkTArray<SkSL::dsl::DSLParameter*, false>::operator[](int) Unexecuted instantiation: SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::operator[](int) SkTArray<signed char, false>::operator[](int) Line | Count | Source | 376 | 1.76M | T& operator[] (int i) { | 377 | 1.76M | SkASSERT(i < this->count()); | 378 | 1.76M | SkASSERT(i >= 0); | 379 | 1.76M | return fItemArray[i]; | 380 | 1.76M | } |
Unexecuted instantiation: SkTArray<GrOnFlushCallbackObject*, false>::operator[](int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::operator[](int) Unexecuted instantiation: SkTArray<GrGpu::SubmittedProc, false>::operator[](int) Unexecuted instantiation: SkTArray<GrTextureProxy*, true>::operator[](int) Unexecuted instantiation: SkTArray<GrTextureFreedMessage, false>::operator[](int) Unexecuted instantiation: SkTArray<GrTextureResolveRenderTask::Resolve, false>::operator[](int) Unexecuted instantiation: SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::operator[](int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::operator[](int) Unexecuted instantiation: SkTArray<GrAuditTrail::Op*, false>::operator[](int) Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::operator[](int) Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::operator[](int) Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::operator[](int) Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::operator[](int) SkTArray<SkSL::VariableReference*, false>::operator[](int) Line | Count | Source | 376 | 29.2k | T& operator[] (int i) { | 377 | 29.2k | SkASSERT(i < this->count()); | 378 | 29.2k | SkASSERT(i >= 0); | 379 | 29.2k | return fItemArray[i]; | 380 | 29.2k | } |
Unexecuted instantiation: SkTArray<GrMipLevel, false>::operator[](int) Unexecuted instantiation: SkTArray<GrGLProgramDataManager::Uniform, true>::operator[](int) Unexecuted instantiation: SkTArray<SkSL::String, false>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<SkImage const>, false>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<SkDrawable>, false>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<SkTextBlob const>, false>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<SkVertices const>, false>::operator[](int) Unexecuted instantiation: SkTArray<PathSegment, true>::operator[](int) Unexecuted instantiation: SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::operator[](int) Unexecuted instantiation: SkTArray<GrXPFactoryTestFactory*, true>::operator[](int) Unexecuted instantiation: SkTArray<GrProcessorTestFactory<GrGeometryProcessor*>*, true>::operator[](int) Unexecuted instantiation: SkTArray<GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*, true>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::operator[](int) Unexecuted instantiation: SkTArray<skgpu::v1::ClipStack::Element, false>::operator[](int) Unexecuted instantiation: SkTArray<std::__1::thread, false>::operator[](int) Unexecuted instantiation: SkTArray<sk_sp<SkFontStyleSet_Custom>, false>::operator[](int) Unexecuted instantiation: SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true>::operator[](int) Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo, false>::operator[](int) Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo::Op, false>::operator[](int) Unexecuted instantiation: SkTArray<SkTArray<SkPDFTagNode*, false>, false>::operator[](int) SkTArray<SkSVGDevice::ClipRec, false>::operator[](int) Line | Count | Source | 376 | 36.2k | T& operator[] (int i) { | 377 | 36.2k | SkASSERT(i < this->count()); | 378 | 36.2k | SkASSERT(i >= 0); | 379 | 36.2k | return fItemArray[i]; | 380 | 36.2k | } |
Unexecuted instantiation: SkTArray<GrUniqueKey, false>::operator[](int) |
381 | | |
382 | 18.0M | const T& operator[] (int i) const { |
383 | 18.0M | SkASSERT(i < this->count()); |
384 | 18.0M | SkASSERT(i >= 0); |
385 | 18.0M | return fItemArray[i]; |
386 | 18.0M | } SkTArray<SkString, false>::operator[](int) const Line | Count | Source | 382 | 25 | const T& operator[] (int i) const { | 383 | 25 | SkASSERT(i < this->count()); | 384 | 25 | SkASSERT(i >= 0); | 385 | 25 | return fItemArray[i]; | 386 | 25 | } |
SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::operator[](int) const Line | Count | Source | 382 | 553k | const T& operator[] (int i) const { | 383 | 553k | SkASSERT(i < this->count()); | 384 | 553k | SkASSERT(i >= 0); | 385 | 553k | return fItemArray[i]; | 386 | 553k | } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::operator[](int) const Unexecuted instantiation: SkTArray<GrGLFormat, true>::operator[](int) const Unexecuted instantiation: SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::operator[](int) const SkTArray<sk_sp<GrSurfaceProxy>, false>::operator[](int) const Line | Count | Source | 382 | 3.69M | const T& operator[] (int i) const { | 383 | 3.69M | SkASSERT(i < this->count()); | 384 | 3.69M | SkASSERT(i >= 0); | 385 | 3.69M | return fItemArray[i]; | 386 | 3.69M | } |
Unexecuted instantiation: SkTArray<GrOpsTask::OpChain, false>::operator[](int) const Unexecuted instantiation: SkTArray<sk_sp<SkImage const>, false>::operator[](int) const SkTArray<SkPath, false>::operator[](int) const Line | Count | Source | 382 | 13.8k | const T& operator[] (int i) const { | 383 | 13.8k | SkASSERT(i < this->count()); | 384 | 13.8k | SkASSERT(i >= 0); | 385 | 13.8k | return fItemArray[i]; | 386 | 13.8k | } |
Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::operator[](int) const Unexecuted instantiation: SkTArray<sk_sp<SkDrawable>, false>::operator[](int) const Unexecuted instantiation: SkTArray<sk_sp<SkTextBlob const>, false>::operator[](int) const Unexecuted instantiation: SkTArray<sk_sp<SkVertices const>, false>::operator[](int) const SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::operator[](int) const Line | Count | Source | 382 | 1.36M | const T& operator[] (int i) const { | 383 | 1.36M | SkASSERT(i < this->count()); | 384 | 1.36M | SkASSERT(i >= 0); | 385 | 1.36M | return fItemArray[i]; | 386 | 1.36M | } |
SkTArray<signed char, false>::operator[](int) const Line | Count | Source | 382 | 2.76M | const T& operator[] (int i) const { | 383 | 2.76M | SkASSERT(i < this->count()); | 384 | 2.76M | SkASSERT(i >= 0); | 385 | 2.76M | return fItemArray[i]; | 386 | 2.76M | } |
SkTArray<int, true>::operator[](int) const Line | Count | Source | 382 | 2.18M | const T& operator[] (int i) const { | 383 | 2.18M | SkASSERT(i < this->count()); | 384 | 2.18M | SkASSERT(i >= 0); | 385 | 2.18M | return fItemArray[i]; | 386 | 2.18M | } |
SkTArray<GrRenderTask*, true>::operator[](int) const Line | Count | Source | 382 | 1.98M | const T& operator[] (int i) const { | 383 | 1.98M | SkASSERT(i < this->count()); | 384 | 1.98M | SkASSERT(i >= 0); | 385 | 1.98M | return fItemArray[i]; | 386 | 1.98M | } |
Unexecuted instantiation: SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::operator[](int) const Unexecuted instantiation: SkTArray<sk_sp<GrTextBlob>, false>::operator[](int) const Unexecuted instantiation: SkTArray<GrAuditTrail::Op*, false>::operator[](int) const Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::operator[](int) const Unexecuted instantiation: SkTArray<GrTextureProxy*, true>::operator[](int) const AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Segment, true>::operator[](int) const Line | Count | Source | 382 | 37.9k | const T& operator[] (int i) const { | 383 | 37.9k | SkASSERT(i < this->count()); | 384 | 37.9k | SkASSERT(i >= 0); | 385 | 37.9k | return fItemArray[i]; | 386 | 37.9k | } |
AAHairLinePathRenderer.cpp:SkTArray<(anonymous namespace)::AAHairlineOp::PathData, true>::operator[](int) const Line | Count | Source | 382 | 11.5k | const T& operator[] (int i) const { | 383 | 11.5k | SkASSERT(i < this->count()); | 384 | 11.5k | SkASSERT(i >= 0); | 385 | 11.5k | return fItemArray[i]; | 386 | 11.5k | } |
DefaultPathRenderer.cpp:SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::operator[](int) const Line | Count | Source | 382 | 2.34k | const T& operator[] (int i) const { | 383 | 2.34k | SkASSERT(i < this->count()); | 384 | 2.34k | SkASSERT(i >= 0); | 385 | 2.34k | return fItemArray[i]; | 386 | 2.34k | } |
SkTArray<DashOp::LineData, true>::operator[](int) const Line | Count | Source | 382 | 1 | const T& operator[] (int i) const { | 383 | 1 | SkASSERT(i < this->count()); | 384 | 1 | SkASSERT(i >= 0); | 385 | 1 | return fItemArray[i]; | 386 | 1 | } |
GrDrawVerticesOp.cpp:SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::operator[](int) const Line | Count | Source | 382 | 1.25k | const T& operator[] (int i) const { | 383 | 1.25k | SkASSERT(i < this->count()); | 384 | 1.25k | SkASSERT(i >= 0); | 385 | 1.25k | return fItemArray[i]; | 386 | 1.25k | } |
Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::operator[](int) const Unexecuted instantiation: SkTArray<CircularRRectOp::RRect, true>::operator[](int) const Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::operator[](int) const Unexecuted instantiation: SkTArray<CircleOp::Circle, true>::operator[](int) const SkTArray<DIEllipseOp::Ellipse, true>::operator[](int) const Line | Count | Source | 382 | 15 | const T& operator[] (int i) const { | 383 | 15 | SkASSERT(i < this->count()); | 384 | 15 | SkASSERT(i >= 0); | 385 | 15 | return fItemArray[i]; | 386 | 15 | } |
Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::operator[](int) const Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::operator[](int) const SmallPathRenderer.cpp:SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::operator[](int) const Line | Count | Source | 382 | 31 | const T& operator[] (int i) const { | 383 | 31 | SkASSERT(i < this->count()); | 384 | 31 | SkASSERT(i >= 0); | 385 | 31 | return fItemArray[i]; | 386 | 31 | } |
Unexecuted instantiation: SkTArray<GrSwizzle, false>::operator[](int) const Unexecuted instantiation: SkTArray<GrGLProgramDataManager::Uniform, true>::operator[](int) const Unexecuted instantiation: SkTArray<GrRecordingContext::ProgramData, false>::operator[](int) const SkTArray<SkPaint, false>::operator[](int) const Line | Count | Source | 382 | 26 | const T& operator[] (int i) const { | 383 | 26 | SkASSERT(i < this->count()); | 384 | 26 | SkASSERT(i >= 0); | 385 | 26 | return fItemArray[i]; | 386 | 26 | } |
Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::operator[](int) const SkTArray<sk_sp<SkFontStyleSet_Custom>, false>::operator[](int) const Line | Count | Source | 382 | 50.7k | const T& operator[] (int i) const { | 383 | 50.7k | SkASSERT(i < this->count()); | 384 | 50.7k | SkASSERT(i >= 0); | 385 | 50.7k | return fItemArray[i]; | 386 | 50.7k | } |
SkTArray<SkClosestRecord, true>::operator[](int) const Line | Count | Source | 382 | 2.95M | const T& operator[] (int i) const { | 383 | 2.95M | SkASSERT(i < this->count()); | 384 | 2.95M | SkASSERT(i >= 0); | 385 | 2.95M | return fItemArray[i]; | 386 | 2.95M | } |
Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfInfo, false>::operator[](int) const Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfLayerInfo, false>::operator[](int) const SkTArray<sk_sp<SkSVGNode>, true>::operator[](int) const Line | Count | Source | 382 | 456k | const T& operator[] (int i) const { | 383 | 456k | SkASSERT(i < this->count()); | 384 | 456k | SkASSERT(i >= 0); | 385 | 456k | return fItemArray[i]; | 386 | 456k | } |
SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::operator[](int) const Line | Count | Source | 382 | 1.25M | const T& operator[] (int i) const { | 383 | 1.25M | SkASSERT(i < this->count()); | 384 | 1.25M | SkASSERT(i >= 0); | 385 | 1.25M | return fItemArray[i]; | 386 | 1.25M | } |
Unexecuted instantiation: SkTArray<SkPoint, true>::operator[](int) const Unexecuted instantiation: SkTArray<unsigned int, true>::operator[](int) const Unexecuted instantiation: SkTArray<SkRect, true>::operator[](int) const SkTArray<skia::textlayout::CodeUnitFlags, false>::operator[](int) const Line | Count | Source | 382 | 3.78k | const T& operator[] (int i) const { | 383 | 3.78k | SkASSERT(i < this->count()); | 384 | 3.78k | SkASSERT(i >= 0); | 385 | 3.78k | return fItemArray[i]; | 386 | 3.78k | } |
SkTArray<skia::textlayout::Block, true>::operator[](int) const Line | Count | Source | 382 | 9.15k | const T& operator[] (int i) const { | 383 | 9.15k | SkASSERT(i < this->count()); | 384 | 9.15k | SkASSERT(i >= 0); | 385 | 9.15k | return fItemArray[i]; | 386 | 9.15k | } |
SkTArray<skia::textlayout::Placeholder, true>::operator[](int) const Line | Count | Source | 382 | 9.15k | const T& operator[] (int i) const { | 383 | 9.15k | SkASSERT(i < this->count()); | 384 | 9.15k | SkASSERT(i >= 0); | 385 | 9.15k | return fItemArray[i]; | 386 | 9.15k | } |
Unexecuted instantiation: SkTArray<float, true>::operator[](int) const Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::operator[](int) const Unexecuted instantiation: SkTArray<GrGLFormat, true>::operator[](int) const Unexecuted instantiation: SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::operator[](int) const Unexecuted instantiation: SkTArray<GrOpsTask::OpChain, false>::operator[](int) const Unexecuted instantiation: SkTArray<sk_sp<SkImage const>, false>::operator[](int) const Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::operator[](int) const Unexecuted instantiation: SkTArray<sk_sp<SkDrawable>, false>::operator[](int) const Unexecuted instantiation: SkTArray<sk_sp<SkTextBlob const>, false>::operator[](int) const Unexecuted instantiation: SkTArray<sk_sp<SkVertices const>, false>::operator[](int) const SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::operator[](int) const Line | Count | Source | 382 | 551k | const T& operator[] (int i) const { | 383 | 551k | SkASSERT(i < this->count()); | 384 | 551k | SkASSERT(i >= 0); | 385 | 551k | return fItemArray[i]; | 386 | 551k | } |
SkTArray<signed char, false>::operator[](int) const Line | Count | Source | 382 | 82.2k | const T& operator[] (int i) const { | 383 | 82.2k | SkASSERT(i < this->count()); | 384 | 82.2k | SkASSERT(i >= 0); | 385 | 82.2k | return fItemArray[i]; | 386 | 82.2k | } |
Unexecuted instantiation: SkTArray<sk_sp<GrRenderTask>, false>::operator[](int) const Unexecuted instantiation: SkTArray<GrTextureProxy*, true>::operator[](int) const Unexecuted instantiation: SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::operator[](int) const Unexecuted instantiation: SkTArray<sk_sp<GrTextBlob>, false>::operator[](int) const Unexecuted instantiation: SkTArray<GrAuditTrail::Op*, false>::operator[](int) const Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::operator[](int) const Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::operator[](int) const Unexecuted instantiation: SkTArray<CircularRRectOp::RRect, true>::operator[](int) const Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::operator[](int) const Unexecuted instantiation: SkTArray<CircleOp::Circle, true>::operator[](int) const Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::operator[](int) const Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::operator[](int) const SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::operator[](int) const Line | Count | Source | 382 | 4.79k | const T& operator[] (int i) const { | 383 | 4.79k | SkASSERT(i < this->count()); | 384 | 4.79k | SkASSERT(i >= 0); | 385 | 4.79k | return fItemArray[i]; | 386 | 4.79k | } |
SkTArray<SkSL::VariableReference*, false>::operator[](int) const Line | Count | Source | 382 | 64.3k | const T& operator[] (int i) const { | 383 | 64.3k | SkASSERT(i < this->count()); | 384 | 64.3k | SkASSERT(i >= 0); | 385 | 64.3k | return fItemArray[i]; | 386 | 64.3k | } |
Unexecuted instantiation: SkTArray<GrSwizzle, false>::operator[](int) const Unexecuted instantiation: SkTArray<GrGLProgramDataManager::Uniform, true>::operator[](int) const Unexecuted instantiation: SkTArray<GrRecordingContext::ProgramData, false>::operator[](int) const Unexecuted instantiation: SkTArray<GrBufferAllocPool::BufferBlock, false>::operator[](int) const Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::operator[](int) const Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::operator[](int) const |
387 | | |
388 | 122k | T& at(int i) { return (*this)[i]; } |
389 | | const T& at(int i) const { return (*this)[i]; } |
390 | | |
391 | | /** |
392 | | * equivalent to operator[](0) |
393 | | */ |
394 | 1.36M | T& front() { SkASSERT(fCount > 0); return fItemArray[0];} SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::front() Line | Count | Source | 394 | 34 | T& front() { SkASSERT(fCount > 0); return fItemArray[0];} |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::front() Line | Count | Source | 394 | 65 | T& front() { SkASSERT(fCount > 0); return fItemArray[0];} |
GrDrawVerticesOp.cpp:SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::front() Line | Count | Source | 394 | 646 | T& front() { SkASSERT(fCount > 0); return fItemArray[0];} |
SkTArray<CircularRRectOp::RRect, true>::front() Line | Count | Source | 394 | 5 | T& front() { SkASSERT(fCount > 0); return fItemArray[0];} |
SkTArray<EllipticalRRectOp::RRect, true>::front() Line | Count | Source | 394 | 2 | T& front() { SkASSERT(fCount > 0); return fItemArray[0];} |
Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::front() SkTArray<CircleOp::Circle, true>::front() Line | Count | Source | 394 | 14 | T& front() { SkASSERT(fCount > 0); return fItemArray[0];} |
Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::front() SkTArray<DIEllipseOp::Ellipse, true>::front() Line | Count | Source | 394 | 5 | T& front() { SkASSERT(fCount > 0); return fItemArray[0];} |
SmallPathRenderer.cpp:SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::front() Line | Count | Source | 394 | 2.43k | T& front() { SkASSERT(fCount > 0); return fItemArray[0];} |
Unexecuted instantiation: SkTArray<dng_exception, false>::front() Layer.cpp:SkTArray<skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::front() Line | Count | Source | 394 | 8.43k | T& front() { SkASSERT(fCount > 0); return fItemArray[0];} |
Unexecuted instantiation: SkTArray<skia::textlayout::TextLine, false>::front() SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::front() Line | Count | Source | 394 | 1.32M | T& front() { SkASSERT(fCount > 0); return fItemArray[0];} |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::front() Line | Count | Source | 394 | 30.5k | T& front() { SkASSERT(fCount > 0); return fItemArray[0];} |
Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::front() Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::front() Unexecuted instantiation: SkTArray<dng_exception, false>::front() |
395 | | |
396 | 2.85M | const T& front() const { SkASSERT(fCount > 0); return fItemArray[0];} SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::front() const Line | Count | Source | 396 | 214k | const T& front() const { SkASSERT(fCount > 0); return fItemArray[0];} |
Unexecuted instantiation: SkTArray<SkString, false>::front() const SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::front() const Line | Count | Source | 396 | 2.64M | const T& front() const { SkASSERT(fCount > 0); return fItemArray[0];} |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::front() const Line | Count | Source | 396 | 200 | const T& front() const { SkASSERT(fCount > 0); return fItemArray[0];} |
Unexecuted instantiation: SkTArray<SkString, false>::front() const Unexecuted instantiation: SkTArray<Sk4fGradientInterval, true>::front() const |
397 | | |
398 | | /** |
399 | | * equivalent to operator[](count() - 1) |
400 | | */ |
401 | 8.04M | T& back() { SkASSERT(fCount); return fItemArray[fCount - 1];} SkTArray<SkNoPixelsDevice::ClipState, false>::back() Line | Count | Source | 401 | 1.86M | T& back() { SkASSERT(fCount); return fItemArray[fCount - 1];} |
Unexecuted instantiation: SkTArray<sk_sp<GrRenderTask>, false>::back() Unexecuted instantiation: SkTArray<int, false>::back() AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAConvexPathOp::PathData, true>::back() Line | Count | Source | 401 | 541 | T& back() { SkASSERT(fCount); return fItemArray[fCount - 1];} |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Segment, true>::back() Line | Count | Source | 401 | 54.8k | T& back() { SkASSERT(fCount); return fItemArray[fCount - 1];} |
AALinearizingConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::back() Line | Count | Source | 401 | 157 | T& back() { SkASSERT(fCount); return fItemArray[fCount - 1];} |
Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::back() GrStrokeRectOp.cpp:SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::back() Line | Count | Source | 401 | 176 | T& back() { SkASSERT(fCount); return fItemArray[fCount - 1];} |
SkTArray<GrBufferAllocPool::BufferBlock, false>::back() Line | Count | Source | 401 | 213k | T& back() { SkASSERT(fCount); return fItemArray[fCount - 1];} |
Unexecuted instantiation: SkTArray<PathSegment, true>::back() Unexecuted instantiation: SkTArray<GrDrawOpAtlas::Plot*, false>::back() Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::back() SkTArray<__jmp_buf_tag (*) [1], false>::back() Line | Count | Source | 401 | 2.43k | T& back() { SkASSERT(fCount); return fItemArray[fCount - 1];} |
Unexecuted instantiation: SkTArray<std::__1::function<void ()>, false>::back() Unexecuted instantiation: SkTArray<GrVertexChunk, false>::back() SkTArray<SkSVGTextContext::PositionAdjustment, true>::back() Line | Count | Source | 401 | 5.21M | T& back() { SkASSERT(fCount); return fItemArray[fCount - 1];} |
Unexecuted instantiation: SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::back() SkTArray<skia::textlayout::Block, true>::back() Line | Count | Source | 401 | 47.9k | T& back() { SkASSERT(fCount); return fItemArray[fCount - 1];} |
Unexecuted instantiation: SkTArray<skia::textlayout::Placeholder, true>::back() Unexecuted instantiation: SkTArray<skia::textlayout::TextLine, false>::back() Unexecuted instantiation: SkTArray<skia::textlayout::Run, false>::back() SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::back() Line | Count | Source | 401 | 494k | T& back() { SkASSERT(fCount); return fItemArray[fCount - 1];} |
SkSLSwizzle.cpp:SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::back() Line | Count | Source | 401 | 152k | T& back() { SkASSERT(fCount); return fItemArray[fCount - 1];} |
Unexecuted instantiation: SkTArray<sk_sp<GrRenderTask>, false>::back() Unexecuted instantiation: SkTArray<GrTextureProxy*, true>::back() Unexecuted instantiation: SkTArray<int, false>::back() Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::back() Unexecuted instantiation: SkTArray<PathSegment, true>::back() Unexecuted instantiation: SkTArray<GrDrawOpAtlas::Plot*, false>::back() Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::back() Unexecuted instantiation: SkTArray<std::__1::function<void ()>, false>::back() Unexecuted instantiation: SkTArray<Sk4fGradientInterval, true>::back() Unexecuted instantiation: SkTArray<GrVertexChunk, false>::back() |
402 | | |
403 | 5.12M | const T& back() const { SkASSERT(fCount > 0); return fItemArray[fCount - 1];} SkTArray<SkNoPixelsDevice::ClipState, false>::back() const Line | Count | Source | 403 | 2.26M | const T& back() const { SkASSERT(fCount > 0); return fItemArray[fCount - 1];} |
Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::back() const Unexecuted instantiation: SkTArray<bool, true>::back() const SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::back() const Line | Count | Source | 403 | 2.85M | const T& back() const { SkASSERT(fCount > 0); return fItemArray[fCount - 1];} |
Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::back() const Unexecuted instantiation: SkTArray<bool, true>::back() const Unexecuted instantiation: SkTArray<sk_sp<GrRenderTask>, false>::back() const Unexecuted instantiation: SkTArray<GrBufferAllocPool::BufferBlock, false>::back() const Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::back() const Unexecuted instantiation: SkTArray<Sk4fGradientInterval, true>::back() const |
404 | | |
405 | | /** |
406 | | * equivalent to operator[](count()-1-i) |
407 | | */ |
408 | 88.8k | T& fromBack(int i) { |
409 | 88.8k | SkASSERT(i >= 0); |
410 | 88.8k | SkASSERT(i < this->count()); |
411 | 88.8k | return fItemArray[fCount - i - 1]; |
412 | 88.8k | } SkTArray<GrOpsTask::OpChain, false>::fromBack(int) Line | Count | Source | 408 | 87.8k | T& fromBack(int i) { | 409 | 87.8k | SkASSERT(i >= 0); | 410 | 87.8k | SkASSERT(i < this->count()); | 411 | 87.8k | return fItemArray[fCount - i - 1]; | 412 | 87.8k | } |
SkTArray<GrBufferAllocPool::BufferBlock, false>::fromBack(int) Line | Count | Source | 408 | 1.03k | T& fromBack(int i) { | 409 | 1.03k | SkASSERT(i >= 0); | 410 | 1.03k | SkASSERT(i < this->count()); | 411 | 1.03k | return fItemArray[fCount - i - 1]; | 412 | 1.03k | } |
|
413 | | |
414 | | const T& fromBack(int i) const { |
415 | | SkASSERT(i >= 0); |
416 | | SkASSERT(i < this->count()); |
417 | | return fItemArray[fCount - i - 1]; |
418 | | } |
419 | | |
420 | 35.4k | bool operator==(const SkTArray<T, MEM_MOVE>& right) const { |
421 | 35.4k | int leftCount = this->count(); |
422 | 35.4k | if (leftCount != right.count()) { |
423 | 0 | return false; |
424 | 0 | } |
425 | 37.8k | for (int index = 0; index < leftCount; ++index) { |
426 | 36.7k | if (fItemArray[index] != right.fItemArray[index]) { |
427 | 34.3k | return false; |
428 | 34.3k | } |
429 | 36.7k | } |
430 | 1.08k | return true; |
431 | 35.4k | } Unexecuted instantiation: SkTArray<unsigned int, true>::operator==(SkTArray<unsigned int, true> const&) const SkTArray<signed char, false>::operator==(SkTArray<signed char, false> const&) const Line | Count | Source | 420 | 35.4k | bool operator==(const SkTArray<T, MEM_MOVE>& right) const { | 421 | 35.4k | int leftCount = this->count(); | 422 | 35.4k | if (leftCount != right.count()) { | 423 | 0 | return false; | 424 | 0 | } | 425 | 37.8k | for (int index = 0; index < leftCount; ++index) { | 426 | 36.7k | if (fItemArray[index] != right.fItemArray[index]) { | 427 | 34.3k | return false; | 428 | 34.3k | } | 429 | 36.7k | } | 430 | 1.08k | return true; | 431 | 35.4k | } |
|
432 | | |
433 | | bool operator!=(const SkTArray<T, MEM_MOVE>& right) const { |
434 | | return !(*this == right); |
435 | | } |
436 | | |
437 | | int capacity() const { |
438 | | return fAllocCount; |
439 | | } |
440 | | |
441 | | protected: |
442 | | /** |
443 | | * Creates an empty array that will use the passed storage block until it |
444 | | * is insufficiently large to hold the entire array. |
445 | | */ |
446 | | template <int N> |
447 | 92.5M | SkTArray(SkAlignedSTStorage<N,T>* storage) { |
448 | 92.5M | this->initWithPreallocatedStorage(0, storage->get(), N); |
449 | 92.5M | } SkTArray<SkNoPixelsDevice::ClipState, false>::SkTArray<4>(SkAlignedSTStorage<4, SkNoPixelsDevice::ClipState>*) Line | Count | Source | 447 | 327k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 327k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 327k | } |
SkTArray<sk_sp<SkImageFilter>, true>::SkTArray<2>(SkAlignedSTStorage<2, sk_sp<SkImageFilter> >*) Line | Count | Source | 447 | 20.8k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 20.8k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 20.8k | } |
SkTArray<SkRGBA4f<(SkAlphaType)2>, true>::SkTArray<4>(SkAlignedSTStorage<4, SkRGBA4f<(SkAlphaType)2> >*) Line | Count | Source | 447 | 7.63k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 7.63k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 7.63k | } |
SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::SkTArray<8>(SkAlignedSTStorage<8, std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*) Line | Count | Source | 447 | 203 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 203 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 203 | } |
SkTArray<SkRuntimeEffect::ChildPtr, false>::SkTArray<4>(SkAlignedSTStorage<4, SkRuntimeEffect::ChildPtr>*) Line | Count | Source | 447 | 4.04k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 4.04k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 4.04k | } |
Unexecuted instantiation: SkTArray<int, false>::SkTArray<2>(SkAlignedSTStorage<2, int>*) SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::SkTArray<2>(SkAlignedSTStorage<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> > >*) Line | Count | Source | 447 | 16.5M | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 16.5M | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 16.5M | } |
SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::SkTArray<2>(SkAlignedSTStorage<2, std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> > >*) Line | Count | Source | 447 | 19.9M | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 19.9M | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 19.9M | } |
SkTArray<SkSL::Type const*, false>::SkTArray<8>(SkAlignedSTStorage<8, SkSL::Type const*>*) Line | Count | Source | 447 | 394k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 394k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 394k | } |
SkTArray<signed char, false>::SkTArray<4>(SkAlignedSTStorage<4, signed char>*) Line | Count | Source | 447 | 33.5M | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 33.5M | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 33.5M | } |
SkTArray<unsigned long, true>::SkTArray<4>(SkAlignedSTStorage<4, unsigned long>*) Line | Count | Source | 447 | 261k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 261k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 261k | } |
SkTArray<int, true>::SkTArray<4>(SkAlignedSTStorage<4, int>*) Line | Count | Source | 447 | 11.2M | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 11.2M | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 11.2M | } |
SkSLSwizzle.cpp:SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::SkTArray<4>(SkAlignedSTStorage<4, SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument>*) Line | Count | Source | 447 | 170k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 170k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 170k | } |
SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::SkTArray<1>(SkAlignedSTStorage<1, std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*) Line | Count | Source | 447 | 630k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 630k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 630k | } |
SkTArray<unsigned int, true>::SkTArray<8>(SkAlignedSTStorage<8, unsigned int>*) Line | Count | Source | 447 | 1.32k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 1.32k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 1.32k | } |
SkTArray<sk_sp<GrRenderTask>, false>::SkTArray<4>(SkAlignedSTStorage<4, sk_sp<GrRenderTask> >*) Line | Count | Source | 447 | 1.32k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 1.32k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 1.32k | } |
Unexecuted instantiation: SkTArray<GrTextureResolveRenderTask::Resolve, false>::SkTArray<4>(SkAlignedSTStorage<4, GrTextureResolveRenderTask::Resolve>*) SkTArray<GrGpu::SubmittedProc, false>::SkTArray<4>(SkAlignedSTStorage<4, GrGpu::SubmittedProc>*) Line | Count | Source | 447 | 1.32k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 1.32k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 1.32k | } |
SkTArray<sk_sp<GrSurfaceProxy>, false>::SkTArray<1>(SkAlignedSTStorage<1, sk_sp<GrSurfaceProxy> >*) Line | Count | Source | 447 | 100k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 100k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 100k | } |
SkTArray<GrRenderTask*, true>::SkTArray<1>(SkAlignedSTStorage<1, GrRenderTask*>*) Line | Count | Source | 447 | 201k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 201k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 201k | } |
Unexecuted instantiation: SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::SkTArray<3>(SkAlignedSTStorage<3, skgpu::SurfaceContext::AsyncReadResult::Plane>*) SkTArray<sk_sp<GrTextBlob>, false>::SkTArray<1>(SkAlignedSTStorage<1, sk_sp<GrTextBlob> >*) Line | Count | Source | 447 | 2.84k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 2.84k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 2.84k | } |
Unexecuted instantiation: SkTArray<SkString, false>::SkTArray<15>(SkAlignedSTStorage<15, SkString>*) Unexecuted instantiation: SkTArray<SkString, false>::SkTArray<1>(SkAlignedSTStorage<1, SkString>*) SkTArray<GrOpsTask::OpChain, false>::SkTArray<25>(SkAlignedSTStorage<25, GrOpsTask::OpChain>*) Line | Count | Source | 447 | 89.6k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 89.6k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 89.6k | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAConvexPathOp::PathData, true>::SkTArray<1>(SkAlignedSTStorage<1, (anonymous namespace)::AAConvexPathOp::PathData>*) Line | Count | Source | 447 | 646 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 646 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 646 | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Segment, true>::SkTArray<11>(SkAlignedSTStorage<11, (anonymous namespace)::Segment>*) Line | Count | Source | 447 | 461 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 461 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 461 | } |
SkTArray<SkPoint, true>::SkTArray<15>(SkAlignedSTStorage<15, SkPoint>*) Line | Count | Source | 447 | 28 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 28 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 28 | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Draw, true>::SkTArray<4>(SkAlignedSTStorage<4, (anonymous namespace)::Draw>*) Line | Count | Source | 447 | 332 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 332 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 332 | } |
AAHairLinePathRenderer.cpp:SkTArray<(anonymous namespace)::AAHairlineOp::PathData, true>::SkTArray<1>(SkAlignedSTStorage<1, (anonymous namespace)::AAHairlineOp::PathData>*) Line | Count | Source | 447 | 3.64k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 3.64k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 3.64k | } |
SkTArray<SkPoint, true>::SkTArray<128>(SkAlignedSTStorage<128, SkPoint>*) Line | Count | Source | 447 | 7.38k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 7.38k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 7.38k | } |
SkTArray<SkPoint, true>::SkTArray<32>(SkAlignedSTStorage<32, SkPoint>*) Line | Count | Source | 447 | 50.8k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 50.8k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 50.8k | } |
AALinearizingConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::SkTArray<1>(SkAlignedSTStorage<1, (anonymous namespace)::AAFlatteningConvexPathOp::PathData>*) Line | Count | Source | 447 | 574 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 574 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 574 | } |
DefaultPathRenderer.cpp:SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::SkTArray<1>(SkAlignedSTStorage<1, (anonymous namespace)::DefaultPathOp::PathData>*) Line | Count | Source | 447 | 9.24k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 9.24k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 9.24k | } |
SkTArray<DashOp::LineData, true>::SkTArray<1>(SkAlignedSTStorage<1, DashOp::LineData>*) Line | Count | Source | 447 | 1 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 1 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 1 | } |
SkTArray<SkRect, true>::SkTArray<128>(SkAlignedSTStorage<128, SkRect>*) Line | Count | Source | 447 | 1 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 1 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 1 | } |
SkTArray<DashOp::DashDraw, true>::SkTArray<128>(SkAlignedSTStorage<128, DashOp::DashDraw>*) Line | Count | Source | 447 | 1 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 1 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 1 | } |
Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::SkTArray<1>(SkAlignedSTStorage<1, (anonymous namespace)::DrawAtlasOp::Geometry>*) GrDrawVerticesOp.cpp:SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::SkTArray<1>(SkAlignedSTStorage<1, (anonymous namespace)::DrawVerticesOp::Mesh>*) Line | Count | Source | 447 | 1.85k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 1.85k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 1.85k | } |
Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::SkTArray<1>(SkAlignedSTStorage<1, (anonymous namespace)::NonAALatticeOp::Patch>*) SkTArray<CircularRRectOp::RRect, true>::SkTArray<1>(SkAlignedSTStorage<1, CircularRRectOp::RRect>*) Line | Count | Source | 447 | 5 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 5 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 5 | } |
SkTArray<EllipticalRRectOp::RRect, true>::SkTArray<1>(SkAlignedSTStorage<1, EllipticalRRectOp::RRect>*) Line | Count | Source | 447 | 2 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 2 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 2 | } |
Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::SkTArray<1>(SkAlignedSTStorage<1, ButtCapDashedCircleOp::Circle>*) SkTArray<CircleOp::Circle, true>::SkTArray<1>(SkAlignedSTStorage<1, CircleOp::Circle>*) Line | Count | Source | 447 | 14 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 14 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 14 | } |
Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::SkTArray<1>(SkAlignedSTStorage<1, EllipseOp::Ellipse>*) SkTArray<DIEllipseOp::Ellipse, true>::SkTArray<1>(SkAlignedSTStorage<1, DIEllipseOp::Ellipse>*) Line | Count | Source | 447 | 7 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 7 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 7 | } |
Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::SkTArray<1>(SkAlignedSTStorage<1, (anonymous namespace)::RegionOp::RegionInfo>*) Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::SkTArray<1>(SkAlignedSTStorage<1, (anonymous namespace)::ShadowCircularRRectOp::Geometry>*) GrStrokeRectOp.cpp:SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::SkTArray<1>(SkAlignedSTStorage<1, (anonymous namespace)::AAStrokeRectOp::RectInfo>*) Line | Count | Source | 447 | 208 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 208 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 208 | } |
SmallPathRenderer.cpp:SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::SkTArray<1>(SkAlignedSTStorage<1, (anonymous namespace)::SmallPathOp::Entry>*) Line | Count | Source | 447 | 2.96k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 2.96k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 2.96k | } |
SkTArray<sk_sp<skgpu::v1::PathRenderer>, false>::SkTArray<8>(SkAlignedSTStorage<8, sk_sp<skgpu::v1::PathRenderer> >*) Line | Count | Source | 447 | 673 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 673 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 673 | } |
SkTArray<SkSL::VariableReference*, false>::SkTArray<16>(SkAlignedSTStorage<16, SkSL::VariableReference*>*) Line | Count | Source | 447 | 38.9k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 38.9k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 38.9k | } |
Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::SkTArray<16>(SkAlignedSTStorage<16, GrGLAttribArrayState::AttribArrayState>*) Unexecuted instantiation: SkTArray<GrMipLevel, false>::SkTArray<16>(SkAlignedSTStorage<16, GrMipLevel>*) Unexecuted instantiation: SkTArray<unsigned int, false>::SkTArray<2>(SkAlignedSTStorage<2, unsigned int>*) Unexecuted instantiation: SkTArray<unsigned int, true>::SkTArray<33>(SkAlignedSTStorage<33, unsigned int>*) SkTArray<__jmp_buf_tag (*) [1], false>::SkTArray<4>(SkAlignedSTStorage<4, __jmp_buf_tag (*) [1]>*) Line | Count | Source | 447 | 12.7k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 12.7k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 12.7k | } |
SkTArray<unsigned short, false>::SkTArray<4>(SkAlignedSTStorage<4, unsigned short>*) Line | Count | Source | 447 | 386k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 386k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 386k | } |
SkTArray<SkPoint, false>::SkTArray<4>(SkAlignedSTStorage<4, SkPoint>*) Line | Count | Source | 447 | 386k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 386k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 386k | } |
Unexecuted instantiation: SkTArray<GrUniqueKeyInvalidatedMessage, false>::SkTArray<1>(SkAlignedSTStorage<1, GrUniqueKeyInvalidatedMessage>*) SkTArray<OffsetEdge, false>::SkTArray<64>(SkAlignedSTStorage<64, OffsetEdge>*) Line | Count | Source | 447 | 348 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 348 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 348 | } |
SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::SkTArray<2>(SkAlignedSTStorage<2, SkRGBA4f<(SkAlphaType)3> >*) Line | Count | Source | 447 | 19.6k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 19.6k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 19.6k | } |
SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::SkTArray<4>(SkAlignedSTStorage<4, SkRGBA4f<(SkAlphaType)3> >*) Line | Count | Source | 447 | 26.1k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 26.1k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 26.1k | } |
SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::SkTArray<16>(SkAlignedSTStorage<16, SkRGBA4f<(SkAlphaType)3> >*) Line | Count | Source | 447 | 198 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 198 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 198 | } |
SkTArray<float, true>::SkTArray<16>(SkAlignedSTStorage<16, float>*) Line | Count | Source | 447 | 198 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 198 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 198 | } |
SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::SkTArray<4>(SkAlignedSTStorage<4, GrClientMappedBufferManager::BufferFinishedMessage>*) Line | Count | Source | 447 | 21.9k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 21.9k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 21.9k | } |
Unexecuted instantiation: SkTArray<PathSegment, true>::SkTArray<15>(SkAlignedSTStorage<15, PathSegment>*) SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::SkTArray<4>(SkAlignedSTStorage<4, GrDrawOpAtlas::BulkUseTokenUpdater::PlotData>*) Line | Count | Source | 447 | 1.83k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 1.83k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 1.83k | } |
Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::SkTArray<4>(SkAlignedSTStorage<4, sk_sp<GrAtlasRenderTask> >*) Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::SkTArray<6>(SkAlignedSTStorage<6, GrGeometryProcessor::Attribute>*) Unexecuted instantiation: SkTArray<GrProgramInfo const*, false>::SkTArray<2>(SkAlignedSTStorage<2, GrProgramInfo const*>*) SkTArray<skgpu::v1::ClipStack::Element const*, false>::SkTArray<4>(SkAlignedSTStorage<4, skgpu::v1::ClipStack::Element const*>*) Line | Count | Source | 447 | 12.8k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 12.8k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 12.8k | } |
SkTArray<SkOpRayHit*, false>::SkTArray<1>(SkAlignedSTStorage<1, SkOpRayHit*>*) Line | Count | Source | 447 | 2.60M | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 2.60M | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 2.60M | } |
SkTArray<double, true>::SkTArray<8>(SkAlignedSTStorage<8, double>*) Line | Count | Source | 447 | 94.5k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 94.5k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 94.5k | } |
SkTArray<int, true>::SkTArray<8>(SkAlignedSTStorage<8, int>*) Line | Count | Source | 447 | 189k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 189k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 189k | } |
SkTArray<Sk4fGradientInterval, true>::SkTArray<8>(SkAlignedSTStorage<8, Sk4fGradientInterval>*) Line | Count | Source | 447 | 730 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 730 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 730 | } |
Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::SkTArray<3>(SkAlignedSTStorage<3, GrGeometryProcessor::Attribute>*) SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true>::SkTArray<4>(SkAlignedSTStorage<4, SkTypeface_FreeType::Scanner::AxisDefinition>*) Line | Count | Source | 447 | 8.66k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 8.66k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 8.66k | } |
SkTArray<SkClosestRecord, true>::SkTArray<18>(SkAlignedSTStorage<18, SkClosestRecord>*) Line | Count | Source | 447 | 2.25M | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 2.25M | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 2.25M | } |
SkTArray<SkClosestRecord const*, true>::SkTArray<27>(SkAlignedSTStorage<27, SkClosestRecord const*>*) Line | Count | Source | 447 | 2.25M | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 2.25M | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 2.25M | } |
Unexecuted instantiation: SkTArray<GrVertexChunk, false>::SkTArray<1>(SkAlignedSTStorage<1, GrVertexChunk>*) Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::SkTArray<4>(SkAlignedSTStorage<4, GrGeometryProcessor::Attribute>*) Unexecuted instantiation: SkTArray<int, false>::SkTArray<8>(SkAlignedSTStorage<8, int>*) Layer.cpp:SkTArray<skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::SkTArray<4>(SkAlignedSTStorage<4, skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord>*) Line | Count | Source | 447 | 9.42k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 9.42k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 9.42k | } |
Unexecuted instantiation: SkottieShaper.cpp:SkTArray<skottie::(anonymous namespace)::BlobMaker::RunRec, false>::SkTArray<16>(SkAlignedSTStorage<16, skottie::(anonymous namespace)::BlobMaker::RunRec>*) Unexecuted instantiation: SkTArray<float, true>::SkTArray<64>(SkAlignedSTStorage<64, float>*) SkTArray<float, true>::SkTArray<128>(SkAlignedSTStorage<128, float>*) Line | Count | Source | 447 | 7.68k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 7.68k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 7.68k | } |
SkTArray<char, true>::SkTArray<128>(SkAlignedSTStorage<128, char>*) Line | Count | Source | 447 | 19.7k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 19.7k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 19.7k | } |
SkTArray<SkSVGTextContext::PositionAdjustment, true>::SkTArray<128>(SkAlignedSTStorage<128, SkSVGTextContext::PositionAdjustment>*) Line | Count | Source | 447 | 19.7k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 19.7k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 19.7k | } |
SkTArray<sk_sp<SkSVGNode>, true>::SkTArray<1>(SkAlignedSTStorage<1, sk_sp<SkSVGNode> >*) Line | Count | Source | 447 | 76.5k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 76.5k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 76.5k | } |
SkTArray<float, true>::SkTArray<2>(SkAlignedSTStorage<2, float>*) Line | Count | Source | 447 | 30 | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 30 | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 30 | } |
SkTArray<float, true>::SkTArray<32>(SkAlignedSTStorage<32, float>*) Line | Count | Source | 447 | 1.11k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 1.11k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 1.11k | } |
SkTArray<hb_feature_t, false>::SkTArray<32>(SkAlignedSTStorage<32, hb_feature_t>*) Line | Count | Source | 447 | 464k | SkTArray(SkAlignedSTStorage<N,T>* storage) { | 448 | 464k | this->initWithPreallocatedStorage(0, storage->get(), N); | 449 | 464k | } |
Unexecuted instantiation: SkTArray<unsigned short, true>::SkTArray<128>(SkAlignedSTStorage<128, unsigned short>*) Unexecuted instantiation: SkTArray<unsigned int, true>::SkTArray<128>(SkAlignedSTStorage<128, unsigned int>*) Unexecuted instantiation: SkTArray<unsigned long, true>::SkTArray<1>(SkAlignedSTStorage<1, unsigned long>*) Unexecuted instantiation: SkTArray<unsigned int, false>::SkTArray<128>(SkAlignedSTStorage<128, unsigned int>*) Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::SkTArray<16>(SkAlignedSTStorage<16, SkJSONWriter::Scope>*) Unexecuted instantiation: SkTArray<bool, true>::SkTArray<16>(SkAlignedSTStorage<16, bool>*) |
450 | | |
451 | | /** |
452 | | * Copy a C array, using preallocated storage if preAllocCount >= |
453 | | * count. Otherwise storage will only be used when array shrinks |
454 | | * to fit. |
455 | | */ |
456 | | template <int N> |
457 | 1.83M | SkTArray(const T* array, int count, SkAlignedSTStorage<N,T>* storage) { |
458 | 1.83M | this->initWithPreallocatedStorage(count, storage->get(), N); |
459 | 1.83M | this->copy(array); |
460 | 1.83M | } SkTArray<int, true>::SkTArray<4>(int const*, int, SkAlignedSTStorage<4, int>*) Line | Count | Source | 457 | 1.75M | SkTArray(const T* array, int count, SkAlignedSTStorage<N,T>* storage) { | 458 | 1.75M | this->initWithPreallocatedStorage(count, storage->get(), N); | 459 | 1.75M | this->copy(array); | 460 | 1.75M | } |
SkTArray<signed char, false>::SkTArray<4>(signed char const*, int, SkAlignedSTStorage<4, signed char>*) Line | Count | Source | 457 | 82.4k | SkTArray(const T* array, int count, SkAlignedSTStorage<N,T>* storage) { | 458 | 82.4k | this->initWithPreallocatedStorage(count, storage->get(), N); | 459 | 82.4k | this->copy(array); | 460 | 82.4k | } |
SkTArray<SkSL::Type const*, false>::SkTArray<2>(SkSL::Type const* const*, int, SkAlignedSTStorage<2, SkSL::Type const*>*) Line | Count | Source | 457 | 219 | SkTArray(const T* array, int count, SkAlignedSTStorage<N,T>* storage) { | 458 | 219 | this->initWithPreallocatedStorage(count, storage->get(), N); | 459 | 219 | this->copy(array); | 460 | 219 | } |
|
461 | | |
462 | | private: |
463 | 2.27M | void init(int count) { |
464 | 2.27M | fCount = SkToU32(count); |
465 | 2.27M | if (!count) { |
466 | 2.23M | fAllocCount = 0; |
467 | 2.23M | fItemArray = nullptr; |
468 | 35.2k | } else { |
469 | 35.2k | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); |
470 | 35.2k | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); |
471 | 35.2k | } |
472 | 2.27M | fOwnMemory = true; |
473 | 2.27M | fReserved = false; |
474 | 2.27M | } SkTArray<SkString, false>::init(int) Line | Count | Source | 463 | 1.34k | void init(int count) { | 464 | 1.34k | fCount = SkToU32(count); | 465 | 1.34k | if (!count) { | 466 | 1.34k | fAllocCount = 0; | 467 | 1.34k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 1.34k | fOwnMemory = true; | 473 | 1.34k | fReserved = false; | 474 | 1.34k | } |
SkTArray<GrUniqueKey, false>::init(int) Line | Count | Source | 463 | 103k | void init(int count) { | 464 | 103k | fCount = SkToU32(count); | 465 | 103k | if (!count) { | 466 | 103k | fAllocCount = 0; | 467 | 103k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 103k | fOwnMemory = true; | 473 | 103k | fReserved = false; | 474 | 103k | } |
SkTArray<sk_gpu_test::GrContextFactory::Context, true>::init(int) Line | Count | Source | 463 | 1.50k | void init(int count) { | 464 | 1.50k | fCount = SkToU32(count); | 465 | 1.50k | if (!count) { | 466 | 1.50k | fAllocCount = 0; | 467 | 1.50k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 1.50k | fOwnMemory = true; | 473 | 1.50k | fReserved = false; | 474 | 1.50k | } |
SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::init(int) Line | Count | Source | 463 | 1.32k | void init(int count) { | 464 | 1.32k | fCount = SkToU32(count); | 465 | 1.32k | if (!count) { | 466 | 1.32k | fAllocCount = 0; | 467 | 1.32k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 1.32k | fOwnMemory = true; | 473 | 1.32k | fReserved = false; | 474 | 1.32k | } |
SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::init(int) Line | Count | Source | 463 | 1.32k | void init(int count) { | 464 | 1.32k | fCount = SkToU32(count); | 465 | 1.32k | if (!count) { | 466 | 1.32k | fAllocCount = 0; | 467 | 1.32k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 1.32k | fOwnMemory = true; | 473 | 1.32k | fReserved = false; | 474 | 1.32k | } |
Unexecuted instantiation: SkTArray<GrAuditTrail::Op*, false>::init(int) SkTArray<int, false>::init(int) Line | Count | Source | 463 | 456 | void init(int count) { | 464 | 456 | fCount = SkToU32(count); | 465 | 456 | if (!count) { | 466 | 456 | fAllocCount = 0; | 467 | 456 | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 456 | fOwnMemory = true; | 473 | 456 | fReserved = false; | 474 | 456 | } |
SkTArray<float, false>::init(int) Line | Count | Source | 463 | 456 | void init(int count) { | 464 | 456 | fCount = SkToU32(count); | 465 | 456 | if (!count) { | 466 | 456 | fAllocCount = 0; | 467 | 456 | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 456 | fOwnMemory = true; | 473 | 456 | fReserved = false; | 474 | 456 | } |
SkTArray<SkCanvas::Lattice::RectType, false>::init(int) Line | Count | Source | 463 | 228 | void init(int count) { | 464 | 228 | fCount = SkToU32(count); | 465 | 228 | if (!count) { | 466 | 228 | fAllocCount = 0; | 467 | 228 | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 228 | fOwnMemory = true; | 473 | 228 | fReserved = false; | 474 | 228 | } |
SkTArray<unsigned int, false>::init(int) Line | Count | Source | 463 | 228 | void init(int count) { | 464 | 228 | fCount = SkToU32(count); | 465 | 228 | if (!count) { | 466 | 228 | fAllocCount = 0; | 467 | 228 | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 228 | fOwnMemory = true; | 473 | 228 | fReserved = false; | 474 | 228 | } |
Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::init(int) Unexecuted instantiation: SkTArray<SkSL::dsl::DSLParameter*, false>::init(int) Unexecuted instantiation: SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::init(int) SkTArray<SkSL::Parser::Checkpoint::ForwardingErrorReporter::Error, false>::init(int) Line | Count | Source | 463 | 73.4k | void init(int count) { | 464 | 73.4k | fCount = SkToU32(count); | 465 | 73.4k | if (!count) { | 466 | 73.4k | fAllocCount = 0; | 467 | 73.4k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 73.4k | fOwnMemory = true; | 473 | 73.4k | fReserved = false; | 474 | 73.4k | } |
Unexecuted instantiation: SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::init(int) Unexecuted instantiation: SkTArray<SkSL::dsl::DSLField, false>::init(int) Unexecuted instantiation: SkTArray<SkSL::dsl::DSLCase, false>::init(int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::init(int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::init(int) SkTArray<sk_sp<GrRenderTask>, false>::init(int) Line | Count | Source | 463 | 1.32k | void init(int count) { | 464 | 1.32k | fCount = SkToU32(count); | 465 | 1.32k | if (!count) { | 466 | 1.32k | fAllocCount = 0; | 467 | 1.32k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 1.32k | fOwnMemory = true; | 473 | 1.32k | fReserved = false; | 474 | 1.32k | } |
SkTArray<GrOnFlushCallbackObject*, false>::init(int) Line | Count | Source | 463 | 1.32k | void init(int count) { | 464 | 1.32k | fCount = SkToU32(count); | 465 | 1.32k | if (!count) { | 466 | 1.32k | fAllocCount = 0; | 467 | 1.32k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 1.32k | fOwnMemory = true; | 473 | 1.32k | fReserved = false; | 474 | 1.32k | } |
SkTArray<GrTextureProxy*, true>::init(int) Line | Count | Source | 463 | 100k | void init(int count) { | 464 | 100k | fCount = SkToU32(count); | 465 | 100k | if (!count) { | 466 | 100k | fAllocCount = 0; | 467 | 100k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 100k | fOwnMemory = true; | 473 | 100k | fReserved = false; | 474 | 100k | } |
SkTArray<GrUniqueKeyInvalidatedMessage, false>::init(int) Line | Count | Source | 463 | 83.6k | void init(int count) { | 464 | 83.6k | fCount = SkToU32(count); | 465 | 83.6k | if (!count) { | 466 | 83.6k | fAllocCount = 0; | 467 | 83.6k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 83.6k | fOwnMemory = true; | 473 | 83.6k | fReserved = false; | 474 | 83.6k | } |
SkTArray<GrTextureFreedMessage, false>::init(int) Line | Count | Source | 463 | 1.32k | void init(int count) { | 464 | 1.32k | fCount = SkToU32(count); | 465 | 1.32k | if (!count) { | 466 | 1.32k | fAllocCount = 0; | 467 | 1.32k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 1.32k | fOwnMemory = true; | 473 | 1.32k | fReserved = false; | 474 | 1.32k | } |
SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::init(int) Line | Count | Source | 463 | 1.85k | void init(int count) { | 464 | 1.85k | fCount = SkToU32(count); | 465 | 1.85k | if (!count) { | 466 | 1.85k | fAllocCount = 0; | 467 | 1.85k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 1.85k | fOwnMemory = true; | 473 | 1.85k | fReserved = false; | 474 | 1.85k | } |
Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo::Op, false>::init(int) SkTArray<GrSurfaceProxy*, true>::init(int) Line | Count | Source | 463 | 89.6k | void init(int count) { | 464 | 89.6k | fCount = SkToU32(count); | 465 | 89.6k | if (!count) { | 466 | 89.6k | fAllocCount = 0; | 467 | 89.6k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 89.6k | fOwnMemory = true; | 473 | 89.6k | fReserved = false; | 474 | 89.6k | } |
SkTArray<int, true>::init(int) Line | Count | Source | 463 | 2.46k | void init(int count) { | 464 | 2.46k | fCount = SkToU32(count); | 465 | 2.46k | if (!count) { | 466 | 2.46k | fAllocCount = 0; | 467 | 2.46k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 2.46k | fOwnMemory = true; | 473 | 2.46k | fReserved = false; | 474 | 2.46k | } |
SkTArray<float, true>::init(int) Line | Count | Source | 463 | 4.14k | void init(int count) { | 464 | 4.14k | fCount = SkToU32(count); | 465 | 4.14k | if (!count) { | 466 | 4.14k | fAllocCount = 0; | 467 | 4.14k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 4.14k | fOwnMemory = true; | 473 | 4.14k | fReserved = false; | 474 | 4.14k | } |
Unexecuted instantiation: SkTArray<unsigned char, true>::init(int) Unexecuted instantiation: SkTArray<SkRSXform, false>::init(int) Unexecuted instantiation: SkTArray<SkRect, false>::init(int) Unexecuted instantiation: SkTArray<SkPoint, false>::init(int) Unexecuted instantiation: SkTArray<unsigned short, false>::init(int) Unexecuted instantiation: SkTArray<GrSwizzle, false>::init(int) Unexecuted instantiation: SkTArray<GrGLProgramDataManager::Uniform, true>::init(int) Unexecuted instantiation: SkTArray<SkSL::String, false>::init(int) Unexecuted instantiation: SkTArray<GrRecordingContext::ProgramData, false>::init(int) SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::init(int) Line | Count | Source | 463 | 7.47k | void init(int count) { | 464 | 7.47k | fCount = SkToU32(count); | 465 | 7.47k | if (!count) { | 466 | 7.47k | fAllocCount = 0; | 467 | 7.47k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 7.47k | fOwnMemory = true; | 473 | 7.47k | fReserved = false; | 474 | 7.47k | } |
SkTArray<SkPaint, false>::init(int) Line | Count | Source | 463 | 4.97k | void init(int count) { | 464 | 4.97k | fCount = SkToU32(count); | 465 | 4.97k | if (!count) { | 466 | 4.97k | fAllocCount = 0; | 467 | 4.97k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 4.97k | fOwnMemory = true; | 473 | 4.97k | fReserved = false; | 474 | 4.97k | } |
SkTArray<SkPath, false>::init(int) Line | Count | Source | 463 | 1.41M | void init(int count) { | 464 | 1.41M | fCount = SkToU32(count); | 465 | 1.41M | if (!count) { | 466 | 1.41M | fAllocCount = 0; | 467 | 1.41M | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 1.41M | fOwnMemory = true; | 473 | 1.41M | fReserved = false; | 474 | 1.41M | } |
SkTArray<sk_sp<SkPicture const>, false>::init(int) Line | Count | Source | 463 | 4.97k | void init(int count) { | 464 | 4.97k | fCount = SkToU32(count); | 465 | 4.97k | if (!count) { | 466 | 4.97k | fAllocCount = 0; | 467 | 4.97k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 4.97k | fOwnMemory = true; | 473 | 4.97k | fReserved = false; | 474 | 4.97k | } |
SkTArray<sk_sp<SkDrawable>, false>::init(int) Line | Count | Source | 463 | 4.97k | void init(int count) { | 464 | 4.97k | fCount = SkToU32(count); | 465 | 4.97k | if (!count) { | 466 | 4.97k | fAllocCount = 0; | 467 | 4.97k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 4.97k | fOwnMemory = true; | 473 | 4.97k | fReserved = false; | 474 | 4.97k | } |
SkTArray<sk_sp<SkTextBlob const>, false>::init(int) Line | Count | Source | 463 | 4.97k | void init(int count) { | 464 | 4.97k | fCount = SkToU32(count); | 465 | 4.97k | if (!count) { | 466 | 4.97k | fAllocCount = 0; | 467 | 4.97k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 4.97k | fOwnMemory = true; | 473 | 4.97k | fReserved = false; | 474 | 4.97k | } |
SkTArray<sk_sp<SkVertices const>, false>::init(int) Line | Count | Source | 463 | 4.97k | void init(int count) { | 464 | 4.97k | fCount = SkToU32(count); | 465 | 4.97k | if (!count) { | 466 | 4.97k | fAllocCount = 0; | 467 | 4.97k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 4.97k | fOwnMemory = true; | 473 | 4.97k | fReserved = false; | 474 | 4.97k | } |
SkTArray<sk_sp<SkImage const>, false>::init(int) Line | Count | Source | 463 | 4.97k | void init(int count) { | 464 | 4.97k | fCount = SkToU32(count); | 465 | 4.97k | if (!count) { | 466 | 4.97k | fAllocCount = 0; | 467 | 4.97k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 4.97k | fOwnMemory = true; | 473 | 4.97k | fReserved = false; | 474 | 4.97k | } |
SkTArray<SkMatrix, false>::init(int) Line | Count | Source | 463 | 1 | void init(int count) { | 464 | 1 | fCount = SkToU32(count); | 465 | 1 | if (!count) { | 466 | 1 | fAllocCount = 0; | 467 | 1 | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 1 | fOwnMemory = true; | 473 | 1 | fReserved = false; | 474 | 1 | } |
SkTArray<GrBufferAllocPool::BufferBlock, false>::init(int) Line | Count | Source | 463 | 61.8k | void init(int count) { | 464 | 61.8k | fCount = SkToU32(count); | 465 | 61.8k | if (!count) { | 466 | 61.8k | fAllocCount = 0; | 467 | 61.8k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 61.8k | fOwnMemory = true; | 473 | 61.8k | fReserved = false; | 474 | 61.8k | } |
SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::init(int) Line | Count | Source | 463 | 23.2k | void init(int count) { | 464 | 23.2k | fCount = SkToU32(count); | 465 | 23.2k | if (!count) { | 466 | 23.2k | fAllocCount = 0; | 467 | 23.2k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 23.2k | fOwnMemory = true; | 473 | 23.2k | fReserved = false; | 474 | 23.2k | } |
SkTArray<GrDrawOpAtlas::Plot*, false>::init(int) Line | Count | Source | 463 | 863 | void init(int count) { | 464 | 863 | fCount = SkToU32(count); | 465 | 863 | if (!count) { | 466 | 863 | fAllocCount = 0; | 467 | 863 | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 863 | fOwnMemory = true; | 473 | 863 | fReserved = false; | 474 | 863 | } |
Unexecuted instantiation: SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::init(int) SkTArray<GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*, true>::init(int) Line | Count | Source | 463 | 76 | void init(int count) { | 464 | 76 | fCount = SkToU32(count); | 465 | 76 | if (!count) { | 466 | 76 | fAllocCount = 0; | 467 | 76 | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 76 | fOwnMemory = true; | 473 | 76 | fReserved = false; | 474 | 76 | } |
SkTArray<GrProcessorTestFactory<GrGeometryProcessor*>*, true>::init(int) Line | Count | Source | 463 | 76 | void init(int count) { | 464 | 76 | fCount = SkToU32(count); | 465 | 76 | if (!count) { | 466 | 76 | fAllocCount = 0; | 467 | 76 | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 76 | fOwnMemory = true; | 473 | 76 | fReserved = false; | 474 | 76 | } |
SkTArray<GrXPFactoryTestFactory*, true>::init(int) Line | Count | Source | 463 | 76 | void init(int count) { | 464 | 76 | fCount = SkToU32(count); | 465 | 76 | if (!count) { | 466 | 76 | fAllocCount = 0; | 467 | 76 | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 76 | fOwnMemory = true; | 473 | 76 | fReserved = false; | 474 | 76 | } |
Unexecuted instantiation: SkTArray<skgpu::v1::ClipStack::Element, false>::init(int) Unexecuted instantiation: SkTArray<GrGLFormat, true>::init(int) SkTArray<std::__1::unique_ptr<SkCodec, std::__1::default_delete<SkCodec> >, true>::init(int) Line | Count | Source | 463 | 3.38k | void init(int count) { | 464 | 3.38k | fCount = SkToU32(count); | 465 | 3.38k | if (!count) { | 466 | 3.38k | fAllocCount = 0; | 467 | 3.38k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 3.38k | fOwnMemory = true; | 473 | 3.38k | fReserved = false; | 474 | 3.38k | } |
Unexecuted instantiation: SkTArray<dng_exception, false>::init(int) Unexecuted instantiation: SkTArray<std::__1::thread, false>::init(int) Unexecuted instantiation: SkTArray<std::__1::function<void ()>, false>::init(int) SkTArray<sk_sp<SkTypeface_Custom>, false>::init(int) Line | Count | Source | 463 | 5 | void init(int count) { | 464 | 5 | fCount = SkToU32(count); | 465 | 5 | if (!count) { | 466 | 5 | fAllocCount = 0; | 467 | 5 | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 5 | fOwnMemory = true; | 473 | 5 | fReserved = false; | 474 | 5 | } |
SkTArray<sk_sp<SkFontStyleSet_Custom>, false>::init(int) Line | Count | Source | 463 | 5 | void init(int count) { | 464 | 5 | fCount = SkToU32(count); | 465 | 5 | if (!count) { | 466 | 5 | fAllocCount = 0; | 467 | 5 | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 5 | fOwnMemory = true; | 473 | 5 | fReserved = false; | 474 | 5 | } |
Unexecuted instantiation: SkTArray<std::__1::array<unsigned short, 3ul>, false>::init(int) Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfLayerInfo, false>::init(int) Unexecuted instantiation: SkTArray<SkPoint, true>::init(int) Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfInfo, false>::init(int) SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::init(int) Line | Count | Source | 463 | 19.4k | void init(int count) { | 464 | 19.4k | fCount = SkToU32(count); | 465 | 19.4k | if (!count) { | 466 | 19.4k | fAllocCount = 0; | 467 | 19.4k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 19.4k | fOwnMemory = true; | 473 | 19.4k | fReserved = false; | 474 | 19.4k | } |
SkTArray<skia::textlayout::ResolvedFontDescriptor, false>::init(int) Line | Count | Source | 463 | 4.02k | void init(int count) { | 464 | 4.02k | fCount = SkToU32(count); | 465 | 4.02k | if (!count) { | 466 | 4.02k | fAllocCount = 0; | 467 | 4.02k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 4.02k | fOwnMemory = true; | 473 | 4.02k | fReserved = false; | 474 | 4.02k | } |
SkTArray<skia::textlayout::Block, true>::init(int) Line | Count | Source | 463 | 20.4k | void init(int count) { | 464 | 20.4k | fCount = SkToU32(count); | 465 | 20.4k | if (!count) { | 466 | 4.02k | fAllocCount = 0; | 467 | 4.02k | fItemArray = nullptr; | 468 | 16.4k | } else { | 469 | 16.4k | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 16.4k | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 16.4k | } | 472 | 20.4k | fOwnMemory = true; | 473 | 20.4k | fReserved = false; | 474 | 20.4k | } |
SkTArray<skia::textlayout::Placeholder, true>::init(int) Line | Count | Source | 463 | 20.4k | void init(int count) { | 464 | 20.4k | fCount = SkToU32(count); | 465 | 20.4k | if (!count) { | 466 | 4.02k | fAllocCount = 0; | 467 | 4.02k | fItemArray = nullptr; | 468 | 16.4k | } else { | 469 | 16.4k | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 16.4k | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 16.4k | } | 472 | 20.4k | fOwnMemory = true; | 473 | 20.4k | fReserved = false; | 474 | 20.4k | } |
SkTArray<skia::textlayout::Run, false>::init(int) Line | Count | Source | 463 | 6.43k | void init(int count) { | 464 | 6.43k | fCount = SkToU32(count); | 465 | 6.43k | if (!count) { | 466 | 6.43k | fAllocCount = 0; | 467 | 6.43k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 6.43k | fOwnMemory = true; | 473 | 6.43k | fReserved = false; | 474 | 6.43k | } |
SkTArray<skia::textlayout::CodeUnitFlags, false>::init(int) Line | Count | Source | 463 | 6.43k | void init(int count) { | 464 | 6.43k | fCount = SkToU32(count); | 465 | 6.43k | if (!count) { | 466 | 4.02k | fAllocCount = 0; | 467 | 4.02k | fItemArray = nullptr; | 468 | 2.40k | } else { | 469 | 2.40k | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 2.40k | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 2.40k | } | 472 | 6.43k | fOwnMemory = true; | 473 | 6.43k | fReserved = false; | 474 | 6.43k | } |
SkTArray<unsigned long, true>::init(int) Line | Count | Source | 463 | 12.8k | void init(int count) { | 464 | 12.8k | fCount = SkToU32(count); | 465 | 12.8k | if (!count) { | 466 | 12.8k | fAllocCount = 0; | 467 | 12.8k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 12.8k | fOwnMemory = true; | 473 | 12.8k | fReserved = false; | 474 | 12.8k | } |
SkTArray<skia::textlayout::StyleBlock<float>, false>::init(int) Line | Count | Source | 463 | 8.05k | void init(int count) { | 464 | 8.05k | fCount = SkToU32(count); | 465 | 8.05k | if (!count) { | 466 | 8.05k | fAllocCount = 0; | 467 | 8.05k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 8.05k | fOwnMemory = true; | 473 | 8.05k | fReserved = false; | 474 | 8.05k | } |
SkTArray<skia::textlayout::StyleBlock<SkPaint>, false>::init(int) Line | Count | Source | 463 | 8.05k | void init(int count) { | 464 | 8.05k | fCount = SkToU32(count); | 465 | 8.05k | if (!count) { | 466 | 8.05k | fAllocCount = 0; | 467 | 8.05k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 8.05k | fOwnMemory = true; | 473 | 8.05k | fReserved = false; | 474 | 8.05k | } |
SkTArray<skia::textlayout::StyleBlock<std::__1::vector<skia::textlayout::TextShadow, std::__1::allocator<skia::textlayout::TextShadow> > >, false>::init(int) Line | Count | Source | 463 | 4.02k | void init(int count) { | 464 | 4.02k | fCount = SkToU32(count); | 465 | 4.02k | if (!count) { | 466 | 4.02k | fAllocCount = 0; | 467 | 4.02k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 4.02k | fOwnMemory = true; | 473 | 4.02k | fReserved = false; | 474 | 4.02k | } |
SkTArray<skia::textlayout::StyleBlock<skia::textlayout::Decoration>, false>::init(int) Line | Count | Source | 463 | 4.02k | void init(int count) { | 464 | 4.02k | fCount = SkToU32(count); | 465 | 4.02k | if (!count) { | 466 | 4.02k | fAllocCount = 0; | 467 | 4.02k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 4.02k | fOwnMemory = true; | 473 | 4.02k | fReserved = false; | 474 | 4.02k | } |
SkTArray<skia::textlayout::Cluster, true>::init(int) Line | Count | Source | 463 | 4.02k | void init(int count) { | 464 | 4.02k | fCount = SkToU32(count); | 465 | 4.02k | if (!count) { | 466 | 4.02k | fAllocCount = 0; | 467 | 4.02k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 4.02k | fOwnMemory = true; | 473 | 4.02k | fReserved = false; | 474 | 4.02k | } |
SkTArray<unsigned long, false>::init(int) Line | Count | Source | 463 | 4.02k | void init(int count) { | 464 | 4.02k | fCount = SkToU32(count); | 465 | 4.02k | if (!count) { | 466 | 4.02k | fAllocCount = 0; | 467 | 4.02k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 4.02k | fOwnMemory = true; | 473 | 4.02k | fReserved = false; | 474 | 4.02k | } |
SkTArray<skia::textlayout::TextLine, false>::init(int) Line | Count | Source | 463 | 4.02k | void init(int count) { | 464 | 4.02k | fCount = SkToU32(count); | 465 | 4.02k | if (!count) { | 466 | 4.02k | fAllocCount = 0; | 467 | 4.02k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 4.02k | fOwnMemory = true; | 473 | 4.02k | fReserved = false; | 474 | 4.02k | } |
SkTArray<SkShaper::Feature, false>::init(int) Line | Count | Source | 463 | 115k | void init(int count) { | 464 | 115k | fCount = SkToU32(count); | 465 | 115k | if (!count) { | 466 | 115k | fAllocCount = 0; | 467 | 115k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 115k | fOwnMemory = true; | 473 | 115k | fReserved = false; | 474 | 115k | } |
Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo, false>::init(int) Unexecuted instantiation: SkTArray<SkTArray<SkPDFTagNode*, false>, false>::init(int) Unexecuted instantiation: SkTArray<SkPDFTagNode::MarkedContentInfo, false>::init(int) Unexecuted instantiation: SkTArray<SkPDFTagNode*, false>::init(int) SkTArray<SkSVGDevice::ClipRec, false>::init(int) Line | Count | Source | 463 | 12.9k | void init(int count) { | 464 | 12.9k | fCount = SkToU32(count); | 465 | 12.9k | if (!count) { | 466 | 12.9k | fAllocCount = 0; | 467 | 12.9k | fItemArray = nullptr; | 468 | 0 | } else { | 469 | 0 | fAllocCount = SkToU32(std::max(count, kMinHeapAllocCount)); | 470 | 0 | fItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 471 | 0 | } | 472 | 12.9k | fOwnMemory = true; | 473 | 12.9k | fReserved = false; | 474 | 12.9k | } |
|
475 | | |
476 | 94.3M | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { |
477 | 94.3M | SkASSERT(count >= 0); |
478 | 94.3M | SkASSERT(preallocCount > 0); |
479 | 94.3M | SkASSERT(preallocStorage); |
480 | 94.3M | fCount = count; |
481 | 94.3M | fItemArray = nullptr; |
482 | 94.3M | fReserved = false; |
483 | 94.3M | if (count > preallocCount) { |
484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); |
485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); |
486 | 0 | fOwnMemory = true; |
487 | 94.3M | } else { |
488 | 94.3M | fAllocCount = preallocCount; |
489 | 94.3M | fItemArray = (T*)preallocStorage; |
490 | 94.3M | fOwnMemory = false; |
491 | 94.3M | } |
492 | 94.3M | } SkTArray<SkNoPixelsDevice::ClipState, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 327k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 327k | SkASSERT(count >= 0); | 478 | 327k | SkASSERT(preallocCount > 0); | 479 | 327k | SkASSERT(preallocStorage); | 480 | 327k | fCount = count; | 481 | 327k | fItemArray = nullptr; | 482 | 327k | fReserved = false; | 483 | 327k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 327k | } else { | 488 | 327k | fAllocCount = preallocCount; | 489 | 327k | fItemArray = (T*)preallocStorage; | 490 | 327k | fOwnMemory = false; | 491 | 327k | } | 492 | 327k | } |
SkTArray<unsigned int, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 1.32k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 1.32k | SkASSERT(count >= 0); | 478 | 1.32k | SkASSERT(preallocCount > 0); | 479 | 1.32k | SkASSERT(preallocStorage); | 480 | 1.32k | fCount = count; | 481 | 1.32k | fItemArray = nullptr; | 482 | 1.32k | fReserved = false; | 483 | 1.32k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 1.32k | } else { | 488 | 1.32k | fAllocCount = preallocCount; | 489 | 1.32k | fItemArray = (T*)preallocStorage; | 490 | 1.32k | fOwnMemory = false; | 491 | 1.32k | } | 492 | 1.32k | } |
SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 630k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 630k | SkASSERT(count >= 0); | 478 | 630k | SkASSERT(preallocCount > 0); | 479 | 630k | SkASSERT(preallocStorage); | 480 | 630k | fCount = count; | 481 | 630k | fItemArray = nullptr; | 482 | 630k | fReserved = false; | 483 | 630k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 630k | } else { | 488 | 630k | fAllocCount = preallocCount; | 489 | 630k | fItemArray = (T*)preallocStorage; | 490 | 630k | fOwnMemory = false; | 491 | 630k | } | 492 | 630k | } |
Unexecuted instantiation: SkTArray<GrFragmentProcessor::ProgramImpl*, true>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::initWithPreallocatedStorage(int, void*, int) SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 1.83k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 1.83k | SkASSERT(count >= 0); | 478 | 1.83k | SkASSERT(preallocCount > 0); | 479 | 1.83k | SkASSERT(preallocStorage); | 480 | 1.83k | fCount = count; | 481 | 1.83k | fItemArray = nullptr; | 482 | 1.83k | fReserved = false; | 483 | 1.83k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 1.83k | } else { | 488 | 1.83k | fAllocCount = preallocCount; | 489 | 1.83k | fItemArray = (T*)preallocStorage; | 490 | 1.83k | fOwnMemory = false; | 491 | 1.83k | } | 492 | 1.83k | } |
SkTArray<unsigned short, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 386k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 386k | SkASSERT(count >= 0); | 478 | 386k | SkASSERT(preallocCount > 0); | 479 | 386k | SkASSERT(preallocStorage); | 480 | 386k | fCount = count; | 481 | 386k | fItemArray = nullptr; | 482 | 386k | fReserved = false; | 483 | 386k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 386k | } else { | 488 | 386k | fAllocCount = preallocCount; | 489 | 386k | fItemArray = (T*)preallocStorage; | 490 | 386k | fOwnMemory = false; | 491 | 386k | } | 492 | 386k | } |
SkTArray<SkPoint, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 386k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 386k | SkASSERT(count >= 0); | 478 | 386k | SkASSERT(preallocCount > 0); | 479 | 386k | SkASSERT(preallocStorage); | 480 | 386k | fCount = count; | 481 | 386k | fItemArray = nullptr; | 482 | 386k | fReserved = false; | 483 | 386k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 386k | } else { | 488 | 386k | fAllocCount = preallocCount; | 489 | 386k | fItemArray = (T*)preallocStorage; | 490 | 386k | fOwnMemory = false; | 491 | 386k | } | 492 | 386k | } |
SkTArray<sk_sp<SkImageFilter>, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 20.8k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 20.8k | SkASSERT(count >= 0); | 478 | 20.8k | SkASSERT(preallocCount > 0); | 479 | 20.8k | SkASSERT(preallocStorage); | 480 | 20.8k | fCount = count; | 481 | 20.8k | fItemArray = nullptr; | 482 | 20.8k | fReserved = false; | 483 | 20.8k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 20.8k | } else { | 488 | 20.8k | fAllocCount = preallocCount; | 489 | 20.8k | fItemArray = (T*)preallocStorage; | 490 | 20.8k | fOwnMemory = false; | 491 | 20.8k | } | 492 | 20.8k | } |
SkTArray<SkRGBA4f<(SkAlphaType)2>, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 7.63k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 7.63k | SkASSERT(count >= 0); | 478 | 7.63k | SkASSERT(preallocCount > 0); | 479 | 7.63k | SkASSERT(preallocStorage); | 480 | 7.63k | fCount = count; | 481 | 7.63k | fItemArray = nullptr; | 482 | 7.63k | fReserved = false; | 483 | 7.63k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 7.63k | } else { | 488 | 7.63k | fAllocCount = preallocCount; | 489 | 7.63k | fItemArray = (T*)preallocStorage; | 490 | 7.63k | fOwnMemory = false; | 491 | 7.63k | } | 492 | 7.63k | } |
SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 203 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 203 | SkASSERT(count >= 0); | 478 | 203 | SkASSERT(preallocCount > 0); | 479 | 203 | SkASSERT(preallocStorage); | 480 | 203 | fCount = count; | 481 | 203 | fItemArray = nullptr; | 482 | 203 | fReserved = false; | 483 | 203 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 203 | } else { | 488 | 203 | fAllocCount = preallocCount; | 489 | 203 | fItemArray = (T*)preallocStorage; | 490 | 203 | fOwnMemory = false; | 491 | 203 | } | 492 | 203 | } |
SkTArray<SkRuntimeEffect::ChildPtr, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 4.04k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 4.04k | SkASSERT(count >= 0); | 478 | 4.04k | SkASSERT(preallocCount > 0); | 479 | 4.04k | SkASSERT(preallocStorage); | 480 | 4.04k | fCount = count; | 481 | 4.04k | fItemArray = nullptr; | 482 | 4.04k | fReserved = false; | 483 | 4.04k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 4.04k | } else { | 488 | 4.04k | fAllocCount = preallocCount; | 489 | 4.04k | fItemArray = (T*)preallocStorage; | 490 | 4.04k | fOwnMemory = false; | 491 | 4.04k | } | 492 | 4.04k | } |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 1.22k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 1.22k | SkASSERT(count >= 0); | 478 | 1.22k | SkASSERT(preallocCount > 0); | 479 | 1.22k | SkASSERT(preallocStorage); | 480 | 1.22k | fCount = count; | 481 | 1.22k | fItemArray = nullptr; | 482 | 1.22k | fReserved = false; | 483 | 1.22k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 1.22k | } else { | 488 | 1.22k | fAllocCount = preallocCount; | 489 | 1.22k | fItemArray = (T*)preallocStorage; | 490 | 1.22k | fOwnMemory = false; | 491 | 1.22k | } | 492 | 1.22k | } |
Unexecuted instantiation: SkTArray<int, false>::initWithPreallocatedStorage(int, void*, int) SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 2.24k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 2.24k | SkASSERT(count >= 0); | 478 | 2.24k | SkASSERT(preallocCount > 0); | 479 | 2.24k | SkASSERT(preallocStorage); | 480 | 2.24k | fCount = count; | 481 | 2.24k | fItemArray = nullptr; | 482 | 2.24k | fReserved = false; | 483 | 2.24k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 2.24k | } else { | 488 | 2.24k | fAllocCount = preallocCount; | 489 | 2.24k | fItemArray = (T*)preallocStorage; | 490 | 2.24k | fOwnMemory = false; | 491 | 2.24k | } | 492 | 2.24k | } |
SkTArray<signed char, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 1.82k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 1.82k | SkASSERT(count >= 0); | 478 | 1.82k | SkASSERT(preallocCount > 0); | 479 | 1.82k | SkASSERT(preallocStorage); | 480 | 1.82k | fCount = count; | 481 | 1.82k | fItemArray = nullptr; | 482 | 1.82k | fReserved = false; | 483 | 1.82k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 1.82k | } else { | 488 | 1.82k | fAllocCount = preallocCount; | 489 | 1.82k | fItemArray = (T*)preallocStorage; | 490 | 1.82k | fOwnMemory = false; | 491 | 1.82k | } | 492 | 1.82k | } |
SkTArray<SkSL::Type const*, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 471 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 471 | SkASSERT(count >= 0); | 478 | 471 | SkASSERT(preallocCount > 0); | 479 | 471 | SkASSERT(preallocStorage); | 480 | 471 | fCount = count; | 481 | 471 | fItemArray = nullptr; | 482 | 471 | fReserved = false; | 483 | 471 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 471 | } else { | 488 | 471 | fAllocCount = preallocCount; | 489 | 471 | fItemArray = (T*)preallocStorage; | 490 | 471 | fOwnMemory = false; | 491 | 471 | } | 492 | 471 | } |
SkTArray<unsigned long, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 261k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 261k | SkASSERT(count >= 0); | 478 | 261k | SkASSERT(preallocCount > 0); | 479 | 261k | SkASSERT(preallocStorage); | 480 | 261k | fCount = count; | 481 | 261k | fItemArray = nullptr; | 482 | 261k | fReserved = false; | 483 | 261k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 261k | } else { | 488 | 261k | fAllocCount = preallocCount; | 489 | 261k | fItemArray = (T*)preallocStorage; | 490 | 261k | fOwnMemory = false; | 491 | 261k | } | 492 | 261k | } |
SkTArray<int, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 13.2M | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 13.2M | SkASSERT(count >= 0); | 478 | 13.2M | SkASSERT(preallocCount > 0); | 479 | 13.2M | SkASSERT(preallocStorage); | 480 | 13.2M | fCount = count; | 481 | 13.2M | fItemArray = nullptr; | 482 | 13.2M | fReserved = false; | 483 | 13.2M | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 13.2M | } else { | 488 | 13.2M | fAllocCount = preallocCount; | 489 | 13.2M | fItemArray = (T*)preallocStorage; | 490 | 13.2M | fOwnMemory = false; | 491 | 13.2M | } | 492 | 13.2M | } |
SkSLSwizzle.cpp:SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 6 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 6 | SkASSERT(count >= 0); | 478 | 6 | SkASSERT(preallocCount > 0); | 479 | 6 | SkASSERT(preallocStorage); | 480 | 6 | fCount = count; | 481 | 6 | fItemArray = nullptr; | 482 | 6 | fReserved = false; | 483 | 6 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 6 | } else { | 488 | 6 | fAllocCount = preallocCount; | 489 | 6 | fItemArray = (T*)preallocStorage; | 490 | 6 | fOwnMemory = false; | 491 | 6 | } | 492 | 6 | } |
Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<bool, true>::initWithPreallocatedStorage(int, void*, int) SkTArray<sk_sp<GrRenderTask>, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 1.32k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 1.32k | SkASSERT(count >= 0); | 478 | 1.32k | SkASSERT(preallocCount > 0); | 479 | 1.32k | SkASSERT(preallocStorage); | 480 | 1.32k | fCount = count; | 481 | 1.32k | fItemArray = nullptr; | 482 | 1.32k | fReserved = false; | 483 | 1.32k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 1.32k | } else { | 488 | 1.32k | fAllocCount = preallocCount; | 489 | 1.32k | fItemArray = (T*)preallocStorage; | 490 | 1.32k | fOwnMemory = false; | 491 | 1.32k | } | 492 | 1.32k | } |
Unexecuted instantiation: SkTArray<GrTextureResolveRenderTask::Resolve, false>::initWithPreallocatedStorage(int, void*, int) SkTArray<GrGpu::SubmittedProc, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 1.32k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 1.32k | SkASSERT(count >= 0); | 478 | 1.32k | SkASSERT(preallocCount > 0); | 479 | 1.32k | SkASSERT(preallocStorage); | 480 | 1.32k | fCount = count; | 481 | 1.32k | fItemArray = nullptr; | 482 | 1.32k | fReserved = false; | 483 | 1.32k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 1.32k | } else { | 488 | 1.32k | fAllocCount = preallocCount; | 489 | 1.32k | fItemArray = (T*)preallocStorage; | 490 | 1.32k | fOwnMemory = false; | 491 | 1.32k | } | 492 | 1.32k | } |
SkTArray<sk_sp<GrSurfaceProxy>, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 100k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 100k | SkASSERT(count >= 0); | 478 | 100k | SkASSERT(preallocCount > 0); | 479 | 100k | SkASSERT(preallocStorage); | 480 | 100k | fCount = count; | 481 | 100k | fItemArray = nullptr; | 482 | 100k | fReserved = false; | 483 | 100k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 100k | } else { | 488 | 100k | fAllocCount = preallocCount; | 489 | 100k | fItemArray = (T*)preallocStorage; | 490 | 100k | fOwnMemory = false; | 491 | 100k | } | 492 | 100k | } |
SkTArray<GrRenderTask*, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 201k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 201k | SkASSERT(count >= 0); | 478 | 201k | SkASSERT(preallocCount > 0); | 479 | 201k | SkASSERT(preallocStorage); | 480 | 201k | fCount = count; | 481 | 201k | fItemArray = nullptr; | 482 | 201k | fReserved = false; | 483 | 201k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 201k | } else { | 488 | 201k | fAllocCount = preallocCount; | 489 | 201k | fItemArray = (T*)preallocStorage; | 490 | 201k | fOwnMemory = false; | 491 | 201k | } | 492 | 201k | } |
Unexecuted instantiation: SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::initWithPreallocatedStorage(int, void*, int) SkTArray<sk_sp<GrTextBlob>, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 2.84k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 2.84k | SkASSERT(count >= 0); | 478 | 2.84k | SkASSERT(preallocCount > 0); | 479 | 2.84k | SkASSERT(preallocStorage); | 480 | 2.84k | fCount = count; | 481 | 2.84k | fItemArray = nullptr; | 482 | 2.84k | fReserved = false; | 483 | 2.84k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 2.84k | } else { | 488 | 2.84k | fAllocCount = preallocCount; | 489 | 2.84k | fItemArray = (T*)preallocStorage; | 490 | 2.84k | fOwnMemory = false; | 491 | 2.84k | } | 492 | 2.84k | } |
Unexecuted instantiation: SkTArray<SkString, false>::initWithPreallocatedStorage(int, void*, int) SkTArray<GrOpsTask::OpChain, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 89.6k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 89.6k | SkASSERT(count >= 0); | 478 | 89.6k | SkASSERT(preallocCount > 0); | 479 | 89.6k | SkASSERT(preallocStorage); | 480 | 89.6k | fCount = count; | 481 | 89.6k | fItemArray = nullptr; | 482 | 89.6k | fReserved = false; | 483 | 89.6k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 89.6k | } else { | 488 | 89.6k | fAllocCount = preallocCount; | 489 | 89.6k | fItemArray = (T*)preallocStorage; | 490 | 89.6k | fOwnMemory = false; | 491 | 89.6k | } | 492 | 89.6k | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAConvexPathOp::PathData, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 646 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 646 | SkASSERT(count >= 0); | 478 | 646 | SkASSERT(preallocCount > 0); | 479 | 646 | SkASSERT(preallocStorage); | 480 | 646 | fCount = count; | 481 | 646 | fItemArray = nullptr; | 482 | 646 | fReserved = false; | 483 | 646 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 646 | } else { | 488 | 646 | fAllocCount = preallocCount; | 489 | 646 | fItemArray = (T*)preallocStorage; | 490 | 646 | fOwnMemory = false; | 491 | 646 | } | 492 | 646 | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Segment, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 461 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 461 | SkASSERT(count >= 0); | 478 | 461 | SkASSERT(preallocCount > 0); | 479 | 461 | SkASSERT(preallocStorage); | 480 | 461 | fCount = count; | 481 | 461 | fItemArray = nullptr; | 482 | 461 | fReserved = false; | 483 | 461 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 461 | } else { | 488 | 461 | fAllocCount = preallocCount; | 489 | 461 | fItemArray = (T*)preallocStorage; | 490 | 461 | fOwnMemory = false; | 491 | 461 | } | 492 | 461 | } |
SkTArray<SkPoint, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 58.2k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 58.2k | SkASSERT(count >= 0); | 478 | 58.2k | SkASSERT(preallocCount > 0); | 479 | 58.2k | SkASSERT(preallocStorage); | 480 | 58.2k | fCount = count; | 481 | 58.2k | fItemArray = nullptr; | 482 | 58.2k | fReserved = false; | 483 | 58.2k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 58.2k | } else { | 488 | 58.2k | fAllocCount = preallocCount; | 489 | 58.2k | fItemArray = (T*)preallocStorage; | 490 | 58.2k | fOwnMemory = false; | 491 | 58.2k | } | 492 | 58.2k | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Draw, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 332 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 332 | SkASSERT(count >= 0); | 478 | 332 | SkASSERT(preallocCount > 0); | 479 | 332 | SkASSERT(preallocStorage); | 480 | 332 | fCount = count; | 481 | 332 | fItemArray = nullptr; | 482 | 332 | fReserved = false; | 483 | 332 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 332 | } else { | 488 | 332 | fAllocCount = preallocCount; | 489 | 332 | fItemArray = (T*)preallocStorage; | 490 | 332 | fOwnMemory = false; | 491 | 332 | } | 492 | 332 | } |
AAHairLinePathRenderer.cpp:SkTArray<(anonymous namespace)::AAHairlineOp::PathData, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 3.64k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 3.64k | SkASSERT(count >= 0); | 478 | 3.64k | SkASSERT(preallocCount > 0); | 479 | 3.64k | SkASSERT(preallocStorage); | 480 | 3.64k | fCount = count; | 481 | 3.64k | fItemArray = nullptr; | 482 | 3.64k | fReserved = false; | 483 | 3.64k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 3.64k | } else { | 488 | 3.64k | fAllocCount = preallocCount; | 489 | 3.64k | fItemArray = (T*)preallocStorage; | 490 | 3.64k | fOwnMemory = false; | 491 | 3.64k | } | 492 | 3.64k | } |
AALinearizingConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 574 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 574 | SkASSERT(count >= 0); | 478 | 574 | SkASSERT(preallocCount > 0); | 479 | 574 | SkASSERT(preallocStorage); | 480 | 574 | fCount = count; | 481 | 574 | fItemArray = nullptr; | 482 | 574 | fReserved = false; | 483 | 574 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 574 | } else { | 488 | 574 | fAllocCount = preallocCount; | 489 | 574 | fItemArray = (T*)preallocStorage; | 490 | 574 | fOwnMemory = false; | 491 | 574 | } | 492 | 574 | } |
DefaultPathRenderer.cpp:SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 9.24k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 9.24k | SkASSERT(count >= 0); | 478 | 9.24k | SkASSERT(preallocCount > 0); | 479 | 9.24k | SkASSERT(preallocStorage); | 480 | 9.24k | fCount = count; | 481 | 9.24k | fItemArray = nullptr; | 482 | 9.24k | fReserved = false; | 483 | 9.24k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 9.24k | } else { | 488 | 9.24k | fAllocCount = preallocCount; | 489 | 9.24k | fItemArray = (T*)preallocStorage; | 490 | 9.24k | fOwnMemory = false; | 491 | 9.24k | } | 492 | 9.24k | } |
SkTArray<DashOp::LineData, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 1 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 1 | SkASSERT(count >= 0); | 478 | 1 | SkASSERT(preallocCount > 0); | 479 | 1 | SkASSERT(preallocStorage); | 480 | 1 | fCount = count; | 481 | 1 | fItemArray = nullptr; | 482 | 1 | fReserved = false; | 483 | 1 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 1 | } else { | 488 | 1 | fAllocCount = preallocCount; | 489 | 1 | fItemArray = (T*)preallocStorage; | 490 | 1 | fOwnMemory = false; | 491 | 1 | } | 492 | 1 | } |
SkTArray<SkRect, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 1 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 1 | SkASSERT(count >= 0); | 478 | 1 | SkASSERT(preallocCount > 0); | 479 | 1 | SkASSERT(preallocStorage); | 480 | 1 | fCount = count; | 481 | 1 | fItemArray = nullptr; | 482 | 1 | fReserved = false; | 483 | 1 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 1 | } else { | 488 | 1 | fAllocCount = preallocCount; | 489 | 1 | fItemArray = (T*)preallocStorage; | 490 | 1 | fOwnMemory = false; | 491 | 1 | } | 492 | 1 | } |
SkTArray<DashOp::DashDraw, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 1 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 1 | SkASSERT(count >= 0); | 478 | 1 | SkASSERT(preallocCount > 0); | 479 | 1 | SkASSERT(preallocStorage); | 480 | 1 | fCount = count; | 481 | 1 | fItemArray = nullptr; | 482 | 1 | fReserved = false; | 483 | 1 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 1 | } else { | 488 | 1 | fAllocCount = preallocCount; | 489 | 1 | fItemArray = (T*)preallocStorage; | 490 | 1 | fOwnMemory = false; | 491 | 1 | } | 492 | 1 | } |
Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::initWithPreallocatedStorage(int, void*, int) GrDrawVerticesOp.cpp:SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 1.85k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 1.85k | SkASSERT(count >= 0); | 478 | 1.85k | SkASSERT(preallocCount > 0); | 479 | 1.85k | SkASSERT(preallocStorage); | 480 | 1.85k | fCount = count; | 481 | 1.85k | fItemArray = nullptr; | 482 | 1.85k | fReserved = false; | 483 | 1.85k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 1.85k | } else { | 488 | 1.85k | fAllocCount = preallocCount; | 489 | 1.85k | fItemArray = (T*)preallocStorage; | 490 | 1.85k | fOwnMemory = false; | 491 | 1.85k | } | 492 | 1.85k | } |
Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::initWithPreallocatedStorage(int, void*, int) SkTArray<CircularRRectOp::RRect, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 5 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 5 | SkASSERT(count >= 0); | 478 | 5 | SkASSERT(preallocCount > 0); | 479 | 5 | SkASSERT(preallocStorage); | 480 | 5 | fCount = count; | 481 | 5 | fItemArray = nullptr; | 482 | 5 | fReserved = false; | 483 | 5 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 5 | } else { | 488 | 5 | fAllocCount = preallocCount; | 489 | 5 | fItemArray = (T*)preallocStorage; | 490 | 5 | fOwnMemory = false; | 491 | 5 | } | 492 | 5 | } |
SkTArray<EllipticalRRectOp::RRect, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 2 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 2 | SkASSERT(count >= 0); | 478 | 2 | SkASSERT(preallocCount > 0); | 479 | 2 | SkASSERT(preallocStorage); | 480 | 2 | fCount = count; | 481 | 2 | fItemArray = nullptr; | 482 | 2 | fReserved = false; | 483 | 2 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 2 | } else { | 488 | 2 | fAllocCount = preallocCount; | 489 | 2 | fItemArray = (T*)preallocStorage; | 490 | 2 | fOwnMemory = false; | 491 | 2 | } | 492 | 2 | } |
Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::initWithPreallocatedStorage(int, void*, int) SkTArray<CircleOp::Circle, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 14 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 14 | SkASSERT(count >= 0); | 478 | 14 | SkASSERT(preallocCount > 0); | 479 | 14 | SkASSERT(preallocStorage); | 480 | 14 | fCount = count; | 481 | 14 | fItemArray = nullptr; | 482 | 14 | fReserved = false; | 483 | 14 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 14 | } else { | 488 | 14 | fAllocCount = preallocCount; | 489 | 14 | fItemArray = (T*)preallocStorage; | 490 | 14 | fOwnMemory = false; | 491 | 14 | } | 492 | 14 | } |
Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::initWithPreallocatedStorage(int, void*, int) SkTArray<DIEllipseOp::Ellipse, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 7 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 7 | SkASSERT(count >= 0); | 478 | 7 | SkASSERT(preallocCount > 0); | 479 | 7 | SkASSERT(preallocStorage); | 480 | 7 | fCount = count; | 481 | 7 | fItemArray = nullptr; | 482 | 7 | fReserved = false; | 483 | 7 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 7 | } else { | 488 | 7 | fAllocCount = preallocCount; | 489 | 7 | fItemArray = (T*)preallocStorage; | 490 | 7 | fOwnMemory = false; | 491 | 7 | } | 492 | 7 | } |
Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::initWithPreallocatedStorage(int, void*, int) GrStrokeRectOp.cpp:SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 208 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 208 | SkASSERT(count >= 0); | 478 | 208 | SkASSERT(preallocCount > 0); | 479 | 208 | SkASSERT(preallocStorage); | 480 | 208 | fCount = count; | 481 | 208 | fItemArray = nullptr; | 482 | 208 | fReserved = false; | 483 | 208 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 208 | } else { | 488 | 208 | fAllocCount = preallocCount; | 489 | 208 | fItemArray = (T*)preallocStorage; | 490 | 208 | fOwnMemory = false; | 491 | 208 | } | 492 | 208 | } |
SmallPathRenderer.cpp:SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 2.96k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 2.96k | SkASSERT(count >= 0); | 478 | 2.96k | SkASSERT(preallocCount > 0); | 479 | 2.96k | SkASSERT(preallocStorage); | 480 | 2.96k | fCount = count; | 481 | 2.96k | fItemArray = nullptr; | 482 | 2.96k | fReserved = false; | 483 | 2.96k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 2.96k | } else { | 488 | 2.96k | fAllocCount = preallocCount; | 489 | 2.96k | fItemArray = (T*)preallocStorage; | 490 | 2.96k | fOwnMemory = false; | 491 | 2.96k | } | 492 | 2.96k | } |
SkTArray<sk_sp<skgpu::v1::PathRenderer>, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 673 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 673 | SkASSERT(count >= 0); | 478 | 673 | SkASSERT(preallocCount > 0); | 479 | 673 | SkASSERT(preallocStorage); | 480 | 673 | fCount = count; | 481 | 673 | fItemArray = nullptr; | 482 | 673 | fReserved = false; | 483 | 673 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 673 | } else { | 488 | 673 | fAllocCount = preallocCount; | 489 | 673 | fItemArray = (T*)preallocStorage; | 490 | 673 | fOwnMemory = false; | 491 | 673 | } | 492 | 673 | } |
Unexecuted instantiation: SkTArray<GrMipLevel, false>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<unsigned int, false>::initWithPreallocatedStorage(int, void*, int) SkTArray<__jmp_buf_tag (*) [1], false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 12.7k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 12.7k | SkASSERT(count >= 0); | 478 | 12.7k | SkASSERT(preallocCount > 0); | 479 | 12.7k | SkASSERT(preallocStorage); | 480 | 12.7k | fCount = count; | 481 | 12.7k | fItemArray = nullptr; | 482 | 12.7k | fReserved = false; | 483 | 12.7k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 12.7k | } else { | 488 | 12.7k | fAllocCount = preallocCount; | 489 | 12.7k | fItemArray = (T*)preallocStorage; | 490 | 12.7k | fOwnMemory = false; | 491 | 12.7k | } | 492 | 12.7k | } |
Unexecuted instantiation: SkTArray<GrUniqueKeyInvalidatedMessage, false>::initWithPreallocatedStorage(int, void*, int) SkTArray<OffsetEdge, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 348 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 348 | SkASSERT(count >= 0); | 478 | 348 | SkASSERT(preallocCount > 0); | 479 | 348 | SkASSERT(preallocStorage); | 480 | 348 | fCount = count; | 481 | 348 | fItemArray = nullptr; | 482 | 348 | fReserved = false; | 483 | 348 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 348 | } else { | 488 | 348 | fAllocCount = preallocCount; | 489 | 348 | fItemArray = (T*)preallocStorage; | 490 | 348 | fOwnMemory = false; | 491 | 348 | } | 492 | 348 | } |
SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 45.9k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 45.9k | SkASSERT(count >= 0); | 478 | 45.9k | SkASSERT(preallocCount > 0); | 479 | 45.9k | SkASSERT(preallocStorage); | 480 | 45.9k | fCount = count; | 481 | 45.9k | fItemArray = nullptr; | 482 | 45.9k | fReserved = false; | 483 | 45.9k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 45.9k | } else { | 488 | 45.9k | fAllocCount = preallocCount; | 489 | 45.9k | fItemArray = (T*)preallocStorage; | 490 | 45.9k | fOwnMemory = false; | 491 | 45.9k | } | 492 | 45.9k | } |
SkTArray<float, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 9.03k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 9.03k | SkASSERT(count >= 0); | 478 | 9.03k | SkASSERT(preallocCount > 0); | 479 | 9.03k | SkASSERT(preallocStorage); | 480 | 9.03k | fCount = count; | 481 | 9.03k | fItemArray = nullptr; | 482 | 9.03k | fReserved = false; | 483 | 9.03k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 9.03k | } else { | 488 | 9.03k | fAllocCount = preallocCount; | 489 | 9.03k | fItemArray = (T*)preallocStorage; | 490 | 9.03k | fOwnMemory = false; | 491 | 9.03k | } | 492 | 9.03k | } |
SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 21.9k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 21.9k | SkASSERT(count >= 0); | 478 | 21.9k | SkASSERT(preallocCount > 0); | 479 | 21.9k | SkASSERT(preallocStorage); | 480 | 21.9k | fCount = count; | 481 | 21.9k | fItemArray = nullptr; | 482 | 21.9k | fReserved = false; | 483 | 21.9k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 21.9k | } else { | 488 | 21.9k | fAllocCount = preallocCount; | 489 | 21.9k | fItemArray = (T*)preallocStorage; | 490 | 21.9k | fOwnMemory = false; | 491 | 21.9k | } | 492 | 21.9k | } |
Unexecuted instantiation: SkTArray<PathSegment, true>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<GrProgramInfo const*, false>::initWithPreallocatedStorage(int, void*, int) SkTArray<skgpu::v1::ClipStack::Element const*, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 12.8k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 12.8k | SkASSERT(count >= 0); | 478 | 12.8k | SkASSERT(preallocCount > 0); | 479 | 12.8k | SkASSERT(preallocStorage); | 480 | 12.8k | fCount = count; | 481 | 12.8k | fItemArray = nullptr; | 482 | 12.8k | fReserved = false; | 483 | 12.8k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 12.8k | } else { | 488 | 12.8k | fAllocCount = preallocCount; | 489 | 12.8k | fItemArray = (T*)preallocStorage; | 490 | 12.8k | fOwnMemory = false; | 491 | 12.8k | } | 492 | 12.8k | } |
SkTArray<SkOpRayHit*, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 2.60M | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 2.60M | SkASSERT(count >= 0); | 478 | 2.60M | SkASSERT(preallocCount > 0); | 479 | 2.60M | SkASSERT(preallocStorage); | 480 | 2.60M | fCount = count; | 481 | 2.60M | fItemArray = nullptr; | 482 | 2.60M | fReserved = false; | 483 | 2.60M | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 2.60M | } else { | 488 | 2.60M | fAllocCount = preallocCount; | 489 | 2.60M | fItemArray = (T*)preallocStorage; | 490 | 2.60M | fOwnMemory = false; | 491 | 2.60M | } | 492 | 2.60M | } |
SkTArray<double, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 94.5k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 94.5k | SkASSERT(count >= 0); | 478 | 94.5k | SkASSERT(preallocCount > 0); | 479 | 94.5k | SkASSERT(preallocStorage); | 480 | 94.5k | fCount = count; | 481 | 94.5k | fItemArray = nullptr; | 482 | 94.5k | fReserved = false; | 483 | 94.5k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 94.5k | } else { | 488 | 94.5k | fAllocCount = preallocCount; | 489 | 94.5k | fItemArray = (T*)preallocStorage; | 490 | 94.5k | fOwnMemory = false; | 491 | 94.5k | } | 492 | 94.5k | } |
SkTArray<Sk4fGradientInterval, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 730 | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 730 | SkASSERT(count >= 0); | 478 | 730 | SkASSERT(preallocCount > 0); | 479 | 730 | SkASSERT(preallocStorage); | 480 | 730 | fCount = count; | 481 | 730 | fItemArray = nullptr; | 482 | 730 | fReserved = false; | 483 | 730 | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 730 | } else { | 488 | 730 | fAllocCount = preallocCount; | 489 | 730 | fItemArray = (T*)preallocStorage; | 490 | 730 | fOwnMemory = false; | 491 | 730 | } | 492 | 730 | } |
Unexecuted instantiation: SkTArray<GrVertexChunk, false>::initWithPreallocatedStorage(int, void*, int) SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 8.66k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 8.66k | SkASSERT(count >= 0); | 478 | 8.66k | SkASSERT(preallocCount > 0); | 479 | 8.66k | SkASSERT(preallocStorage); | 480 | 8.66k | fCount = count; | 481 | 8.66k | fItemArray = nullptr; | 482 | 8.66k | fReserved = false; | 483 | 8.66k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 8.66k | } else { | 488 | 8.66k | fAllocCount = preallocCount; | 489 | 8.66k | fItemArray = (T*)preallocStorage; | 490 | 8.66k | fOwnMemory = false; | 491 | 8.66k | } | 492 | 8.66k | } |
SkTArray<SkClosestRecord, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 2.25M | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 2.25M | SkASSERT(count >= 0); | 478 | 2.25M | SkASSERT(preallocCount > 0); | 479 | 2.25M | SkASSERT(preallocStorage); | 480 | 2.25M | fCount = count; | 481 | 2.25M | fItemArray = nullptr; | 482 | 2.25M | fReserved = false; | 483 | 2.25M | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 2.25M | } else { | 488 | 2.25M | fAllocCount = preallocCount; | 489 | 2.25M | fItemArray = (T*)preallocStorage; | 490 | 2.25M | fOwnMemory = false; | 491 | 2.25M | } | 492 | 2.25M | } |
SkTArray<SkClosestRecord const*, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 2.25M | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 2.25M | SkASSERT(count >= 0); | 478 | 2.25M | SkASSERT(preallocCount > 0); | 479 | 2.25M | SkASSERT(preallocStorage); | 480 | 2.25M | fCount = count; | 481 | 2.25M | fItemArray = nullptr; | 482 | 2.25M | fReserved = false; | 483 | 2.25M | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 2.25M | } else { | 488 | 2.25M | fAllocCount = preallocCount; | 489 | 2.25M | fItemArray = (T*)preallocStorage; | 490 | 2.25M | fOwnMemory = false; | 491 | 2.25M | } | 492 | 2.25M | } |
Layer.cpp:SkTArray<skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 9.42k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 9.42k | SkASSERT(count >= 0); | 478 | 9.42k | SkASSERT(preallocCount > 0); | 479 | 9.42k | SkASSERT(preallocStorage); | 480 | 9.42k | fCount = count; | 481 | 9.42k | fItemArray = nullptr; | 482 | 9.42k | fReserved = false; | 483 | 9.42k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 9.42k | } else { | 488 | 9.42k | fAllocCount = preallocCount; | 489 | 9.42k | fItemArray = (T*)preallocStorage; | 490 | 9.42k | fOwnMemory = false; | 491 | 9.42k | } | 492 | 9.42k | } |
Unexecuted instantiation: SkottieShaper.cpp:SkTArray<skottie::(anonymous namespace)::BlobMaker::RunRec, false>::initWithPreallocatedStorage(int, void*, int) SkTArray<char, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 19.7k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 19.7k | SkASSERT(count >= 0); | 478 | 19.7k | SkASSERT(preallocCount > 0); | 479 | 19.7k | SkASSERT(preallocStorage); | 480 | 19.7k | fCount = count; | 481 | 19.7k | fItemArray = nullptr; | 482 | 19.7k | fReserved = false; | 483 | 19.7k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 19.7k | } else { | 488 | 19.7k | fAllocCount = preallocCount; | 489 | 19.7k | fItemArray = (T*)preallocStorage; | 490 | 19.7k | fOwnMemory = false; | 491 | 19.7k | } | 492 | 19.7k | } |
SkTArray<SkSVGTextContext::PositionAdjustment, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 19.7k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 19.7k | SkASSERT(count >= 0); | 478 | 19.7k | SkASSERT(preallocCount > 0); | 479 | 19.7k | SkASSERT(preallocStorage); | 480 | 19.7k | fCount = count; | 481 | 19.7k | fItemArray = nullptr; | 482 | 19.7k | fReserved = false; | 483 | 19.7k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 19.7k | } else { | 488 | 19.7k | fAllocCount = preallocCount; | 489 | 19.7k | fItemArray = (T*)preallocStorage; | 490 | 19.7k | fOwnMemory = false; | 491 | 19.7k | } | 492 | 19.7k | } |
SkTArray<sk_sp<SkSVGNode>, true>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 76.5k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 76.5k | SkASSERT(count >= 0); | 478 | 76.5k | SkASSERT(preallocCount > 0); | 479 | 76.5k | SkASSERT(preallocStorage); | 480 | 76.5k | fCount = count; | 481 | 76.5k | fItemArray = nullptr; | 482 | 76.5k | fReserved = false; | 483 | 76.5k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 76.5k | } else { | 488 | 76.5k | fAllocCount = preallocCount; | 489 | 76.5k | fItemArray = (T*)preallocStorage; | 490 | 76.5k | fOwnMemory = false; | 491 | 76.5k | } | 492 | 76.5k | } |
SkTArray<hb_feature_t, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 464k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 464k | SkASSERT(count >= 0); | 478 | 464k | SkASSERT(preallocCount > 0); | 479 | 464k | SkASSERT(preallocStorage); | 480 | 464k | fCount = count; | 481 | 464k | fItemArray = nullptr; | 482 | 464k | fReserved = false; | 483 | 464k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 464k | } else { | 488 | 464k | fAllocCount = preallocCount; | 489 | 464k | fItemArray = (T*)preallocStorage; | 490 | 464k | fOwnMemory = false; | 491 | 464k | } | 492 | 464k | } |
Unexecuted instantiation: SkTArray<unsigned short, true>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::initWithPreallocatedStorage(int, void*, int) SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 16.5M | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 16.5M | SkASSERT(count >= 0); | 478 | 16.5M | SkASSERT(preallocCount > 0); | 479 | 16.5M | SkASSERT(preallocStorage); | 480 | 16.5M | fCount = count; | 481 | 16.5M | fItemArray = nullptr; | 482 | 16.5M | fReserved = false; | 483 | 16.5M | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 16.5M | } else { | 488 | 16.5M | fAllocCount = preallocCount; | 489 | 16.5M | fItemArray = (T*)preallocStorage; | 490 | 16.5M | fOwnMemory = false; | 491 | 16.5M | } | 492 | 16.5M | } |
Unexecuted instantiation: SkTArray<int, false>::initWithPreallocatedStorage(int, void*, int) SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 19.9M | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 19.9M | SkASSERT(count >= 0); | 478 | 19.9M | SkASSERT(preallocCount > 0); | 479 | 19.9M | SkASSERT(preallocStorage); | 480 | 19.9M | fCount = count; | 481 | 19.9M | fItemArray = nullptr; | 482 | 19.9M | fReserved = false; | 483 | 19.9M | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 19.9M | } else { | 488 | 19.9M | fAllocCount = preallocCount; | 489 | 19.9M | fItemArray = (T*)preallocStorage; | 490 | 19.9M | fOwnMemory = false; | 491 | 19.9M | } | 492 | 19.9M | } |
SkTArray<signed char, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 33.6M | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 33.6M | SkASSERT(count >= 0); | 478 | 33.6M | SkASSERT(preallocCount > 0); | 479 | 33.6M | SkASSERT(preallocStorage); | 480 | 33.6M | fCount = count; | 481 | 33.6M | fItemArray = nullptr; | 482 | 33.6M | fReserved = false; | 483 | 33.6M | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 33.6M | } else { | 488 | 33.6M | fAllocCount = preallocCount; | 489 | 33.6M | fItemArray = (T*)preallocStorage; | 490 | 33.6M | fOwnMemory = false; | 491 | 33.6M | } | 492 | 33.6M | } |
SkTArray<SkSL::Type const*, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 393k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 393k | SkASSERT(count >= 0); | 478 | 393k | SkASSERT(preallocCount > 0); | 479 | 393k | SkASSERT(preallocStorage); | 480 | 393k | fCount = count; | 481 | 393k | fItemArray = nullptr; | 482 | 393k | fReserved = false; | 483 | 393k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 393k | } else { | 488 | 393k | fAllocCount = preallocCount; | 489 | 393k | fItemArray = (T*)preallocStorage; | 490 | 393k | fOwnMemory = false; | 491 | 393k | } | 492 | 393k | } |
SkSLSwizzle.cpp:SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 170k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 170k | SkASSERT(count >= 0); | 478 | 170k | SkASSERT(preallocCount > 0); | 479 | 170k | SkASSERT(preallocStorage); | 480 | 170k | fCount = count; | 481 | 170k | fItemArray = nullptr; | 482 | 170k | fReserved = false; | 483 | 170k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 170k | } else { | 488 | 170k | fAllocCount = preallocCount; | 489 | 170k | fItemArray = (T*)preallocStorage; | 490 | 170k | fOwnMemory = false; | 491 | 170k | } | 492 | 170k | } |
Unexecuted instantiation: SkTArray<GrTextureResolveRenderTask::Resolve, false>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<SkString, false>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::initWithPreallocatedStorage(int, void*, int) SkTArray<SkSL::VariableReference*, false>::initWithPreallocatedStorage(int, void*, int) Line | Count | Source | 476 | 38.9k | void initWithPreallocatedStorage(int count, void* preallocStorage, int preallocCount) { | 477 | 38.9k | SkASSERT(count >= 0); | 478 | 38.9k | SkASSERT(preallocCount > 0); | 479 | 38.9k | SkASSERT(preallocStorage); | 480 | 38.9k | fCount = count; | 481 | 38.9k | fItemArray = nullptr; | 482 | 38.9k | fReserved = false; | 483 | 38.9k | if (count > preallocCount) { | 484 | 0 | fAllocCount = std::max(count, kMinHeapAllocCount); | 485 | 0 | fItemArray = (T*)sk_malloc_throw(fAllocCount, sizeof(T)); | 486 | 0 | fOwnMemory = true; | 487 | 38.9k | } else { | 488 | 38.9k | fAllocCount = preallocCount; | 489 | 38.9k | fItemArray = (T*)preallocStorage; | 490 | 38.9k | fOwnMemory = false; | 491 | 38.9k | } | 492 | 38.9k | } |
Unexecuted instantiation: SkTArray<GrMipLevel, false>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<unsigned int, false>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<GrUniqueKeyInvalidatedMessage, false>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<PathSegment, true>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<GrProgramInfo const*, false>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<GrVertexChunk, false>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::initWithPreallocatedStorage(int, void*, int) Unexecuted instantiation: SkTArray<bool, true>::initWithPreallocatedStorage(int, void*, int) |
493 | | |
494 | | /** In the following move and copy methods, 'dst' is assumed to be uninitialized raw storage. |
495 | | * In the following move methods, 'src' is destroyed leaving behind uninitialized raw storage. |
496 | | */ |
497 | 26.7M | void copy(const T* src) { |
498 | | // Some types may be trivially copyable, in which case we *could* use memcopy; but |
499 | | // MEM_MOVE == true implies that the type is trivially movable, and not necessarily |
500 | | // trivially copyable (think sk_sp<>). So short of adding another template arg, we |
501 | | // must be conservative and use copy construction. |
502 | 65.7M | for (int i = 0; i < this->count(); ++i) { |
503 | 38.9M | new (fItemArray + i) T(src[i]); |
504 | 38.9M | } |
505 | 26.7M | } Unexecuted instantiation: SkTArray<SkString, false>::copy(SkString const*) Unexecuted instantiation: SkTArray<unsigned int, true>::copy(unsigned int const*) SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::copy(GrDrawOpAtlas::BulkUseTokenUpdater::PlotData const*) Line | Count | Source | 497 | 1.22k | void copy(const T* src) { | 498 | | // Some types may be trivially copyable, in which case we *could* use memcopy; but | 499 | | // MEM_MOVE == true implies that the type is trivially movable, and not necessarily | 500 | | // trivially copyable (think sk_sp<>). So short of adding another template arg, we | 501 | | // must be conservative and use copy construction. | 502 | 1.22k | for (int i = 0; i < this->count(); ++i) { | 503 | 0 | new (fItemArray + i) T(src[i]); | 504 | 0 | } | 505 | 1.22k | } |
SkTArray<signed char, false>::copy(signed char const*) Line | Count | Source | 497 | 22.8M | void copy(const T* src) { | 498 | | // Some types may be trivially copyable, in which case we *could* use memcopy; but | 499 | | // MEM_MOVE == true implies that the type is trivially movable, and not necessarily | 500 | | // trivially copyable (think sk_sp<>). So short of adding another template arg, we | 501 | | // must be conservative and use copy construction. | 502 | 56.1M | for (int i = 0; i < this->count(); ++i) { | 503 | 33.2M | new (fItemArray + i) T(src[i]); | 504 | 33.2M | } | 505 | 22.8M | } |
SkTArray<int, true>::copy(int const*) Line | Count | Source | 497 | 3.75M | void copy(const T* src) { | 498 | | // Some types may be trivially copyable, in which case we *could* use memcopy; but | 499 | | // MEM_MOVE == true implies that the type is trivially movable, and not necessarily | 500 | | // trivially copyable (think sk_sp<>). So short of adding another template arg, we | 501 | | // must be conservative and use copy construction. | 502 | 8.64M | for (int i = 0; i < this->count(); ++i) { | 503 | 4.89M | new (fItemArray + i) T(src[i]); | 504 | 4.89M | } | 505 | 3.75M | } |
SkTArray<SkSL::Type const*, false>::copy(SkSL::Type const* const*) Line | Count | Source | 497 | 219 | void copy(const T* src) { | 498 | | // Some types may be trivially copyable, in which case we *could* use memcopy; but | 499 | | // MEM_MOVE == true implies that the type is trivially movable, and not necessarily | 500 | | // trivially copyable (think sk_sp<>). So short of adding another template arg, we | 501 | | // must be conservative and use copy construction. | 502 | 438 | for (int i = 0; i < this->count(); ++i) { | 503 | 219 | new (fItemArray + i) T(src[i]); | 504 | 219 | } | 505 | 219 | } |
Unexecuted instantiation: SkTArray<unsigned char, true>::copy(unsigned char const*) Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::copy(sk_sp<SkPicture const> const*) Unexecuted instantiation: SkTArray<sk_sp<SkDrawable>, false>::copy(sk_sp<SkDrawable> const*) Unexecuted instantiation: SkTArray<sk_sp<SkTextBlob const>, false>::copy(sk_sp<SkTextBlob const> const*) Unexecuted instantiation: SkTArray<sk_sp<SkVertices const>, false>::copy(sk_sp<SkVertices const> const*) Unexecuted instantiation: SkTArray<sk_sp<SkImage const>, false>::copy(sk_sp<SkImage const> const*) Unexecuted instantiation: SkTArray<SkPaint, false>::copy(SkPaint const*) Unexecuted instantiation: SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::copy(std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType> const*) SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true>::copy(SkTypeface_FreeType::Scanner::AxisDefinition const*) Line | Count | Source | 497 | 2.02k | void copy(const T* src) { | 498 | | // Some types may be trivially copyable, in which case we *could* use memcopy; but | 499 | | // MEM_MOVE == true implies that the type is trivially movable, and not necessarily | 500 | | // trivially copyable (think sk_sp<>). So short of adding another template arg, we | 501 | | // must be conservative and use copy construction. | 502 | 2.02k | for (int i = 0; i < this->count(); ++i) { | 503 | 0 | new (fItemArray + i) T(src[i]); | 504 | 0 | } | 505 | 2.02k | } |
Unexecuted instantiation: SkTArray<skia::textlayout::ResolvedFontDescriptor, false>::copy(skia::textlayout::ResolvedFontDescriptor const*) SkTArray<skia::textlayout::Block, true>::copy(skia::textlayout::Block const*) Line | Count | Source | 497 | 16.4k | void copy(const T* src) { | 498 | | // Some types may be trivially copyable, in which case we *could* use memcopy; but | 499 | | // MEM_MOVE == true implies that the type is trivially movable, and not necessarily | 500 | | // trivially copyable (think sk_sp<>). So short of adding another template arg, we | 501 | | // must be conservative and use copy construction. | 502 | 32.8k | for (int i = 0; i < this->count(); ++i) { | 503 | 16.4k | new (fItemArray + i) T(src[i]); | 504 | 16.4k | } | 505 | 16.4k | } |
SkTArray<skia::textlayout::Placeholder, true>::copy(skia::textlayout::Placeholder const*) Line | Count | Source | 497 | 16.4k | void copy(const T* src) { | 498 | | // Some types may be trivially copyable, in which case we *could* use memcopy; but | 499 | | // MEM_MOVE == true implies that the type is trivially movable, and not necessarily | 500 | | // trivially copyable (think sk_sp<>). So short of adding another template arg, we | 501 | | // must be conservative and use copy construction. | 502 | 32.8k | for (int i = 0; i < this->count(); ++i) { | 503 | 16.4k | new (fItemArray + i) T(src[i]); | 504 | 16.4k | } | 505 | 16.4k | } |
SkTArray<skia::textlayout::Run, false>::copy(skia::textlayout::Run const*) Line | Count | Source | 497 | 2.42k | void copy(const T* src) { | 498 | | // Some types may be trivially copyable, in which case we *could* use memcopy; but | 499 | | // MEM_MOVE == true implies that the type is trivially movable, and not necessarily | 500 | | // trivially copyable (think sk_sp<>). So short of adding another template arg, we | 501 | | // must be conservative and use copy construction. | 502 | 2.42k | for (int i = 0; i < this->count(); ++i) { | 503 | 0 | new (fItemArray + i) T(src[i]); | 504 | 0 | } | 505 | 2.42k | } |
Unexecuted instantiation: SkTArray<unsigned short, true>::copy(unsigned short const*) Unexecuted instantiation: SkTArray<SkPoint, true>::copy(SkPoint const*) Unexecuted instantiation: SkTArray<SkRect, true>::copy(SkRect const*) Unexecuted instantiation: SkTArray<float, true>::copy(float const*) SkTArray<skia::textlayout::CodeUnitFlags, false>::copy(skia::textlayout::CodeUnitFlags const*) Line | Count | Source | 497 | 2.42k | void copy(const T* src) { | 498 | | // Some types may be trivially copyable, in which case we *could* use memcopy; but | 499 | | // MEM_MOVE == true implies that the type is trivially movable, and not necessarily | 500 | | // trivially copyable (think sk_sp<>). So short of adding another template arg, we | 501 | | // must be conservative and use copy construction. | 502 | 840k | for (int i = 0; i < this->count(); ++i) { | 503 | 838k | new (fItemArray + i) T(src[i]); | 504 | 838k | } | 505 | 2.42k | } |
SkTArray<unsigned long, true>::copy(unsigned long const*) Line | Count | Source | 497 | 4.85k | void copy(const T* src) { | 498 | | // Some types may be trivially copyable, in which case we *could* use memcopy; but | 499 | | // MEM_MOVE == true implies that the type is trivially movable, and not necessarily | 500 | | // trivially copyable (think sk_sp<>). So short of adding another template arg, we | 501 | | // must be conservative and use copy construction. | 502 | 4.85k | for (int i = 0; i < this->count(); ++i) { | 503 | 0 | new (fItemArray + i) T(src[i]); | 504 | 0 | } | 505 | 4.85k | } |
SkTArray<SkShaper::Feature, false>::copy(SkShaper::Feature const*) Line | Count | Source | 497 | 57.6k | void copy(const T* src) { | 498 | | // Some types may be trivially copyable, in which case we *could* use memcopy; but | 499 | | // MEM_MOVE == true implies that the type is trivially movable, and not necessarily | 500 | | // trivially copyable (think sk_sp<>). So short of adding another template arg, we | 501 | | // must be conservative and use copy construction. | 502 | 57.6k | for (int i = 0; i < this->count(); ++i) { | 503 | 0 | new (fItemArray + i) T(src[i]); | 504 | 0 | } | 505 | 57.6k | } |
|
506 | | |
507 | | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(int dst, int src) { |
508 | | memcpy(&fItemArray[dst], &fItemArray[src], sizeof(T)); |
509 | | } |
510 | 2.18M | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { |
511 | 2.18M | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); |
512 | 2.18M | } std::__1::enable_if<true, void>::type SkTArray<unsigned int, true>::move<true>(void*) Line | Count | Source | 510 | 1.08k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 1.08k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 1.08k | } |
Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<GrFragmentProcessor::ProgramImpl*, true>::move<true>(void*) std::__1::enable_if<true, void>::type SkTArray<sk_gpu_test::GrContextFactory::Context, true>::move<true>(void*) Line | Count | Source | 510 | 2.65k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 2.65k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 2.65k | } |
Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<GrGLAttribArrayState::AttribArrayState, true>::move<true>(void*) Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::move<true>(void*) std::__1::enable_if<true, void>::type SkTArray<GrSurfaceProxy*, true>::move<true>(void*) Line | Count | Source | 510 | 80.7k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 80.7k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 80.7k | } |
std::__1::enable_if<true, void>::type SkTArray<sk_sp<SkImageFilter>, true>::move<true>(void*) Line | Count | Source | 510 | 277 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 277 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 277 | } |
Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<SkRGBA4f<(SkAlphaType)2>, true>::move<true>(void*) Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<unsigned long, true>::move<true>(void*) std::__1::enable_if<true, void>::type SkTArray<int, true>::move<true>(void*) Line | Count | Source | 510 | 1.77M | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 1.77M | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 1.77M | } |
Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<SkJSONWriter::Scope, true>::move<true>(void*) Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<bool, true>::move<true>(void*) Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::move<true>(void*) std::__1::enable_if<true, void>::type SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::move<true>(void*) Line | Count | Source | 510 | 131k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 131k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 131k | } |
std::__1::enable_if<true, void>::type SkTArray<GrRenderTask*, true>::move<true>(void*) Line | Count | Source | 510 | 20.3k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 20.3k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 20.3k | } |
Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<GrTextureProxy*, true>::move<true>(void*) Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::move<true>(void*) Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::move<true>(void*) AAConvexPathRenderer.cpp:std::__1::enable_if<true, void>::type SkTArray<(anonymous namespace)::AAConvexPathOp::PathData, true>::move<true>(void*) Line | Count | Source | 510 | 29 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 29 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 29 | } |
AAConvexPathRenderer.cpp:std::__1::enable_if<true, void>::type SkTArray<(anonymous namespace)::Segment, true>::move<true>(void*) Line | Count | Source | 510 | 225 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 225 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 225 | } |
Unexecuted instantiation: AAConvexPathRenderer.cpp:std::__1::enable_if<true, void>::type SkTArray<(anonymous namespace)::Draw, true>::move<true>(void*) AAHairLinePathRenderer.cpp:std::__1::enable_if<true, void>::type SkTArray<(anonymous namespace)::AAHairlineOp::PathData, true>::move<true>(void*) Line | Count | Source | 510 | 56 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 56 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 56 | } |
std::__1::enable_if<true, void>::type SkTArray<SkPoint, true>::move<true>(void*) Line | Count | Source | 510 | 4.76k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 4.76k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 4.76k | } |
std::__1::enable_if<true, void>::type SkTArray<float, true>::move<true>(void*) Line | Count | Source | 510 | 1.75k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 1.75k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 1.75k | } |
AALinearizingConvexPathRenderer.cpp:std::__1::enable_if<true, void>::type SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::move<true>(void*) Line | Count | Source | 510 | 4 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 4 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 4 | } |
DefaultPathRenderer.cpp:std::__1::enable_if<true, void>::type SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::move<true>(void*) Line | Count | Source | 510 | 200 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 200 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 200 | } |
Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<DashOp::LineData, true>::move<true>(void*) Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<SkRect, true>::move<true>(void*) Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<DashOp::DashDraw, true>::move<true>(void*) Unexecuted instantiation: GrDrawAtlasOp.cpp:std::__1::enable_if<true, void>::type SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::move<true>(void*) Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<unsigned char, true>::move<true>(void*) GrDrawVerticesOp.cpp:std::__1::enable_if<true, void>::type SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::move<true>(void*) Line | Count | Source | 510 | 19 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 19 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 19 | } |
Unexecuted instantiation: GrLatticeOp.cpp:std::__1::enable_if<true, void>::type SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::move<true>(void*) std::__1::enable_if<true, void>::type SkTArray<CircularRRectOp::RRect, true>::move<true>(void*) Line | Count | Source | 510 | 2 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 2 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 2 | } |
Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<EllipticalRRectOp::RRect, true>::move<true>(void*) Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<ButtCapDashedCircleOp::Circle, true>::move<true>(void*) std::__1::enable_if<true, void>::type SkTArray<CircleOp::Circle, true>::move<true>(void*) Line | Count | Source | 510 | 3 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 3 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 3 | } |
Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<EllipseOp::Ellipse, true>::move<true>(void*) Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<DIEllipseOp::Ellipse, true>::move<true>(void*) Unexecuted instantiation: GrRegionOp.cpp:std::__1::enable_if<true, void>::type SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::move<true>(void*) Unexecuted instantiation: GrShadowRRectOp.cpp:std::__1::enable_if<true, void>::type SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::move<true>(void*) GrStrokeRectOp.cpp:std::__1::enable_if<true, void>::type SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::move<true>(void*) Line | Count | Source | 510 | 11 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 11 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 11 | } |
Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<GrGLProgramDataManager::Uniform, true>::move<true>(void*) std::__1::enable_if<true, void>::type SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::move<true>(void*) Line | Count | Source | 510 | 19.4k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 19.4k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 19.4k | } |
Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<PathSegment, true>::move<true>(void*) std::__1::enable_if<true, void>::type SkTArray<GrXPFactoryTestFactory*, true>::move<true>(void*) Line | Count | Source | 510 | 76 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 76 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 76 | } |
std::__1::enable_if<true, void>::type SkTArray<GrProcessorTestFactory<GrGeometryProcessor*>*, true>::move<true>(void*) Line | Count | Source | 510 | 152 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 152 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 152 | } |
std::__1::enable_if<true, void>::type SkTArray<GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*, true>::move<true>(void*) Line | Count | Source | 510 | 152 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 152 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 152 | } |
Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<GrGLFormat, true>::move<true>(void*) std::__1::enable_if<true, void>::type SkTArray<std::__1::unique_ptr<SkCodec, std::__1::default_delete<SkCodec> >, true>::move<true>(void*) Line | Count | Source | 510 | 3.38k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 3.38k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 3.38k | } |
std::__1::enable_if<true, void>::type SkTArray<double, true>::move<true>(void*) Line | Count | Source | 510 | 52.5k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 52.5k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 52.5k | } |
std::__1::enable_if<true, void>::type SkTArray<Sk4fGradientInterval, true>::move<true>(void*) Line | Count | Source | 510 | 270 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 270 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 270 | } |
Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true>::move<true>(void*) std::__1::enable_if<true, void>::type SkTArray<SkClosestRecord, true>::move<true>(void*) Line | Count | Source | 510 | 3.59k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 3.59k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 3.59k | } |
std::__1::enable_if<true, void>::type SkTArray<SkClosestRecord const*, true>::move<true>(void*) Line | Count | Source | 510 | 2.61k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 2.61k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 2.61k | } |
Layer.cpp:std::__1::enable_if<true, void>::type SkTArray<skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::move<true>(void*) Line | Count | Source | 510 | 24 | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 24 | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 24 | } |
std::__1::enable_if<true, void>::type SkTArray<char, true>::move<true>(void*) Line | Count | Source | 510 | 8.62k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 8.62k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 8.62k | } |
std::__1::enable_if<true, void>::type SkTArray<SkSVGTextContext::PositionAdjustment, true>::move<true>(void*) Line | Count | Source | 510 | 8.62k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 8.62k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 8.62k | } |
std::__1::enable_if<true, void>::type SkTArray<sk_sp<SkSVGNode>, true>::move<true>(void*) Line | Count | Source | 510 | 40.4k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 40.4k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 40.4k | } |
std::__1::enable_if<true, void>::type SkTArray<skia::textlayout::Block, true>::move<true>(void*) Line | Count | Source | 510 | 13.0k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 13.0k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 13.0k | } |
std::__1::enable_if<true, void>::type SkTArray<skia::textlayout::Placeholder, true>::move<true>(void*) Line | Count | Source | 510 | 4.02k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 4.02k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 4.02k | } |
Unexecuted instantiation: std::__1::enable_if<true, void>::type SkTArray<unsigned short, true>::move<true>(void*) std::__1::enable_if<true, void>::type SkTArray<skia::textlayout::Cluster, true>::move<true>(void*) Line | Count | Source | 510 | 3.78k | template <bool E = MEM_MOVE> std::enable_if_t<E, void> move(void* dst) { | 511 | 3.78k | sk_careful_memcpy(dst, fItemArray, fCount * sizeof(T)); | 512 | 3.78k | } |
|
513 | | |
514 | 0 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(int dst, int src) { |
515 | 0 | new (&fItemArray[dst]) T(std::move(fItemArray[src])); |
516 | 0 | fItemArray[src].~T(); |
517 | 0 | } Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<SkTypeface>, false>::move<false>(int, int) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrOnFlushCallbackObject*, false>::move<false>(int, int) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<GrTextBlob>, false>::move<false>(int, int) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkString, false>::move<false>(int, int) |
518 | 38.4M | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { |
519 | 130M | for (int i = 0; i < this->count(); ++i) { |
520 | 91.7M | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); |
521 | 91.7M | fItemArray[i].~T(); |
522 | 91.7M | } |
523 | 38.4M | } std::__1::enable_if<!(false), void>::type SkTArray<SkString, false>::move<false>(void*) Line | Count | Source | 518 | 20 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 20 | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 20 | } |
std::__1::enable_if<!(false), void>::type SkTArray<SkNoPixelsDevice::ClipState, false>::move<false>(void*) Line | Count | Source | 518 | 8.02k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 198k | for (int i = 0; i < this->count(); ++i) { | 520 | 190k | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 190k | fItemArray[i].~T(); | 522 | 190k | } | 523 | 8.02k | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrUniqueKey, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<unsigned short, false>::move<false>(void*) Line | Count | Source | 518 | 74 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 590 | for (int i = 0; i < this->count(); ++i) { | 520 | 516 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 516 | fItemArray[i].~T(); | 522 | 516 | } | 523 | 74 | } |
std::__1::enable_if<!(false), void>::type SkTArray<SkPoint, false>::move<false>(void*) Line | Count | Source | 518 | 74 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 590 | for (int i = 0; i < this->count(); ++i) { | 520 | 516 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 516 | fItemArray[i].~T(); | 522 | 516 | } | 523 | 74 | } |
std::__1::enable_if<!(false), void>::type SkTArray<int, false>::move<false>(void*) Line | Count | Source | 518 | 456 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 456 | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 456 | } |
std::__1::enable_if<!(false), void>::type SkTArray<float, false>::move<false>(void*) Line | Count | Source | 518 | 456 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 456 | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 456 | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkCanvas::Lattice::RectType, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<unsigned int, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkRuntimeEffect::ChildPtr, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::move<false>(void*) Line | Count | Source | 518 | 14.9M | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 38.5M | for (int i = 0; i < this->count(); ++i) { | 520 | 23.5M | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 23.5M | fItemArray[i].~T(); | 522 | 23.5M | } | 523 | 14.9M | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<SkTypeface>, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::move<false>(void*) Line | Count | Source | 518 | 17.9M | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 46.4M | for (int i = 0; i < this->count(); ++i) { | 520 | 28.4M | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 28.4M | fItemArray[i].~T(); | 522 | 28.4M | } | 523 | 17.9M | } |
std::__1::enable_if<!(false), void>::type SkTArray<signed char, false>::move<false>(void*) Line | Count | Source | 518 | 636k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 1.65M | for (int i = 0; i < this->count(); ++i) { | 520 | 1.02M | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 1.02M | fItemArray[i].~T(); | 522 | 1.02M | } | 523 | 636k | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkSL::dsl::DSLParameter*, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<SkSL::Parser::Checkpoint::ForwardingErrorReporter::Error, false>::move<false>(void*) Line | Count | Source | 518 | 15.3k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 15.3k | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 15.3k | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkSL::dsl::DSLField, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkSL::dsl::DSLCase, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkSL::Type const*, false>::move<false>(void*) Unexecuted instantiation: SkSLSwizzle.cpp:std::__1::enable_if<!(false), void>::type SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<GrRenderTask>, false>::move<false>(void*) Line | Count | Source | 518 | 7.22k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 211k | for (int i = 0; i < this->count(); ++i) { | 520 | 203k | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 203k | fItemArray[i].~T(); | 522 | 203k | } | 523 | 7.22k | } |
std::__1::enable_if<!(false), void>::type SkTArray<GrOnFlushCallbackObject*, false>::move<false>(void*) Line | Count | Source | 518 | 1.32k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 1.32k | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 1.32k | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrGpu::SubmittedProc, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<double, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkSL::String, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<GrSurfaceProxy>, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<GrUniqueKeyInvalidatedMessage, false>::move<false>(void*) Line | Count | Source | 518 | 8.59k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 78.7k | for (int i = 0; i < this->count(); ++i) { | 520 | 70.1k | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 70.1k | fItemArray[i].~T(); | 522 | 70.1k | } | 523 | 8.59k | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrTextureFreedMessage, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrTextureResolveRenderTask::Resolve, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::move<false>(void*) Line | Count | Source | 518 | 65.8k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 65.8k | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 65.8k | } |
std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<GrTextBlob>, false>::move<false>(void*) Line | Count | Source | 518 | 1.22k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 1.30k | for (int i = 0; i < this->count(); ++i) { | 520 | 71 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 71 | fItemArray[i].~T(); | 522 | 71 | } | 523 | 1.22k | } |
std::__1::enable_if<!(false), void>::type SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::move<false>(void*) Line | Count | Source | 518 | 494 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 494 | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 494 | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrAuditTrail::Op*, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrAuditTrail::OpInfo::Op, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrAuditTrail::OpInfo, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<GrOpsTask::OpChain, false>::move<false>(void*) Line | Count | Source | 518 | 614 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 21.9k | for (int i = 0; i < this->count(); ++i) { | 520 | 21.3k | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 21.3k | fItemArray[i].~T(); | 522 | 21.3k | } | 523 | 614 | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkRSXform, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkRect, false>::move<false>(void*) SmallPathRenderer.cpp:std::__1::enable_if<!(false), void>::type SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::move<false>(void*) Line | Count | Source | 518 | 162 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 1.04k | for (int i = 0; i < this->count(); ++i) { | 520 | 883 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 883 | fItemArray[i].~T(); | 522 | 883 | } | 523 | 162 | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<skgpu::v1::PathRenderer>, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkSL::VariableReference*, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrMipLevel, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<__jmp_buf_tag (*) [1], false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<unsigned long, false>::move<false>(void*) Line | Count | Source | 518 | 3.78k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 3.78k | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 3.78k | } |
std::__1::enable_if<!(false), void>::type SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::move<false>(void*) Line | Count | Source | 518 | 1.86k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 1.86k | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 1.86k | } |
std::__1::enable_if<!(false), void>::type SkTArray<SkPaint, false>::move<false>(void*) Line | Count | Source | 518 | 1.13k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 39.2k | for (int i = 0; i < this->count(); ++i) { | 520 | 38.0k | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 38.0k | fItemArray[i].~T(); | 522 | 38.0k | } | 523 | 1.13k | } |
std::__1::enable_if<!(false), void>::type SkTArray<SkPath, false>::move<false>(void*) Line | Count | Source | 518 | 290k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 564k | for (int i = 0; i < this->count(); ++i) { | 520 | 273k | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 273k | fItemArray[i].~T(); | 522 | 273k | } | 523 | 290k | } |
std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<SkPicture const>, false>::move<false>(void*) Line | Count | Source | 518 | 11 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 11 | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 11 | } |
std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<SkTextBlob const>, false>::move<false>(void*) Line | Count | Source | 518 | 134 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 1.02k | for (int i = 0; i < this->count(); ++i) { | 520 | 888 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 888 | fItemArray[i].~T(); | 522 | 888 | } | 523 | 134 | } |
std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<SkVertices const>, false>::move<false>(void*) Line | Count | Source | 518 | 181 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 3.02k | for (int i = 0; i < this->count(); ++i) { | 520 | 2.84k | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 2.84k | fItemArray[i].~T(); | 522 | 2.84k | } | 523 | 181 | } |
std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<SkImage const>, false>::move<false>(void*) Line | Count | Source | 518 | 3.68k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 43.1k | for (int i = 0; i < this->count(); ++i) { | 520 | 39.4k | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 39.4k | fItemArray[i].~T(); | 522 | 39.4k | } | 523 | 3.68k | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<SkDrawable>, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkMatrix, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<OffsetEdge, false>::move<false>(void*) Line | Count | Source | 518 | 270 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 270 | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 270 | } |
std::__1::enable_if<!(false), void>::type SkTArray<GrBufferAllocPool::BufferBlock, false>::move<false>(void*) Line | Count | Source | 518 | 61.9k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 63.6k | for (int i = 0; i < this->count(); ++i) { | 520 | 1.67k | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 1.67k | fItemArray[i].~T(); | 522 | 1.67k | } | 523 | 61.9k | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrDrawOpAtlas::Plot*, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<GrAtlasRenderTask>, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrGeometryProcessor::Attribute, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<skgpu::v1::ClipStack::Element, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<skgpu::v1::ClipStack::Element const*, false>::move<false>(void*) Line | Count | Source | 518 | 34 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 182 | for (int i = 0; i < this->count(); ++i) { | 520 | 148 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 148 | fItemArray[i].~T(); | 522 | 148 | } | 523 | 34 | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrSwizzle, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<dng_exception, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<std::__1::thread, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<std::__1::function<void ()>, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<SkOpRayHit*, false>::move<false>(void*) Line | Count | Source | 518 | 4.37M | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 41.4M | for (int i = 0; i < this->count(); ++i) { | 520 | 37.0M | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 37.0M | fItemArray[i].~T(); | 522 | 37.0M | } | 523 | 4.37M | } |
std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<SkFontStyleSet_Custom>, false>::move<false>(void*) Line | Count | Source | 518 | 5 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 5 | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 5 | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrProgramInfo const*, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<SkTypeface_Custom>, false>::move<false>(void*) Line | Count | Source | 518 | 5 | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 5 | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 5 | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<std::__1::array<unsigned short, 3ul>, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrVertexChunk, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<sk_sp<ToolUtils::TopoTestNode>, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<TestSVGTypeface::GlyfLayerInfo, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<TestSVGTypeface::GlyfInfo, false>::move<false>(void*) Unexecuted instantiation: SkottieShaper.cpp:std::__1::enable_if<!(false), void>::type SkTArray<skottie::(anonymous namespace)::BlobMaker::RunRec, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<hb_feature_t, false>::move<false>(void*) SkShaper_harfbuzz.cpp:std::__1::enable_if<!(false), void>::type SkTArray<(anonymous namespace)::ShapedRun, false>::move<false>(void*) Line | Count | Source | 518 | 29.7k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 768k | for (int i = 0; i < this->count(); ++i) { | 520 | 739k | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 739k | fItemArray[i].~T(); | 522 | 739k | } | 523 | 29.7k | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<GrRecordingContext::ProgramData, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<skia::textlayout::Run, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<skia::textlayout::CodeUnitFlags, false>::move<false>(void*) Line | Count | Source | 518 | 4.02k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 4.02k | for (int i = 0; i < this->count(); ++i) { | 520 | 0 | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 0 | fItemArray[i].~T(); | 522 | 0 | } | 523 | 4.02k | } |
Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<skia::textlayout::TextLine, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<skia::textlayout::ResolvedFontDescriptor, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkShaper::Feature, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkTArray<SkPDFTagNode*, false>, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkPDFTagNode*, false>::move<false>(void*) Unexecuted instantiation: std::__1::enable_if<!(false), void>::type SkTArray<SkPDFTagNode::MarkedContentInfo, false>::move<false>(void*) std::__1::enable_if<!(false), void>::type SkTArray<SkSVGDevice::ClipRec, false>::move<false>(void*) Line | Count | Source | 518 | 2.64k | template <bool E = MEM_MOVE> std::enable_if_t<!E, void> move(void* dst) { | 519 | 19.0k | for (int i = 0; i < this->count(); ++i) { | 520 | 16.3k | new (static_cast<char*>(dst) + sizeof(T) * (size_t)i) T(std::move(fItemArray[i])); | 521 | 16.3k | fItemArray[i].~T(); | 522 | 16.3k | } | 523 | 2.64k | } |
|
524 | | |
525 | | static constexpr int kMinHeapAllocCount = 8; |
526 | | |
527 | | // Helper function that makes space for n objects, adjusts the count, but does not initialize |
528 | | // the new objects. |
529 | 247M | void* push_back_raw(int n) { |
530 | 247M | this->checkRealloc(n, kGrowing); |
531 | 247M | void* ptr = fItemArray + fCount; |
532 | 247M | fCount += n; |
533 | 247M | return ptr; |
534 | 247M | } SkTArray<SkString, false>::push_back_raw(int) Line | Count | Source | 529 | 20 | void* push_back_raw(int n) { | 530 | 20 | this->checkRealloc(n, kGrowing); | 531 | 20 | void* ptr = fItemArray + fCount; | 532 | 20 | fCount += n; | 533 | 20 | return ptr; | 534 | 20 | } |
SkTArray<SkNoPixelsDevice::ClipState, false>::push_back_raw(int) Line | Count | Source | 529 | 600k | void* push_back_raw(int n) { | 530 | 600k | this->checkRealloc(n, kGrowing); | 531 | 600k | void* ptr = fItemArray + fCount; | 532 | 600k | fCount += n; | 533 | 600k | return ptr; | 534 | 600k | } |
Unexecuted instantiation: SkTArray<GrUniqueKey, false>::push_back_raw(int) SkTArray<unsigned int, true>::push_back_raw(int) Line | Count | Source | 529 | 100k | void* push_back_raw(int n) { | 530 | 100k | this->checkRealloc(n, kGrowing); | 531 | 100k | void* ptr = fItemArray + fCount; | 532 | 100k | fCount += n; | 533 | 100k | return ptr; | 534 | 100k | } |
Unexecuted instantiation: SkTArray<GrFragmentProcessor::ProgramImpl*, true>::push_back_raw(int) SkTArray<sk_gpu_test::GrContextFactory::Context, true>::push_back_raw(int) Line | Count | Source | 529 | 1.32k | void* push_back_raw(int n) { | 530 | 1.32k | this->checkRealloc(n, kGrowing); | 531 | 1.32k | void* ptr = fItemArray + fCount; | 532 | 1.32k | fCount += n; | 533 | 1.32k | return ptr; | 534 | 1.32k | } |
Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::push_back_raw(int) SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::push_back_raw(int) Line | Count | Source | 529 | 516 | void* push_back_raw(int n) { | 530 | 516 | this->checkRealloc(n, kGrowing); | 531 | 516 | void* ptr = fItemArray + fCount; | 532 | 516 | fCount += n; | 533 | 516 | return ptr; | 534 | 516 | } |
SkTArray<unsigned short, false>::push_back_raw(int) Line | Count | Source | 529 | 444 | void* push_back_raw(int n) { | 530 | 444 | this->checkRealloc(n, kGrowing); | 531 | 444 | void* ptr = fItemArray + fCount; | 532 | 444 | fCount += n; | 533 | 444 | return ptr; | 534 | 444 | } |
SkTArray<SkPoint, false>::push_back_raw(int) Line | Count | Source | 529 | 444 | void* push_back_raw(int n) { | 530 | 444 | this->checkRealloc(n, kGrowing); | 531 | 444 | void* ptr = fItemArray + fCount; | 532 | 444 | fCount += n; | 533 | 444 | return ptr; | 534 | 444 | } |
SkTArray<GrSurfaceProxy*, true>::push_back_raw(int) Line | Count | Source | 529 | 188k | void* push_back_raw(int n) { | 530 | 188k | this->checkRealloc(n, kGrowing); | 531 | 188k | void* ptr = fItemArray + fCount; | 532 | 188k | fCount += n; | 533 | 188k | return ptr; | 534 | 188k | } |
SkTArray<sk_sp<SkImageFilter>, true>::push_back_raw(int) Line | Count | Source | 529 | 26.8k | void* push_back_raw(int n) { | 530 | 26.8k | this->checkRealloc(n, kGrowing); | 531 | 26.8k | void* ptr = fItemArray + fCount; | 532 | 26.8k | fCount += n; | 533 | 26.8k | return ptr; | 534 | 26.8k | } |
Unexecuted instantiation: SkTArray<SkCanvas::Lattice::RectType, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<unsigned int, false>::push_back_raw(int) SkTArray<SkRuntimeEffect::ChildPtr, false>::push_back_raw(int) Line | Count | Source | 529 | 8.09k | void* push_back_raw(int n) { | 530 | 8.09k | this->checkRealloc(n, kGrowing); | 531 | 8.09k | void* ptr = fItemArray + fCount; | 532 | 8.09k | fCount += n; | 533 | 8.09k | return ptr; | 534 | 8.09k | } |
SkTArray<SkRGBA4f<(SkAlphaType)2>, true>::push_back_raw(int) Line | Count | Source | 529 | 7.63k | void* push_back_raw(int n) { | 530 | 7.63k | this->checkRealloc(n, kGrowing); | 531 | 7.63k | void* ptr = fItemArray + fCount; | 532 | 7.63k | fCount += n; | 533 | 7.63k | return ptr; | 534 | 7.63k | } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<int, false>::push_back_raw(int) SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::push_back_raw(int) Line | Count | Source | 529 | 9.50M | void* push_back_raw(int n) { | 530 | 9.50M | this->checkRealloc(n, kGrowing); | 531 | 9.50M | void* ptr = fItemArray + fCount; | 532 | 9.50M | fCount += n; | 533 | 9.50M | return ptr; | 534 | 9.50M | } |
SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::push_back_raw(int) Line | Count | Source | 529 | 7.52M | void* push_back_raw(int n) { | 530 | 7.52M | this->checkRealloc(n, kGrowing); | 531 | 7.52M | void* ptr = fItemArray + fCount; | 532 | 7.52M | fCount += n; | 533 | 7.52M | return ptr; | 534 | 7.52M | } |
SkTArray<SkSL::Parser::Checkpoint::ForwardingErrorReporter::Error, false>::push_back_raw(int) Line | Count | Source | 529 | 16.5k | void* push_back_raw(int n) { | 530 | 16.5k | this->checkRealloc(n, kGrowing); | 531 | 16.5k | void* ptr = fItemArray + fCount; | 532 | 16.5k | fCount += n; | 533 | 16.5k | return ptr; | 534 | 16.5k | } |
SkTArray<signed char, false>::push_back_raw(int) Line | Count | Source | 529 | 15.0M | void* push_back_raw(int n) { | 530 | 15.0M | this->checkRealloc(n, kGrowing); | 531 | 15.0M | void* ptr = fItemArray + fCount; | 532 | 15.0M | fCount += n; | 533 | 15.0M | return ptr; | 534 | 15.0M | } |
SkTArray<unsigned long, true>::push_back_raw(int) Line | Count | Source | 529 | 261k | void* push_back_raw(int n) { | 530 | 261k | this->checkRealloc(n, kGrowing); | 531 | 261k | void* ptr = fItemArray + fCount; | 532 | 261k | fCount += n; | 533 | 261k | return ptr; | 534 | 261k | } |
SkTArray<int, true>::push_back_raw(int) Line | Count | Source | 529 | 110M | void* push_back_raw(int n) { | 530 | 110M | this->checkRealloc(n, kGrowing); | 531 | 110M | void* ptr = fItemArray + fCount; | 532 | 110M | fCount += n; | 533 | 110M | return ptr; | 534 | 110M | } |
Unexecuted instantiation: SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::push_back_raw(int) SkTArray<SkSL::Type const*, false>::push_back_raw(int) Line | Count | Source | 529 | 252k | void* push_back_raw(int n) { | 530 | 252k | this->checkRealloc(n, kGrowing); | 531 | 252k | void* ptr = fItemArray + fCount; | 532 | 252k | fCount += n; | 533 | 252k | return ptr; | 534 | 252k | } |
SkSLSwizzle.cpp:SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::push_back_raw(int) Line | Count | Source | 529 | 389k | void* push_back_raw(int n) { | 530 | 389k | this->checkRealloc(n, kGrowing); | 531 | 389k | void* ptr = fItemArray + fCount; | 532 | 389k | fCount += n; | 533 | 389k | return ptr; | 534 | 389k | } |
Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::push_back_raw(int) Unexecuted instantiation: SkTArray<bool, true>::push_back_raw(int) SkTArray<sk_sp<GrRenderTask>, false>::push_back_raw(int) Line | Count | Source | 529 | 100k | void* push_back_raw(int n) { | 530 | 100k | this->checkRealloc(n, kGrowing); | 531 | 100k | void* ptr = fItemArray + fCount; | 532 | 100k | fCount += n; | 533 | 100k | return ptr; | 534 | 100k | } |
SkTArray<GrOnFlushCallbackObject*, false>::push_back_raw(int) Line | Count | Source | 529 | 1.36k | void* push_back_raw(int n) { | 530 | 1.36k | this->checkRealloc(n, kGrowing); | 531 | 1.36k | void* ptr = fItemArray + fCount; | 532 | 1.36k | fCount += n; | 533 | 1.36k | return ptr; | 534 | 1.36k | } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::push_back_raw(int) SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::push_back_raw(int) Line | Count | Source | 529 | 554k | void* push_back_raw(int n) { | 530 | 554k | this->checkRealloc(n, kGrowing); | 531 | 554k | void* ptr = fItemArray + fCount; | 532 | 554k | fCount += n; | 533 | 554k | return ptr; | 534 | 554k | } |
Unexecuted instantiation: SkTArray<GrGpu::SubmittedProc, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<double, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<SkSL::String, false>::push_back_raw(int) SkTArray<GrRenderTask*, true>::push_back_raw(int) Line | Count | Source | 529 | 194k | void* push_back_raw(int n) { | 530 | 194k | this->checkRealloc(n, kGrowing); | 531 | 194k | void* ptr = fItemArray + fCount; | 532 | 194k | fCount += n; | 533 | 194k | return ptr; | 534 | 194k | } |
Unexecuted instantiation: SkTArray<GrTextureProxy*, true>::push_back_raw(int) SkTArray<sk_sp<GrSurfaceProxy>, false>::push_back_raw(int) Line | Count | Source | 529 | 100k | void* push_back_raw(int n) { | 530 | 100k | this->checkRealloc(n, kGrowing); | 531 | 100k | void* ptr = fItemArray + fCount; | 532 | 100k | fCount += n; | 533 | 100k | return ptr; | 534 | 100k | } |
Unexecuted instantiation: SkTArray<GrTextureResolveRenderTask::Resolve, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::push_back_raw(int) SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::push_back_raw(int) Line | Count | Source | 529 | 531 | void* push_back_raw(int n) { | 530 | 531 | this->checkRealloc(n, kGrowing); | 531 | 531 | void* ptr = fItemArray + fCount; | 532 | 531 | fCount += n; | 533 | 531 | return ptr; | 534 | 531 | } |
SkTArray<sk_sp<GrTextBlob>, false>::push_back_raw(int) Line | Count | Source | 529 | 531 | void* push_back_raw(int n) { | 530 | 531 | this->checkRealloc(n, kGrowing); | 531 | 531 | void* ptr = fItemArray + fCount; | 532 | 531 | fCount += n; | 533 | 531 | return ptr; | 534 | 531 | } |
SkTArray<GrUniqueKeyInvalidatedMessage, false>::push_back_raw(int) Line | Count | Source | 529 | 59.0k | void* push_back_raw(int n) { | 530 | 59.0k | this->checkRealloc(n, kGrowing); | 531 | 59.0k | void* ptr = fItemArray + fCount; | 532 | 59.0k | fCount += n; | 533 | 59.0k | return ptr; | 534 | 59.0k | } |
Unexecuted instantiation: SkTArray<GrTextureFreedMessage, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::push_back_raw(int) Unexecuted instantiation: SkTArray<GrAuditTrail::Op*, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::push_back_raw(int) Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo::Op, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo, false>::push_back_raw(int) SkTArray<GrOpsTask::OpChain, false>::push_back_raw(int) Line | Count | Source | 529 | 119k | void* push_back_raw(int n) { | 530 | 119k | this->checkRealloc(n, kGrowing); | 531 | 119k | void* ptr = fItemArray + fCount; | 532 | 119k | fCount += n; | 533 | 119k | return ptr; | 534 | 119k | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAConvexPathOp::PathData, true>::push_back_raw(int) Line | Count | Source | 529 | 646 | void* push_back_raw(int n) { | 530 | 646 | this->checkRealloc(n, kGrowing); | 531 | 646 | void* ptr = fItemArray + fCount; | 532 | 646 | fCount += n; | 533 | 646 | return ptr; | 534 | 646 | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Segment, true>::push_back_raw(int) Line | Count | Source | 529 | 19.3k | void* push_back_raw(int n) { | 530 | 19.3k | this->checkRealloc(n, kGrowing); | 531 | 19.3k | void* ptr = fItemArray + fCount; | 532 | 19.3k | fCount += n; | 533 | 19.3k | return ptr; | 534 | 19.3k | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Draw, true>::push_back_raw(int) Line | Count | Source | 529 | 332 | void* push_back_raw(int n) { | 530 | 332 | this->checkRealloc(n, kGrowing); | 531 | 332 | void* ptr = fItemArray + fCount; | 532 | 332 | fCount += n; | 533 | 332 | return ptr; | 534 | 332 | } |
AAHairLinePathRenderer.cpp:SkTArray<(anonymous namespace)::AAHairlineOp::PathData, true>::push_back_raw(int) Line | Count | Source | 529 | 3.64k | void* push_back_raw(int n) { | 530 | 3.64k | this->checkRealloc(n, kGrowing); | 531 | 3.64k | void* ptr = fItemArray + fCount; | 532 | 3.64k | fCount += n; | 533 | 3.64k | return ptr; | 534 | 3.64k | } |
SkTArray<SkPoint, true>::push_back_raw(int) Line | Count | Source | 529 | 635k | void* push_back_raw(int n) { | 530 | 635k | this->checkRealloc(n, kGrowing); | 531 | 635k | void* ptr = fItemArray + fCount; | 532 | 635k | fCount += n; | 533 | 635k | return ptr; | 534 | 635k | } |
SkTArray<float, true>::push_back_raw(int) Line | Count | Source | 529 | 30.2k | void* push_back_raw(int n) { | 530 | 30.2k | this->checkRealloc(n, kGrowing); | 531 | 30.2k | void* ptr = fItemArray + fCount; | 532 | 30.2k | fCount += n; | 533 | 30.2k | return ptr; | 534 | 30.2k | } |
AALinearizingConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::push_back_raw(int) Line | Count | Source | 529 | 574 | void* push_back_raw(int n) { | 530 | 574 | this->checkRealloc(n, kGrowing); | 531 | 574 | void* ptr = fItemArray + fCount; | 532 | 574 | fCount += n; | 533 | 574 | return ptr; | 534 | 574 | } |
DefaultPathRenderer.cpp:SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::push_back_raw(int) Line | Count | Source | 529 | 9.24k | void* push_back_raw(int n) { | 530 | 9.24k | this->checkRealloc(n, kGrowing); | 531 | 9.24k | void* ptr = fItemArray + fCount; | 532 | 9.24k | fCount += n; | 533 | 9.24k | return ptr; | 534 | 9.24k | } |
SkTArray<DashOp::LineData, true>::push_back_raw(int) Line | Count | Source | 529 | 1 | void* push_back_raw(int n) { | 530 | 1 | this->checkRealloc(n, kGrowing); | 531 | 1 | void* ptr = fItemArray + fCount; | 532 | 1 | fCount += n; | 533 | 1 | return ptr; | 534 | 1 | } |
SkTArray<SkRect, true>::push_back_raw(int) Line | Count | Source | 529 | 1 | void* push_back_raw(int n) { | 530 | 1 | this->checkRealloc(n, kGrowing); | 531 | 1 | void* ptr = fItemArray + fCount; | 532 | 1 | fCount += n; | 533 | 1 | return ptr; | 534 | 1 | } |
SkTArray<DashOp::DashDraw, true>::push_back_raw(int) Line | Count | Source | 529 | 1 | void* push_back_raw(int n) { | 530 | 1 | this->checkRealloc(n, kGrowing); | 531 | 1 | void* ptr = fItemArray + fCount; | 532 | 1 | fCount += n; | 533 | 1 | return ptr; | 534 | 1 | } |
Unexecuted instantiation: SkTArray<SkRSXform, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<SkRect, false>::push_back_raw(int) Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::push_back_raw(int) GrDrawVerticesOp.cpp:SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::push_back_raw(int) Line | Count | Source | 529 | 1.85k | void* push_back_raw(int n) { | 530 | 1.85k | this->checkRealloc(n, kGrowing); | 531 | 1.85k | void* ptr = fItemArray + fCount; | 532 | 1.85k | fCount += n; | 533 | 1.85k | return ptr; | 534 | 1.85k | } |
Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::push_back_raw(int) SkTArray<CircularRRectOp::RRect, true>::push_back_raw(int) Line | Count | Source | 529 | 5 | void* push_back_raw(int n) { | 530 | 5 | this->checkRealloc(n, kGrowing); | 531 | 5 | void* ptr = fItemArray + fCount; | 532 | 5 | fCount += n; | 533 | 5 | return ptr; | 534 | 5 | } |
SkTArray<EllipticalRRectOp::RRect, true>::push_back_raw(int) Line | Count | Source | 529 | 2 | void* push_back_raw(int n) { | 530 | 2 | this->checkRealloc(n, kGrowing); | 531 | 2 | void* ptr = fItemArray + fCount; | 532 | 2 | fCount += n; | 533 | 2 | return ptr; | 534 | 2 | } |
Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::push_back_raw(int) SkTArray<CircleOp::Circle, true>::push_back_raw(int) Line | Count | Source | 529 | 14 | void* push_back_raw(int n) { | 530 | 14 | this->checkRealloc(n, kGrowing); | 531 | 14 | void* ptr = fItemArray + fCount; | 532 | 14 | fCount += n; | 533 | 14 | return ptr; | 534 | 14 | } |
Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::push_back_raw(int) SkTArray<DIEllipseOp::Ellipse, true>::push_back_raw(int) Line | Count | Source | 529 | 7 | void* push_back_raw(int n) { | 530 | 7 | this->checkRealloc(n, kGrowing); | 531 | 7 | void* ptr = fItemArray + fCount; | 532 | 7 | fCount += n; | 533 | 7 | return ptr; | 534 | 7 | } |
Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::push_back_raw(int) Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::push_back_raw(int) GrStrokeRectOp.cpp:SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::push_back_raw(int) Line | Count | Source | 529 | 208 | void* push_back_raw(int n) { | 530 | 208 | this->checkRealloc(n, kGrowing); | 531 | 208 | void* ptr = fItemArray + fCount; | 532 | 208 | fCount += n; | 533 | 208 | return ptr; | 534 | 208 | } |
SmallPathRenderer.cpp:SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::push_back_raw(int) Line | Count | Source | 529 | 2.96k | void* push_back_raw(int n) { | 530 | 2.96k | this->checkRealloc(n, kGrowing); | 531 | 2.96k | void* ptr = fItemArray + fCount; | 532 | 2.96k | fCount += n; | 533 | 2.96k | return ptr; | 534 | 2.96k | } |
SkTArray<sk_sp<skgpu::v1::PathRenderer>, false>::push_back_raw(int) Line | Count | Source | 529 | 4.71k | void* push_back_raw(int n) { | 530 | 4.71k | this->checkRealloc(n, kGrowing); | 531 | 4.71k | void* ptr = fItemArray + fCount; | 532 | 4.71k | fCount += n; | 533 | 4.71k | return ptr; | 534 | 4.71k | } |
SkTArray<SkSL::VariableReference*, false>::push_back_raw(int) Line | Count | Source | 529 | 38.9k | void* push_back_raw(int n) { | 530 | 38.9k | this->checkRealloc(n, kGrowing); | 531 | 38.9k | void* ptr = fItemArray + fCount; | 532 | 38.9k | fCount += n; | 533 | 38.9k | return ptr; | 534 | 38.9k | } |
Unexecuted instantiation: SkTArray<GrMipLevel, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<GrGLProgramDataManager::Uniform, true>::push_back_raw(int) SkTArray<__jmp_buf_tag (*) [1], false>::push_back_raw(int) Line | Count | Source | 529 | 104k | void* push_back_raw(int n) { | 530 | 104k | this->checkRealloc(n, kGrowing); | 531 | 104k | void* ptr = fItemArray + fCount; | 532 | 104k | fCount += n; | 533 | 104k | return ptr; | 534 | 104k | } |
SkTArray<unsigned long, false>::push_back_raw(int) Line | Count | Source | 529 | 3.78k | void* push_back_raw(int n) { | 530 | 3.78k | this->checkRealloc(n, kGrowing); | 531 | 3.78k | void* ptr = fItemArray + fCount; | 532 | 3.78k | fCount += n; | 533 | 3.78k | return ptr; | 534 | 3.78k | } |
SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::push_back_raw(int) Line | Count | Source | 529 | 1.86k | void* push_back_raw(int n) { | 530 | 1.86k | this->checkRealloc(n, kGrowing); | 531 | 1.86k | void* ptr = fItemArray + fCount; | 532 | 1.86k | fCount += n; | 533 | 1.86k | return ptr; | 534 | 1.86k | } |
Unexecuted instantiation: SkTArray<sk_sp<SkPicture const>, false>::push_back_raw(int) SkTArray<SkPaint, false>::push_back_raw(int) Line | Count | Source | 529 | 20.3k | void* push_back_raw(int n) { | 530 | 20.3k | this->checkRealloc(n, kGrowing); | 531 | 20.3k | void* ptr = fItemArray + fCount; | 532 | 20.3k | fCount += n; | 533 | 20.3k | return ptr; | 534 | 20.3k | } |
SkTArray<SkPath, false>::push_back_raw(int) Line | Count | Source | 529 | 716k | void* push_back_raw(int n) { | 530 | 716k | this->checkRealloc(n, kGrowing); | 531 | 716k | void* ptr = fItemArray + fCount; | 532 | 716k | fCount += n; | 533 | 716k | return ptr; | 534 | 716k | } |
SkTArray<sk_sp<SkTextBlob const>, false>::push_back_raw(int) Line | Count | Source | 529 | 706 | void* push_back_raw(int n) { | 530 | 706 | this->checkRealloc(n, kGrowing); | 531 | 706 | void* ptr = fItemArray + fCount; | 532 | 706 | fCount += n; | 533 | 706 | return ptr; | 534 | 706 | } |
SkTArray<sk_sp<SkVertices const>, false>::push_back_raw(int) Line | Count | Source | 529 | 1.64k | void* push_back_raw(int n) { | 530 | 1.64k | this->checkRealloc(n, kGrowing); | 531 | 1.64k | void* ptr = fItemArray + fCount; | 532 | 1.64k | fCount += n; | 533 | 1.64k | return ptr; | 534 | 1.64k | } |
SkTArray<sk_sp<SkImage const>, false>::push_back_raw(int) Line | Count | Source | 529 | 21.7k | void* push_back_raw(int n) { | 530 | 21.7k | this->checkRealloc(n, kGrowing); | 531 | 21.7k | void* ptr = fItemArray + fCount; | 532 | 21.7k | fCount += n; | 533 | 21.7k | return ptr; | 534 | 21.7k | } |
Unexecuted instantiation: SkTArray<sk_sp<SkDrawable>, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<SkMatrix, false>::push_back_raw(int) SkTArray<OffsetEdge, false>::push_back_raw(int) Line | Count | Source | 529 | 21.9k | void* push_back_raw(int n) { | 530 | 21.9k | this->checkRealloc(n, kGrowing); | 531 | 21.9k | void* ptr = fItemArray + fCount; | 532 | 21.9k | fCount += n; | 533 | 21.9k | return ptr; | 534 | 21.9k | } |
SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::push_back_raw(int) Line | Count | Source | 529 | 270k | void* push_back_raw(int n) { | 530 | 270k | this->checkRealloc(n, kGrowing); | 531 | 270k | void* ptr = fItemArray + fCount; | 532 | 270k | fCount += n; | 533 | 270k | return ptr; | 534 | 270k | } |
SkTArray<GrBufferAllocPool::BufferBlock, false>::push_back_raw(int) Line | Count | Source | 529 | 3.30k | void* push_back_raw(int n) { | 530 | 3.30k | this->checkRealloc(n, kGrowing); | 531 | 3.30k | void* ptr = fItemArray + fCount; | 532 | 3.30k | fCount += n; | 533 | 3.30k | return ptr; | 534 | 3.30k | } |
Unexecuted instantiation: SkTArray<PathSegment, true>::push_back_raw(int) Unexecuted instantiation: SkTArray<GrDrawOpAtlas::Plot*, false>::push_back_raw(int) SkTArray<GrXPFactoryTestFactory*, true>::push_back_raw(int) Line | Count | Source | 529 | 304 | void* push_back_raw(int n) { | 530 | 304 | this->checkRealloc(n, kGrowing); | 531 | 304 | void* ptr = fItemArray + fCount; | 532 | 304 | fCount += n; | 533 | 304 | return ptr; | 534 | 304 | } |
SkTArray<GrProcessorTestFactory<GrGeometryProcessor*>*, true>::push_back_raw(int) Line | Count | Source | 529 | 1.06k | void* push_back_raw(int n) { | 530 | 1.06k | this->checkRealloc(n, kGrowing); | 531 | 1.06k | void* ptr = fItemArray + fCount; | 532 | 1.06k | fCount += n; | 533 | 1.06k | return ptr; | 534 | 1.06k | } |
SkTArray<GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*, true>::push_back_raw(int) Line | Count | Source | 529 | 1.14k | void* push_back_raw(int n) { | 530 | 1.14k | this->checkRealloc(n, kGrowing); | 531 | 1.14k | void* ptr = fItemArray + fCount; | 532 | 1.14k | fCount += n; | 533 | 1.14k | return ptr; | 534 | 1.14k | } |
Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<skgpu::v1::ClipStack::Element, false>::push_back_raw(int) SkTArray<skgpu::v1::ClipStack::Element const*, false>::push_back_raw(int) Line | Count | Source | 529 | 10.3k | void* push_back_raw(int n) { | 530 | 10.3k | this->checkRealloc(n, kGrowing); | 531 | 10.3k | void* ptr = fItemArray + fCount; | 532 | 10.3k | fCount += n; | 533 | 10.3k | return ptr; | 534 | 10.3k | } |
Unexecuted instantiation: SkTArray<GrGLFormat, true>::push_back_raw(int) Unexecuted instantiation: SkTArray<GrSwizzle, false>::push_back_raw(int) SkTArray<std::__1::unique_ptr<SkCodec, std::__1::default_delete<SkCodec> >, true>::push_back_raw(int) Line | Count | Source | 529 | 2.74k | void* push_back_raw(int n) { | 530 | 2.74k | this->checkRealloc(n, kGrowing); | 531 | 2.74k | void* ptr = fItemArray + fCount; | 532 | 2.74k | fCount += n; | 533 | 2.74k | return ptr; | 534 | 2.74k | } |
Unexecuted instantiation: SkTArray<dng_exception, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<std::__1::thread, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<std::__1::function<void ()>, false>::push_back_raw(int) SkTArray<SkOpRayHit*, false>::push_back_raw(int) Line | Count | Source | 529 | 33.5M | void* push_back_raw(int n) { | 530 | 33.5M | this->checkRealloc(n, kGrowing); | 531 | 33.5M | void* ptr = fItemArray + fCount; | 532 | 33.5M | fCount += n; | 533 | 33.5M | return ptr; | 534 | 33.5M | } |
SkTArray<double, true>::push_back_raw(int) Line | Count | Source | 529 | 51.9M | void* push_back_raw(int n) { | 530 | 51.9M | this->checkRealloc(n, kGrowing); | 531 | 51.9M | void* ptr = fItemArray + fCount; | 532 | 51.9M | fCount += n; | 533 | 51.9M | return ptr; | 534 | 51.9M | } |
SkTArray<Sk4fGradientInterval, true>::push_back_raw(int) Line | Count | Source | 529 | 8.47k | void* push_back_raw(int n) { | 530 | 8.47k | this->checkRealloc(n, kGrowing); | 531 | 8.47k | void* ptr = fItemArray + fCount; | 532 | 8.47k | fCount += n; | 533 | 8.47k | return ptr; | 534 | 8.47k | } |
SkTArray<sk_sp<SkFontStyleSet_Custom>, false>::push_back_raw(int) Line | Count | Source | 529 | 5 | void* push_back_raw(int n) { | 530 | 5 | this->checkRealloc(n, kGrowing); | 531 | 5 | void* ptr = fItemArray + fCount; | 532 | 5 | fCount += n; | 533 | 5 | return ptr; | 534 | 5 | } |
Unexecuted instantiation: SkTArray<GrProgramInfo const*, false>::push_back_raw(int) SkTArray<sk_sp<SkTypeface_Custom>, false>::push_back_raw(int) Line | Count | Source | 529 | 5 | void* push_back_raw(int n) { | 530 | 5 | this->checkRealloc(n, kGrowing); | 531 | 5 | void* ptr = fItemArray + fCount; | 532 | 5 | fCount += n; | 533 | 5 | return ptr; | 534 | 5 | } |
SkTArray<SkClosestRecord, true>::push_back_raw(int) Line | Count | Source | 529 | 5.21M | void* push_back_raw(int n) { | 530 | 5.21M | this->checkRealloc(n, kGrowing); | 531 | 5.21M | void* ptr = fItemArray + fCount; | 532 | 5.21M | fCount += n; | 533 | 5.21M | return ptr; | 534 | 5.21M | } |
SkTArray<SkClosestRecord const*, true>::push_back_raw(int) Line | Count | Source | 529 | 2.95M | void* push_back_raw(int n) { | 530 | 2.95M | this->checkRealloc(n, kGrowing); | 531 | 2.95M | void* ptr = fItemArray + fCount; | 532 | 2.95M | fCount += n; | 533 | 2.95M | return ptr; | 534 | 2.95M | } |
Unexecuted instantiation: SkTArray<std::__1::array<unsigned short, 3ul>, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<GrVertexChunk, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<sk_sp<ToolUtils::TopoTestNode>, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfLayerInfo, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfInfo, false>::push_back_raw(int) Layer.cpp:SkTArray<skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::push_back_raw(int) Line | Count | Source | 529 | 8.61k | void* push_back_raw(int n) { | 530 | 8.61k | this->checkRealloc(n, kGrowing); | 531 | 8.61k | void* ptr = fItemArray + fCount; | 532 | 8.61k | fCount += n; | 533 | 8.61k | return ptr; | 534 | 8.61k | } |
Unexecuted instantiation: SkottieShaper.cpp:SkTArray<skottie::(anonymous namespace)::BlobMaker::RunRec, false>::push_back_raw(int) SkTArray<SkSVGTextContext::PositionAdjustment, true>::push_back_raw(int) Line | Count | Source | 529 | 4.81M | void* push_back_raw(int n) { | 530 | 4.81M | this->checkRealloc(n, kGrowing); | 531 | 4.81M | void* ptr = fItemArray + fCount; | 532 | 4.81M | fCount += n; | 533 | 4.81M | return ptr; | 534 | 4.81M | } |
SkTArray<sk_sp<SkSVGNode>, true>::push_back_raw(int) Line | Count | Source | 529 | 293k | void* push_back_raw(int n) { | 530 | 293k | this->checkRealloc(n, kGrowing); | 531 | 293k | void* ptr = fItemArray + fCount; | 532 | 293k | fCount += n; | 533 | 293k | return ptr; | 534 | 293k | } |
Unexecuted instantiation: SkTArray<hb_feature_t, false>::push_back_raw(int) SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::push_back_raw(int) Line | Count | Source | 529 | 418k | void* push_back_raw(int n) { | 530 | 418k | this->checkRealloc(n, kGrowing); | 531 | 418k | void* ptr = fItemArray + fCount; | 532 | 418k | fCount += n; | 533 | 418k | return ptr; | 534 | 418k | } |
Unexecuted instantiation: SkTArray<GrRecordingContext::ProgramData, false>::push_back_raw(int) SkTArray<skia::textlayout::Block, true>::push_back_raw(int) Line | Count | Source | 529 | 12.9k | void* push_back_raw(int n) { | 530 | 12.9k | this->checkRealloc(n, kGrowing); | 531 | 12.9k | void* ptr = fItemArray + fCount; | 532 | 12.9k | fCount += n; | 533 | 12.9k | return ptr; | 534 | 12.9k | } |
SkTArray<skia::textlayout::Placeholder, true>::push_back_raw(int) Line | Count | Source | 529 | 4.02k | void* push_back_raw(int n) { | 530 | 4.02k | this->checkRealloc(n, kGrowing); | 531 | 4.02k | void* ptr = fItemArray + fCount; | 532 | 4.02k | fCount += n; | 533 | 4.02k | return ptr; | 534 | 4.02k | } |
SkTArray<skia::textlayout::CodeUnitFlags, false>::push_back_raw(int) Line | Count | Source | 529 | 4.02k | void* push_back_raw(int n) { | 530 | 4.02k | this->checkRealloc(n, kGrowing); | 531 | 4.02k | void* ptr = fItemArray + fCount; | 532 | 4.02k | fCount += n; | 533 | 4.02k | return ptr; | 534 | 4.02k | } |
SkTArray<skia::textlayout::Cluster, true>::push_back_raw(int) Line | Count | Source | 529 | 3.78k | void* push_back_raw(int n) { | 530 | 3.78k | this->checkRealloc(n, kGrowing); | 531 | 3.78k | void* ptr = fItemArray + fCount; | 532 | 3.78k | fCount += n; | 533 | 3.78k | return ptr; | 534 | 3.78k | } |
Unexecuted instantiation: SkTArray<skia::textlayout::TextLine, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<unsigned short, true>::push_back_raw(int) Unexecuted instantiation: SkTArray<float, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<SkShaper::Feature, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<skia::textlayout::ResolvedFontDescriptor, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<skia::textlayout::Run, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<SkTArray<SkPDFTagNode*, false>, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<SkPDFTagNode::MarkedContentInfo, false>::push_back_raw(int) Unexecuted instantiation: SkTArray<SkPDFTagNode*, false>::push_back_raw(int) SkTArray<SkSVGDevice::ClipRec, false>::push_back_raw(int) Line | Count | Source | 529 | 7.86k | void* push_back_raw(int n) { | 530 | 7.86k | this->checkRealloc(n, kGrowing); | 531 | 7.86k | void* ptr = fItemArray + fCount; | 532 | 7.86k | fCount += n; | 533 | 7.86k | return ptr; | 534 | 7.86k | } |
|
535 | | |
536 | 315M | void checkRealloc(int delta, ReallocType reallocType) { |
537 | 315M | SkASSERT(fCount >= 0); |
538 | 315M | SkASSERT(fAllocCount >= 0); |
539 | 315M | SkASSERT(-delta <= this->count()); |
540 | | |
541 | | // Move into 64bit math temporarily, to avoid local overflows |
542 | 315M | int64_t newCount = fCount + delta; |
543 | | |
544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink |
545 | | // when we're currently using preallocated memory, would allocate less than |
546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. |
547 | 315M | bool mustGrow = newCount > fAllocCount; |
548 | 315M | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; |
549 | 315M | if (!mustGrow && !shouldShrink) { |
550 | 303M | return; |
551 | 303M | } |
552 | | |
553 | 11.5M | int64_t newAllocCount = newCount; |
554 | 11.5M | if (reallocType != kExactFit) { |
555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. |
556 | 5.95M | newAllocCount += ((newCount + 1) >> 1); |
557 | | // Align the new allocation count to kMinHeapAllocCount. |
558 | 5.95M | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); |
559 | 5.95M | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); |
560 | 5.95M | } |
561 | | |
562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. |
563 | 11.5M | if (newAllocCount == fAllocCount) { |
564 | 237k | return; |
565 | 237k | } |
566 | | |
567 | 11.3M | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); |
568 | 11.3M | SkASSERT(fAllocCount >= newCount); |
569 | 11.3M | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); |
570 | 11.3M | this->move(newItemArray); |
571 | 11.3M | if (fOwnMemory) { |
572 | 2.60M | sk_free(fItemArray); |
573 | 2.60M | } |
574 | 11.3M | fItemArray = newItemArray; |
575 | 11.3M | fOwnMemory = true; |
576 | 11.3M | fReserved = false; |
577 | 11.3M | } SkTArray<SkString, false>::checkRealloc(int, SkTArray<SkString, false>::ReallocType) Line | Count | Source | 536 | 40 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 40 | SkASSERT(fCount >= 0); | 538 | 40 | SkASSERT(fAllocCount >= 0); | 539 | 40 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 40 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 40 | bool mustGrow = newCount > fAllocCount; | 548 | 40 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 40 | if (!mustGrow && !shouldShrink) { | 550 | 20 | return; | 551 | 20 | } | 552 | | | 553 | 20 | int64_t newAllocCount = newCount; | 554 | 20 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 20 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 20 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 20 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 20 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 20 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 20 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 20 | SkASSERT(fAllocCount >= newCount); | 569 | 20 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 20 | this->move(newItemArray); | 571 | 20 | if (fOwnMemory) { | 572 | 20 | sk_free(fItemArray); | 573 | 20 | } | 574 | 20 | fItemArray = newItemArray; | 575 | 20 | fOwnMemory = true; | 576 | 20 | fReserved = false; | 577 | 20 | } |
SkTArray<SkNoPixelsDevice::ClipState, false>::checkRealloc(int, SkTArray<SkNoPixelsDevice::ClipState, false>::ReallocType) Line | Count | Source | 536 | 1.20M | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 1.20M | SkASSERT(fCount >= 0); | 538 | 1.20M | SkASSERT(fAllocCount >= 0); | 539 | 1.20M | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 1.20M | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 1.20M | bool mustGrow = newCount > fAllocCount; | 548 | 1.20M | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 1.20M | if (!mustGrow && !shouldShrink) { | 550 | 1.18M | return; | 551 | 1.18M | } | 552 | | | 553 | 19.4k | int64_t newAllocCount = newCount; | 554 | 19.4k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 19.4k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 19.4k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 19.4k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 19.4k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 19.4k | if (newAllocCount == fAllocCount) { | 564 | 11.3k | return; | 565 | 11.3k | } | 566 | | | 567 | 8.02k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 8.02k | SkASSERT(fAllocCount >= newCount); | 569 | 8.02k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 8.02k | this->move(newItemArray); | 571 | 8.02k | if (fOwnMemory) { | 572 | 6.25k | sk_free(fItemArray); | 573 | 6.25k | } | 574 | 8.02k | fItemArray = newItemArray; | 575 | 8.02k | fOwnMemory = true; | 576 | 8.02k | fReserved = false; | 577 | 8.02k | } |
Unexecuted instantiation: SkTArray<GrUniqueKey, false>::checkRealloc(int, SkTArray<GrUniqueKey, false>::ReallocType) SkTArray<unsigned int, true>::checkRealloc(int, SkTArray<unsigned int, true>::ReallocType) Line | Count | Source | 536 | 124k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 124k | SkASSERT(fCount >= 0); | 538 | 124k | SkASSERT(fAllocCount >= 0); | 539 | 124k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 124k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 124k | bool mustGrow = newCount > fAllocCount; | 548 | 124k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 124k | if (!mustGrow && !shouldShrink) { | 550 | 122k | return; | 551 | 122k | } | 552 | | | 553 | 1.08k | int64_t newAllocCount = newCount; | 554 | 1.08k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 280 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 280 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 280 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 280 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 1.08k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 1.08k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 1.08k | SkASSERT(fAllocCount >= newCount); | 569 | 1.08k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 1.08k | this->move(newItemArray); | 571 | 1.08k | if (fOwnMemory) { | 572 | 554 | sk_free(fItemArray); | 573 | 554 | } | 574 | 1.08k | fItemArray = newItemArray; | 575 | 1.08k | fOwnMemory = true; | 576 | 1.08k | fReserved = false; | 577 | 1.08k | } |
Unexecuted instantiation: SkTArray<GrFragmentProcessor::ProgramImpl*, true>::checkRealloc(int, SkTArray<GrFragmentProcessor::ProgramImpl*, true>::ReallocType) SkTArray<sk_gpu_test::GrContextFactory::Context, true>::checkRealloc(int, SkTArray<sk_gpu_test::GrContextFactory::Context, true>::ReallocType) Line | Count | Source | 536 | 2.83k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 2.83k | SkASSERT(fCount >= 0); | 538 | 2.83k | SkASSERT(fAllocCount >= 0); | 539 | 2.83k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 2.83k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 2.83k | bool mustGrow = newCount > fAllocCount; | 548 | 2.83k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 2.83k | if (!mustGrow && !shouldShrink) { | 550 | 183 | return; | 551 | 183 | } | 552 | | | 553 | 2.65k | int64_t newAllocCount = newCount; | 554 | 2.65k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 2.65k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 2.65k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 2.65k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 2.65k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 2.65k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 2.65k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 2.65k | SkASSERT(fAllocCount >= newCount); | 569 | 2.65k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 2.65k | this->move(newItemArray); | 571 | 2.65k | if (fOwnMemory) { | 572 | 2.65k | sk_free(fItemArray); | 573 | 2.65k | } | 574 | 2.65k | fItemArray = newItemArray; | 575 | 2.65k | fOwnMemory = true; | 576 | 2.65k | fReserved = false; | 577 | 2.65k | } |
Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::checkRealloc(int, SkTArray<GrGLAttribArrayState::AttribArrayState, true>::ReallocType) SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::checkRealloc(int, SkTArray<GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::ReallocType) Line | Count | Source | 536 | 2.24k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 2.24k | SkASSERT(fCount >= 0); | 538 | 2.24k | SkASSERT(fAllocCount >= 0); | 539 | 2.24k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 2.24k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 2.24k | bool mustGrow = newCount > fAllocCount; | 548 | 2.24k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 2.24k | if (!mustGrow && !shouldShrink) { | 550 | 2.24k | return; | 551 | 2.24k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<unsigned short, false>::checkRealloc(int, SkTArray<unsigned short, false>::ReallocType) Line | Count | Source | 536 | 210k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 210k | SkASSERT(fCount >= 0); | 538 | 210k | SkASSERT(fAllocCount >= 0); | 539 | 210k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 210k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 210k | bool mustGrow = newCount > fAllocCount; | 548 | 210k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 210k | if (!mustGrow && !shouldShrink) { | 550 | 210k | return; | 551 | 210k | } | 552 | | | 553 | 74 | int64_t newAllocCount = newCount; | 554 | 74 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 74 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 74 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 74 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 74 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 74 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 74 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 74 | SkASSERT(fAllocCount >= newCount); | 569 | 74 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 74 | this->move(newItemArray); | 571 | 74 | if (fOwnMemory) { | 572 | 55 | sk_free(fItemArray); | 573 | 55 | } | 574 | 74 | fItemArray = newItemArray; | 575 | 74 | fOwnMemory = true; | 576 | 74 | fReserved = false; | 577 | 74 | } |
SkTArray<SkPoint, false>::checkRealloc(int, SkTArray<SkPoint, false>::ReallocType) Line | Count | Source | 536 | 210k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 210k | SkASSERT(fCount >= 0); | 538 | 210k | SkASSERT(fAllocCount >= 0); | 539 | 210k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 210k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 210k | bool mustGrow = newCount > fAllocCount; | 548 | 210k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 210k | if (!mustGrow && !shouldShrink) { | 550 | 210k | return; | 551 | 210k | } | 552 | | | 553 | 74 | int64_t newAllocCount = newCount; | 554 | 74 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 74 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 74 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 74 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 74 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 74 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 74 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 74 | SkASSERT(fAllocCount >= newCount); | 569 | 74 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 74 | this->move(newItemArray); | 571 | 74 | if (fOwnMemory) { | 572 | 55 | sk_free(fItemArray); | 573 | 55 | } | 574 | 74 | fItemArray = newItemArray; | 575 | 74 | fOwnMemory = true; | 576 | 74 | fReserved = false; | 577 | 74 | } |
SkTArray<GrSurfaceProxy*, true>::checkRealloc(int, SkTArray<GrSurfaceProxy*, true>::ReallocType) Line | Count | Source | 536 | 236k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 236k | SkASSERT(fCount >= 0); | 538 | 236k | SkASSERT(fAllocCount >= 0); | 539 | 236k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 236k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 236k | bool mustGrow = newCount > fAllocCount; | 548 | 236k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 236k | if (!mustGrow && !shouldShrink) { | 550 | 118k | return; | 551 | 118k | } | 552 | | | 553 | 117k | int64_t newAllocCount = newCount; | 554 | 117k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 117k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 117k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 117k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 117k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 117k | if (newAllocCount == fAllocCount) { | 564 | 36.8k | return; | 565 | 36.8k | } | 566 | | | 567 | 80.7k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 80.7k | SkASSERT(fAllocCount >= newCount); | 569 | 80.7k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 80.7k | this->move(newItemArray); | 571 | 80.7k | if (fOwnMemory) { | 572 | 80.7k | sk_free(fItemArray); | 573 | 80.7k | } | 574 | 80.7k | fItemArray = newItemArray; | 575 | 80.7k | fOwnMemory = true; | 576 | 80.7k | fReserved = false; | 577 | 80.7k | } |
SkTArray<sk_sp<SkImageFilter>, true>::checkRealloc(int, SkTArray<sk_sp<SkImageFilter>, true>::ReallocType) Line | Count | Source | 536 | 26.8k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 26.8k | SkASSERT(fCount >= 0); | 538 | 26.8k | SkASSERT(fAllocCount >= 0); | 539 | 26.8k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 26.8k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 26.8k | bool mustGrow = newCount > fAllocCount; | 548 | 26.8k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 26.8k | if (!mustGrow && !shouldShrink) { | 550 | 26.5k | return; | 551 | 26.5k | } | 552 | | | 553 | 277 | int64_t newAllocCount = newCount; | 554 | 277 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 277 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 277 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 277 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 277 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 277 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 277 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 277 | SkASSERT(fAllocCount >= newCount); | 569 | 277 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 277 | this->move(newItemArray); | 571 | 277 | if (fOwnMemory) { | 572 | 92 | sk_free(fItemArray); | 573 | 92 | } | 574 | 277 | fItemArray = newItemArray; | 575 | 277 | fOwnMemory = true; | 576 | 277 | fReserved = false; | 577 | 277 | } |
SkTArray<int, false>::checkRealloc(int, SkTArray<int, false>::ReallocType) Line | Count | Source | 536 | 456 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 456 | SkASSERT(fCount >= 0); | 538 | 456 | SkASSERT(fAllocCount >= 0); | 539 | 456 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 456 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 456 | bool mustGrow = newCount > fAllocCount; | 548 | 456 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 456 | if (!mustGrow && !shouldShrink) { | 550 | 0 | return; | 551 | 0 | } | 552 | | | 553 | 456 | int64_t newAllocCount = newCount; | 554 | 456 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 456 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 456 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 456 | SkASSERT(fAllocCount >= newCount); | 569 | 456 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 456 | this->move(newItemArray); | 571 | 456 | if (fOwnMemory) { | 572 | 456 | sk_free(fItemArray); | 573 | 456 | } | 574 | 456 | fItemArray = newItemArray; | 575 | 456 | fOwnMemory = true; | 576 | 456 | fReserved = false; | 577 | 456 | } |
SkTArray<float, false>::checkRealloc(int, SkTArray<float, false>::ReallocType) Line | Count | Source | 536 | 456 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 456 | SkASSERT(fCount >= 0); | 538 | 456 | SkASSERT(fAllocCount >= 0); | 539 | 456 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 456 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 456 | bool mustGrow = newCount > fAllocCount; | 548 | 456 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 456 | if (!mustGrow && !shouldShrink) { | 550 | 0 | return; | 551 | 0 | } | 552 | | | 553 | 456 | int64_t newAllocCount = newCount; | 554 | 456 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 456 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 456 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 456 | SkASSERT(fAllocCount >= newCount); | 569 | 456 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 456 | this->move(newItemArray); | 571 | 456 | if (fOwnMemory) { | 572 | 456 | sk_free(fItemArray); | 573 | 456 | } | 574 | 456 | fItemArray = newItemArray; | 575 | 456 | fOwnMemory = true; | 576 | 456 | fReserved = false; | 577 | 456 | } |
Unexecuted instantiation: SkTArray<SkCanvas::Lattice::RectType, false>::checkRealloc(int, SkTArray<SkCanvas::Lattice::RectType, false>::ReallocType) Unexecuted instantiation: SkTArray<unsigned int, false>::checkRealloc(int, SkTArray<unsigned int, false>::ReallocType) SkTArray<SkRuntimeEffect::ChildPtr, false>::checkRealloc(int, SkTArray<SkRuntimeEffect::ChildPtr, false>::ReallocType) Line | Count | Source | 536 | 12.1k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 12.1k | SkASSERT(fCount >= 0); | 538 | 12.1k | SkASSERT(fAllocCount >= 0); | 539 | 12.1k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 12.1k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 12.1k | bool mustGrow = newCount > fAllocCount; | 548 | 12.1k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 12.1k | if (!mustGrow && !shouldShrink) { | 550 | 12.1k | return; | 551 | 12.1k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<SkRGBA4f<(SkAlphaType)2>, true>::checkRealloc(int, SkTArray<SkRGBA4f<(SkAlphaType)2>, true>::ReallocType) Line | Count | Source | 536 | 7.63k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 7.63k | SkASSERT(fCount >= 0); | 538 | 7.63k | SkASSERT(fAllocCount >= 0); | 539 | 7.63k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 7.63k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 7.63k | bool mustGrow = newCount > fAllocCount; | 548 | 7.63k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 7.63k | if (!mustGrow && !shouldShrink) { | 550 | 7.63k | return; | 551 | 7.63k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::checkRealloc(int, SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::ReallocType) SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::checkRealloc(int, SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::ReallocType) Line | Count | Source | 536 | 1.52k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 1.52k | SkASSERT(fCount >= 0); | 538 | 1.52k | SkASSERT(fAllocCount >= 0); | 539 | 1.52k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 1.52k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 1.52k | bool mustGrow = newCount > fAllocCount; | 548 | 1.52k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 1.52k | if (!mustGrow && !shouldShrink) { | 550 | 1.27k | return; | 551 | 1.27k | } | 552 | | | 553 | 253 | int64_t newAllocCount = newCount; | 554 | 253 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 68 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 68 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 68 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 68 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 253 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 253 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 253 | SkASSERT(fAllocCount >= newCount); | 569 | 253 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 253 | this->move(newItemArray); | 571 | 253 | if (fOwnMemory) { | 572 | 5 | sk_free(fItemArray); | 573 | 5 | } | 574 | 253 | fItemArray = newItemArray; | 575 | 253 | fOwnMemory = true; | 576 | 253 | fReserved = false; | 577 | 253 | } |
Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::checkRealloc(int, SkTArray<sk_sp<SkTypeface>, false>::ReallocType) SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::checkRealloc(int, SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::ReallocType) Line | Count | Source | 536 | 2.55k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 2.55k | SkASSERT(fCount >= 0); | 538 | 2.55k | SkASSERT(fAllocCount >= 0); | 539 | 2.55k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 2.55k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 2.55k | bool mustGrow = newCount > fAllocCount; | 548 | 2.55k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 2.55k | if (!mustGrow && !shouldShrink) { | 550 | 2.17k | return; | 551 | 2.17k | } | 552 | | | 553 | 374 | int64_t newAllocCount = newCount; | 554 | 374 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 39 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 39 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 39 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 39 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 374 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 374 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 374 | SkASSERT(fAllocCount >= newCount); | 569 | 374 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 374 | this->move(newItemArray); | 571 | 374 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 374 | fItemArray = newItemArray; | 575 | 374 | fOwnMemory = true; | 576 | 374 | fReserved = false; | 577 | 374 | } |
SkTArray<signed char, false>::checkRealloc(int, SkTArray<signed char, false>::ReallocType) Line | Count | Source | 536 | 2.22k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 2.22k | SkASSERT(fCount >= 0); | 538 | 2.22k | SkASSERT(fAllocCount >= 0); | 539 | 2.22k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 2.22k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 2.22k | bool mustGrow = newCount > fAllocCount; | 548 | 2.22k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 2.22k | if (!mustGrow && !shouldShrink) { | 550 | 2.22k | return; | 551 | 2.22k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
Unexecuted instantiation: SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::checkRealloc(int, SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::ReallocType) SkTArray<unsigned long, true>::checkRealloc(int, SkTArray<unsigned long, true>::ReallocType) Line | Count | Source | 536 | 269k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 269k | SkASSERT(fCount >= 0); | 538 | 269k | SkASSERT(fAllocCount >= 0); | 539 | 269k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 269k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 269k | bool mustGrow = newCount > fAllocCount; | 548 | 269k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 269k | if (!mustGrow && !shouldShrink) { | 550 | 269k | return; | 551 | 269k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<int, true>::checkRealloc(int, SkTArray<int, true>::ReallocType) Line | Count | Source | 536 | 114M | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 114M | SkASSERT(fCount >= 0); | 538 | 114M | SkASSERT(fAllocCount >= 0); | 539 | 114M | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 114M | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 114M | bool mustGrow = newCount > fAllocCount; | 548 | 114M | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 114M | if (!mustGrow && !shouldShrink) { | 550 | 114M | return; | 551 | 114M | } | 552 | | | 553 | 105k | int64_t newAllocCount = newCount; | 554 | 105k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 133 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 133 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 133 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 133 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 105k | if (newAllocCount == fAllocCount) { | 564 | 43 | return; | 565 | 43 | } | 566 | | | 567 | 105k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 105k | SkASSERT(fAllocCount >= newCount); | 569 | 105k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 105k | this->move(newItemArray); | 571 | 105k | if (fOwnMemory) { | 572 | 89 | sk_free(fItemArray); | 573 | 89 | } | 574 | 105k | fItemArray = newItemArray; | 575 | 105k | fOwnMemory = true; | 576 | 105k | fReserved = false; | 577 | 105k | } |
Unexecuted instantiation: SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::checkRealloc(int, SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::ReallocType) SkTArray<SkSL::Type const*, false>::checkRealloc(int, SkTArray<SkSL::Type const*, false>::ReallocType) Line | Count | Source | 536 | 1.25k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 1.25k | SkASSERT(fCount >= 0); | 538 | 1.25k | SkASSERT(fAllocCount >= 0); | 539 | 1.25k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 1.25k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 1.25k | bool mustGrow = newCount > fAllocCount; | 548 | 1.25k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 1.25k | if (!mustGrow && !shouldShrink) { | 550 | 1.25k | return; | 551 | 1.25k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkSLSwizzle.cpp:SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::checkRealloc(int, SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::ReallocType) Line | Count | Source | 536 | 24 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 24 | SkASSERT(fCount >= 0); | 538 | 24 | SkASSERT(fAllocCount >= 0); | 539 | 24 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 24 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 24 | bool mustGrow = newCount > fAllocCount; | 548 | 24 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 24 | if (!mustGrow && !shouldShrink) { | 550 | 24 | return; | 551 | 24 | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::checkRealloc(int, SkTArray<SkJSONWriter::Scope, true>::ReallocType) Unexecuted instantiation: SkTArray<bool, true>::checkRealloc(int, SkTArray<bool, true>::ReallocType) SkTArray<sk_sp<GrRenderTask>, false>::checkRealloc(int, SkTArray<sk_sp<GrRenderTask>, false>::ReallocType) Line | Count | Source | 536 | 166k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 166k | SkASSERT(fCount >= 0); | 538 | 166k | SkASSERT(fAllocCount >= 0); | 539 | 166k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 166k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 166k | bool mustGrow = newCount > fAllocCount; | 548 | 166k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 166k | if (!mustGrow && !shouldShrink) { | 550 | 157k | return; | 551 | 157k | } | 552 | | | 553 | 8.57k | int64_t newAllocCount = newCount; | 554 | 8.57k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 8.57k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 8.57k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 8.57k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 8.57k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 8.57k | if (newAllocCount == fAllocCount) { | 564 | 1.34k | return; | 565 | 1.34k | } | 566 | | | 567 | 7.22k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 7.22k | SkASSERT(fAllocCount >= newCount); | 569 | 7.22k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 7.22k | this->move(newItemArray); | 571 | 7.22k | if (fOwnMemory) { | 572 | 7.22k | sk_free(fItemArray); | 573 | 7.22k | } | 574 | 7.22k | fItemArray = newItemArray; | 575 | 7.22k | fOwnMemory = true; | 576 | 7.22k | fReserved = false; | 577 | 7.22k | } |
SkTArray<GrOnFlushCallbackObject*, false>::checkRealloc(int, SkTArray<GrOnFlushCallbackObject*, false>::ReallocType) Line | Count | Source | 536 | 1.36k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 1.36k | SkASSERT(fCount >= 0); | 538 | 1.36k | SkASSERT(fAllocCount >= 0); | 539 | 1.36k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 1.36k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 1.36k | bool mustGrow = newCount > fAllocCount; | 548 | 1.36k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 1.36k | if (!mustGrow && !shouldShrink) { | 550 | 0 | return; | 551 | 0 | } | 552 | | | 553 | 1.36k | int64_t newAllocCount = newCount; | 554 | 1.36k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 1.36k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 1.36k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 1.36k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 1.36k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 1.36k | if (newAllocCount == fAllocCount) { | 564 | 42 | return; | 565 | 42 | } | 566 | | | 567 | 1.32k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 1.32k | SkASSERT(fAllocCount >= newCount); | 569 | 1.32k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 1.32k | this->move(newItemArray); | 571 | 1.32k | if (fOwnMemory) { | 572 | 1.32k | sk_free(fItemArray); | 573 | 1.32k | } | 574 | 1.32k | fItemArray = newItemArray; | 575 | 1.32k | fOwnMemory = true; | 576 | 1.32k | fReserved = false; | 577 | 1.32k | } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::checkRealloc(int, SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::ReallocType) SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::checkRealloc(int, SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::ReallocType) Line | Count | Source | 536 | 554k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 554k | SkASSERT(fCount >= 0); | 538 | 554k | SkASSERT(fAllocCount >= 0); | 539 | 554k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 554k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 554k | bool mustGrow = newCount > fAllocCount; | 548 | 554k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 554k | if (!mustGrow && !shouldShrink) { | 550 | 423k | return; | 551 | 423k | } | 552 | | | 553 | 131k | int64_t newAllocCount = newCount; | 554 | 131k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 131k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 131k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 131k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 131k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 131k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 131k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 131k | SkASSERT(fAllocCount >= newCount); | 569 | 131k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 131k | this->move(newItemArray); | 571 | 131k | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 131k | fItemArray = newItemArray; | 575 | 131k | fOwnMemory = true; | 576 | 131k | fReserved = false; | 577 | 131k | } |
SkTArray<GrGpu::SubmittedProc, false>::checkRealloc(int, SkTArray<GrGpu::SubmittedProc, false>::ReallocType) Line | Count | Source | 536 | 22.6k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 22.6k | SkASSERT(fCount >= 0); | 538 | 22.6k | SkASSERT(fAllocCount >= 0); | 539 | 22.6k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 22.6k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 22.6k | bool mustGrow = newCount > fAllocCount; | 548 | 22.6k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 22.6k | if (!mustGrow && !shouldShrink) { | 550 | 22.6k | return; | 551 | 22.6k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
Unexecuted instantiation: SkTArray<double, false>::checkRealloc(int, SkTArray<double, false>::ReallocType) Unexecuted instantiation: SkTArray<SkSL::String, false>::checkRealloc(int, SkTArray<SkSL::String, false>::ReallocType) SkTArray<GrRenderTask*, true>::checkRealloc(int, SkTArray<GrRenderTask*, true>::ReallocType) Line | Count | Source | 536 | 194k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 194k | SkASSERT(fCount >= 0); | 538 | 194k | SkASSERT(fAllocCount >= 0); | 539 | 194k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 194k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 194k | bool mustGrow = newCount > fAllocCount; | 548 | 194k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 194k | if (!mustGrow && !shouldShrink) { | 550 | 173k | return; | 551 | 173k | } | 552 | | | 553 | 20.3k | int64_t newAllocCount = newCount; | 554 | 20.3k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 20.3k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 20.3k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 20.3k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 20.3k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 20.3k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 20.3k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 20.3k | SkASSERT(fAllocCount >= newCount); | 569 | 20.3k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 20.3k | this->move(newItemArray); | 571 | 20.3k | if (fOwnMemory) { | 572 | 463 | sk_free(fItemArray); | 573 | 463 | } | 574 | 20.3k | fItemArray = newItemArray; | 575 | 20.3k | fOwnMemory = true; | 576 | 20.3k | fReserved = false; | 577 | 20.3k | } |
SkTArray<GrTextureProxy*, true>::checkRealloc(int, SkTArray<GrTextureProxy*, true>::ReallocType) Line | Count | Source | 536 | 48.0k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 48.0k | SkASSERT(fCount >= 0); | 538 | 48.0k | SkASSERT(fAllocCount >= 0); | 539 | 48.0k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 48.0k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 48.0k | bool mustGrow = newCount > fAllocCount; | 548 | 48.0k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 48.0k | if (!mustGrow && !shouldShrink) { | 550 | 48.0k | return; | 551 | 48.0k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<sk_sp<GrSurfaceProxy>, false>::checkRealloc(int, SkTArray<sk_sp<GrSurfaceProxy>, false>::ReallocType) Line | Count | Source | 536 | 100k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 100k | SkASSERT(fCount >= 0); | 538 | 100k | SkASSERT(fAllocCount >= 0); | 539 | 100k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 100k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 100k | bool mustGrow = newCount > fAllocCount; | 548 | 100k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 100k | if (!mustGrow && !shouldShrink) { | 550 | 100k | return; | 551 | 100k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<GrUniqueKeyInvalidatedMessage, false>::checkRealloc(int, SkTArray<GrUniqueKeyInvalidatedMessage, false>::ReallocType) Line | Count | Source | 536 | 141k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 141k | SkASSERT(fCount >= 0); | 538 | 141k | SkASSERT(fAllocCount >= 0); | 539 | 141k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 141k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 141k | bool mustGrow = newCount > fAllocCount; | 548 | 141k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 141k | if (!mustGrow && !shouldShrink) { | 550 | 126k | return; | 551 | 126k | } | 552 | | | 553 | 14.4k | int64_t newAllocCount = newCount; | 554 | 14.4k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 14.4k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 14.4k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 14.4k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 14.4k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 14.4k | if (newAllocCount == fAllocCount) { | 564 | 5.84k | return; | 565 | 5.84k | } | 566 | | | 567 | 8.59k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 8.59k | SkASSERT(fAllocCount >= newCount); | 569 | 8.59k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 8.59k | this->move(newItemArray); | 571 | 8.59k | if (fOwnMemory) { | 572 | 8.59k | sk_free(fItemArray); | 573 | 8.59k | } | 574 | 8.59k | fItemArray = newItemArray; | 575 | 8.59k | fOwnMemory = true; | 576 | 8.59k | fReserved = false; | 577 | 8.59k | } |
Unexecuted instantiation: SkTArray<GrTextureFreedMessage, false>::checkRealloc(int, SkTArray<GrTextureFreedMessage, false>::ReallocType) Unexecuted instantiation: SkTArray<GrTextureResolveRenderTask::Resolve, false>::checkRealloc(int, SkTArray<GrTextureResolveRenderTask::Resolve, false>::ReallocType) Unexecuted instantiation: SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::checkRealloc(int, SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::ReallocType) SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::checkRealloc(int, SkTArray<GrClientMappedBufferManager::BufferFinishedMessage, false>::ReallocType) Line | Count | Source | 536 | 65.8k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 65.8k | SkASSERT(fCount >= 0); | 538 | 65.8k | SkASSERT(fAllocCount >= 0); | 539 | 65.8k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 65.8k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 65.8k | bool mustGrow = newCount > fAllocCount; | 548 | 65.8k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 65.8k | if (!mustGrow && !shouldShrink) { | 550 | 65.8k | return; | 551 | 65.8k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<sk_sp<GrTextBlob>, false>::checkRealloc(int, SkTArray<sk_sp<GrTextBlob>, false>::ReallocType) Line | Count | Source | 536 | 1.76k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 1.76k | SkASSERT(fCount >= 0); | 538 | 1.76k | SkASSERT(fAllocCount >= 0); | 539 | 1.76k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 1.76k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 1.76k | bool mustGrow = newCount > fAllocCount; | 548 | 1.76k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 1.76k | if (!mustGrow && !shouldShrink) { | 550 | 1.76k | return; | 551 | 1.76k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::checkRealloc(int, SkTArray<GrTextBlobCache::PurgeBlobMessage, false>::ReallocType) Line | Count | Source | 536 | 1.06k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 1.06k | SkASSERT(fCount >= 0); | 538 | 1.06k | SkASSERT(fAllocCount >= 0); | 539 | 1.06k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 1.06k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 1.06k | bool mustGrow = newCount > fAllocCount; | 548 | 1.06k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 1.06k | if (!mustGrow && !shouldShrink) { | 550 | 556 | return; | 551 | 556 | } | 552 | | | 553 | 506 | int64_t newAllocCount = newCount; | 554 | 506 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 506 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 506 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 506 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 506 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 506 | if (newAllocCount == fAllocCount) { | 564 | 12 | return; | 565 | 12 | } | 566 | | | 567 | 494 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 494 | SkASSERT(fAllocCount >= newCount); | 569 | 494 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 494 | this->move(newItemArray); | 571 | 494 | if (fOwnMemory) { | 572 | 494 | sk_free(fItemArray); | 573 | 494 | } | 574 | 494 | fItemArray = newItemArray; | 575 | 494 | fOwnMemory = true; | 576 | 494 | fReserved = false; | 577 | 494 | } |
Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::checkRealloc(int, SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::ReallocType) Unexecuted instantiation: SkTArray<GrAuditTrail::Op*, false>::checkRealloc(int, SkTArray<GrAuditTrail::Op*, false>::ReallocType) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::checkRealloc(int, SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::ReallocType) Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo::Op, false>::checkRealloc(int, SkTArray<GrAuditTrail::OpInfo::Op, false>::ReallocType) Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo, false>::checkRealloc(int, SkTArray<GrAuditTrail::OpInfo, false>::ReallocType) SkTArray<GrOpsTask::OpChain, false>::checkRealloc(int, SkTArray<GrOpsTask::OpChain, false>::ReallocType) Line | Count | Source | 536 | 258k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 258k | SkASSERT(fCount >= 0); | 538 | 258k | SkASSERT(fAllocCount >= 0); | 539 | 258k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 258k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 258k | bool mustGrow = newCount > fAllocCount; | 548 | 258k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 258k | if (!mustGrow && !shouldShrink) { | 550 | 257k | return; | 551 | 257k | } | 552 | | | 553 | 614 | int64_t newAllocCount = newCount; | 554 | 614 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 553 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 553 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 553 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 553 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 614 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 614 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 614 | SkASSERT(fAllocCount >= newCount); | 569 | 614 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 614 | this->move(newItemArray); | 571 | 614 | if (fOwnMemory) { | 572 | 409 | sk_free(fItemArray); | 573 | 409 | } | 574 | 614 | fItemArray = newItemArray; | 575 | 614 | fOwnMemory = true; | 576 | 614 | fReserved = false; | 577 | 614 | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAConvexPathOp::PathData, true>::checkRealloc(int, SkTArray<(anonymous namespace)::AAConvexPathOp::PathData, true>::ReallocType) Line | Count | Source | 536 | 741 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 741 | SkASSERT(fCount >= 0); | 538 | 741 | SkASSERT(fAllocCount >= 0); | 539 | 741 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 741 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 741 | bool mustGrow = newCount > fAllocCount; | 548 | 741 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 741 | if (!mustGrow && !shouldShrink) { | 550 | 712 | return; | 551 | 712 | } | 552 | | | 553 | 29 | int64_t newAllocCount = newCount; | 554 | 29 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 29 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 29 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 29 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 29 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 29 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 29 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 29 | SkASSERT(fAllocCount >= newCount); | 569 | 29 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 29 | this->move(newItemArray); | 571 | 29 | if (fOwnMemory) { | 572 | 4 | sk_free(fItemArray); | 573 | 4 | } | 574 | 29 | fItemArray = newItemArray; | 575 | 29 | fOwnMemory = true; | 576 | 29 | fReserved = false; | 577 | 29 | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Segment, true>::checkRealloc(int, SkTArray<(anonymous namespace)::Segment, true>::ReallocType) Line | Count | Source | 536 | 19.3k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 19.3k | SkASSERT(fCount >= 0); | 538 | 19.3k | SkASSERT(fAllocCount >= 0); | 539 | 19.3k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 19.3k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 19.3k | bool mustGrow = newCount > fAllocCount; | 548 | 19.3k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 19.3k | if (!mustGrow && !shouldShrink) { | 550 | 19.1k | return; | 551 | 19.1k | } | 552 | | | 553 | 225 | int64_t newAllocCount = newCount; | 554 | 225 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 225 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 225 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 225 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 225 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 225 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 225 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 225 | SkASSERT(fAllocCount >= newCount); | 569 | 225 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 225 | this->move(newItemArray); | 571 | 225 | if (fOwnMemory) { | 572 | 166 | sk_free(fItemArray); | 573 | 166 | } | 574 | 225 | fItemArray = newItemArray; | 575 | 225 | fOwnMemory = true; | 576 | 225 | fReserved = false; | 577 | 225 | } |
AAConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::Draw, true>::checkRealloc(int, SkTArray<(anonymous namespace)::Draw, true>::ReallocType) Line | Count | Source | 536 | 332 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 332 | SkASSERT(fCount >= 0); | 538 | 332 | SkASSERT(fAllocCount >= 0); | 539 | 332 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 332 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 332 | bool mustGrow = newCount > fAllocCount; | 548 | 332 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 332 | if (!mustGrow && !shouldShrink) { | 550 | 332 | return; | 551 | 332 | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
AAHairLinePathRenderer.cpp:SkTArray<(anonymous namespace)::AAHairlineOp::PathData, true>::checkRealloc(int, SkTArray<(anonymous namespace)::AAHairlineOp::PathData, true>::ReallocType) Line | Count | Source | 536 | 4.11k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 4.11k | SkASSERT(fCount >= 0); | 538 | 4.11k | SkASSERT(fAllocCount >= 0); | 539 | 4.11k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 4.11k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 4.11k | bool mustGrow = newCount > fAllocCount; | 548 | 4.11k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 4.11k | if (!mustGrow && !shouldShrink) { | 550 | 4.05k | return; | 551 | 4.05k | } | 552 | | | 553 | 56 | int64_t newAllocCount = newCount; | 554 | 56 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 56 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 56 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 56 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 56 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 56 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 56 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 56 | SkASSERT(fAllocCount >= newCount); | 569 | 56 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 56 | this->move(newItemArray); | 571 | 56 | if (fOwnMemory) { | 572 | 35 | sk_free(fItemArray); | 573 | 35 | } | 574 | 56 | fItemArray = newItemArray; | 575 | 56 | fOwnMemory = true; | 576 | 56 | fReserved = false; | 577 | 56 | } |
SkTArray<SkPoint, true>::checkRealloc(int, SkTArray<SkPoint, true>::ReallocType) Line | Count | Source | 536 | 635k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 635k | SkASSERT(fCount >= 0); | 538 | 635k | SkASSERT(fAllocCount >= 0); | 539 | 635k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 635k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 635k | bool mustGrow = newCount > fAllocCount; | 548 | 635k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 635k | if (!mustGrow && !shouldShrink) { | 550 | 630k | return; | 551 | 630k | } | 552 | | | 553 | 4.76k | int64_t newAllocCount = newCount; | 554 | 4.76k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 4.76k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 4.76k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 4.76k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 4.76k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 4.76k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 4.76k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 4.76k | SkASSERT(fAllocCount >= newCount); | 569 | 4.76k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 4.76k | this->move(newItemArray); | 571 | 4.76k | if (fOwnMemory) { | 572 | 3.88k | sk_free(fItemArray); | 573 | 3.88k | } | 574 | 4.76k | fItemArray = newItemArray; | 575 | 4.76k | fOwnMemory = true; | 576 | 4.76k | fReserved = false; | 577 | 4.76k | } |
SkTArray<float, true>::checkRealloc(int, SkTArray<float, true>::ReallocType) Line | Count | Source | 536 | 39.0k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 39.0k | SkASSERT(fCount >= 0); | 538 | 39.0k | SkASSERT(fAllocCount >= 0); | 539 | 39.0k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 39.0k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 39.0k | bool mustGrow = newCount > fAllocCount; | 548 | 39.0k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 39.0k | if (!mustGrow && !shouldShrink) { | 550 | 37.3k | return; | 551 | 37.3k | } | 552 | | | 553 | 1.76k | int64_t newAllocCount = newCount; | 554 | 1.76k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 611 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 611 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 611 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 611 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 1.76k | if (newAllocCount == fAllocCount) { | 564 | 11 | return; | 565 | 11 | } | 566 | | | 567 | 1.75k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 1.75k | SkASSERT(fAllocCount >= newCount); | 569 | 1.75k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 1.75k | this->move(newItemArray); | 571 | 1.75k | if (fOwnMemory) { | 572 | 1.20k | sk_free(fItemArray); | 573 | 1.20k | } | 574 | 1.75k | fItemArray = newItemArray; | 575 | 1.75k | fOwnMemory = true; | 576 | 1.75k | fReserved = false; | 577 | 1.75k | } |
AALinearizingConvexPathRenderer.cpp:SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::checkRealloc(int, SkTArray<(anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::ReallocType) Line | Count | Source | 536 | 596 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 596 | SkASSERT(fCount >= 0); | 538 | 596 | SkASSERT(fAllocCount >= 0); | 539 | 596 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 596 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 596 | bool mustGrow = newCount > fAllocCount; | 548 | 596 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 596 | if (!mustGrow && !shouldShrink) { | 550 | 592 | return; | 551 | 592 | } | 552 | | | 553 | 4 | int64_t newAllocCount = newCount; | 554 | 4 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 4 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 4 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 4 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 4 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 4 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 4 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 4 | SkASSERT(fAllocCount >= newCount); | 569 | 4 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 4 | this->move(newItemArray); | 571 | 4 | if (fOwnMemory) { | 572 | 2 | sk_free(fItemArray); | 573 | 2 | } | 574 | 4 | fItemArray = newItemArray; | 575 | 4 | fOwnMemory = true; | 576 | 4 | fReserved = false; | 577 | 4 | } |
DefaultPathRenderer.cpp:SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::checkRealloc(int, SkTArray<(anonymous namespace)::DefaultPathOp::PathData, true>::ReallocType) Line | Count | Source | 536 | 10.1k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 10.1k | SkASSERT(fCount >= 0); | 538 | 10.1k | SkASSERT(fAllocCount >= 0); | 539 | 10.1k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 10.1k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 10.1k | bool mustGrow = newCount > fAllocCount; | 548 | 10.1k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 10.1k | if (!mustGrow && !shouldShrink) { | 550 | 9.99k | return; | 551 | 9.99k | } | 552 | | | 553 | 200 | int64_t newAllocCount = newCount; | 554 | 200 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 200 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 200 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 200 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 200 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 200 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 200 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 200 | SkASSERT(fAllocCount >= newCount); | 569 | 200 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 200 | this->move(newItemArray); | 571 | 200 | if (fOwnMemory) { | 572 | 68 | sk_free(fItemArray); | 573 | 68 | } | 574 | 200 | fItemArray = newItemArray; | 575 | 200 | fOwnMemory = true; | 576 | 200 | fReserved = false; | 577 | 200 | } |
SkTArray<DashOp::LineData, true>::checkRealloc(int, SkTArray<DashOp::LineData, true>::ReallocType) Line | Count | Source | 536 | 1 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 1 | SkASSERT(fCount >= 0); | 538 | 1 | SkASSERT(fAllocCount >= 0); | 539 | 1 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 1 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 1 | bool mustGrow = newCount > fAllocCount; | 548 | 1 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 1 | if (!mustGrow && !shouldShrink) { | 550 | 1 | return; | 551 | 1 | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<SkRect, true>::checkRealloc(int, SkTArray<SkRect, true>::ReallocType) Line | Count | Source | 536 | 1 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 1 | SkASSERT(fCount >= 0); | 538 | 1 | SkASSERT(fAllocCount >= 0); | 539 | 1 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 1 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 1 | bool mustGrow = newCount > fAllocCount; | 548 | 1 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 1 | if (!mustGrow && !shouldShrink) { | 550 | 1 | return; | 551 | 1 | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<DashOp::DashDraw, true>::checkRealloc(int, SkTArray<DashOp::DashDraw, true>::ReallocType) Line | Count | Source | 536 | 1 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 1 | SkASSERT(fCount >= 0); | 538 | 1 | SkASSERT(fAllocCount >= 0); | 539 | 1 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 1 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 1 | bool mustGrow = newCount > fAllocCount; | 548 | 1 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 1 | if (!mustGrow && !shouldShrink) { | 550 | 1 | return; | 551 | 1 | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
Unexecuted instantiation: SkTArray<SkRSXform, false>::checkRealloc(int, SkTArray<SkRSXform, false>::ReallocType) Unexecuted instantiation: SkTArray<SkRect, false>::checkRealloc(int, SkTArray<SkRect, false>::ReallocType) Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::checkRealloc(int, SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::ReallocType) Unexecuted instantiation: SkTArray<unsigned char, true>::checkRealloc(int, SkTArray<unsigned char, true>::ReallocType) GrDrawVerticesOp.cpp:SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::checkRealloc(int, SkTArray<(anonymous namespace)::DrawVerticesOp::Mesh, true>::ReallocType) Line | Count | Source | 536 | 1.89k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 1.89k | SkASSERT(fCount >= 0); | 538 | 1.89k | SkASSERT(fAllocCount >= 0); | 539 | 1.89k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 1.89k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 1.89k | bool mustGrow = newCount > fAllocCount; | 548 | 1.89k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 1.89k | if (!mustGrow && !shouldShrink) { | 550 | 1.87k | return; | 551 | 1.87k | } | 552 | | | 553 | 19 | int64_t newAllocCount = newCount; | 554 | 19 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 19 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 19 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 19 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 19 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 19 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 19 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 19 | SkASSERT(fAllocCount >= newCount); | 569 | 19 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 19 | this->move(newItemArray); | 571 | 19 | if (fOwnMemory) { | 572 | 1 | sk_free(fItemArray); | 573 | 1 | } | 574 | 19 | fItemArray = newItemArray; | 575 | 19 | fOwnMemory = true; | 576 | 19 | fReserved = false; | 577 | 19 | } |
Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::checkRealloc(int, SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::ReallocType) SkTArray<CircularRRectOp::RRect, true>::checkRealloc(int, SkTArray<CircularRRectOp::RRect, true>::ReallocType) Line | Count | Source | 536 | 8 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 8 | SkASSERT(fCount >= 0); | 538 | 8 | SkASSERT(fAllocCount >= 0); | 539 | 8 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 8 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 8 | bool mustGrow = newCount > fAllocCount; | 548 | 8 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 8 | if (!mustGrow && !shouldShrink) { | 550 | 6 | return; | 551 | 6 | } | 552 | | | 553 | 2 | int64_t newAllocCount = newCount; | 554 | 2 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 2 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 2 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 2 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 2 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 2 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 2 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 2 | SkASSERT(fAllocCount >= newCount); | 569 | 2 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 2 | this->move(newItemArray); | 571 | 2 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 2 | fItemArray = newItemArray; | 575 | 2 | fOwnMemory = true; | 576 | 2 | fReserved = false; | 577 | 2 | } |
SkTArray<EllipticalRRectOp::RRect, true>::checkRealloc(int, SkTArray<EllipticalRRectOp::RRect, true>::ReallocType) Line | Count | Source | 536 | 2 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 2 | SkASSERT(fCount >= 0); | 538 | 2 | SkASSERT(fAllocCount >= 0); | 539 | 2 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 2 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 2 | bool mustGrow = newCount > fAllocCount; | 548 | 2 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 2 | if (!mustGrow && !shouldShrink) { | 550 | 2 | return; | 551 | 2 | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::checkRealloc(int, SkTArray<ButtCapDashedCircleOp::Circle, true>::ReallocType) SkTArray<CircleOp::Circle, true>::checkRealloc(int, SkTArray<CircleOp::Circle, true>::ReallocType) Line | Count | Source | 536 | 25 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 25 | SkASSERT(fCount >= 0); | 538 | 25 | SkASSERT(fAllocCount >= 0); | 539 | 25 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 25 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 25 | bool mustGrow = newCount > fAllocCount; | 548 | 25 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 25 | if (!mustGrow && !shouldShrink) { | 550 | 22 | return; | 551 | 22 | } | 552 | | | 553 | 3 | int64_t newAllocCount = newCount; | 554 | 3 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 3 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 3 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 3 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 3 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 3 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 3 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 3 | SkASSERT(fAllocCount >= newCount); | 569 | 3 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 3 | this->move(newItemArray); | 571 | 3 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 3 | fItemArray = newItemArray; | 575 | 3 | fOwnMemory = true; | 576 | 3 | fReserved = false; | 577 | 3 | } |
Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::checkRealloc(int, SkTArray<EllipseOp::Ellipse, true>::ReallocType) SkTArray<DIEllipseOp::Ellipse, true>::checkRealloc(int, SkTArray<DIEllipseOp::Ellipse, true>::ReallocType) Line | Count | Source | 536 | 7 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 7 | SkASSERT(fCount >= 0); | 538 | 7 | SkASSERT(fAllocCount >= 0); | 539 | 7 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 7 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 7 | bool mustGrow = newCount > fAllocCount; | 548 | 7 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 7 | if (!mustGrow && !shouldShrink) { | 550 | 7 | return; | 551 | 7 | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::checkRealloc(int, SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::ReallocType) Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::checkRealloc(int, SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::ReallocType) GrStrokeRectOp.cpp:SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::checkRealloc(int, SkTArray<(anonymous namespace)::AAStrokeRectOp::RectInfo, true>::ReallocType) Line | Count | Source | 536 | 269 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 269 | SkASSERT(fCount >= 0); | 538 | 269 | SkASSERT(fAllocCount >= 0); | 539 | 269 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 269 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 269 | bool mustGrow = newCount > fAllocCount; | 548 | 269 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 269 | if (!mustGrow && !shouldShrink) { | 550 | 258 | return; | 551 | 258 | } | 552 | | | 553 | 11 | int64_t newAllocCount = newCount; | 554 | 11 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 11 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 11 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 11 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 11 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 11 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 11 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 11 | SkASSERT(fAllocCount >= newCount); | 569 | 11 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 11 | this->move(newItemArray); | 571 | 11 | if (fOwnMemory) { | 572 | 5 | sk_free(fItemArray); | 573 | 5 | } | 574 | 11 | fItemArray = newItemArray; | 575 | 11 | fOwnMemory = true; | 576 | 11 | fReserved = false; | 577 | 11 | } |
SmallPathRenderer.cpp:SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::checkRealloc(int, SkTArray<(anonymous namespace)::SmallPathOp::Entry, false>::ReallocType) Line | Count | Source | 536 | 3.85k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 3.85k | SkASSERT(fCount >= 0); | 538 | 3.85k | SkASSERT(fAllocCount >= 0); | 539 | 3.85k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 3.85k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 3.85k | bool mustGrow = newCount > fAllocCount; | 548 | 3.85k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 3.85k | if (!mustGrow && !shouldShrink) { | 550 | 3.69k | return; | 551 | 3.69k | } | 552 | | | 553 | 162 | int64_t newAllocCount = newCount; | 554 | 162 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 162 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 162 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 162 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 162 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 162 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 162 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 162 | SkASSERT(fAllocCount >= newCount); | 569 | 162 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 162 | this->move(newItemArray); | 571 | 162 | if (fOwnMemory) { | 572 | 63 | sk_free(fItemArray); | 573 | 63 | } | 574 | 162 | fItemArray = newItemArray; | 575 | 162 | fOwnMemory = true; | 576 | 162 | fReserved = false; | 577 | 162 | } |
SkTArray<sk_sp<skgpu::v1::PathRenderer>, false>::checkRealloc(int, SkTArray<sk_sp<skgpu::v1::PathRenderer>, false>::ReallocType) Line | Count | Source | 536 | 4.71k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 4.71k | SkASSERT(fCount >= 0); | 538 | 4.71k | SkASSERT(fAllocCount >= 0); | 539 | 4.71k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 4.71k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 4.71k | bool mustGrow = newCount > fAllocCount; | 548 | 4.71k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 4.71k | if (!mustGrow && !shouldShrink) { | 550 | 4.71k | return; | 551 | 4.71k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
Unexecuted instantiation: SkTArray<GrMipLevel, false>::checkRealloc(int, SkTArray<GrMipLevel, false>::ReallocType) Unexecuted instantiation: SkTArray<GrGLProgramDataManager::Uniform, true>::checkRealloc(int, SkTArray<GrGLProgramDataManager::Uniform, true>::ReallocType) SkTArray<__jmp_buf_tag (*) [1], false>::checkRealloc(int, SkTArray<__jmp_buf_tag (*) [1], false>::ReallocType) Line | Count | Source | 536 | 209k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 209k | SkASSERT(fCount >= 0); | 538 | 209k | SkASSERT(fAllocCount >= 0); | 539 | 209k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 209k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 209k | bool mustGrow = newCount > fAllocCount; | 548 | 209k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 209k | if (!mustGrow && !shouldShrink) { | 550 | 209k | return; | 551 | 209k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<unsigned long, false>::checkRealloc(int, SkTArray<unsigned long, false>::ReallocType) Line | Count | Source | 536 | 7.56k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 7.56k | SkASSERT(fCount >= 0); | 538 | 7.56k | SkASSERT(fAllocCount >= 0); | 539 | 7.56k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 7.56k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 7.56k | bool mustGrow = newCount > fAllocCount; | 548 | 7.56k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 7.56k | if (!mustGrow && !shouldShrink) { | 550 | 3.78k | return; | 551 | 3.78k | } | 552 | | | 553 | 3.78k | int64_t newAllocCount = newCount; | 554 | 3.78k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 3.78k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 3.78k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 3.78k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 3.78k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 3.78k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 3.78k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 3.78k | SkASSERT(fAllocCount >= newCount); | 569 | 3.78k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 3.78k | this->move(newItemArray); | 571 | 3.78k | if (fOwnMemory) { | 572 | 3.78k | sk_free(fItemArray); | 573 | 3.78k | } | 574 | 3.78k | fItemArray = newItemArray; | 575 | 3.78k | fOwnMemory = true; | 576 | 3.78k | fReserved = false; | 577 | 3.78k | } |
SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::checkRealloc(int, SkTArray<SkResourceCache::PurgeSharedIDMessage, false>::ReallocType) Line | Count | Source | 536 | 9.34k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 9.34k | SkASSERT(fCount >= 0); | 538 | 9.34k | SkASSERT(fAllocCount >= 0); | 539 | 9.34k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 9.34k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 9.34k | bool mustGrow = newCount > fAllocCount; | 548 | 9.34k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 9.34k | if (!mustGrow && !shouldShrink) { | 550 | 7.47k | return; | 551 | 7.47k | } | 552 | | | 553 | 1.86k | int64_t newAllocCount = newCount; | 554 | 1.86k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 1.86k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 1.86k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 1.86k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 1.86k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 1.86k | if (newAllocCount == fAllocCount) { | 564 | 3 | return; | 565 | 3 | } | 566 | | | 567 | 1.86k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 1.86k | SkASSERT(fAllocCount >= newCount); | 569 | 1.86k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 1.86k | this->move(newItemArray); | 571 | 1.86k | if (fOwnMemory) { | 572 | 1.86k | sk_free(fItemArray); | 573 | 1.86k | } | 574 | 1.86k | fItemArray = newItemArray; | 575 | 1.86k | fOwnMemory = true; | 576 | 1.86k | fReserved = false; | 577 | 1.86k | } |
SkTArray<SkPaint, false>::checkRealloc(int, SkTArray<SkPaint, false>::ReallocType) Line | Count | Source | 536 | 20.3k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 20.3k | SkASSERT(fCount >= 0); | 538 | 20.3k | SkASSERT(fAllocCount >= 0); | 539 | 20.3k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 20.3k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 20.3k | bool mustGrow = newCount > fAllocCount; | 548 | 20.3k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 20.3k | if (!mustGrow && !shouldShrink) { | 550 | 18.8k | return; | 551 | 18.8k | } | 552 | | | 553 | 1.42k | int64_t newAllocCount = newCount; | 554 | 1.42k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 1.42k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 1.42k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 1.42k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 1.42k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 1.42k | if (newAllocCount == fAllocCount) { | 564 | 295 | return; | 565 | 295 | } | 566 | | | 567 | 1.13k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 1.13k | SkASSERT(fAllocCount >= newCount); | 569 | 1.13k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 1.13k | this->move(newItemArray); | 571 | 1.13k | if (fOwnMemory) { | 572 | 1.13k | sk_free(fItemArray); | 573 | 1.13k | } | 574 | 1.13k | fItemArray = newItemArray; | 575 | 1.13k | fOwnMemory = true; | 576 | 1.13k | fReserved = false; | 577 | 1.13k | } |
SkTArray<SkPath, false>::checkRealloc(int, SkTArray<SkPath, false>::ReallocType) Line | Count | Source | 536 | 792k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 792k | SkASSERT(fCount >= 0); | 538 | 792k | SkASSERT(fAllocCount >= 0); | 539 | 792k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 792k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 792k | bool mustGrow = newCount > fAllocCount; | 548 | 792k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 792k | if (!mustGrow && !shouldShrink) { | 550 | 342k | return; | 551 | 342k | } | 552 | | | 553 | 450k | int64_t newAllocCount = newCount; | 554 | 450k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 450k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 450k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 450k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 450k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 450k | if (newAllocCount == fAllocCount) { | 564 | 159k | return; | 565 | 159k | } | 566 | | | 567 | 290k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 290k | SkASSERT(fAllocCount >= newCount); | 569 | 290k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 290k | this->move(newItemArray); | 571 | 290k | if (fOwnMemory) { | 572 | 290k | sk_free(fItemArray); | 573 | 290k | } | 574 | 290k | fItemArray = newItemArray; | 575 | 290k | fOwnMemory = true; | 576 | 290k | fReserved = false; | 577 | 290k | } |
SkTArray<sk_sp<SkPicture const>, false>::checkRealloc(int, SkTArray<sk_sp<SkPicture const>, false>::ReallocType) Line | Count | Source | 536 | 11 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 11 | SkASSERT(fCount >= 0); | 538 | 11 | SkASSERT(fAllocCount >= 0); | 539 | 11 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 11 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 11 | bool mustGrow = newCount > fAllocCount; | 548 | 11 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 11 | if (!mustGrow && !shouldShrink) { | 550 | 0 | return; | 551 | 0 | } | 552 | | | 553 | 11 | int64_t newAllocCount = newCount; | 554 | 11 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 11 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 11 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 11 | SkASSERT(fAllocCount >= newCount); | 569 | 11 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 11 | this->move(newItemArray); | 571 | 11 | if (fOwnMemory) { | 572 | 11 | sk_free(fItemArray); | 573 | 11 | } | 574 | 11 | fItemArray = newItemArray; | 575 | 11 | fOwnMemory = true; | 576 | 11 | fReserved = false; | 577 | 11 | } |
SkTArray<sk_sp<SkTextBlob const>, false>::checkRealloc(int, SkTArray<sk_sp<SkTextBlob const>, false>::ReallocType) Line | Count | Source | 536 | 833 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 833 | SkASSERT(fCount >= 0); | 538 | 833 | SkASSERT(fAllocCount >= 0); | 539 | 833 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 833 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 833 | bool mustGrow = newCount > fAllocCount; | 548 | 833 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 833 | if (!mustGrow && !shouldShrink) { | 550 | 662 | return; | 551 | 662 | } | 552 | | | 553 | 171 | int64_t newAllocCount = newCount; | 554 | 171 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 171 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 171 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 171 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 171 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 171 | if (newAllocCount == fAllocCount) { | 564 | 37 | return; | 565 | 37 | } | 566 | | | 567 | 134 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 134 | SkASSERT(fAllocCount >= newCount); | 569 | 134 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 134 | this->move(newItemArray); | 571 | 134 | if (fOwnMemory) { | 572 | 134 | sk_free(fItemArray); | 573 | 134 | } | 574 | 134 | fItemArray = newItemArray; | 575 | 134 | fOwnMemory = true; | 576 | 134 | fReserved = false; | 577 | 134 | } |
SkTArray<sk_sp<SkVertices const>, false>::checkRealloc(int, SkTArray<sk_sp<SkVertices const>, false>::ReallocType) Line | Count | Source | 536 | 1.68k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 1.68k | SkASSERT(fCount >= 0); | 538 | 1.68k | SkASSERT(fAllocCount >= 0); | 539 | 1.68k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 1.68k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 1.68k | bool mustGrow = newCount > fAllocCount; | 548 | 1.68k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 1.68k | if (!mustGrow && !shouldShrink) { | 550 | 1.45k | return; | 551 | 1.45k | } | 552 | | | 553 | 229 | int64_t newAllocCount = newCount; | 554 | 229 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 229 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 229 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 229 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 229 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 229 | if (newAllocCount == fAllocCount) { | 564 | 48 | return; | 565 | 48 | } | 566 | | | 567 | 181 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 181 | SkASSERT(fAllocCount >= newCount); | 569 | 181 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 181 | this->move(newItemArray); | 571 | 181 | if (fOwnMemory) { | 572 | 181 | sk_free(fItemArray); | 573 | 181 | } | 574 | 181 | fItemArray = newItemArray; | 575 | 181 | fOwnMemory = true; | 576 | 181 | fReserved = false; | 577 | 181 | } |
SkTArray<sk_sp<SkImage const>, false>::checkRealloc(int, SkTArray<sk_sp<SkImage const>, false>::ReallocType) Line | Count | Source | 536 | 23.4k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 23.4k | SkASSERT(fCount >= 0); | 538 | 23.4k | SkASSERT(fAllocCount >= 0); | 539 | 23.4k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 23.4k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 23.4k | bool mustGrow = newCount > fAllocCount; | 548 | 23.4k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 23.4k | if (!mustGrow && !shouldShrink) { | 550 | 19.0k | return; | 551 | 19.0k | } | 552 | | | 553 | 4.36k | int64_t newAllocCount = newCount; | 554 | 4.36k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 4.36k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 4.36k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 4.36k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 4.36k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 4.36k | if (newAllocCount == fAllocCount) { | 564 | 678 | return; | 565 | 678 | } | 566 | | | 567 | 3.68k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 3.68k | SkASSERT(fAllocCount >= newCount); | 569 | 3.68k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 3.68k | this->move(newItemArray); | 571 | 3.68k | if (fOwnMemory) { | 572 | 3.68k | sk_free(fItemArray); | 573 | 3.68k | } | 574 | 3.68k | fItemArray = newItemArray; | 575 | 3.68k | fOwnMemory = true; | 576 | 3.68k | fReserved = false; | 577 | 3.68k | } |
SkTArray<sk_sp<SkDrawable>, false>::checkRealloc(int, SkTArray<sk_sp<SkDrawable>, false>::ReallocType) Line | Count | Source | 536 | 7 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 7 | SkASSERT(fCount >= 0); | 538 | 7 | SkASSERT(fAllocCount >= 0); | 539 | 7 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 7 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 7 | bool mustGrow = newCount > fAllocCount; | 548 | 7 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 7 | if (!mustGrow && !shouldShrink) { | 550 | 7 | return; | 551 | 7 | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
Unexecuted instantiation: SkTArray<SkMatrix, false>::checkRealloc(int, SkTArray<SkMatrix, false>::ReallocType) SkTArray<OffsetEdge, false>::checkRealloc(int, SkTArray<OffsetEdge, false>::ReallocType) Line | Count | Source | 536 | 22.3k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 22.3k | SkASSERT(fCount >= 0); | 538 | 22.3k | SkASSERT(fAllocCount >= 0); | 539 | 22.3k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 22.3k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 22.3k | bool mustGrow = newCount > fAllocCount; | 548 | 22.3k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 22.3k | if (!mustGrow && !shouldShrink) { | 550 | 22.0k | return; | 551 | 22.0k | } | 552 | | | 553 | 270 | int64_t newAllocCount = newCount; | 554 | 270 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 270 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 270 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 270 | SkASSERT(fAllocCount >= newCount); | 569 | 270 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 270 | this->move(newItemArray); | 571 | 270 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 270 | fItemArray = newItemArray; | 575 | 270 | fOwnMemory = true; | 576 | 270 | fReserved = false; | 577 | 270 | } |
SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::checkRealloc(int, SkTArray<SkRGBA4f<(SkAlphaType)3>, true>::ReallocType) Line | Count | Source | 536 | 270k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 270k | SkASSERT(fCount >= 0); | 538 | 270k | SkASSERT(fAllocCount >= 0); | 539 | 270k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 270k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 270k | bool mustGrow = newCount > fAllocCount; | 548 | 270k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 270k | if (!mustGrow && !shouldShrink) { | 550 | 251k | return; | 551 | 251k | } | 552 | | | 553 | 19.4k | int64_t newAllocCount = newCount; | 554 | 19.4k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 19.4k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 19.4k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 19.4k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 19.4k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 19.4k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 19.4k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 19.4k | SkASSERT(fAllocCount >= newCount); | 569 | 19.4k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 19.4k | this->move(newItemArray); | 571 | 19.4k | if (fOwnMemory) { | 572 | 9.73k | sk_free(fItemArray); | 573 | 9.73k | } | 574 | 19.4k | fItemArray = newItemArray; | 575 | 19.4k | fOwnMemory = true; | 576 | 19.4k | fReserved = false; | 577 | 19.4k | } |
SkTArray<GrBufferAllocPool::BufferBlock, false>::checkRealloc(int, SkTArray<GrBufferAllocPool::BufferBlock, false>::ReallocType) Line | Count | Source | 536 | 68.4k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 68.4k | SkASSERT(fCount >= 0); | 538 | 68.4k | SkASSERT(fAllocCount >= 0); | 539 | 68.4k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 68.4k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 68.4k | bool mustGrow = newCount > fAllocCount; | 548 | 68.4k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 68.4k | if (!mustGrow && !shouldShrink) { | 550 | 6.50k | return; | 551 | 6.50k | } | 552 | | | 553 | 61.9k | int64_t newAllocCount = newCount; | 554 | 61.9k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 107 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 107 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 107 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 107 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 61.9k | if (newAllocCount == fAllocCount) { | 564 | 26 | return; | 565 | 26 | } | 566 | | | 567 | 61.9k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 61.9k | SkASSERT(fAllocCount >= newCount); | 569 | 61.9k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 61.9k | this->move(newItemArray); | 571 | 61.9k | if (fOwnMemory) { | 572 | 61.9k | sk_free(fItemArray); | 573 | 61.9k | } | 574 | 61.9k | fItemArray = newItemArray; | 575 | 61.9k | fOwnMemory = true; | 576 | 61.9k | fReserved = false; | 577 | 61.9k | } |
Unexecuted instantiation: SkTArray<PathSegment, true>::checkRealloc(int, SkTArray<PathSegment, true>::ReallocType) Unexecuted instantiation: SkTArray<GrDrawOpAtlas::Plot*, false>::checkRealloc(int, SkTArray<GrDrawOpAtlas::Plot*, false>::ReallocType) Unexecuted instantiation: SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::checkRealloc(int, SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::ReallocType) SkTArray<GrXPFactoryTestFactory*, true>::checkRealloc(int, SkTArray<GrXPFactoryTestFactory*, true>::ReallocType) Line | Count | Source | 536 | 264 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 264 | SkASSERT(fCount >= 0); | 538 | 264 | SkASSERT(fAllocCount >= 0); | 539 | 264 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 264 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 264 | bool mustGrow = newCount > fAllocCount; | 548 | 264 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 264 | if (!mustGrow && !shouldShrink) { | 550 | 132 | return; | 551 | 132 | } | 552 | | | 553 | 132 | int64_t newAllocCount = newCount; | 554 | 132 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 132 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 132 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 132 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 132 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 132 | if (newAllocCount == fAllocCount) { | 564 | 66 | return; | 565 | 66 | } | 566 | | | 567 | 66 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 66 | SkASSERT(fAllocCount >= newCount); | 569 | 66 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 66 | this->move(newItemArray); | 571 | 66 | if (fOwnMemory) { | 572 | 66 | sk_free(fItemArray); | 573 | 66 | } | 574 | 66 | fItemArray = newItemArray; | 575 | 66 | fOwnMemory = true; | 576 | 66 | fReserved = false; | 577 | 66 | } |
SkTArray<GrProcessorTestFactory<GrGeometryProcessor*>*, true>::checkRealloc(int, SkTArray<GrProcessorTestFactory<GrGeometryProcessor*>*, true>::ReallocType) Line | Count | Source | 536 | 924 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 924 | SkASSERT(fCount >= 0); | 538 | 924 | SkASSERT(fAllocCount >= 0); | 539 | 924 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 924 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 924 | bool mustGrow = newCount > fAllocCount; | 548 | 924 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 924 | if (!mustGrow && !shouldShrink) { | 550 | 726 | return; | 551 | 726 | } | 552 | | | 553 | 198 | int64_t newAllocCount = newCount; | 554 | 198 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 198 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 198 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 198 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 198 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 198 | if (newAllocCount == fAllocCount) { | 564 | 66 | return; | 565 | 66 | } | 566 | | | 567 | 132 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 132 | SkASSERT(fAllocCount >= newCount); | 569 | 132 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 132 | this->move(newItemArray); | 571 | 132 | if (fOwnMemory) { | 572 | 132 | sk_free(fItemArray); | 573 | 132 | } | 574 | 132 | fItemArray = newItemArray; | 575 | 132 | fOwnMemory = true; | 576 | 132 | fReserved = false; | 577 | 132 | } |
SkTArray<GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*, true>::checkRealloc(int, SkTArray<GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*, true>::ReallocType) Line | Count | Source | 536 | 990 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 990 | SkASSERT(fCount >= 0); | 538 | 990 | SkASSERT(fAllocCount >= 0); | 539 | 990 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 990 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 990 | bool mustGrow = newCount > fAllocCount; | 548 | 990 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 990 | if (!mustGrow && !shouldShrink) { | 550 | 792 | return; | 551 | 792 | } | 552 | | | 553 | 198 | int64_t newAllocCount = newCount; | 554 | 198 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 198 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 198 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 198 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 198 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 198 | if (newAllocCount == fAllocCount) { | 564 | 66 | return; | 565 | 66 | } | 566 | | | 567 | 132 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 132 | SkASSERT(fAllocCount >= newCount); | 569 | 132 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 132 | this->move(newItemArray); | 571 | 132 | if (fOwnMemory) { | 572 | 132 | sk_free(fItemArray); | 573 | 132 | } | 574 | 132 | fItemArray = newItemArray; | 575 | 132 | fOwnMemory = true; | 576 | 132 | fReserved = false; | 577 | 132 | } |
Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::checkRealloc(int, SkTArray<sk_sp<GrAtlasRenderTask>, false>::ReallocType) Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::checkRealloc(int, SkTArray<GrGeometryProcessor::Attribute, false>::ReallocType) Unexecuted instantiation: SkTArray<skgpu::v1::ClipStack::Element, false>::checkRealloc(int, SkTArray<skgpu::v1::ClipStack::Element, false>::ReallocType) SkTArray<skgpu::v1::ClipStack::Element const*, false>::checkRealloc(int, SkTArray<skgpu::v1::ClipStack::Element const*, false>::ReallocType) Line | Count | Source | 536 | 10.3k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 10.3k | SkASSERT(fCount >= 0); | 538 | 10.3k | SkASSERT(fAllocCount >= 0); | 539 | 10.3k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 10.3k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 10.3k | bool mustGrow = newCount > fAllocCount; | 548 | 10.3k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 10.3k | if (!mustGrow && !shouldShrink) { | 550 | 10.2k | return; | 551 | 10.2k | } | 552 | | | 553 | 34 | int64_t newAllocCount = newCount; | 554 | 34 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 34 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 34 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 34 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 34 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 34 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 34 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 34 | SkASSERT(fAllocCount >= newCount); | 569 | 34 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 34 | this->move(newItemArray); | 571 | 34 | if (fOwnMemory) { | 572 | 3 | sk_free(fItemArray); | 573 | 3 | } | 574 | 34 | fItemArray = newItemArray; | 575 | 34 | fOwnMemory = true; | 576 | 34 | fReserved = false; | 577 | 34 | } |
Unexecuted instantiation: SkTArray<GrGLFormat, true>::checkRealloc(int, SkTArray<GrGLFormat, true>::ReallocType) Unexecuted instantiation: SkTArray<GrSwizzle, false>::checkRealloc(int, SkTArray<GrSwizzle, false>::ReallocType) SkTArray<std::__1::unique_ptr<SkCodec, std::__1::default_delete<SkCodec> >, true>::checkRealloc(int, SkTArray<std::__1::unique_ptr<SkCodec, std::__1::default_delete<SkCodec> >, true>::ReallocType) Line | Count | Source | 536 | 6.13k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 6.13k | SkASSERT(fCount >= 0); | 538 | 6.13k | SkASSERT(fAllocCount >= 0); | 539 | 6.13k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 6.13k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 6.13k | bool mustGrow = newCount > fAllocCount; | 548 | 6.13k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 6.13k | if (!mustGrow && !shouldShrink) { | 550 | 2.74k | return; | 551 | 2.74k | } | 552 | | | 553 | 3.38k | int64_t newAllocCount = newCount; | 554 | 3.38k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 3.38k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 3.38k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 3.38k | SkASSERT(fAllocCount >= newCount); | 569 | 3.38k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 3.38k | this->move(newItemArray); | 571 | 3.38k | if (fOwnMemory) { | 572 | 3.38k | sk_free(fItemArray); | 573 | 3.38k | } | 574 | 3.38k | fItemArray = newItemArray; | 575 | 3.38k | fOwnMemory = true; | 576 | 3.38k | fReserved = false; | 577 | 3.38k | } |
Unexecuted instantiation: SkTArray<dng_exception, false>::checkRealloc(int, SkTArray<dng_exception, false>::ReallocType) Unexecuted instantiation: SkTArray<std::__1::thread, false>::checkRealloc(int, SkTArray<std::__1::thread, false>::ReallocType) Unexecuted instantiation: SkTArray<std::__1::function<void ()>, false>::checkRealloc(int, SkTArray<std::__1::function<void ()>, false>::ReallocType) SkTArray<SkOpRayHit*, false>::checkRealloc(int, SkTArray<SkOpRayHit*, false>::ReallocType) Line | Count | Source | 536 | 33.5M | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 33.5M | SkASSERT(fCount >= 0); | 538 | 33.5M | SkASSERT(fAllocCount >= 0); | 539 | 33.5M | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 33.5M | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 33.5M | bool mustGrow = newCount > fAllocCount; | 548 | 33.5M | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 33.5M | if (!mustGrow && !shouldShrink) { | 550 | 29.1M | return; | 551 | 29.1M | } | 552 | | | 553 | 4.37M | int64_t newAllocCount = newCount; | 554 | 4.37M | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 4.37M | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 4.37M | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 4.37M | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 4.37M | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 4.37M | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 4.37M | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 4.37M | SkASSERT(fAllocCount >= newCount); | 569 | 4.37M | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 4.37M | this->move(newItemArray); | 571 | 4.37M | if (fOwnMemory) { | 572 | 1.89M | sk_free(fItemArray); | 573 | 1.89M | } | 574 | 4.37M | fItemArray = newItemArray; | 575 | 4.37M | fOwnMemory = true; | 576 | 4.37M | fReserved = false; | 577 | 4.37M | } |
SkTArray<double, true>::checkRealloc(int, SkTArray<double, true>::ReallocType) Line | Count | Source | 536 | 52.0M | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 52.0M | SkASSERT(fCount >= 0); | 538 | 52.0M | SkASSERT(fAllocCount >= 0); | 539 | 52.0M | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 52.0M | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 52.0M | bool mustGrow = newCount > fAllocCount; | 548 | 52.0M | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 52.0M | if (!mustGrow && !shouldShrink) { | 550 | 52.0M | return; | 551 | 52.0M | } | 552 | | | 553 | 52.5k | int64_t newAllocCount = newCount; | 554 | 52.5k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 52.5k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 52.5k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 52.5k | SkASSERT(fAllocCount >= newCount); | 569 | 52.5k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 52.5k | this->move(newItemArray); | 571 | 52.5k | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 52.5k | fItemArray = newItemArray; | 575 | 52.5k | fOwnMemory = true; | 576 | 52.5k | fReserved = false; | 577 | 52.5k | } |
SkTArray<Sk4fGradientInterval, true>::checkRealloc(int, SkTArray<Sk4fGradientInterval, true>::ReallocType) Line | Count | Source | 536 | 9.20k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 9.20k | SkASSERT(fCount >= 0); | 538 | 9.20k | SkASSERT(fAllocCount >= 0); | 539 | 9.20k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 9.20k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 9.20k | bool mustGrow = newCount > fAllocCount; | 548 | 9.20k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 9.20k | if (!mustGrow && !shouldShrink) { | 550 | 8.93k | return; | 551 | 8.93k | } | 552 | | | 553 | 270 | int64_t newAllocCount = newCount; | 554 | 270 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 270 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 270 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 270 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 270 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 270 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 270 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 270 | SkASSERT(fAllocCount >= newCount); | 569 | 270 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 270 | this->move(newItemArray); | 571 | 270 | if (fOwnMemory) { | 572 | 193 | sk_free(fItemArray); | 573 | 193 | } | 574 | 270 | fItemArray = newItemArray; | 575 | 270 | fOwnMemory = true; | 576 | 270 | fReserved = false; | 577 | 270 | } |
SkTArray<sk_sp<SkFontStyleSet_Custom>, false>::checkRealloc(int, SkTArray<sk_sp<SkFontStyleSet_Custom>, false>::ReallocType) Line | Count | Source | 536 | 5 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 5 | SkASSERT(fCount >= 0); | 538 | 5 | SkASSERT(fAllocCount >= 0); | 539 | 5 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 5 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 5 | bool mustGrow = newCount > fAllocCount; | 548 | 5 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 5 | if (!mustGrow && !shouldShrink) { | 550 | 0 | return; | 551 | 0 | } | 552 | | | 553 | 5 | int64_t newAllocCount = newCount; | 554 | 5 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 5 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 5 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 5 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 5 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 5 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 5 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 5 | SkASSERT(fAllocCount >= newCount); | 569 | 5 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 5 | this->move(newItemArray); | 571 | 5 | if (fOwnMemory) { | 572 | 5 | sk_free(fItemArray); | 573 | 5 | } | 574 | 5 | fItemArray = newItemArray; | 575 | 5 | fOwnMemory = true; | 576 | 5 | fReserved = false; | 577 | 5 | } |
Unexecuted instantiation: SkTArray<GrProgramInfo const*, false>::checkRealloc(int, SkTArray<GrProgramInfo const*, false>::ReallocType) SkTArray<sk_sp<SkTypeface_Custom>, false>::checkRealloc(int, SkTArray<sk_sp<SkTypeface_Custom>, false>::ReallocType) Line | Count | Source | 536 | 5 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 5 | SkASSERT(fCount >= 0); | 538 | 5 | SkASSERT(fAllocCount >= 0); | 539 | 5 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 5 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 5 | bool mustGrow = newCount > fAllocCount; | 548 | 5 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 5 | if (!mustGrow && !shouldShrink) { | 550 | 0 | return; | 551 | 0 | } | 552 | | | 553 | 5 | int64_t newAllocCount = newCount; | 554 | 5 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 5 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 5 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 5 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 5 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 5 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 5 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 5 | SkASSERT(fAllocCount >= newCount); | 569 | 5 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 5 | this->move(newItemArray); | 571 | 5 | if (fOwnMemory) { | 572 | 5 | sk_free(fItemArray); | 573 | 5 | } | 574 | 5 | fItemArray = newItemArray; | 575 | 5 | fOwnMemory = true; | 576 | 5 | fReserved = false; | 577 | 5 | } |
SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true>::checkRealloc(int, SkTArray<SkTypeface_FreeType::Scanner::AxisDefinition, true>::ReallocType) Line | Count | Source | 536 | 2.02k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 2.02k | SkASSERT(fCount >= 0); | 538 | 2.02k | SkASSERT(fAllocCount >= 0); | 539 | 2.02k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 2.02k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 2.02k | bool mustGrow = newCount > fAllocCount; | 548 | 2.02k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 2.02k | if (!mustGrow && !shouldShrink) { | 550 | 2.02k | return; | 551 | 2.02k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<SkClosestRecord, true>::checkRealloc(int, SkTArray<SkClosestRecord, true>::ReallocType) Line | Count | Source | 536 | 5.21M | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 5.21M | SkASSERT(fCount >= 0); | 538 | 5.21M | SkASSERT(fAllocCount >= 0); | 539 | 5.21M | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 5.21M | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 5.21M | bool mustGrow = newCount > fAllocCount; | 548 | 5.21M | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 5.21M | if (!mustGrow && !shouldShrink) { | 550 | 5.20M | return; | 551 | 5.20M | } | 552 | | | 553 | 3.59k | int64_t newAllocCount = newCount; | 554 | 3.59k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 3.59k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 3.59k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 3.59k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 3.59k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 3.59k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 3.59k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 3.59k | SkASSERT(fAllocCount >= newCount); | 569 | 3.59k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 3.59k | this->move(newItemArray); | 571 | 3.59k | if (fOwnMemory) { | 572 | 2.61k | sk_free(fItemArray); | 573 | 2.61k | } | 574 | 3.59k | fItemArray = newItemArray; | 575 | 3.59k | fOwnMemory = true; | 576 | 3.59k | fReserved = false; | 577 | 3.59k | } |
SkTArray<SkClosestRecord const*, true>::checkRealloc(int, SkTArray<SkClosestRecord const*, true>::ReallocType) Line | Count | Source | 536 | 2.95M | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 2.95M | SkASSERT(fCount >= 0); | 538 | 2.95M | SkASSERT(fAllocCount >= 0); | 539 | 2.95M | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 2.95M | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 2.95M | bool mustGrow = newCount > fAllocCount; | 548 | 2.95M | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 2.95M | if (!mustGrow && !shouldShrink) { | 550 | 2.95M | return; | 551 | 2.95M | } | 552 | | | 553 | 2.61k | int64_t newAllocCount = newCount; | 554 | 2.61k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 2.61k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 2.61k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 2.61k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 2.61k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 2.61k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 2.61k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 2.61k | SkASSERT(fAllocCount >= newCount); | 569 | 2.61k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 2.61k | this->move(newItemArray); | 571 | 2.61k | if (fOwnMemory) { | 572 | 1.64k | sk_free(fItemArray); | 573 | 1.64k | } | 574 | 2.61k | fItemArray = newItemArray; | 575 | 2.61k | fOwnMemory = true; | 576 | 2.61k | fReserved = false; | 577 | 2.61k | } |
Unexecuted instantiation: SkTArray<std::__1::array<unsigned short, 3ul>, false>::checkRealloc(int, SkTArray<std::__1::array<unsigned short, 3ul>, false>::ReallocType) Unexecuted instantiation: SkTArray<GrVertexChunk, false>::checkRealloc(int, SkTArray<GrVertexChunk, false>::ReallocType) Unexecuted instantiation: SkTArray<sk_sp<ToolUtils::TopoTestNode>, false>::checkRealloc(int, SkTArray<sk_sp<ToolUtils::TopoTestNode>, false>::ReallocType) Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfLayerInfo, false>::checkRealloc(int, SkTArray<TestSVGTypeface::GlyfLayerInfo, false>::ReallocType) Unexecuted instantiation: SkTArray<TestSVGTypeface::GlyfInfo, false>::checkRealloc(int, SkTArray<TestSVGTypeface::GlyfInfo, false>::ReallocType) Layer.cpp:SkTArray<skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::checkRealloc(int, SkTArray<skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::ReallocType) Line | Count | Source | 536 | 8.61k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 8.61k | SkASSERT(fCount >= 0); | 538 | 8.61k | SkASSERT(fAllocCount >= 0); | 539 | 8.61k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 8.61k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 8.61k | bool mustGrow = newCount > fAllocCount; | 548 | 8.61k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 8.61k | if (!mustGrow && !shouldShrink) { | 550 | 8.59k | return; | 551 | 8.59k | } | 552 | | | 553 | 24 | int64_t newAllocCount = newCount; | 554 | 24 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 24 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 24 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 24 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 24 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 24 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 24 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 24 | SkASSERT(fAllocCount >= newCount); | 569 | 24 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 24 | this->move(newItemArray); | 571 | 24 | if (fOwnMemory) { | 572 | 6 | sk_free(fItemArray); | 573 | 6 | } | 574 | 24 | fItemArray = newItemArray; | 575 | 24 | fOwnMemory = true; | 576 | 24 | fReserved = false; | 577 | 24 | } |
Unexecuted instantiation: SkottieShaper.cpp:SkTArray<skottie::(anonymous namespace)::BlobMaker::RunRec, false>::checkRealloc(int, SkTArray<skottie::(anonymous namespace)::BlobMaker::RunRec, false>::ReallocType) SkTArray<char, true>::checkRealloc(int, SkTArray<char, true>::ReallocType) Line | Count | Source | 536 | 4.85M | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 4.85M | SkASSERT(fCount >= 0); | 538 | 4.85M | SkASSERT(fAllocCount >= 0); | 539 | 4.85M | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 4.85M | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 4.85M | bool mustGrow = newCount > fAllocCount; | 548 | 4.85M | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 4.85M | if (!mustGrow && !shouldShrink) { | 550 | 4.84M | return; | 551 | 4.84M | } | 552 | | | 553 | 8.69k | int64_t newAllocCount = newCount; | 554 | 8.69k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 477 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 477 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 477 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 477 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 8.69k | if (newAllocCount == fAllocCount) { | 564 | 73 | return; | 565 | 73 | } | 566 | | | 567 | 8.62k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 8.62k | SkASSERT(fAllocCount >= newCount); | 569 | 8.62k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 8.62k | this->move(newItemArray); | 571 | 8.62k | if (fOwnMemory) { | 572 | 5.03k | sk_free(fItemArray); | 573 | 5.03k | } | 574 | 8.62k | fItemArray = newItemArray; | 575 | 8.62k | fOwnMemory = true; | 576 | 8.62k | fReserved = false; | 577 | 8.62k | } |
SkTArray<SkSVGTextContext::PositionAdjustment, true>::checkRealloc(int, SkTArray<SkSVGTextContext::PositionAdjustment, true>::ReallocType) Line | Count | Source | 536 | 4.85M | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 4.85M | SkASSERT(fCount >= 0); | 538 | 4.85M | SkASSERT(fAllocCount >= 0); | 539 | 4.85M | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 4.85M | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 4.85M | bool mustGrow = newCount > fAllocCount; | 548 | 4.85M | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 4.85M | if (!mustGrow && !shouldShrink) { | 550 | 4.84M | return; | 551 | 4.84M | } | 552 | | | 553 | 8.69k | int64_t newAllocCount = newCount; | 554 | 8.69k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 477 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 477 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 477 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 477 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 8.69k | if (newAllocCount == fAllocCount) { | 564 | 73 | return; | 565 | 73 | } | 566 | | | 567 | 8.62k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 8.62k | SkASSERT(fAllocCount >= newCount); | 569 | 8.62k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 8.62k | this->move(newItemArray); | 571 | 8.62k | if (fOwnMemory) { | 572 | 5.03k | sk_free(fItemArray); | 573 | 5.03k | } | 574 | 8.62k | fItemArray = newItemArray; | 575 | 8.62k | fOwnMemory = true; | 576 | 8.62k | fReserved = false; | 577 | 8.62k | } |
SkTArray<sk_sp<SkSVGNode>, true>::checkRealloc(int, SkTArray<sk_sp<SkSVGNode>, true>::ReallocType) Line | Count | Source | 536 | 293k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 293k | SkASSERT(fCount >= 0); | 538 | 293k | SkASSERT(fAllocCount >= 0); | 539 | 293k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 293k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 293k | bool mustGrow = newCount > fAllocCount; | 548 | 293k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 293k | if (!mustGrow && !shouldShrink) { | 550 | 253k | return; | 551 | 253k | } | 552 | | | 553 | 40.4k | int64_t newAllocCount = newCount; | 554 | 40.4k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 40.4k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 40.4k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 40.4k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 40.4k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 40.4k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 40.4k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 40.4k | SkASSERT(fAllocCount >= newCount); | 569 | 40.4k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 40.4k | this->move(newItemArray); | 571 | 40.4k | if (fOwnMemory) { | 572 | 10.9k | sk_free(fItemArray); | 573 | 10.9k | } | 574 | 40.4k | fItemArray = newItemArray; | 575 | 40.4k | fOwnMemory = true; | 576 | 40.4k | fReserved = false; | 577 | 40.4k | } |
Unexecuted instantiation: SkTArray<hb_feature_t, false>::checkRealloc(int, SkTArray<hb_feature_t, false>::ReallocType) SkShaper_harfbuzz.cpp:SkTArray<(anonymous namespace)::ShapedRun, false>::checkRealloc(int, SkTArray<(anonymous namespace)::ShapedRun, false>::ReallocType) Line | Count | Source | 536 | 418k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 418k | SkASSERT(fCount >= 0); | 538 | 418k | SkASSERT(fAllocCount >= 0); | 539 | 418k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 418k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 418k | bool mustGrow = newCount > fAllocCount; | 548 | 418k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 418k | if (!mustGrow && !shouldShrink) { | 550 | 378k | return; | 551 | 378k | } | 552 | | | 553 | 39.6k | int64_t newAllocCount = newCount; | 554 | 39.6k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 39.6k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 39.6k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 39.6k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 39.6k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 39.6k | if (newAllocCount == fAllocCount) { | 564 | 9.96k | return; | 565 | 9.96k | } | 566 | | | 567 | 29.7k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 29.7k | SkASSERT(fAllocCount >= newCount); | 569 | 29.7k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 29.7k | this->move(newItemArray); | 571 | 29.7k | if (fOwnMemory) { | 572 | 29.7k | sk_free(fItemArray); | 573 | 29.7k | } | 574 | 29.7k | fItemArray = newItemArray; | 575 | 29.7k | fOwnMemory = true; | 576 | 29.7k | fReserved = false; | 577 | 29.7k | } |
Unexecuted instantiation: SkTArray<GrRecordingContext::ProgramData, false>::checkRealloc(int, SkTArray<GrRecordingContext::ProgramData, false>::ReallocType) SkTArray<skia::textlayout::Block, true>::checkRealloc(int, SkTArray<skia::textlayout::Block, true>::ReallocType) Line | Count | Source | 536 | 21.7k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 21.7k | SkASSERT(fCount >= 0); | 538 | 21.7k | SkASSERT(fAllocCount >= 0); | 539 | 21.7k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 21.7k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 21.7k | bool mustGrow = newCount > fAllocCount; | 548 | 21.7k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 21.7k | if (!mustGrow && !shouldShrink) { | 550 | 0 | return; | 551 | 0 | } | 552 | | | 553 | 21.7k | int64_t newAllocCount = newCount; | 554 | 21.7k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 21.7k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 21.7k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 21.7k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 21.7k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 21.7k | if (newAllocCount == fAllocCount) { | 564 | 8.76k | return; | 565 | 8.76k | } | 566 | | | 567 | 13.0k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 13.0k | SkASSERT(fAllocCount >= newCount); | 569 | 13.0k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 13.0k | this->move(newItemArray); | 571 | 13.0k | if (fOwnMemory) { | 572 | 13.0k | sk_free(fItemArray); | 573 | 13.0k | } | 574 | 13.0k | fItemArray = newItemArray; | 575 | 13.0k | fOwnMemory = true; | 576 | 13.0k | fReserved = false; | 577 | 13.0k | } |
SkTArray<skia::textlayout::Placeholder, true>::checkRealloc(int, SkTArray<skia::textlayout::Placeholder, true>::ReallocType) Line | Count | Source | 536 | 4.02k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 4.02k | SkASSERT(fCount >= 0); | 538 | 4.02k | SkASSERT(fAllocCount >= 0); | 539 | 4.02k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 4.02k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 4.02k | bool mustGrow = newCount > fAllocCount; | 548 | 4.02k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 4.02k | if (!mustGrow && !shouldShrink) { | 550 | 0 | return; | 551 | 0 | } | 552 | | | 553 | 4.02k | int64_t newAllocCount = newCount; | 554 | 4.02k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 4.02k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 4.02k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 4.02k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 4.02k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 4.02k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 4.02k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 4.02k | SkASSERT(fAllocCount >= newCount); | 569 | 4.02k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 4.02k | this->move(newItemArray); | 571 | 4.02k | if (fOwnMemory) { | 572 | 4.02k | sk_free(fItemArray); | 573 | 4.02k | } | 574 | 4.02k | fItemArray = newItemArray; | 575 | 4.02k | fOwnMemory = true; | 576 | 4.02k | fReserved = false; | 577 | 4.02k | } |
Unexecuted instantiation: SkTArray<unsigned short, true>::checkRealloc(int, SkTArray<unsigned short, true>::ReallocType) SkTArray<skia::textlayout::Run, false>::checkRealloc(int, SkTArray<skia::textlayout::Run, false>::ReallocType) Line | Count | Source | 536 | 4.06k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 4.06k | SkASSERT(fCount >= 0); | 538 | 4.06k | SkASSERT(fAllocCount >= 0); | 539 | 4.06k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 4.06k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 4.06k | bool mustGrow = newCount > fAllocCount; | 548 | 4.06k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 4.06k | if (!mustGrow && !shouldShrink) { | 550 | 4.06k | return; | 551 | 4.06k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<skia::textlayout::CodeUnitFlags, false>::checkRealloc(int, SkTArray<skia::textlayout::CodeUnitFlags, false>::ReallocType) Line | Count | Source | 536 | 8.07k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 8.07k | SkASSERT(fCount >= 0); | 538 | 8.07k | SkASSERT(fAllocCount >= 0); | 539 | 8.07k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 8.07k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 8.07k | bool mustGrow = newCount > fAllocCount; | 548 | 8.07k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 8.07k | if (!mustGrow && !shouldShrink) { | 550 | 4.04k | return; | 551 | 4.04k | } | 552 | | | 553 | 4.02k | int64_t newAllocCount = newCount; | 554 | 4.02k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 4.02k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 4.02k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 4.02k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 4.02k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 4.02k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 4.02k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 4.02k | SkASSERT(fAllocCount >= newCount); | 569 | 4.02k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 4.02k | this->move(newItemArray); | 571 | 4.02k | if (fOwnMemory) { | 572 | 4.02k | sk_free(fItemArray); | 573 | 4.02k | } | 574 | 4.02k | fItemArray = newItemArray; | 575 | 4.02k | fOwnMemory = true; | 576 | 4.02k | fReserved = false; | 577 | 4.02k | } |
SkTArray<skia::textlayout::TextLine, false>::checkRealloc(int, SkTArray<skia::textlayout::TextLine, false>::ReallocType) Line | Count | Source | 536 | 4.02k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 4.02k | SkASSERT(fCount >= 0); | 538 | 4.02k | SkASSERT(fAllocCount >= 0); | 539 | 4.02k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 4.02k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 4.02k | bool mustGrow = newCount > fAllocCount; | 548 | 4.02k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 4.02k | if (!mustGrow && !shouldShrink) { | 550 | 4.02k | return; | 551 | 4.02k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<skia::textlayout::Cluster, true>::checkRealloc(int, SkTArray<skia::textlayout::Cluster, true>::ReallocType) Line | Count | Source | 536 | 11.3k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 11.3k | SkASSERT(fCount >= 0); | 538 | 11.3k | SkASSERT(fAllocCount >= 0); | 539 | 11.3k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 11.3k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 11.3k | bool mustGrow = newCount > fAllocCount; | 548 | 11.3k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 11.3k | if (!mustGrow && !shouldShrink) { | 550 | 7.56k | return; | 551 | 7.56k | } | 552 | | | 553 | 3.78k | int64_t newAllocCount = newCount; | 554 | 3.78k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 3.78k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 3.78k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 3.78k | SkASSERT(fAllocCount >= newCount); | 569 | 3.78k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 3.78k | this->move(newItemArray); | 571 | 3.78k | if (fOwnMemory) { | 572 | 3.78k | sk_free(fItemArray); | 573 | 3.78k | } | 574 | 3.78k | fItemArray = newItemArray; | 575 | 3.78k | fOwnMemory = true; | 576 | 3.78k | fReserved = false; | 577 | 3.78k | } |
SkTArray<skia::textlayout::ResolvedFontDescriptor, false>::checkRealloc(int, SkTArray<skia::textlayout::ResolvedFontDescriptor, false>::ReallocType) Line | Count | Source | 536 | 3.76k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 3.76k | SkASSERT(fCount >= 0); | 538 | 3.76k | SkASSERT(fAllocCount >= 0); | 539 | 3.76k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 3.76k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 3.76k | bool mustGrow = newCount > fAllocCount; | 548 | 3.76k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 3.76k | if (!mustGrow && !shouldShrink) { | 550 | 3.76k | return; | 551 | 3.76k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkTArray<SkShaper::Feature, false>::checkRealloc(int, SkTArray<SkShaper::Feature, false>::ReallocType) Line | Count | Source | 536 | 57.6k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 57.6k | SkASSERT(fCount >= 0); | 538 | 57.6k | SkASSERT(fAllocCount >= 0); | 539 | 57.6k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 57.6k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 57.6k | bool mustGrow = newCount > fAllocCount; | 548 | 57.6k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 57.6k | if (!mustGrow && !shouldShrink) { | 550 | 57.6k | return; | 551 | 57.6k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
Unexecuted instantiation: SkTArray<GrUniqueKey, false>::checkRealloc(int, SkTArray<GrUniqueKey, false>::ReallocType) Unexecuted instantiation: SkTArray<GrGLAttribArrayState::AttribArrayState, true>::checkRealloc(int, SkTArray<GrGLAttribArrayState::AttribArrayState, true>::ReallocType) Unexecuted instantiation: SkTArray<SkCanvas::Lattice::RectType, false>::checkRealloc(int, SkTArray<SkCanvas::Lattice::RectType, false>::ReallocType) Unexecuted instantiation: SkTArray<unsigned int, false>::checkRealloc(int, SkTArray<unsigned int, false>::ReallocType) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::checkRealloc(int, SkTArray<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::ReallocType) SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::checkRealloc(int, SkTArray<std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::ReallocType) Line | Count | Source | 536 | 22.5M | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 22.5M | SkASSERT(fCount >= 0); | 538 | 22.5M | SkASSERT(fAllocCount >= 0); | 539 | 22.5M | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 22.5M | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 22.5M | bool mustGrow = newCount > fAllocCount; | 548 | 22.5M | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 22.5M | if (!mustGrow && !shouldShrink) { | 550 | 19.7M | return; | 551 | 19.7M | } | 552 | | | 553 | 2.78M | int64_t newAllocCount = newCount; | 554 | 2.78M | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 616k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 616k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 616k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 616k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 2.78M | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 2.78M | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 2.78M | SkASSERT(fAllocCount >= newCount); | 569 | 2.78M | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 2.78M | this->move(newItemArray); | 571 | 2.78M | if (fOwnMemory) { | 572 | 109k | sk_free(fItemArray); | 573 | 109k | } | 574 | 2.78M | fItemArray = newItemArray; | 575 | 2.78M | fOwnMemory = true; | 576 | 2.78M | fReserved = false; | 577 | 2.78M | } |
Unexecuted instantiation: SkTArray<sk_sp<SkTypeface>, false>::checkRealloc(int, SkTArray<sk_sp<SkTypeface>, false>::ReallocType) SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::checkRealloc(int, SkTArray<std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::ReallocType) Line | Count | Source | 536 | 28.1M | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 28.1M | SkASSERT(fCount >= 0); | 538 | 28.1M | SkASSERT(fAllocCount >= 0); | 539 | 28.1M | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 28.1M | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 28.1M | bool mustGrow = newCount > fAllocCount; | 548 | 28.1M | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 28.1M | if (!mustGrow && !shouldShrink) { | 550 | 24.9M | return; | 551 | 24.9M | } | 552 | | | 553 | 3.20M | int64_t newAllocCount = newCount; | 554 | 3.20M | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 7.29k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 7.29k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 7.29k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 7.29k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 3.20M | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 3.20M | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 3.20M | SkASSERT(fAllocCount >= newCount); | 569 | 3.20M | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 3.20M | this->move(newItemArray); | 571 | 3.20M | if (fOwnMemory) { | 572 | 6.22k | sk_free(fItemArray); | 573 | 6.22k | } | 574 | 3.20M | fItemArray = newItemArray; | 575 | 3.20M | fOwnMemory = true; | 576 | 3.20M | fReserved = false; | 577 | 3.20M | } |
SkTArray<signed char, false>::checkRealloc(int, SkTArray<signed char, false>::ReallocType) Line | Count | Source | 536 | 38.4M | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 38.4M | SkASSERT(fCount >= 0); | 538 | 38.4M | SkASSERT(fAllocCount >= 0); | 539 | 38.4M | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 38.4M | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 38.4M | bool mustGrow = newCount > fAllocCount; | 548 | 38.4M | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 38.4M | if (!mustGrow && !shouldShrink) { | 550 | 38.4M | return; | 551 | 38.4M | } | 552 | | | 553 | 10.2k | int64_t newAllocCount = newCount; | 554 | 10.2k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 7.26k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 7.26k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 7.26k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 7.26k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 10.2k | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 10.2k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 10.2k | SkASSERT(fAllocCount >= newCount); | 569 | 10.2k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 10.2k | this->move(newItemArray); | 571 | 10.2k | if (fOwnMemory) { | 572 | 4.25k | sk_free(fItemArray); | 573 | 4.25k | } | 574 | 10.2k | fItemArray = newItemArray; | 575 | 10.2k | fOwnMemory = true; | 576 | 10.2k | fReserved = false; | 577 | 10.2k | } |
Unexecuted instantiation: SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::checkRealloc(int, SkTArray<SkSL::dsl::DSLWrapper<SkSL::dsl::DSLExpression>, false>::ReallocType) SkTArray<SkSL::Parser::Checkpoint::ForwardingErrorReporter::Error, false>::checkRealloc(int, SkTArray<SkSL::Parser::Checkpoint::ForwardingErrorReporter::Error, false>::ReallocType) Line | Count | Source | 536 | 16.5k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 16.5k | SkASSERT(fCount >= 0); | 538 | 16.5k | SkASSERT(fAllocCount >= 0); | 539 | 16.5k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 16.5k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 16.5k | bool mustGrow = newCount > fAllocCount; | 548 | 16.5k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 16.5k | if (!mustGrow && !shouldShrink) { | 550 | 0 | return; | 551 | 0 | } | 552 | | | 553 | 16.5k | int64_t newAllocCount = newCount; | 554 | 16.5k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 16.5k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 16.5k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 16.5k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 16.5k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 16.5k | if (newAllocCount == fAllocCount) { | 564 | 1.23k | return; | 565 | 1.23k | } | 566 | | | 567 | 15.3k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 15.3k | SkASSERT(fAllocCount >= newCount); | 569 | 15.3k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 15.3k | this->move(newItemArray); | 571 | 15.3k | if (fOwnMemory) { | 572 | 15.3k | sk_free(fItemArray); | 573 | 15.3k | } | 574 | 15.3k | fItemArray = newItemArray; | 575 | 15.3k | fOwnMemory = true; | 576 | 15.3k | fReserved = false; | 577 | 15.3k | } |
Unexecuted instantiation: SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::checkRealloc(int, SkTArray<SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>, false>::ReallocType) SkTArray<SkSL::Type const*, false>::checkRealloc(int, SkTArray<SkSL::Type const*, false>::ReallocType) Line | Count | Source | 536 | 439k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 439k | SkASSERT(fCount >= 0); | 538 | 439k | SkASSERT(fAllocCount >= 0); | 539 | 439k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 439k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 439k | bool mustGrow = newCount > fAllocCount; | 548 | 439k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 439k | if (!mustGrow && !shouldShrink) { | 550 | 439k | return; | 551 | 439k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
SkSLSwizzle.cpp:SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::checkRealloc(int, SkTArray<SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::ReallocType) Line | Count | Source | 536 | 389k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 389k | SkASSERT(fCount >= 0); | 538 | 389k | SkASSERT(fAllocCount >= 0); | 539 | 389k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 389k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 389k | bool mustGrow = newCount > fAllocCount; | 548 | 389k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 389k | if (!mustGrow && !shouldShrink) { | 550 | 389k | return; | 551 | 389k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
Unexecuted instantiation: SkTArray<SkJSONWriter::Scope, true>::checkRealloc(int, SkTArray<SkJSONWriter::Scope, true>::ReallocType) Unexecuted instantiation: SkTArray<bool, true>::checkRealloc(int, SkTArray<bool, true>::ReallocType) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::checkRealloc(int, SkTArray<std::__1::unique_ptr<GrFragmentProcessor::ProgramImpl, std::__1::default_delete<GrFragmentProcessor::ProgramImpl> >, true>::ReallocType) Unexecuted instantiation: SkTArray<double, false>::checkRealloc(int, SkTArray<double, false>::ReallocType) Unexecuted instantiation: SkTArray<SkSL::String, false>::checkRealloc(int, SkTArray<SkSL::String, false>::ReallocType) Unexecuted instantiation: SkTArray<GrTextureFreedMessage, false>::checkRealloc(int, SkTArray<GrTextureFreedMessage, false>::ReallocType) Unexecuted instantiation: SkTArray<GrTextureResolveRenderTask::Resolve, false>::checkRealloc(int, SkTArray<GrTextureResolveRenderTask::Resolve, false>::ReallocType) Unexecuted instantiation: SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::checkRealloc(int, SkTArray<skgpu::SurfaceContext::AsyncReadResult::Plane, false>::ReallocType) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::checkRealloc(int, SkTArray<std::__1::unique_ptr<GrAuditTrail::Op, std::__1::default_delete<GrAuditTrail::Op> >, true>::ReallocType) Unexecuted instantiation: SkTArray<GrAuditTrail::Op*, false>::checkRealloc(int, SkTArray<GrAuditTrail::Op*, false>::ReallocType) Unexecuted instantiation: SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::checkRealloc(int, SkTArray<std::__1::unique_ptr<GrAuditTrail::OpNode, std::__1::default_delete<GrAuditTrail::OpNode> >, true>::ReallocType) Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo::Op, false>::checkRealloc(int, SkTArray<GrAuditTrail::OpInfo::Op, false>::ReallocType) Unexecuted instantiation: SkTArray<GrAuditTrail::OpInfo, false>::checkRealloc(int, SkTArray<GrAuditTrail::OpInfo, false>::ReallocType) Unexecuted instantiation: SkTArray<SkRSXform, false>::checkRealloc(int, SkTArray<SkRSXform, false>::ReallocType) Unexecuted instantiation: SkTArray<SkRect, false>::checkRealloc(int, SkTArray<SkRect, false>::ReallocType) Unexecuted instantiation: GrDrawAtlasOp.cpp:SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::checkRealloc(int, SkTArray<(anonymous namespace)::DrawAtlasOp::Geometry, true>::ReallocType) Unexecuted instantiation: SkTArray<unsigned char, true>::checkRealloc(int, SkTArray<unsigned char, true>::ReallocType) Unexecuted instantiation: GrLatticeOp.cpp:SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::checkRealloc(int, SkTArray<(anonymous namespace)::NonAALatticeOp::Patch, true>::ReallocType) Unexecuted instantiation: SkTArray<ButtCapDashedCircleOp::Circle, true>::checkRealloc(int, SkTArray<ButtCapDashedCircleOp::Circle, true>::ReallocType) Unexecuted instantiation: SkTArray<EllipseOp::Ellipse, true>::checkRealloc(int, SkTArray<EllipseOp::Ellipse, true>::ReallocType) Unexecuted instantiation: GrRegionOp.cpp:SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::checkRealloc(int, SkTArray<(anonymous namespace)::RegionOp::RegionInfo, true>::ReallocType) Unexecuted instantiation: GrShadowRRectOp.cpp:SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::checkRealloc(int, SkTArray<(anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::ReallocType) SkTArray<SkSL::VariableReference*, false>::checkRealloc(int, SkTArray<SkSL::VariableReference*, false>::ReallocType) Line | Count | Source | 536 | 38.9k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 38.9k | SkASSERT(fCount >= 0); | 538 | 38.9k | SkASSERT(fAllocCount >= 0); | 539 | 38.9k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 38.9k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 38.9k | bool mustGrow = newCount > fAllocCount; | 548 | 38.9k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 38.9k | if (!mustGrow && !shouldShrink) { | 550 | 38.9k | return; | 551 | 38.9k | } | 552 | | | 553 | 0 | int64_t newAllocCount = newCount; | 554 | 0 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 0 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 0 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 0 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 0 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 0 | if (newAllocCount == fAllocCount) { | 564 | 0 | return; | 565 | 0 | } | 566 | | | 567 | 0 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 0 | SkASSERT(fAllocCount >= newCount); | 569 | 0 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 0 | this->move(newItemArray); | 571 | 0 | if (fOwnMemory) { | 572 | 0 | sk_free(fItemArray); | 573 | 0 | } | 574 | 0 | fItemArray = newItemArray; | 575 | 0 | fOwnMemory = true; | 576 | 0 | fReserved = false; | 577 | 0 | } |
Unexecuted instantiation: SkTArray<GrMipLevel, false>::checkRealloc(int, SkTArray<GrMipLevel, false>::ReallocType) Unexecuted instantiation: SkTArray<GrGLProgramDataManager::Uniform, true>::checkRealloc(int, SkTArray<GrGLProgramDataManager::Uniform, true>::ReallocType) Unexecuted instantiation: SkTArray<SkMatrix, false>::checkRealloc(int, SkTArray<SkMatrix, false>::ReallocType) Unexecuted instantiation: SkTArray<PathSegment, true>::checkRealloc(int, SkTArray<PathSegment, true>::ReallocType) Unexecuted instantiation: SkTArray<GrDrawOpAtlas::Plot*, false>::checkRealloc(int, SkTArray<GrDrawOpAtlas::Plot*, false>::ReallocType) Unexecuted instantiation: SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::checkRealloc(int, SkTArray<std::__1::tuple<GrSurfaceProxyView, GrColorType, SkAlphaType>, false>::ReallocType) SkTArray<GrXPFactoryTestFactory*, true>::checkRealloc(int, SkTArray<GrXPFactoryTestFactory*, true>::ReallocType) Line | Count | Source | 536 | 40 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 40 | SkASSERT(fCount >= 0); | 538 | 40 | SkASSERT(fAllocCount >= 0); | 539 | 40 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 40 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 40 | bool mustGrow = newCount > fAllocCount; | 548 | 40 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 40 | if (!mustGrow && !shouldShrink) { | 550 | 20 | return; | 551 | 20 | } | 552 | | | 553 | 20 | int64_t newAllocCount = newCount; | 554 | 20 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 20 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 20 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 20 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 20 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 20 | if (newAllocCount == fAllocCount) { | 564 | 10 | return; | 565 | 10 | } | 566 | | | 567 | 10 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 10 | SkASSERT(fAllocCount >= newCount); | 569 | 10 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 10 | this->move(newItemArray); | 571 | 10 | if (fOwnMemory) { | 572 | 10 | sk_free(fItemArray); | 573 | 10 | } | 574 | 10 | fItemArray = newItemArray; | 575 | 10 | fOwnMemory = true; | 576 | 10 | fReserved = false; | 577 | 10 | } |
SkTArray<GrProcessorTestFactory<GrGeometryProcessor*>*, true>::checkRealloc(int, SkTArray<GrProcessorTestFactory<GrGeometryProcessor*>*, true>::ReallocType) Line | Count | Source | 536 | 140 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 140 | SkASSERT(fCount >= 0); | 538 | 140 | SkASSERT(fAllocCount >= 0); | 539 | 140 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 140 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 140 | bool mustGrow = newCount > fAllocCount; | 548 | 140 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 140 | if (!mustGrow && !shouldShrink) { | 550 | 110 | return; | 551 | 110 | } | 552 | | | 553 | 30 | int64_t newAllocCount = newCount; | 554 | 30 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 30 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 30 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 30 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 30 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 30 | if (newAllocCount == fAllocCount) { | 564 | 10 | return; | 565 | 10 | } | 566 | | | 567 | 20 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 20 | SkASSERT(fAllocCount >= newCount); | 569 | 20 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 20 | this->move(newItemArray); | 571 | 20 | if (fOwnMemory) { | 572 | 20 | sk_free(fItemArray); | 573 | 20 | } | 574 | 20 | fItemArray = newItemArray; | 575 | 20 | fOwnMemory = true; | 576 | 20 | fReserved = false; | 577 | 20 | } |
SkTArray<GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*, true>::checkRealloc(int, SkTArray<GrProcessorTestFactory<std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> > >*, true>::ReallocType) Line | Count | Source | 536 | 150 | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 150 | SkASSERT(fCount >= 0); | 538 | 150 | SkASSERT(fAllocCount >= 0); | 539 | 150 | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 150 | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 150 | bool mustGrow = newCount > fAllocCount; | 548 | 150 | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 150 | if (!mustGrow && !shouldShrink) { | 550 | 120 | return; | 551 | 120 | } | 552 | | | 553 | 30 | int64_t newAllocCount = newCount; | 554 | 30 | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 30 | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 30 | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 30 | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 30 | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 30 | if (newAllocCount == fAllocCount) { | 564 | 10 | return; | 565 | 10 | } | 566 | | | 567 | 20 | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 20 | SkASSERT(fAllocCount >= newCount); | 569 | 20 | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 20 | this->move(newItemArray); | 571 | 20 | if (fOwnMemory) { | 572 | 20 | sk_free(fItemArray); | 573 | 20 | } | 574 | 20 | fItemArray = newItemArray; | 575 | 20 | fOwnMemory = true; | 576 | 20 | fReserved = false; | 577 | 20 | } |
Unexecuted instantiation: SkTArray<sk_sp<GrAtlasRenderTask>, false>::checkRealloc(int, SkTArray<sk_sp<GrAtlasRenderTask>, false>::ReallocType) Unexecuted instantiation: SkTArray<GrGeometryProcessor::Attribute, false>::checkRealloc(int, SkTArray<GrGeometryProcessor::Attribute, false>::ReallocType) Unexecuted instantiation: SkTArray<skgpu::v1::ClipStack::Element, false>::checkRealloc(int, SkTArray<skgpu::v1::ClipStack::Element, false>::ReallocType) Unexecuted instantiation: SkTArray<GrGLFormat, true>::checkRealloc(int, SkTArray<GrGLFormat, true>::ReallocType) Unexecuted instantiation: SkTArray<GrSwizzle, false>::checkRealloc(int, SkTArray<GrSwizzle, false>::ReallocType) Unexecuted instantiation: SkTArray<dng_exception, false>::checkRealloc(int, SkTArray<dng_exception, false>::ReallocType) Unexecuted instantiation: SkTArray<std::__1::thread, false>::checkRealloc(int, SkTArray<std::__1::thread, false>::ReallocType) Unexecuted instantiation: SkTArray<std::__1::function<void ()>, false>::checkRealloc(int, SkTArray<std::__1::function<void ()>, false>::ReallocType) Unexecuted instantiation: SkTArray<GrProgramInfo const*, false>::checkRealloc(int, SkTArray<GrProgramInfo const*, false>::ReallocType) Unexecuted instantiation: SkTArray<std::__1::array<unsigned short, 3ul>, false>::checkRealloc(int, SkTArray<std::__1::array<unsigned short, 3ul>, false>::ReallocType) Unexecuted instantiation: SkTArray<GrVertexChunk, false>::checkRealloc(int, SkTArray<GrVertexChunk, false>::ReallocType) Unexecuted instantiation: SkTArray<SkTArray<SkPDFTagNode*, false>, false>::checkRealloc(int, SkTArray<SkTArray<SkPDFTagNode*, false>, false>::ReallocType) Unexecuted instantiation: SkTArray<SkPDFTagNode::MarkedContentInfo, false>::checkRealloc(int, SkTArray<SkPDFTagNode::MarkedContentInfo, false>::ReallocType) Unexecuted instantiation: SkTArray<SkPDFTagNode*, false>::checkRealloc(int, SkTArray<SkPDFTagNode*, false>::ReallocType) SkTArray<SkSVGDevice::ClipRec, false>::checkRealloc(int, SkTArray<SkSVGDevice::ClipRec, false>::ReallocType) Line | Count | Source | 536 | 15.7k | void checkRealloc(int delta, ReallocType reallocType) { | 537 | 15.7k | SkASSERT(fCount >= 0); | 538 | 15.7k | SkASSERT(fAllocCount >= 0); | 539 | 15.7k | SkASSERT(-delta <= this->count()); | 540 | | | 541 | | // Move into 64bit math temporarily, to avoid local overflows | 542 | 15.7k | int64_t newCount = fCount + delta; | 543 | | | 544 | | // We allow fAllocCount to be in the range [newCount, 3*newCount]. We also never shrink | 545 | | // when we're currently using preallocated memory, would allocate less than | 546 | | // kMinHeapAllocCount, or a reserve count was specified that has yet to be exceeded. | 547 | 15.7k | bool mustGrow = newCount > fAllocCount; | 548 | 15.7k | bool shouldShrink = fAllocCount > 3 * newCount && fOwnMemory && !fReserved; | 549 | 15.7k | if (!mustGrow && !shouldShrink) { | 550 | 12.2k | return; | 551 | 12.2k | } | 552 | | | 553 | 3.48k | int64_t newAllocCount = newCount; | 554 | 3.48k | if (reallocType != kExactFit) { | 555 | | // Whether we're growing or shrinking, leave at least 50% extra space for future growth. | 556 | 3.48k | newAllocCount += ((newCount + 1) >> 1); | 557 | | // Align the new allocation count to kMinHeapAllocCount. | 558 | 3.48k | static_assert(SkIsPow2(kMinHeapAllocCount), "min alloc count not power of two."); | 559 | 3.48k | newAllocCount = (newAllocCount + (kMinHeapAllocCount - 1)) & ~(kMinHeapAllocCount - 1); | 560 | 3.48k | } | 561 | | | 562 | | // At small sizes the old and new alloc count can both be kMinHeapAllocCount. | 563 | 3.48k | if (newAllocCount == fAllocCount) { | 564 | 835 | return; | 565 | 835 | } | 566 | | | 567 | 2.64k | fAllocCount = SkToU32(Sk64_pin_to_s32(newAllocCount)); | 568 | 2.64k | SkASSERT(fAllocCount >= newCount); | 569 | 2.64k | T* newItemArray = (T*)sk_malloc_throw((size_t)fAllocCount, sizeof(T)); | 570 | 2.64k | this->move(newItemArray); | 571 | 2.64k | if (fOwnMemory) { | 572 | 2.64k | sk_free(fItemArray); | 573 | 2.64k | } | 574 | 2.64k | fItemArray = newItemArray; | 575 | 2.64k | fOwnMemory = true; | 576 | 2.64k | fReserved = false; | 577 | 2.64k | } |
|
578 | | |
579 | | T* fItemArray; |
580 | | uint32_t fOwnMemory : 1; |
581 | | uint32_t fCount : 31; |
582 | | uint32_t fReserved : 1; |
583 | | uint32_t fAllocCount : 31; |
584 | | }; |
585 | | |
586 | 0 | template <typename T, bool M> static inline void swap(SkTArray<T, M>& a, SkTArray<T, M>& b) { |
587 | 0 | a.swap(b); |
588 | 0 | } Unexecuted instantiation: GrContextFactory.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GLTestContext.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GLTestContext_command_buffer.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: CreatePlatformGLTestContext_egl.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrBackendSurface.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrDirectContext.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLSLFragmentShaderBuilder.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: SkImage_Gpu.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLMakeNativeInterface_egl.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLAssembleGLESInterfaceAutogen.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLAssembleHelpers.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLExtensions.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLGpu.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLGpuProgramCache.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLInterfaceAutogen.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLOpsRenderPass.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLProgram.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLProgramDataManager.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLRenderTarget.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLSemaphore.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLTexture.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLTextureRenderTarget.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLUtil.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLVertexArray.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLProgramBuilder.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLShaderStringBuilder.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrBackendTextureImageGenerator.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrBackendUtils.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLMakeEGLInterface.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLAssembleInterface.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLAssembleWebGLInterfaceAutogen.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLAttachment.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLBuffer.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLCaps.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLContext.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLGLSL.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLUniformHandler.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: GrGLAssembleGLInterfaceAutogen.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: FuzzDDLThreading.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: FuzzSkParagraph.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: FuzzCanvas.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) Unexecuted instantiation: FuzzCreateDDL.cpp:void swap<SkString, false>(SkTArray<SkString, false>&, SkTArray<SkString, false>&) |
589 | | |
590 | | template<typename T, bool MEM_MOVE> constexpr int SkTArray<T, MEM_MOVE>::kMinHeapAllocCount; |
591 | | |
592 | | /** |
593 | | * Subclass of SkTArray that contains a preallocated memory block for the array. |
594 | | */ |
595 | | template <int N, typename T, bool MEM_MOVE = false> |
596 | | class SkSTArray : private SkAlignedSTStorage<N,T>, public SkTArray<T, MEM_MOVE> { |
597 | | private: |
598 | | using STORAGE = SkAlignedSTStorage<N,T>; |
599 | | using INHERITED = SkTArray<T, MEM_MOVE>; |
600 | | |
601 | | public: |
602 | | SkSTArray() |
603 | 92.5M | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} SkSTArray<4, SkNoPixelsDevice::ClipState, false>::SkSTArray() Line | Count | Source | 603 | 327k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<2, sk_sp<SkImageFilter>, true>::SkSTArray() Line | Count | Source | 603 | 20.8k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<4, SkRGBA4f<(SkAlphaType)2>, true>::SkSTArray() Line | Count | Source | 603 | 7.63k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<8, std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, false>::SkSTArray() Line | Count | Source | 603 | 203 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<4, SkRuntimeEffect::ChildPtr, false>::SkSTArray() Line | Count | Source | 603 | 4.04k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkSTArray<2, int, false>::SkSTArray() SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::SkSTArray() Line | Count | Source | 603 | 16.5M | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<2, std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::SkSTArray() Line | Count | Source | 603 | 19.9M | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<8, SkSL::Type const*, false>::SkSTArray() Line | Count | Source | 603 | 394k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<4, signed char, false>::SkSTArray() Line | Count | Source | 603 | 33.5M | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<4, unsigned long, true>::SkSTArray() Line | Count | Source | 603 | 261k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<4, int, true>::SkSTArray() Line | Count | Source | 603 | 11.2M | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSLSwizzle.cpp:SkSTArray<4, SkSL::optimize_constructor_swizzle(SkSL::Context const&, SkSL::AnyConstructor const&, SkSTArray<4, signed char, false>)::ReorderedArgument, false>::SkSTArray() Line | Count | Source | 603 | 170k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<1, std::__1::unique_ptr<GrFragmentProcessor, std::__1::default_delete<GrFragmentProcessor> >, true>::SkSTArray() Line | Count | Source | 603 | 630k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<8, unsigned int, true>::SkSTArray() Line | Count | Source | 603 | 1.32k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<4, sk_sp<GrRenderTask>, false>::SkSTArray() Line | Count | Source | 603 | 1.32k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkSTArray<4, GrTextureResolveRenderTask::Resolve, false>::SkSTArray() SkSTArray<4, GrGpu::SubmittedProc, false>::SkSTArray() Line | Count | Source | 603 | 1.32k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<1, sk_sp<GrSurfaceProxy>, false>::SkSTArray() Line | Count | Source | 603 | 100k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<1, GrRenderTask*, true>::SkSTArray() Line | Count | Source | 603 | 201k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkSTArray<3, skgpu::SurfaceContext::AsyncReadResult::Plane, false>::SkSTArray() SkSTArray<1, sk_sp<GrTextBlob>, false>::SkSTArray() Line | Count | Source | 603 | 2.84k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkSTArray<15, SkString, false>::SkSTArray() Unexecuted instantiation: SkSTArray<1, SkString, false>::SkSTArray() SkSTArray<25, GrOpsTask::OpChain, false>::SkSTArray() Line | Count | Source | 603 | 89.6k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
AAConvexPathRenderer.cpp:SkSTArray<1, (anonymous namespace)::AAConvexPathOp::PathData, true>::SkSTArray() Line | Count | Source | 603 | 646 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
AAConvexPathRenderer.cpp:SkSTArray<11, (anonymous namespace)::Segment, true>::SkSTArray() Line | Count | Source | 603 | 461 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<15, SkPoint, true>::SkSTArray() Line | Count | Source | 603 | 28 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
AAConvexPathRenderer.cpp:SkSTArray<4, (anonymous namespace)::Draw, true>::SkSTArray() Line | Count | Source | 603 | 332 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
AAHairLinePathRenderer.cpp:SkSTArray<1, (anonymous namespace)::AAHairlineOp::PathData, true>::SkSTArray() Line | Count | Source | 603 | 3.64k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<128, SkPoint, true>::SkSTArray() Line | Count | Source | 603 | 7.38k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<32, SkPoint, true>::SkSTArray() Line | Count | Source | 603 | 50.8k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
AALinearizingConvexPathRenderer.cpp:SkSTArray<1, (anonymous namespace)::AAFlatteningConvexPathOp::PathData, true>::SkSTArray() Line | Count | Source | 603 | 574 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
DefaultPathRenderer.cpp:SkSTArray<1, (anonymous namespace)::DefaultPathOp::PathData, true>::SkSTArray() Line | Count | Source | 603 | 9.24k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<1, DashOp::LineData, true>::SkSTArray() Line | Count | Source | 603 | 1 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<128, SkRect, true>::SkSTArray() Line | Count | Source | 603 | 1 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<128, DashOp::DashDraw, true>::SkSTArray() Line | Count | Source | 603 | 1 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: GrDrawAtlasOp.cpp:SkSTArray<1, (anonymous namespace)::DrawAtlasOp::Geometry, true>::SkSTArray() GrDrawVerticesOp.cpp:SkSTArray<1, (anonymous namespace)::DrawVerticesOp::Mesh, true>::SkSTArray() Line | Count | Source | 603 | 1.85k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: GrLatticeOp.cpp:SkSTArray<1, (anonymous namespace)::NonAALatticeOp::Patch, true>::SkSTArray() SkSTArray<1, CircularRRectOp::RRect, true>::SkSTArray() Line | Count | Source | 603 | 5 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<1, EllipticalRRectOp::RRect, true>::SkSTArray() Line | Count | Source | 603 | 2 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkSTArray<1, ButtCapDashedCircleOp::Circle, true>::SkSTArray() SkSTArray<1, CircleOp::Circle, true>::SkSTArray() Line | Count | Source | 603 | 14 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkSTArray<1, EllipseOp::Ellipse, true>::SkSTArray() SkSTArray<1, DIEllipseOp::Ellipse, true>::SkSTArray() Line | Count | Source | 603 | 7 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: GrRegionOp.cpp:SkSTArray<1, (anonymous namespace)::RegionOp::RegionInfo, true>::SkSTArray() Unexecuted instantiation: GrShadowRRectOp.cpp:SkSTArray<1, (anonymous namespace)::ShadowCircularRRectOp::Geometry, true>::SkSTArray() GrStrokeRectOp.cpp:SkSTArray<1, (anonymous namespace)::AAStrokeRectOp::RectInfo, true>::SkSTArray() Line | Count | Source | 603 | 208 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SmallPathRenderer.cpp:SkSTArray<1, (anonymous namespace)::SmallPathOp::Entry, false>::SkSTArray() Line | Count | Source | 603 | 2.96k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<8, sk_sp<skgpu::v1::PathRenderer>, false>::SkSTArray() Line | Count | Source | 603 | 673 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<16, SkSL::VariableReference*, false>::SkSTArray() Line | Count | Source | 603 | 38.9k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkSTArray<16, GrGLAttribArrayState::AttribArrayState, true>::SkSTArray() Unexecuted instantiation: SkSTArray<16, GrMipLevel, false>::SkSTArray() Unexecuted instantiation: SkSTArray<2, unsigned int, false>::SkSTArray() Unexecuted instantiation: SkSTArray<33, unsigned int, true>::SkSTArray() SkSTArray<4, __jmp_buf_tag (*) [1], false>::SkSTArray() Line | Count | Source | 603 | 12.7k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<4, unsigned short, false>::SkSTArray() Line | Count | Source | 603 | 386k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<4, SkPoint, false>::SkSTArray() Line | Count | Source | 603 | 386k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkSTArray<1, GrUniqueKeyInvalidatedMessage, false>::SkSTArray() SkSTArray<64, OffsetEdge, false>::SkSTArray() Line | Count | Source | 603 | 348 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<2, SkRGBA4f<(SkAlphaType)3>, true>::SkSTArray() Line | Count | Source | 603 | 19.6k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<4, SkRGBA4f<(SkAlphaType)3>, true>::SkSTArray() Line | Count | Source | 603 | 26.1k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<16, SkRGBA4f<(SkAlphaType)3>, true>::SkSTArray() Line | Count | Source | 603 | 198 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<16, float, true>::SkSTArray() Line | Count | Source | 603 | 198 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<4, GrClientMappedBufferManager::BufferFinishedMessage, false>::SkSTArray() Line | Count | Source | 603 | 21.9k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkSTArray<15, PathSegment, true>::SkSTArray() SkSTArray<4, GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::SkSTArray() Line | Count | Source | 603 | 1.83k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkSTArray<4, sk_sp<GrAtlasRenderTask>, false>::SkSTArray() Unexecuted instantiation: SkSTArray<6, GrGeometryProcessor::Attribute, false>::SkSTArray() Unexecuted instantiation: SkSTArray<2, GrProgramInfo const*, false>::SkSTArray() SkSTArray<4, skgpu::v1::ClipStack::Element const*, false>::SkSTArray() Line | Count | Source | 603 | 12.8k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<1, SkOpRayHit*, false>::SkSTArray() Line | Count | Source | 603 | 2.60M | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<8, double, true>::SkSTArray() Line | Count | Source | 603 | 94.5k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<8, int, true>::SkSTArray() Line | Count | Source | 603 | 189k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<8, Sk4fGradientInterval, true>::SkSTArray() Line | Count | Source | 603 | 730 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkSTArray<3, GrGeometryProcessor::Attribute, false>::SkSTArray() SkSTArray<4, SkTypeface_FreeType::Scanner::AxisDefinition, true>::SkSTArray() Line | Count | Source | 603 | 8.66k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<18, SkClosestRecord, true>::SkSTArray() Line | Count | Source | 603 | 2.25M | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<27, SkClosestRecord const*, true>::SkSTArray() Line | Count | Source | 603 | 2.25M | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkSTArray<1, GrVertexChunk, false>::SkSTArray() Unexecuted instantiation: SkSTArray<4, GrGeometryProcessor::Attribute, false>::SkSTArray() Unexecuted instantiation: SkSTArray<8, int, false>::SkSTArray() Layer.cpp:SkSTArray<4, skottie::internal::(anonymous namespace)::AttachMask(skjson::ArrayValue const*, skottie::internal::AnimationBuilder const*, sk_sp<sksg::RenderNode>)::MaskRecord, true>::SkSTArray() Line | Count | Source | 603 | 9.42k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkottieShaper.cpp:SkSTArray<16, skottie::(anonymous namespace)::BlobMaker::RunRec, false>::SkSTArray() Unexecuted instantiation: SkSTArray<64, float, true>::SkSTArray() SkSTArray<128, float, true>::SkSTArray() Line | Count | Source | 603 | 7.68k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<128, char, true>::SkSTArray() Line | Count | Source | 603 | 19.7k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<128, SkSVGTextContext::PositionAdjustment, true>::SkSTArray() Line | Count | Source | 603 | 19.7k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<1, sk_sp<SkSVGNode>, true>::SkSTArray() Line | Count | Source | 603 | 76.5k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<2, float, true>::SkSTArray() Line | Count | Source | 603 | 30 | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<32, float, true>::SkSTArray() Line | Count | Source | 603 | 1.11k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
SkSTArray<32, hb_feature_t, false>::SkSTArray() Line | Count | Source | 603 | 464k | : STORAGE{}, INHERITED(static_cast<STORAGE*>(this)) {} |
Unexecuted instantiation: SkSTArray<128, unsigned short, true>::SkSTArray() Unexecuted instantiation: SkSTArray<128, unsigned int, true>::SkSTArray() Unexecuted instantiation: SkSTArray<1, unsigned long, true>::SkSTArray() Unexecuted instantiation: SkSTArray<128, unsigned int, false>::SkSTArray() Unexecuted instantiation: SkSTArray<16, SkJSONWriter::Scope, true>::SkSTArray() Unexecuted instantiation: SkSTArray<16, bool, true>::SkSTArray() |
604 | | |
605 | | SkSTArray(const T* array, int count) |
606 | 1.83M | : STORAGE{}, INHERITED(array, count, static_cast<STORAGE*>(this)) {} SkSTArray<4, int, true>::SkSTArray(int const*, int) Line | Count | Source | 606 | 1.75M | : STORAGE{}, INHERITED(array, count, static_cast<STORAGE*>(this)) {} |
SkSTArray<4, signed char, false>::SkSTArray(signed char const*, int) Line | Count | Source | 606 | 82.4k | : STORAGE{}, INHERITED(array, count, static_cast<STORAGE*>(this)) {} |
SkSTArray<2, SkSL::Type const*, false>::SkSTArray(SkSL::Type const* const*, int) Line | Count | Source | 606 | 219 | : STORAGE{}, INHERITED(array, count, static_cast<STORAGE*>(this)) {} |
|
607 | | |
608 | | SkSTArray(std::initializer_list<T> data) |
609 | 1.83M | : SkSTArray(data.begin(), data.size()) {} SkSTArray<4, int, true>::SkSTArray(std::initializer_list<int>) Line | Count | Source | 609 | 1.75M | : SkSTArray(data.begin(), data.size()) {} |
SkSTArray<4, signed char, false>::SkSTArray(std::initializer_list<signed char>) Line | Count | Source | 609 | 82.4k | : SkSTArray(data.begin(), data.size()) {} |
SkSTArray<2, SkSL::Type const*, false>::SkSTArray(std::initializer_list<SkSL::Type const*>) Line | Count | Source | 609 | 219 | : SkSTArray(data.begin(), data.size()) {} |
|
610 | | |
611 | | explicit SkSTArray(int reserveCount) |
612 | 295k | : SkSTArray() { |
613 | 295k | this->reserve_back(reserveCount); |
614 | 295k | } SkSTArray<4, SkRuntimeEffect::ChildPtr, false>::SkSTArray(int) Line | Count | Source | 612 | 4.04k | : SkSTArray() { | 613 | 4.04k | this->reserve_back(reserveCount); | 614 | 4.04k | } |
SkSTArray<64, OffsetEdge, false>::SkSTArray(int) Line | Count | Source | 612 | 348 | : SkSTArray() { | 613 | 348 | this->reserve_back(reserveCount); | 614 | 348 | } |
SkSTArray<8, double, true>::SkSTArray(int) Line | Count | Source | 612 | 94.5k | : SkSTArray() { | 613 | 94.5k | this->reserve_back(reserveCount); | 614 | 94.5k | } |
SkSTArray<8, int, true>::SkSTArray(int) Line | Count | Source | 612 | 189k | : SkSTArray() { | 613 | 189k | this->reserve_back(reserveCount); | 614 | 189k | } |
SkSTArray<128, float, true>::SkSTArray(int) Line | Count | Source | 612 | 7.68k | : SkSTArray() { | 613 | 7.68k | this->reserve_back(reserveCount); | 614 | 7.68k | } |
|
615 | | |
616 | 24.8M | SkSTArray (const SkSTArray& that) : SkSTArray() { *this = that; } SkSTArray<4, signed char, false>::SkSTArray(SkSTArray<4, signed char, false> const&) Line | Count | Source | 616 | 22.7M | SkSTArray (const SkSTArray& that) : SkSTArray() { *this = that; } |
SkSTArray<4, int, true>::SkSTArray(SkSTArray<4, int, true> const&) Line | Count | Source | 616 | 2.00M | SkSTArray (const SkSTArray& that) : SkSTArray() { *this = that; } |
Unexecuted instantiation: SkSTArray<33, unsigned int, true>::SkSTArray(SkSTArray<33, unsigned int, true> const&) SkSTArray<4, GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::SkSTArray(SkSTArray<4, GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true> const&) Line | Count | Source | 616 | 1.22k | SkSTArray (const SkSTArray& that) : SkSTArray() { *this = that; } |
SkSTArray<4, SkTypeface_FreeType::Scanner::AxisDefinition, true>::SkSTArray(SkSTArray<4, SkTypeface_FreeType::Scanner::AxisDefinition, true> const&) Line | Count | Source | 616 | 2.02k | SkSTArray (const SkSTArray& that) : SkSTArray() { *this = that; } |
Unexecuted instantiation: SkSTArray<128, unsigned short, true>::SkSTArray(SkSTArray<128, unsigned short, true> const&) Unexecuted instantiation: SkSTArray<128, SkPoint, true>::SkSTArray(SkSTArray<128, SkPoint, true> const&) Unexecuted instantiation: SkSTArray<128, unsigned int, true>::SkSTArray(SkSTArray<128, unsigned int, true> const&) Unexecuted instantiation: SkSTArray<128, SkRect, true>::SkSTArray(SkSTArray<128, SkRect, true> const&) Unexecuted instantiation: SkSTArray<128, float, true>::SkSTArray(SkSTArray<128, float, true> const&) |
617 | | explicit SkSTArray(const INHERITED& that) : SkSTArray() { *this = that; } |
618 | 27.8M | SkSTArray ( SkSTArray&& that) : SkSTArray() { *this = std::move(that); } Unexecuted instantiation: SkSTArray<2, int, false>::SkSTArray(SkSTArray<2, int, false>&&) SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::SkSTArray(SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>&&) Line | Count | Source | 618 | 12.1M | SkSTArray ( SkSTArray&& that) : SkSTArray() { *this = std::move(that); } |
SkSTArray<2, std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::SkSTArray(SkSTArray<2, std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>&&) Line | Count | Source | 618 | 14.7M | SkSTArray ( SkSTArray&& that) : SkSTArray() { *this = std::move(that); } |
SkSTArray<4, int, true>::SkSTArray(SkSTArray<4, int, true>&&) Line | Count | Source | 618 | 305k | SkSTArray ( SkSTArray&& that) : SkSTArray() { *this = std::move(that); } |
SkSTArray<4, signed char, false>::SkSTArray(SkSTArray<4, signed char, false>&&) Line | Count | Source | 618 | 626k | SkSTArray ( SkSTArray&& that) : SkSTArray() { *this = std::move(that); } |
SkSTArray<1, sk_sp<GrTextBlob>, false>::SkSTArray(SkSTArray<1, sk_sp<GrTextBlob>, false>&&) Line | Count | Source | 618 | 531 | SkSTArray ( SkSTArray&& that) : SkSTArray() { *this = std::move(that); } |
Unexecuted instantiation: SkSTArray<128, unsigned short, true>::SkSTArray(SkSTArray<128, unsigned short, true>&&) Unexecuted instantiation: SkSTArray<128, SkPoint, true>::SkSTArray(SkSTArray<128, SkPoint, true>&&) Unexecuted instantiation: SkSTArray<128, unsigned int, true>::SkSTArray(SkSTArray<128, unsigned int, true>&&) Unexecuted instantiation: SkSTArray<128, SkRect, true>::SkSTArray(SkSTArray<128, SkRect, true>&&) Unexecuted instantiation: SkSTArray<128, float, true>::SkSTArray(SkSTArray<128, float, true>&&) Unexecuted instantiation: SkSTArray<1, unsigned long, true>::SkSTArray(SkSTArray<1, unsigned long, true>&&) |
619 | | explicit SkSTArray( INHERITED&& that) : SkSTArray() { *this = std::move(that); } |
620 | | |
621 | 24.8M | SkSTArray& operator=(const SkSTArray& that) { |
622 | 24.8M | INHERITED::operator=(that); |
623 | 24.8M | return *this; |
624 | 24.8M | } Unexecuted instantiation: SkSTArray<33, unsigned int, true>::operator=(SkSTArray<33, unsigned int, true> const&) SkSTArray<4, GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true>::operator=(SkSTArray<4, GrDrawOpAtlas::BulkUseTokenUpdater::PlotData, true> const&) Line | Count | Source | 621 | 1.22k | SkSTArray& operator=(const SkSTArray& that) { | 622 | 1.22k | INHERITED::operator=(that); | 623 | 1.22k | return *this; | 624 | 1.22k | } |
SkSTArray<4, signed char, false>::operator=(SkSTArray<4, signed char, false> const&) Line | Count | Source | 621 | 22.7M | SkSTArray& operator=(const SkSTArray& that) { | 622 | 22.7M | INHERITED::operator=(that); | 623 | 22.7M | return *this; | 624 | 22.7M | } |
SkSTArray<4, int, true>::operator=(SkSTArray<4, int, true> const&) Line | Count | Source | 621 | 2.00M | SkSTArray& operator=(const SkSTArray& that) { | 622 | 2.00M | INHERITED::operator=(that); | 623 | 2.00M | return *this; | 624 | 2.00M | } |
SkSTArray<4, SkTypeface_FreeType::Scanner::AxisDefinition, true>::operator=(SkSTArray<4, SkTypeface_FreeType::Scanner::AxisDefinition, true> const&) Line | Count | Source | 621 | 2.02k | SkSTArray& operator=(const SkSTArray& that) { | 622 | 2.02k | INHERITED::operator=(that); | 623 | 2.02k | return *this; | 624 | 2.02k | } |
Unexecuted instantiation: SkSTArray<128, unsigned short, true>::operator=(SkSTArray<128, unsigned short, true> const&) Unexecuted instantiation: SkSTArray<128, SkPoint, true>::operator=(SkSTArray<128, SkPoint, true> const&) Unexecuted instantiation: SkSTArray<128, unsigned int, true>::operator=(SkSTArray<128, unsigned int, true> const&) Unexecuted instantiation: SkSTArray<128, SkRect, true>::operator=(SkSTArray<128, SkRect, true> const&) Unexecuted instantiation: SkSTArray<128, float, true>::operator=(SkSTArray<128, float, true> const&) |
625 | | SkSTArray& operator=(const INHERITED& that) { |
626 | | INHERITED::operator=(that); |
627 | | return *this; |
628 | | } |
629 | | |
630 | 29.2M | SkSTArray& operator=(SkSTArray&& that) { |
631 | 29.2M | INHERITED::operator=(std::move(that)); |
632 | 29.2M | return *this; |
633 | 29.2M | } SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>::operator=(SkSTArray<2, std::__1::unique_ptr<SkSL::Statement, std::__1::default_delete<SkSL::Statement> >, false>&&) Line | Count | Source | 630 | 12.1M | SkSTArray& operator=(SkSTArray&& that) { | 631 | 12.1M | INHERITED::operator=(std::move(that)); | 632 | 12.1M | return *this; | 633 | 12.1M | } |
Unexecuted instantiation: SkSTArray<2, int, false>::operator=(SkSTArray<2, int, false>&&) SkSTArray<2, std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>::operator=(SkSTArray<2, std::__1::unique_ptr<SkSL::Expression, std::__1::default_delete<SkSL::Expression> >, false>&&) Line | Count | Source | 630 | 14.7M | SkSTArray& operator=(SkSTArray&& that) { | 631 | 14.7M | INHERITED::operator=(std::move(that)); | 632 | 14.7M | return *this; | 633 | 14.7M | } |
SkSTArray<4, int, true>::operator=(SkSTArray<4, int, true>&&) Line | Count | Source | 630 | 1.67M | SkSTArray& operator=(SkSTArray&& that) { | 631 | 1.67M | INHERITED::operator=(std::move(that)); | 632 | 1.67M | return *this; | 633 | 1.67M | } |
SkSTArray<4, signed char, false>::operator=(SkSTArray<4, signed char, false>&&) Line | Count | Source | 630 | 626k | SkSTArray& operator=(SkSTArray&& that) { | 631 | 626k | INHERITED::operator=(std::move(that)); | 632 | 626k | return *this; | 633 | 626k | } |
SkSTArray<1, sk_sp<GrTextBlob>, false>::operator=(SkSTArray<1, sk_sp<GrTextBlob>, false>&&) Line | Count | Source | 630 | 1.22k | SkSTArray& operator=(SkSTArray&& that) { | 631 | 1.22k | INHERITED::operator=(std::move(that)); | 632 | 1.22k | return *this; | 633 | 1.22k | } |
Unexecuted instantiation: SkSTArray<128, unsigned short, true>::operator=(SkSTArray<128, unsigned short, true>&&) Unexecuted instantiation: SkSTArray<128, SkPoint, true>::operator=(SkSTArray<128, SkPoint, true>&&) Unexecuted instantiation: SkSTArray<128, unsigned int, true>::operator=(SkSTArray<128, unsigned int, true>&&) Unexecuted instantiation: SkSTArray<128, SkRect, true>::operator=(SkSTArray<128, SkRect, true>&&) Unexecuted instantiation: SkSTArray<128, float, true>::operator=(SkSTArray<128, float, true>&&) Unexecuted instantiation: SkSTArray<1, unsigned long, true>::operator=(SkSTArray<1, unsigned long, true>&&) |
634 | | SkSTArray& operator=(INHERITED&& that) { |
635 | | INHERITED::operator=(std::move(that)); |
636 | | return *this; |
637 | | } |
638 | | }; |
639 | | |
640 | | #endif |