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
|
// Copyright 2016 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "third_party/blink/renderer/platform/image-encoders/image_encoder_utils.h"
#include "third_party/blink/renderer/platform/instrumentation/histogram.h"
#include "third_party/blink/renderer/platform/network/mime/mime_type_registry.h"
#include "third_party/blink/renderer/platform/wtf/threading.h"
namespace blink {
const ImageEncodingMimeType ImageEncoderUtils::kDefaultEncodingMimeType =
kMimeTypePng;
const char ImageEncoderUtils::kDefaultRequestedMimeType[] = "image/png";
namespace {
// This enum is used in a UMA histogram; the values should not be changed.
enum RequestedImageMimeType : uint8_t {
kRequestedImageMimeTypePng = 0,
kRequestedImageMimeTypeJpeg = 1,
kRequestedImageMimeTypeWebp = 2,
kRequestedImageMimeTypeGif = 3,
kRequestedImageMimeTypeBmp = 4,
kRequestedImageMimeTypeIco = 5,
kRequestedImageMimeTypeTiff = 6,
kRequestedImageMimeTypeUnknown = 7,
kMaxValue = kRequestedImageMimeTypeUnknown,
};
} // namespace
ImageEncodingMimeType ImageEncoderUtils::ToEncodingMimeType(
const String& mime_type_name,
const EncodeReason encode_reason) {
String lowercase_mime_type = mime_type_name.LowerASCII();
RequestedImageMimeType requested_mime_type;
if (mime_type_name.IsNull())
lowercase_mime_type = kDefaultRequestedMimeType;
if (lowercase_mime_type == "image/png") {
requested_mime_type = kRequestedImageMimeTypePng;
} else if (lowercase_mime_type == "image/jpeg") {
requested_mime_type = kRequestedImageMimeTypeJpeg;
} else if (lowercase_mime_type == "image/webp") {
requested_mime_type = kRequestedImageMimeTypeWebp;
} else if (lowercase_mime_type == "image/gif") {
requested_mime_type = kRequestedImageMimeTypeGif;
} else if (lowercase_mime_type == "image/bmp" ||
lowercase_mime_type == "image/x-windows-bmp") {
requested_mime_type = kRequestedImageMimeTypeBmp;
} else if (lowercase_mime_type == "image/x-icon") {
requested_mime_type = kRequestedImageMimeTypeIco;
} else if (lowercase_mime_type == "image/tiff" ||
lowercase_mime_type == "image/x-tiff") {
requested_mime_type = kRequestedImageMimeTypeTiff;
} else {
requested_mime_type = kRequestedImageMimeTypeUnknown;
}
if (encode_reason == kEncodeReasonToDataURL) {
UMA_HISTOGRAM_ENUMERATION("Blink.Canvas.RequestedImageMimeTypes_toDataURL",
requested_mime_type);
} else if (encode_reason == kEncodeReasonToBlobCallback) {
UMA_HISTOGRAM_ENUMERATION(
"Blink.Canvas.RequestedImageMimeTypes_toBlobCallback",
requested_mime_type);
} else if (encode_reason == kEncodeReasonConvertToBlobPromise) {
UMA_HISTOGRAM_ENUMERATION(
"Blink.Canvas.RequestedImageMimeTypes_convertToBlobPromise",
requested_mime_type);
}
ImageEncodingMimeType encoding_mime_type = kDefaultEncodingMimeType;
// FIXME: Make isSupportedImageMIMETypeForEncoding threadsafe (to allow this
// method to be used on a worker thread).
if (MIMETypeRegistry::IsSupportedImageMIMETypeForEncoding(
lowercase_mime_type))
ParseMimeType(lowercase_mime_type, encoding_mime_type);
return encoding_mime_type;
}
bool ImageEncoderUtils::ParseMimeType(const String& mime_type_name,
ImageEncodingMimeType& mime_type) {
if (mime_type_name == "image/png") {
mime_type = kMimeTypePng;
} else if (mime_type_name == "image/jpeg") {
mime_type = kMimeTypeJpeg;
} else if (mime_type_name == "image/webp") {
mime_type = kMimeTypeWebp;
} else {
return false;
}
return true;
}
String ImageEncoderUtils::MimeTypeName(ImageEncodingMimeType mime_type) {
DCHECK_GE(mime_type, 0);
DCHECK_LT(mime_type, 3);
constexpr std::array<const char* const, 3> kMimeTypeNames = {
"image/png", "image/jpeg", "image/webp"};
return kMimeTypeNames[mime_type];
}
} // namespace blink
|
