1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
// Copyright 2019 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef COMPONENTS_PAINT_PREVIEW_COMMON_SERIAL_UTILS_H_
#define COMPONENTS_PAINT_PREVIEW_COMMON_SERIAL_UTILS_H_
#include <memory>
#include "base/containers/flat_map.h"
#include "base/containers/flat_set.h"
#include "base/files/file.h"
#include "base/memory/raw_ptr.h"
#include "base/unguessable_token.h"
#include "components/paint_preview/common/glyph_usage.h"
#include "third_party/skia/include/core/SkPicture.h"
#include "third_party/skia/include/core/SkRefCnt.h"
#include "third_party/skia/include/core/SkSerialProcs.h"
#include "third_party/skia/include/core/SkTypeface.h"
#include "ui/gfx/geometry/rect_f.h"
namespace paint_preview {
struct PictureSerializationContext {
PictureSerializationContext();
~PictureSerializationContext();
PictureSerializationContext(const PictureSerializationContext&) = delete;
PictureSerializationContext& operator=(const PictureSerializationContext&) =
delete;
PictureSerializationContext(PictureSerializationContext&&) noexcept;
PictureSerializationContext& operator=(
PictureSerializationContext&&) noexcept;
// Maps a content ID to a transformed clip rect.
base::flat_map<uint32_t, SkRect> content_id_to_transformed_clip;
// Maps a content ID to an embedding token.
base::flat_map<uint32_t, base::UnguessableToken>
content_id_to_embedding_token;
};
// Maps a typeface ID to a glyph usage tracker.
using TypefaceUsageMap =
base::flat_map<SkTypefaceID, std::unique_ptr<GlyphUsage>>;
// Tracks typeface deduplication and handles subsetting.
struct TypefaceSerializationContext {
TypefaceSerializationContext(TypefaceUsageMap* usage);
~TypefaceSerializationContext();
raw_ptr<TypefaceUsageMap> usage;
base::flat_set<SkTypefaceID> finished; // Should be empty on first use.
};
struct ImageSerializationContext {
// The remaining memory budget for images. This is ignored if the value is the
// max value of uint64_t.
uint64_t remaining_image_size{std::numeric_limits<uint64_t>::max()};
// The maximum size of a decoded image allowed for serialization. Images that
// are larger than this when decoded are skipped.
uint64_t max_decoded_image_size_bytes{std::numeric_limits<uint64_t>::max()};
// Skip texture backed images. Must be true if serialized off the main
// thread.
bool skip_texture_backed{false};
// Will be set to true post serialization if the `remaining_image_size` budget
// was exceeded.
bool memory_budget_exceeded{false};
};
// Maps a content ID to a clip rect.
using DeserializationContext = base::flat_map<uint32_t, gfx::RectF>;
// A pair that contains a frame's |SkPicture| and its associated scroll offsets.
// Used in |LoadedFramesDeserialContext| to correctly replay the scroll state
// for subframes.
struct FrameAndScrollOffsets {
FrameAndScrollOffsets();
~FrameAndScrollOffsets();
FrameAndScrollOffsets(const FrameAndScrollOffsets&);
FrameAndScrollOffsets& operator=(const FrameAndScrollOffsets&);
sk_sp<SkPicture> picture;
gfx::Size scroll_offsets;
};
// Maps a content ID to a frame's picture. A frame's subframes should be
// loaded into this context before |MakeDeserialProcs| is called to ensure
// that the resulting |SkPicture| contains all subframes.
using LoadedFramesDeserialContext =
base::flat_map<uint32_t, FrameAndScrollOffsets>;
// Creates a no-op SkPicture.
sk_sp<SkPicture> MakeEmptyPicture();
// Creates a SkSerialProcs object. The object *does not* copy |picture_ctx| or
// |typeface_ctx| so they must outlive the use of the returned object.
SkSerialProcs MakeSerialProcs(PictureSerializationContext* picture_ctx,
TypefaceSerializationContext* typeface_ctx,
ImageSerializationContext* image_ctx);
// Creates a SkDeserialProcs object. The object *does not* copy |ctx| so |ctx|
// must outlive the use of the returned object. |ctx| will be filled as pictures
// are being deserialized. Subframes will be filled with |MakeEmptyPicture|.
SkDeserialProcs MakeDeserialProcs(DeserializationContext* ctx);
// Creates a SkDeserialProcs object. The object *does not* copy |ctx| so |ctx|
// must outlive the use of the returned object. |ctx| will be referenced for
// subframes as pictures are being serialized. If a subframe does not exist in
// |ctx|, its rectangle will be fillde with |MakeEmptyPicture|.
SkDeserialProcs MakeDeserialProcs(LoadedFramesDeserialContext* ctx);
} // namespace paint_preview
#endif // COMPONENTS_PAINT_PREVIEW_COMMON_SERIAL_UTILS_H_
|
