Coverage Report

Created: 2024-05-20 07:14

/src/skia/src/text/gpu/GlyphVector.cpp
Line
Count
Source (jump to first uncovered line)
1
/*
2
 * Copyright 2022 Google LLC
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
#include "src/text/gpu/GlyphVector.h"
9
10
#include "include/private/base/SkAssert.h"
11
#include "include/private/base/SkTo.h"
12
#include "src/core/SkGlyph.h"
13
#include "src/core/SkReadBuffer.h"
14
#include "src/core/SkStrike.h"
15
#include "src/core/SkStrikeCache.h"
16
#include "src/core/SkWriteBuffer.h"
17
#include "src/text/StrikeForGPU.h"
18
#include "src/text/gpu/SubRunAllocator.h"
19
20
#include <climits>
21
#include <optional>
22
#include <utility>
23
24
class SkStrikeClient;
25
26
using MaskFormat = skgpu::MaskFormat;
27
28
namespace sktext::gpu {
29
class Glyph;
30
31
// -- GlyphVector ----------------------------------------------------------------------------------
32
GlyphVector::GlyphVector(SkStrikePromise&& strikePromise, SkSpan<Variant> glyphs)
33
        : fStrikePromise{std::move(strikePromise)}
34
839
        , fGlyphs{glyphs} {
35
839
    SkASSERT(fGlyphs.size() > 0);
36
839
}
37
38
GlyphVector GlyphVector::Make(SkStrikePromise&& promise,
39
                              SkSpan<const SkPackedGlyphID> packedIDs,
40
839
                              SubRunAllocator* alloc) {
41
839
    SkASSERT(packedIDs.size() > 0);
42
12.6k
    auto packedIDToVariant = [] (SkPackedGlyphID packedID) {
43
12.6k
        return Variant{packedID};
44
12.6k
    };
GlyphVector.cpp:sktext::gpu::GlyphVector::Make(sktext::SkStrikePromise&&, SkSpan<SkPackedGlyphID const>, sktext::gpu::SubRunAllocator*)::$_0::operator()(SkPackedGlyphID) const
Line
Count
Source
42
12.6k
    auto packedIDToVariant = [] (SkPackedGlyphID packedID) {
43
12.6k
        return Variant{packedID};
44
12.6k
    };
Unexecuted instantiation: GlyphVector.cpp:sktext::gpu::GlyphVector::Make(sktext::SkStrikePromise&&, SkSpan<SkPackedGlyphID const>, sktext::gpu::SubRunAllocator*)::$_1::operator()(SkPackedGlyphID) const
45
46
839
    return GlyphVector{std::move(promise),
47
839
                       alloc->makePODArray<Variant>(packedIDs, packedIDToVariant)};
48
839
}
49
50
std::optional<GlyphVector> GlyphVector::MakeFromBuffer(SkReadBuffer& buffer,
51
                                                       const SkStrikeClient* client,
52
0
                                                       SubRunAllocator* alloc) {
53
0
    std::optional<SkStrikePromise> promise =
54
0
            SkStrikePromise::MakeFromBuffer(buffer, client, SkStrikeCache::GlobalStrikeCache());
55
0
    if (!buffer.validate(promise.has_value())) {
56
0
        return std::nullopt;
57
0
    }
58
59
0
    int32_t glyphCount = buffer.read32();
60
    // Since the glyph count can never be zero. There was a buffer reading problem.
61
0
    if (!buffer.validate(glyphCount > 0)) {
62
0
        return std::nullopt;
63
0
    }
64
65
    // Make sure we can multiply without overflow in the check below.
66
0
    static constexpr int kMaxCount = (int)(INT_MAX / sizeof(uint32_t));
67
0
    if (!buffer.validate(glyphCount <= kMaxCount)) {
68
0
        return std::nullopt;
69
0
    }
70
71
    // Check for enough bytes to populate the packedGlyphID array. If not enough something has
72
    // gone wrong.
73
0
    if (!buffer.validate(glyphCount * sizeof(uint32_t) <= buffer.available())) {
74
0
        return std::nullopt;
75
0
    }
76
77
0
    Variant* variants = alloc->makePODArray<Variant>(glyphCount);
78
0
    for (int i = 0; i < glyphCount; i++) {
79
0
        variants[i].packedGlyphID = SkPackedGlyphID(buffer.readUInt());
80
0
    }
81
0
    return GlyphVector{std::move(promise.value()), SkSpan(variants, glyphCount)};
82
0
}
83
84
0
void GlyphVector::flatten(SkWriteBuffer& buffer) const {
85
    // There should never be a glyph vector with zero glyphs.
86
0
    SkASSERT(fGlyphs.size() != 0);
87
0
    fStrikePromise.flatten(buffer);
88
89
    // Write out the span of packedGlyphIDs.
90
0
    buffer.write32(SkTo<int32_t>(fGlyphs.size()));
91
0
    for (Variant variant : fGlyphs) {
92
0
        buffer.writeUInt(variant.packedGlyphID.value());
93
0
    }
94
0
}
Unexecuted instantiation: sktext::gpu::GlyphVector::flatten(SkWriteBuffer&) const
Unexecuted instantiation: sktext::gpu::GlyphVector::flatten(SkWriteBuffer&) const
95
96
1.93k
SkSpan<const Glyph*> GlyphVector::glyphs() const {
97
1.93k
    return SkSpan(reinterpret_cast<const Glyph**>(fGlyphs.data()), fGlyphs.size());
98
1.93k
}
99
100
// packedGlyphIDToGlyph must be run in single-threaded mode.
101
// If fSkStrike is not sk_sp<SkStrike> then the conversion to Glyph* has not happened.
102
704
void GlyphVector::packedGlyphIDToGlyph(StrikeCache* cache) {
103
704
    if (fTextStrike == nullptr) {
104
557
        SkStrike* strike = fStrikePromise.strike();
105
557
        fTextStrike = cache->findOrCreateStrike(strike->strikeSpec());
106
107
        // Get all the atlas locations for each glyph.
108
9.51k
        for (Variant& variant : fGlyphs) {
109
9.51k
            variant.glyph = fTextStrike->getGlyph(variant.packedGlyphID);
110
9.51k
        }
111
112
        // This must be pinned for the Atlas filling to work.
113
557
        strike->verifyPinnedStrike();
114
115
        // Drop the ref to the strike so that it can be purged if needed.
116
557
        fStrikePromise.resetStrike();
117
557
    }
118
704
}
119
}  // namespace sktext::gpu