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
130
131
132
|
// Copyright 2017 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include <memory>
#include <set>
#include <utility>
#include "base/logging.h"
#include "base/memory/ref_counted_memory.h"
#include "base/memory/scoped_refptr.h"
#include "ui/gfx/codec/png_codec.h"
#include "ui/gfx/image/image_platform.h"
#include "ui/gfx/image/image_skia_rep.h"
#include "ui/gfx/image/image_skia_source.h"
namespace gfx {
namespace internal {
namespace {
// Returns a 16x16 red image to visually show error in decoding PNG.
ImageSkia GetErrorImageSkia() {
SkBitmap bitmap;
bitmap.allocN32Pixels(16, 16);
bitmap.eraseARGB(0xff, 0xff, 0, 0);
return ImageSkia(ImageSkiaRep(bitmap, 1.0f));
}
class PNGImageSource : public ImageSkiaSource {
public:
PNGImageSource() {}
PNGImageSource(const PNGImageSource&) = delete;
PNGImageSource& operator=(const PNGImageSource&) = delete;
~PNGImageSource() override {}
ImageSkiaRep GetImageForScale(float scale) override {
if (image_skia_reps_.empty())
return ImageSkiaRep();
const ImageSkiaRep* rep = nullptr;
// gfx::ImageSkia passes one of the resource scale factors. The source
// should return:
// 1) The ImageSkiaRep with the highest scale if all available
// scales are smaller than |scale|.
// 2) The ImageSkiaRep with the smallest one that is larger than |scale|.
// TODO(crbug.com/329953472): Use a predefined threshold.
for (auto iter = image_skia_reps_.begin(); iter != image_skia_reps_.end();
++iter) {
if ((*iter).scale() == scale)
return (*iter);
if (!rep || rep->scale() < (*iter).scale())
rep = &(*iter);
if (rep->scale() >= scale)
break;
}
return rep ? *rep : ImageSkiaRep();
}
const gfx::Size size() const { return size_; }
bool AddPNGData(const ImagePNGRep& png_rep) {
const gfx::ImageSkiaRep rep = ToImageSkiaRep(png_rep);
if (rep.is_null())
return false;
if (size_.IsEmpty())
size_ = gfx::Size(rep.GetWidth(), rep.GetHeight());
image_skia_reps_.insert(rep);
return true;
}
static ImageSkiaRep ToImageSkiaRep(const ImagePNGRep& png_rep) {
scoped_refptr<base::RefCountedMemory> raw_data = png_rep.raw_data;
CHECK(raw_data.get());
SkBitmap bitmap = PNGCodec::Decode(*raw_data);
if (bitmap.isNull()) {
LOG(ERROR) << "Unable to decode PNG for " << png_rep.scale << ".";
return ImageSkiaRep();
}
return ImageSkiaRep(bitmap, png_rep.scale);
}
private:
struct Compare {
bool operator()(const ImageSkiaRep& rep1, const ImageSkiaRep& rep2) const {
return rep1.scale() < rep2.scale();
}
};
typedef std::set<ImageSkiaRep, Compare> ImageSkiaRepSet;
ImageSkiaRepSet image_skia_reps_;
gfx::Size size_;
};
} // namespace
ImageSkia ImageSkiaFromPNG(const std::vector<ImagePNGRep>& image_png_reps) {
if (image_png_reps.empty())
return GetErrorImageSkia();
std::unique_ptr<PNGImageSource> image_source(new PNGImageSource);
for (size_t i = 0; i < image_png_reps.size(); ++i) {
if (!image_source->AddPNGData(image_png_reps[i]))
return GetErrorImageSkia();
}
const gfx::Size& size = image_source->size();
DCHECK(!size.IsEmpty());
if (size.IsEmpty())
return GetErrorImageSkia();
return ImageSkia(std::move(image_source), size);
}
scoped_refptr<base::RefCountedMemory> Get1xPNGBytesFromImageSkia(
const ImageSkia* image_skia) {
ImageSkiaRep image_skia_rep = image_skia->GetRepresentation(1.0f);
if (image_skia_rep.scale() != 1.0f) {
return nullptr;
}
std::optional<std::vector<uint8_t>> result = PNGCodec::EncodeBGRASkBitmap(
image_skia_rep.GetBitmap(), /*discard_transparency=*/false);
if (!result) {
return nullptr;
}
return base::MakeRefCounted<base::RefCountedBytes>(std::move(result.value()));
}
} // namespace internal
} // namespace gfx
|
