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
121
122
123
124
125
126
127
128
129
|
// Copyright 2018 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ui/lottie/resource.h"
#include <memory>
#include <utility>
#include <vector>
#include "base/functional/bind.h"
#include "base/memory/ref_counted_memory.h"
#include "cc/paint/paint_op_buffer.h"
#include "cc/paint/record_paint_canvas.h"
#include "cc/paint/skottie_color_map.h"
#include "cc/paint/skottie_wrapper.h"
#include "third_party/skia/include/core/SkColor.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/geometry/size.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/gfx/image/image_skia_rep.h"
#include "ui/gfx/image/image_skia_source.h"
#include "ui/lottie/animation.h"
#if BUILDFLAG(IS_CHROMEOS_ASH)
#include "ui/base/models/image_model.h" // nogncheck
#include "ui/color/color_id.h" // nogncheck
#include "ui/color/color_provider.h" // nogncheck
#endif
namespace lottie {
namespace {
// A descendant of |gfx::ImageSkiaSource| that simply uses one
// |gfx::ImageSkiaRep| for all scales.
class LottieImageSource : public gfx::ImageSkiaSource {
public:
explicit LottieImageSource(const gfx::ImageSkiaRep& rep) : rep_(rep) {}
LottieImageSource(const LottieImageSource&) = delete;
LottieImageSource& operator=(const LottieImageSource&) = delete;
~LottieImageSource() override = default;
// gfx::ImageSkiaSource overrides:
gfx::ImageSkiaRep GetImageForScale(float scale) override { return rep_; }
bool HasRepresentationAtAllScales() const override { return true; }
private:
gfx::ImageSkiaRep rep_;
};
// Uses |LottieImageSource| to create a |gfx::ImageSkia| from an |Animation|.
gfx::ImageSkia CreateImageSkia(Animation* content) {
const gfx::Size size = content->GetOriginalSize();
cc::InspectableRecordPaintCanvas record_canvas(size);
gfx::Canvas canvas(&record_canvas, 1.0);
#if DCHECK_IS_ON()
gfx::Rect clip_rect;
DCHECK(canvas.GetClipBounds(&clip_rect));
DCHECK(clip_rect.Contains(gfx::Rect(size)));
#endif
content->PaintFrame(&canvas, 0.f, size);
const gfx::ImageSkiaRep rep(record_canvas.ReleaseAsRecord(), size, 0.f);
return gfx::ImageSkia(std::make_unique<LottieImageSource>(rep),
rep.pixel_size());
}
#if BUILDFLAG(IS_CHROMEOS_ASH)
// Creates a |cc::SkottieColorMap| with theme colors from a |ui::ColorProvider|.
cc::SkottieColorMap CreateColorMap(const ui::ColorProvider* color_provider) {
return {
cc::SkottieMapColor("_CrOS_Color1",
color_provider->GetColor(ui::kColorNativeColor1)),
cc::SkottieMapColor(
"_CrOS_Color1Shade1",
color_provider->GetColor(ui::kColorNativeColor1Shade1)),
cc::SkottieMapColor(
"_CrOS_Color1Shade2",
color_provider->GetColor(ui::kColorNativeColor1Shade2)),
cc::SkottieMapColor("_CrOS_Color2",
color_provider->GetColor(ui::kColorNativeColor2)),
cc::SkottieMapColor("_CrOS_Color3",
color_provider->GetColor(ui::kColorNativeColor3)),
cc::SkottieMapColor("_CrOS_Color4",
color_provider->GetColor(ui::kColorNativeColor4)),
cc::SkottieMapColor("_CrOS_Color5",
color_provider->GetColor(ui::kColorNativeColor5)),
cc::SkottieMapColor("_CrOS_Color6",
color_provider->GetColor(ui::kColorNativeColor6)),
cc::SkottieMapColor("_CrOS_BaseColor",
color_provider->GetColor(ui::kColorNativeBaseColor)),
cc::SkottieMapColor(
"_CrOS_SecondaryColor",
color_provider->GetColor(ui::kColorNativeSecondaryColor))};
}
// Used for a |ui::ImageModel::ImageGenerator|.
gfx::ImageSkia CreateImageSkiaWithCurrentTheme(
std::vector<uint8_t> bytes,
const ui::ColorProvider* color_provider) {
auto content = std::make_unique<Animation>(
cc::SkottieWrapper::CreateSerializable(std::move(bytes)),
CreateColorMap(color_provider));
return CreateImageSkia(content.get());
}
#endif
} // namespace
gfx::ImageSkia ParseLottieAsStillImage(std::vector<uint8_t> data) {
auto content = std::make_unique<Animation>(
cc::SkottieWrapper::CreateSerializable(std::move(data)));
return CreateImageSkia(content.get());
}
#if BUILDFLAG(IS_CHROMEOS_ASH)
ui::ImageModel ParseLottieAsThemedStillImage(std::vector<uint8_t> data) {
const gfx::Size size =
std::make_unique<Animation>(cc::SkottieWrapper::CreateSerializable(data))
->GetOriginalSize();
return ui::ImageModel::FromImageGenerator(
base::BindRepeating(&CreateImageSkiaWithCurrentTheme, std::move(data)),
size);
}
#endif
} // namespace lottie
|
