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
|
// Copyright 2022 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "chrome/browser/apps/app_service/app_icon/app_icon_test_util.h"
#include "base/functional/callback.h"
#include "base/run_loop.h"
#include "chrome/browser/apps/app_service/app_icon/app_icon_factory.h"
#include "extensions/grit/extensions_browser_resources.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/base/resource/resource_scale_factor.h"
#include "ui/gfx/codec/png_codec.h"
#include "ui/gfx/image/image_skia.h"
#include "ui/gfx/image/image_skia_rep.h"
#include "ui/gfx/image/image_unittest_util.h"
#if BUILDFLAG(IS_CHROMEOS)
#include "chrome/browser/apps/app_service/app_launch_params.h"
#include "chrome/test/base/testing_profile.h"
#endif // BUILDFLAG(IS_CHROMEOS)
namespace apps {
void EnsureRepresentationsLoaded(gfx::ImageSkia& output_image_skia) {
for (const auto scale_factor : ui::GetSupportedResourceScaleFactors()) {
// Force the icon to be loaded.
output_image_skia.GetRepresentation(
ui::GetScaleForResourceScaleFactor(scale_factor));
}
}
void LoadDefaultIcon(gfx::ImageSkia& output_image_skia, int resource_id) {
base::RunLoop run_loop;
apps::LoadIconFromResource(
/*profile=*/nullptr, /*app_id=*/std::nullopt,
apps::IconType::kUncompressed, kSizeInDip, resource_id,
/*is_placeholder_icon=*/false, apps::IconEffects::kNone,
base::BindOnce(
[](gfx::ImageSkia* image, base::OnceClosure load_app_icon_callback,
apps::IconValuePtr icon) {
*image = icon->uncompressed;
std::move(load_app_icon_callback).Run();
},
&output_image_skia, run_loop.QuitClosure()));
run_loop.Run();
EnsureRepresentationsLoaded(output_image_skia);
}
void VerifyIcon(const gfx::ImageSkia& src, const gfx::ImageSkia& dst) {
ASSERT_FALSE(src.isNull());
ASSERT_FALSE(dst.isNull());
const std::vector<ui::ResourceScaleFactor>& scale_factors =
ui::GetSupportedResourceScaleFactors();
ASSERT_EQ(2U, scale_factors.size());
for (const auto scale_factor : scale_factors) {
const float scale = ui::GetScaleForResourceScaleFactor(scale_factor);
ASSERT_TRUE(src.HasRepresentation(scale));
ASSERT_TRUE(dst.HasRepresentation(scale));
ASSERT_TRUE(
gfx::test::AreBitmapsEqual(src.GetRepresentation(scale).GetBitmap(),
dst.GetRepresentation(scale).GetBitmap()));
}
}
void VerifyCompressedIcon(const std::vector<uint8_t>& src_data,
const apps::IconValue& icon) {
ASSERT_EQ(apps::IconType::kCompressed, icon.icon_type);
ASSERT_FALSE(icon.is_placeholder_icon);
ASSERT_FALSE(icon.compressed.empty());
// Decompress each PNG and make sure the contents are the same. Comparing the
// compressed bits directly is too strict, since there are many valid ways to
// represent the same image using different bits.
SkBitmap src_bitmap = gfx::PNGCodec::Decode(src_data);
SkBitmap icon_bitmap = gfx::PNGCodec::Decode(icon.compressed);
ASSERT_FALSE(src_bitmap.isNull());
ASSERT_FALSE(icon_bitmap.isNull());
ASSERT_TRUE(gfx::test::AreBitmapsEqual(src_bitmap, icon_bitmap));
}
gfx::ImageSkia CreateSquareIconImageSkia(int size_dp, SkColor solid_color) {
gfx::ImageSkia image;
for (const auto scale_factor : ui::GetSupportedResourceScaleFactors()) {
int icon_size_in_px =
gfx::ScaleToFlooredSize(gfx::Size(size_dp, size_dp), scale_factor)
.width();
SkBitmap bitmap = gfx::test::CreateBitmap(icon_size_in_px, solid_color);
image.AddRepresentation(gfx::ImageSkiaRep(bitmap, scale_factor));
}
return image;
}
#if BUILDFLAG(IS_CHROMEOS)
FakeIconLoader::FakeIconLoader(apps::AppServiceProxy* proxy) : proxy_(proxy) {}
std::unique_ptr<apps::IconLoader::Releaser> FakeIconLoader::LoadIconFromIconKey(
const std::string& id,
const apps::IconKey& icon_key,
apps::IconType icon_type,
int32_t size_in_dip,
bool allow_placeholder_icon,
apps::LoadIconCallback callback) {
if (proxy_) {
proxy_->ReadIconsForTesting(proxy_->AppRegistryCache().GetAppType(id), id,
size_in_dip, icon_key, icon_type,
std::move(callback));
}
return nullptr;
}
FakePublisherForIconTest::FakePublisherForIconTest(apps::AppServiceProxy* proxy,
apps::AppType app_type)
: AppPublisher(proxy) {
RegisterPublisher(app_type);
}
void FakePublisherForIconTest::GetCompressedIconData(
const std::string& app_id,
int32_t size_in_dip,
ui::ResourceScaleFactor scale_factor,
apps::LoadIconCallback callback) {
apps::GetWebAppCompressedIconData(proxy()->profile(), app_id, size_in_dip,
scale_factor, std::move(callback));
}
#endif // BUILDFLAG(IS_CHROMEOS)
} // namespace apps
|
