Diff
Modified: trunk/Source/WebKit/ChangeLog (277905 => 277906)
--- trunk/Source/WebKit/ChangeLog 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/ChangeLog 2021-05-22 02:23:42 UTC (rev 277906)
@@ -1,3 +1,106 @@
+2021-05-21 Sam Weinig <wei...@apple.com>
+
+ Make CGColorSpaceRef argument coding match other CF objects and use CGColorSpaceCreateWithPropertyList for fallback
+ https://bugs.webkit.org/show_bug.cgi?id=226112
+
+ Reviewed by Darin Adler.
+
+ This is a precursor to some color space type unification. This change:
+
+ - Modernizes CF arugment coders to use ArgumentCoder specialization. It also means
+ we now support encoding CF types both as plain types and RetainPtr<> types, with
+ decoding being kept only supporing RetainPtr<>s, as decoding into non-smart pointer
+ is not very useful.
+ - Move CGColorSpaceRef coding to ArgumentCodersCF and use CGColorSpaceCopyPropertyList
+ and CGColorSpaceCreateWithPropertyList as the fallback coding (if there is no name),
+ matching what other libraries on macOS and iOS do.
+ - Switch ColorSpaceData to be a struct wrapping an Optional<RetainPtr<CGColorSpaceRef>>
+ and use the new shared coding. This will be replaced entirely in subsequent changes
+ so I didn't want to change this too much now.
+
+ * NetworkProcess/NetworkProcessCreationParameters.cpp:
+ (WebKit::NetworkProcessCreationParameters::encode const):
+ (WebKit::NetworkProcessCreationParameters::decode):
+ * NetworkProcess/NetworkSessionCreationParameters.cpp:
+ (WebKit::NetworkSessionCreationParameters::encode const):
+ (WebKit::NetworkSessionCreationParameters::decode):
+ * Shared/Cocoa/ArgumentCodersCocoa.mm:
+ (IPC::encodeDataInternal):
+ (IPC::decodeDataInternal):
+ (IPC::encodeDateInternal):
+ (IPC::decodeDateInternal):
+ (IPC::encodeNumberInternal):
+ (IPC::decodeNumberInternal):
+ (IPC::encodeSecureCodingInternal):
+ (IPC::decodeSecureCodingInternal):
+ (IPC::encodeStringInternal):
+ (IPC::decodeStringInternal):
+ (IPC::encodeURLInternal):
+ (IPC::decodeURLInternal):
+ * Shared/Cocoa/WebCoreArgumentCodersCocoa.mm:
+ (IPC::ArgumentCoder<Ref<Font>>::encodePlatformData):
+ (IPC::ArgumentCoder<Ref<Font>>::decodePlatformData):
+ * Shared/FontInfo.cpp:
+ (WebKit::FontInfo::encode const):
+ (WebKit::FontInfo::decode):
+ * Shared/Plugins/PluginProcessCreationParameters.cpp:
+ (WebKit::PluginProcessCreationParameters::encode const):
+ (WebKit::PluginProcessCreationParameters::decode):
+ * Shared/WebProcessCreationParameters.cpp:
+ (WebKit::WebProcessCreationParameters::encode const):
+ (WebKit::WebProcessCreationParameters::decode):
+ * Shared/cf/ArgumentCodersCF.cpp:
+ (IPC::typeFromCFTypeRef):
+ (IPC::ArgumentCoder<CFTypeRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<CFTypeRef>>::decode):
+ (IPC::ArgumentCoder<CFArrayRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<CFArrayRef>>::decode):
+ (IPC::ArgumentCoder<CFBooleanRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<CFBooleanRef>>::decode):
+ (IPC::ArgumentCoder<CFDataRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<CFDataRef>>::decode):
+ (IPC::ArgumentCoder<CFDateRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<CFDateRef>>::decode):
+ (IPC::ArgumentCoder<CFDictionaryRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<CFDictionaryRef>>::decode):
+ (IPC::ArgumentCoder<CFNumberRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<CFNumberRef>>::decode):
+ (IPC::ArgumentCoder<CFStringRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<CFStringRef>>::decode):
+ (IPC::ArgumentCoder<CFURLRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<CFURLRef>>::decode):
+ (IPC::ArgumentCoder<CGColorSpaceRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<CGColorSpaceRef>>::decode):
+ (IPC::ArgumentCoder<SecCertificateRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<SecCertificateRef>>::decode):
+ (IPC::ArgumentCoder<SecKeychainItemRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<SecKeychainItemRef>>::decode):
+ (IPC::ArgumentCoder<SecAccessControlRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<SecAccessControlRef>>::decode):
+ (IPC::ArgumentCoder<SecTrustRef>::encode):
+ (IPC::ArgumentCoder<RetainPtr<SecTrustRef>>::decode):
+ (IPC::encode): Deleted.
+ (IPC::decode): Deleted.
+ * Shared/cf/ArgumentCodersCF.h:
+ (IPC::CFRetainPtrArgumentCoder::encode):
+ * Shared/mac/ColorSpaceData.mm:
+ (WebKit::ColorSpaceData::encode const):
+ (WebKit::ColorSpaceData::decode):
+ (): Deleted.
+ * Shared/mac/SecItemRequestData.cpp:
+ (WebKit::SecItemRequestData::encode const):
+ (WebKit::SecItemRequestData::decode):
+ * Shared/mac/SecItemResponseData.cpp:
+ (WebKit::SecItemResponseData::encode const):
+ (WebKit::SecItemResponseData::decode):
+ * Shared/mac/WebCoreArgumentCodersMac.mm:
+ (IPC::ArgumentCoder<WebCore::CertificateInfo>::encode):
+ (IPC::ArgumentCoder<WebCore::CertificateInfo>::decode):
+ (IPC::encodeNSError):
+ (IPC::decodeNSError):
+ (IPC::ArgumentCoder<WebCore::ContentFilterUnblockHandler>::encode):
+ (IPC::ArgumentCoder<WebCore::ContentFilterUnblockHandler>::decode):
+
2021-05-21 Wenson Hsieh <wenson_hs...@apple.com>
[macOS] Adopt QLItem in WKImageExtractionPreviewController
Modified: trunk/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.cpp (277905 => 277906)
--- trunk/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.cpp 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/NetworkProcess/NetworkProcessCreationParameters.cpp 2021-05-22 02:23:42 UTC (rev 277906)
@@ -57,7 +57,7 @@
encoder << urlSchemesRegisteredForCustomProtocols;
#if PLATFORM(COCOA)
encoder << uiProcessBundleIdentifier;
- IPC::encode(encoder, networkATSContext.get());
+ encoder << networkATSContext;
#endif
#if USE(SOUP)
encoder << cookieAcceptPolicy;
@@ -115,7 +115,7 @@
#if PLATFORM(COCOA)
if (!decoder.decode(result.uiProcessBundleIdentifier))
return false;
- if (!IPC::decode(decoder, result.networkATSContext))
+ if (!decoder.decode(result.networkATSContext))
return false;
#endif
Modified: trunk/Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.cpp (277905 => 277906)
--- trunk/Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.cpp 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/NetworkProcess/NetworkSessionCreationParameters.cpp 2021-05-22 02:23:42 UTC (rev 277906)
@@ -44,7 +44,7 @@
encoder << boundInterfaceIdentifier;
encoder << allowsCellularAccess;
#if PLATFORM(COCOA)
- IPC::encode(encoder, proxyConfiguration.get());
+ encoder << proxyConfiguration;
encoder << sourceApplicationBundleIdentifier;
encoder << sourceApplicationSecondaryIdentifier;
encoder << attributedBundleIdentifier;
@@ -108,7 +108,7 @@
#if PLATFORM(COCOA)
RetainPtr<CFDictionaryRef> proxyConfiguration;
- if (!IPC::decode(decoder, proxyConfiguration))
+ if (!decoder.decode(proxyConfiguration))
return WTF::nullopt;
Optional<String> sourceApplicationBundleIdentifier;
Modified: trunk/Source/WebKit/Shared/Cocoa/ArgumentCodersCocoa.mm (277905 => 277906)
--- trunk/Source/WebKit/Shared/Cocoa/ArgumentCodersCocoa.mm 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/Shared/Cocoa/ArgumentCodersCocoa.mm 2021-05-22 02:23:42 UTC (rev 277906)
@@ -306,13 +306,13 @@
static inline void encodeDataInternal(Encoder& encoder, NSData *data)
{
- encode(encoder, (__bridge CFDataRef)data);
+ encoder << (__bridge CFDataRef)data;
}
static inline Optional<RetainPtr<id>> decodeDataInternal(Decoder& decoder)
{
RetainPtr<CFDataRef> data;
- if (!decode(decoder, data))
+ if (!decoder.decode(data))
return WTF::nullopt;
return { adoptNS((NSData *)data.leakRef()) };
}
@@ -321,13 +321,13 @@
static inline void encodeDateInternal(Encoder& encoder, NSDate *date)
{
- encode(encoder, (__bridge CFDateRef)date);
+ encoder << (__bridge CFDateRef)date;
}
static inline Optional<RetainPtr<id>> decodeDateInternal(Decoder& decoder)
{
RetainPtr<CFDateRef> date;
- if (!decode(decoder, date))
+ if (!decoder.decode(date))
return WTF::nullopt;
return { adoptNS((NSDate *)date.leakRef()) };
}
@@ -414,13 +414,13 @@
static inline void encodeNumberInternal(Encoder& encoder, NSNumber *number)
{
- encode(encoder, (__bridge CFNumberRef)number);
+ encoder << (__bridge CFNumberRef)number;
}
static inline Optional<RetainPtr<id>> decodeNumberInternal(Decoder& decoder)
{
RetainPtr<CFNumberRef> number;
- if (!decode(decoder, number))
+ if (!decoder.decode(number))
return WTF::nullopt;
return { adoptNS((NSNumber *)number.leakRef()) };
}
@@ -438,7 +438,7 @@
[archiver finishEncoding];
[archiver setDelegate:nil];
- encode(encoder, (__bridge CFDataRef)[archiver encodedData]);
+ encoder << (__bridge CFDataRef)[archiver encodedData];
}
static Optional<RetainPtr<id>> decodeSecureCodingInternal(Decoder& decoder, NSArray<Class> *allowedClasses)
@@ -448,7 +448,7 @@
return WTF::nullopt;
RetainPtr<CFDataRef> data;
- if (!decode(decoder, data))
+ if (!decoder.decode(data))
return WTF::nullopt;
auto unarchiver = adoptNS([[NSKeyedUnarchiver alloc] initForReadingFromData:(__bridge NSData *)data.get() error:nullptr]);
@@ -477,13 +477,13 @@
static inline void encodeStringInternal(Encoder& encoder, NSString *string)
{
- encode(encoder, (__bridge CFStringRef)string);
+ encoder << (__bridge CFStringRef)string;
}
static inline Optional<RetainPtr<id>> decodeStringInternal(Decoder& decoder)
{
RetainPtr<CFStringRef> string;
- if (!decode(decoder, string))
+ if (!decoder.decode(string))
return WTF::nullopt;
return { adoptNS((NSString *)string.leakRef()) };
}
@@ -492,13 +492,13 @@
static inline void encodeURLInternal(Encoder& encoder, NSURL *URL)
{
- encode(encoder, (__bridge CFURLRef)URL);
+ encoder << (__bridge CFURLRef)URL;
}
static inline Optional<RetainPtr<id>> decodeURLInternal(Decoder& decoder)
{
RetainPtr<CFURLRef> URL;
- if (!decode(decoder, URL))
+ if (!decoder.decode(URL))
return WTF::nullopt;
return { adoptNS((NSURL *)URL.leakRef()) };
}
Modified: trunk/Source/WebKit/Shared/Cocoa/WebCoreArgumentCodersCocoa.mm (277905 => 277906)
--- trunk/Source/WebKit/Shared/Cocoa/WebCoreArgumentCodersCocoa.mm 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/Shared/Cocoa/WebCoreArgumentCodersCocoa.mm 2021-05-22 02:23:42 UTC (rev 277906)
@@ -431,7 +431,7 @@
auto ctFont = platformData.font();
auto fontDescriptor = adoptCF(CTFontCopyFontDescriptor(ctFont));
auto attributes = adoptCF(CTFontDescriptorCopyAttributes(fontDescriptor.get()));
- IPC::encode(encoder, attributes.get());
+ encoder << attributes;
const auto& creationData = platformData.creationData();
encoder << static_cast<bool>(creationData);
@@ -499,8 +499,9 @@
if (!syntheticOblique.hasValue())
return WTF::nullopt;
- RetainPtr<CFDictionaryRef> attributes;
- if (!IPC::decode(decoder, attributes))
+ Optional<RetainPtr<CFDictionaryRef>> attributes;
+ decoder >> attributes;
+ if (!attributes)
return WTF::nullopt;
Optional<bool> includesCreationData;
@@ -525,7 +526,7 @@
auto baseFontDescriptor = fontCustomPlatformData->fontDescriptor.get();
if (!baseFontDescriptor)
return WTF::nullopt;
- auto fontDescriptor = adoptCF(CTFontDescriptorCreateCopyWithAttributes(baseFontDescriptor, attributes.get()));
+ auto fontDescriptor = adoptCF(CTFontDescriptorCreateCopyWithAttributes(baseFontDescriptor, attributes->get()));
auto ctFont = adoptCF(CTFontCreateWithFontDescriptor(fontDescriptor.get(), size.value(), nullptr));
auto creationData = FontPlatformData::CreationData { fontFaceData.value(), itemInCollection.value() };
@@ -545,7 +546,7 @@
RetainPtr<CTFontDescriptorRef> fontDescriptor = findFontDescriptor(referenceURL.value(), postScriptName.value());
if (!fontDescriptor)
return WTF::nullopt;
- fontDescriptor = adoptCF(CTFontDescriptorCreateCopyWithAttributes(fontDescriptor.get(), attributes.get()));
+ fontDescriptor = adoptCF(CTFontDescriptorCreateCopyWithAttributes(fontDescriptor.get(), attributes->get()));
auto ctFont = adoptCF(CTFontCreateWithFontDescriptor(fontDescriptor.get(), size.value(), nullptr));
return FontPlatformData(ctFont.get(), size.value(), syntheticBold.value(), syntheticOblique.value(), orientation.value(), widthVariant.value(), textRenderingMode.value());
Modified: trunk/Source/WebKit/Shared/FontInfo.cpp (277905 => 277906)
--- trunk/Source/WebKit/Shared/FontInfo.cpp 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/Shared/FontInfo.cpp 2021-05-22 02:23:42 UTC (rev 277906)
@@ -39,7 +39,7 @@
#if PLATFORM(COCOA)
encoder << static_cast<bool>(fontAttributeDictionary);
if (fontAttributeDictionary)
- IPC::encode(encoder, fontAttributeDictionary.get());
+ encoder << fontAttributeDictionary;
#else
UNUSED_PARAM(encoder);
#endif
@@ -55,7 +55,7 @@
if (!hasFontAttributeDictionary)
return true;
- if (!IPC::decode(decoder, fontInfo.fontAttributeDictionary))
+ if (!decoder.decode(fontInfo.fontAttributeDictionary))
return false;
#else
UNUSED_PARAM(decoder);
Modified: trunk/Source/WebKit/Shared/Plugins/PluginProcessCreationParameters.cpp (277905 => 277906)
--- trunk/Source/WebKit/Shared/Plugins/PluginProcessCreationParameters.cpp 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/Shared/Plugins/PluginProcessCreationParameters.cpp 2021-05-22 02:23:42 UTC (rev 277906)
@@ -46,7 +46,7 @@
encoder << terminationTimeout;
#if PLATFORM(COCOA)
encoder << acceleratedCompositingPort;
- IPC::encode(encoder, networkATSContext.get());
+ encoder << networkATSContext;
#endif
}
@@ -61,7 +61,7 @@
#if PLATFORM(COCOA)
if (!decoder.decode(result.acceleratedCompositingPort))
return false;
- if (!IPC::decode(decoder, result.networkATSContext))
+ if (!decoder.decode(result.networkATSContext))
return false;
#endif
Modified: trunk/Source/WebKit/Shared/WebProcessCreationParameters.cpp (277905 => 277906)
--- trunk/Source/WebKit/Shared/WebProcessCreationParameters.cpp 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/Shared/WebProcessCreationParameters.cpp 2021-05-22 02:23:42 UTC (rev 277906)
@@ -129,7 +129,7 @@
#endif
#if PLATFORM(COCOA)
- IPC::encode(encoder, networkATSContext.get());
+ encoder << networkATSContext;
#endif
#if PLATFORM(WAYLAND)
@@ -387,7 +387,7 @@
#endif
#if PLATFORM(COCOA)
- if (!IPC::decode(decoder, parameters.networkATSContext))
+ if (!decoder.decode(parameters.networkATSContext))
return false;
#endif
Modified: trunk/Source/WebKit/Shared/cf/ArgumentCodersCF.cpp (277905 => 277906)
--- trunk/Source/WebKit/Shared/cf/ArgumentCodersCF.cpp 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/Shared/cf/ArgumentCodersCF.cpp 2021-05-22 02:23:42 UTC (rev 277906)
@@ -32,6 +32,8 @@
#include "DataReference.h"
#include "Decoder.h"
#include "Encoder.h"
+#include "StreamConnectionEncoder.h"
+#include <CoreGraphics/CoreGraphics.h>
#include <wtf/EnumTraits.h>
#include <wtf/HashSet.h>
#include <wtf/ProcessPrivilege.h>
@@ -72,6 +74,7 @@
#if HAVE(SEC_TRUST_SERIALIZATION)
SecTrust,
#endif
+ CGColorSpace,
Nullptr,
Unknown,
};
@@ -102,6 +105,8 @@
return CFType::CFString;
if (typeID == CFURLGetTypeID())
return CFType::CFURL;
+ if (typeID == CGColorSpaceGetTypeID())
+ return CFType::CGColorSpace;
if (typeID == SecCertificateGetTypeID())
return CFType::SecCertificate;
#if HAVE(SEC_KEYCHAIN)
@@ -121,54 +126,59 @@
return CFType::Unknown;
}
-void encode(Encoder& encoder, CFTypeRef typeRef)
+
+template<typename Encoder>
+void ArgumentCoder<CFTypeRef>::encode(Encoder& encoder, CFTypeRef typeRef)
{
- CFType type = typeFromCFTypeRef(typeRef);
+ auto type = typeFromCFTypeRef(typeRef);
encoder << type;
switch (type) {
case CFType::CFArray:
- encode(encoder, static_cast<CFArrayRef>(typeRef));
+ encoder << static_cast<CFArrayRef>(typeRef);
return;
case CFType::CFBoolean:
- encode(encoder, static_cast<CFBooleanRef>(typeRef));
+ encoder << static_cast<CFBooleanRef>(typeRef);
return;
case CFType::CFData:
- encode(encoder, static_cast<CFDataRef>(typeRef));
+ encoder << static_cast<CFDataRef>(typeRef);
return;
case CFType::CFDate:
- encode(encoder, static_cast<CFDateRef>(typeRef));
+ encoder << static_cast<CFDateRef>(typeRef);
return;
case CFType::CFDictionary:
- encode(encoder, static_cast<CFDictionaryRef>(typeRef));
+ encoder << static_cast<CFDictionaryRef>(typeRef);
return;
case CFType::CFNull:
return;
case CFType::CFNumber:
- encode(encoder, static_cast<CFNumberRef>(typeRef));
+ encoder << static_cast<CFNumberRef>(typeRef);
return;
case CFType::CFString:
- encode(encoder, static_cast<CFStringRef>(typeRef));
+ encoder << static_cast<CFStringRef>(typeRef);
return;
case CFType::CFURL:
- encode(encoder, static_cast<CFURLRef>(typeRef));
+ encoder << static_cast<CFURLRef>(typeRef);
return;
+ case CFType::CGColorSpace:
+ encoder << static_cast<CGColorSpaceRef>(const_cast<void*>(typeRef));
+ return;
case CFType::SecCertificate:
- encode(encoder, static_cast<SecCertificateRef>(const_cast<void*>(typeRef)));
+ encoder << static_cast<SecCertificateRef>(const_cast<void*>(typeRef));
return;
#if HAVE(SEC_KEYCHAIN)
case CFType::SecKeychainItem:
- encode(encoder, static_cast<SecKeychainItemRef>(const_cast<void*>(typeRef)));
+ encoder << static_cast<SecKeychainItemRef>(const_cast<void*>(typeRef));
return;
#endif
#if HAVE(SEC_ACCESS_CONTROL)
case CFType::SecAccessControl:
- encode(encoder, static_cast<SecAccessControlRef>(const_cast<void*>(typeRef)));
+ encoder << static_cast<SecAccessControlRef>(const_cast<void*>(typeRef));
return;
#endif
#if HAVE(SEC_TRUST_SERIALIZATION)
case CFType::SecTrust:
- encode(encoder, static_cast<SecTrustRef>(const_cast<void*>(typeRef)));
+ encoder << static_cast<SecTrustRef>(const_cast<void*>(typeRef));
return;
#endif
case CFType::Nullptr:
@@ -180,46 +190,50 @@
ASSERT_NOT_REACHED();
}
-bool decode(Decoder& decoder, RetainPtr<CFTypeRef>& result)
+template void ArgumentCoder<CFTypeRef>::encode<Encoder>(Encoder&, CFTypeRef);
+template void ArgumentCoder<CFTypeRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, CFTypeRef);
+
+bool ArgumentCoder<RetainPtr<CFTypeRef>>::decode(Decoder& decoder, RetainPtr<CFTypeRef>& result)
{
- CFType type;
- if (!decoder.decode(type))
+ Optional<CFType> type;
+ decoder >> type;
+ if (!type)
return false;
- switch (type) {
+ switch (*type) {
case CFType::CFArray: {
RetainPtr<CFArrayRef> array;
- if (!decode(decoder, array))
+ if (!decoder.decode(array))
return false;
- result = adoptCF(array.leakRef());
+ result = WTFMove(array);
return true;
}
case CFType::CFBoolean: {
RetainPtr<CFBooleanRef> boolean;
- if (!decode(decoder, boolean))
+ if (!decoder.decode(boolean))
return false;
- result = adoptCF(boolean.leakRef());
+ result = WTFMove(boolean);
return true;
}
case CFType::CFData: {
RetainPtr<CFDataRef> data;
- if (!decode(decoder, data))
+ if (!decoder.decode(data))
return false;
- result = adoptCF(data.leakRef());
+ result = WTFMove(data);
return true;
}
case CFType::CFDate: {
RetainPtr<CFDateRef> date;
- if (!decode(decoder, date))
+ if (!decoder.decode(date))
return false;
- result = adoptCF(date.leakRef());
+ result = WTFMove(date);
return true;
}
case CFType::CFDictionary: {
RetainPtr<CFDictionaryRef> dictionary;
- if (!decode(decoder, dictionary))
+ if (!decoder.decode(dictionary))
return false;
- result = adoptCF(dictionary.leakRef());
+ result = WTFMove(dictionary);
return true;
}
case CFType::CFNull:
@@ -227,38 +241,45 @@
return true;
case CFType::CFNumber: {
RetainPtr<CFNumberRef> number;
- if (!decode(decoder, number))
+ if (!decoder.decode(number))
return false;
- result = adoptCF(number.leakRef());
+ result = WTFMove(number);
return true;
}
case CFType::CFString: {
RetainPtr<CFStringRef> string;
- if (!decode(decoder, string))
+ if (!decoder.decode(string))
return false;
- result = adoptCF(string.leakRef());
+ result = WTFMove(string);
return true;
}
case CFType::CFURL: {
RetainPtr<CFURLRef> url;
- if (!decode(decoder, url))
+ if (!decoder.decode(url))
return false;
- result = adoptCF(url.leakRef());
+ result = WTFMove(url);
return true;
}
+ case CFType::CGColorSpace: {
+ RetainPtr<CGColorSpaceRef> colorSpace;
+ if (!decoder.decode(colorSpace))
+ return false;
+ result = WTFMove(colorSpace);
+ return true;
+ }
case CFType::SecCertificate: {
RetainPtr<SecCertificateRef> certificate;
- if (!decode(decoder, certificate))
+ if (!decoder.decode(certificate))
return false;
- result = adoptCF(certificate.leakRef());
+ result = WTFMove(certificate);
return true;
}
#if HAVE(SEC_KEYCHAIN)
case CFType::SecKeychainItem: {
RetainPtr<SecKeychainItemRef> keychainItem;
- if (!decode(decoder, keychainItem))
+ if (!decoder.decode(keychainItem))
return false;
- result = adoptCF(keychainItem.leakRef());
+ result = WTFMove(keychainItem);
return true;
}
#endif
@@ -265,9 +286,9 @@
#if HAVE(SEC_ACCESS_CONTROL)
case CFType::SecAccessControl: {
RetainPtr<SecAccessControlRef> accessControl;
- if (!decode(decoder, accessControl))
+ if (!decoder.decode(accessControl))
return false;
- result = adoptCF(accessControl.leakRef());
+ result = WTFMove(accessControl);
return true;
}
#endif
@@ -274,9 +295,9 @@
#if HAVE(SEC_TRUST_SERIALIZATION)
case CFType::SecTrust: {
RetainPtr<SecTrustRef> trust;
- if (!decode(decoder, trust))
+ if (!decoder.decode(trust))
return false;
- result = adoptCF(trust.leakRef());
+ result = WTFMove(trust);
return true;
}
#endif
@@ -291,7 +312,8 @@
return false;
}
-void encode(Encoder& encoder, CFArrayRef array)
+template<typename Encoder>
+void ArgumentCoder<CFArrayRef>::encode(Encoder& encoder, CFArrayRef array)
{
if (!array) {
encoder << true;
@@ -318,11 +340,14 @@
for (CFIndex i = 0; i < size; ++i) {
if (invalidIndicies.contains(i))
continue;
- encode(encoder, values[i]);
+ encoder << values[i];
}
}
-bool decode(Decoder& decoder, RetainPtr<CFArrayRef>& result)
+template void ArgumentCoder<CFArrayRef>::encode<Encoder>(Encoder&, CFArrayRef);
+template void ArgumentCoder<CFArrayRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, CFArrayRef);
+
+bool ArgumentCoder<RetainPtr<CFArrayRef>>::decode(Decoder& decoder, RetainPtr<CFArrayRef>& result)
{
bool isNull = false;
if (!decoder.decode(isNull))
@@ -341,7 +366,7 @@
for (size_t i = 0; i < size; ++i) {
RetainPtr<CFTypeRef> element;
- if (!decode(decoder, element))
+ if (!decoder.decode(element))
return false;
if (!element)
@@ -354,12 +379,16 @@
return true;
}
-void encode(Encoder& encoder, CFBooleanRef boolean)
+template<typename Encoder>
+void ArgumentCoder<CFBooleanRef>::encode(Encoder& encoder, CFBooleanRef boolean)
{
encoder << static_cast<bool>(CFBooleanGetValue(boolean));
}
-bool decode(Decoder& decoder, RetainPtr<CFBooleanRef>& result)
+template void ArgumentCoder<CFBooleanRef>::encode<Encoder>(Encoder&, CFBooleanRef);
+template void ArgumentCoder<CFBooleanRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, CFBooleanRef);
+
+bool ArgumentCoder<RetainPtr<CFBooleanRef>>::decode(Decoder& decoder, RetainPtr<CFBooleanRef>& result)
{
bool boolean;
if (!decoder.decode(boolean))
@@ -369,15 +398,16 @@
return true;
}
-void encode(Encoder& encoder, CFDataRef data)
+template<typename Encoder>
+void ArgumentCoder<CFDataRef>::encode(Encoder& encoder, CFDataRef data)
{
- CFIndex length = CFDataGetLength(data);
- const UInt8* bytePtr = CFDataGetBytePtr(data);
-
- encoder << IPC::DataReference(bytePtr, length);
+ encoder << IPC::DataReference(CFDataGetBytePtr(data), CFDataGetLength(data));
}
-bool decode(Decoder& decoder, RetainPtr<CFDataRef>& result)
+template void ArgumentCoder<CFDataRef>::encode<Encoder>(Encoder&, CFDataRef);
+template void ArgumentCoder<CFDataRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, CFDataRef);
+
+bool ArgumentCoder<RetainPtr<CFDataRef>>::decode(Decoder& decoder, RetainPtr<CFDataRef>& result)
{
IPC::DataReference dataReference;
if (!decoder.decode(dataReference))
@@ -387,12 +417,16 @@
return true;
}
-void encode(Encoder& encoder, CFDateRef date)
+template<typename Encoder>
+void ArgumentCoder<CFDateRef>::encode(Encoder& encoder, CFDateRef date)
{
encoder << static_cast<double>(CFDateGetAbsoluteTime(date));
}
-bool decode(Decoder& decoder, RetainPtr<CFDateRef>& result)
+template void ArgumentCoder<CFDateRef>::encode<Encoder>(Encoder&, CFDateRef);
+template void ArgumentCoder<CFDateRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, CFDateRef);
+
+bool ArgumentCoder<RetainPtr<CFDateRef>>::decode(Decoder& decoder, RetainPtr<CFDateRef>& result)
{
double absoluteTime;
if (!decoder.decode(absoluteTime))
@@ -402,7 +436,8 @@
return true;
}
-void encode(Encoder& encoder, CFDictionaryRef dictionary)
+template<typename Encoder>
+void ArgumentCoder<CFDictionaryRef>::encode(Encoder& encoder, CFDictionaryRef dictionary)
{
if (!dictionary) {
encoder << true;
@@ -435,12 +470,14 @@
if (invalidKeys.contains(keys[i]))
continue;
- encode(encoder, keys[i]);
- encode(encoder, values[i]);
+ encoder << keys[i] << values[i];
}
}
-bool decode(Decoder& decoder, RetainPtr<CFDictionaryRef>& result)
+template void ArgumentCoder<CFDictionaryRef>::encode<Encoder>(Encoder&, CFDictionaryRef);
+template void ArgumentCoder<CFDictionaryRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, CFDictionaryRef);
+
+bool ArgumentCoder<RetainPtr<CFDictionaryRef>>::decode(Decoder& decoder, RetainPtr<CFDictionaryRef>& result)
{
bool isNull = false;
if (!decoder.decode(isNull))
@@ -458,21 +495,22 @@
RetainPtr<CFMutableDictionaryRef> dictionary = adoptCF(CFDictionaryCreateMutable(0, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks));
for (uint64_t i = 0; i < size; ++i) {
RetainPtr<CFTypeRef> key;
- if (!decode(decoder, key) || !key)
+ if (!decoder.decode(key) || !key)
return false;
RetainPtr<CFTypeRef> value;
- if (!decode(decoder, value) || !value)
+ if (!decoder.decode(value) || !value)
return false;
CFDictionarySetValue(dictionary.get(), key.get(), value.get());
}
- result = adoptCF(dictionary.leakRef());
+ result = WTFMove(dictionary);
return true;
}
-void encode(Encoder& encoder, CFNumberRef number)
+template<typename Encoder>
+void ArgumentCoder<CFNumberRef>::encode(Encoder& encoder, CFNumberRef number)
{
CFNumberType numberType = CFNumberGetType(number);
@@ -480,10 +518,12 @@
bool result = CFNumberGetValue(number, numberType, buffer.data());
ASSERT_UNUSED(result, result);
- encoder << static_cast<uint8_t>(numberType);
- encoder << IPC::DataReference(buffer);
+ encoder << static_cast<uint8_t>(numberType) << IPC::DataReference(buffer);
}
+template void ArgumentCoder<CFNumberRef>::encode<Encoder>(Encoder&, CFNumberRef);
+template void ArgumentCoder<CFNumberRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, CFNumberRef);
+
static size_t sizeForNumberType(CFNumberType numberType)
{
switch (numberType) {
@@ -524,7 +564,7 @@
return 0;
}
-bool decode(Decoder& decoder, RetainPtr<CFNumberRef>& result)
+bool ArgumentCoder<RetainPtr<CFNumberRef>>::decode(Decoder& decoder, RetainPtr<CFNumberRef>& result)
{
Optional<uint8_t> numberTypeFromIPC;
decoder >> numberTypeFromIPC;
@@ -546,7 +586,8 @@
return true;
}
-void encode(Encoder& encoder, CFStringRef string)
+template<typename Encoder>
+void ArgumentCoder<CFStringRef>::encode(Encoder& encoder, CFStringRef string)
{
CFIndex length = CFStringGetLength(string);
CFStringEncoding encoding = CFStringGetFastestEncoding(string);
@@ -561,11 +602,13 @@
numConvertedBytes = CFStringGetBytes(string, range, encoding, 0, false, buffer.data(), buffer.size(), &bufferLength);
ASSERT(numConvertedBytes == length);
- encoder << static_cast<uint32_t>(encoding);
- encoder << IPC::DataReference(buffer);
+ encoder << static_cast<uint32_t>(encoding) << IPC::DataReference(buffer);
}
-bool decode(Decoder& decoder, RetainPtr<CFStringRef>& result)
+template void ArgumentCoder<CFStringRef>::encode<Encoder>(Encoder&, CFStringRef);
+template void ArgumentCoder<CFStringRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, CFStringRef);
+
+bool ArgumentCoder<RetainPtr<CFStringRef>>::decode(Decoder& decoder, RetainPtr<CFStringRef>& result)
{
Optional<uint32_t> encodingFromIPC;
decoder >> encodingFromIPC;
@@ -588,20 +631,23 @@
return true;
}
-void encode(Encoder& encoder, CFURLRef url)
+template<typename Encoder>
+void ArgumentCoder<CFURLRef>::encode(Encoder& encoder, CFURLRef url)
{
CFURLRef baseURL = CFURLGetBaseURL(url);
encoder << static_cast<bool>(baseURL);
if (baseURL)
- encode(encoder, baseURL);
+ encoder << baseURL;
WTF::URLCharBuffer urlBytes;
WTF::getURLBytes(url, urlBytes);
- IPC::DataReference dataReference(reinterpret_cast<const uint8_t*>(urlBytes.data()), urlBytes.size());
- encoder << dataReference;
+ encoder << IPC::DataReference(reinterpret_cast<const uint8_t*>(urlBytes.data()), urlBytes.size());
}
-bool decode(Decoder& decoder, RetainPtr<CFURLRef>& result)
+template void ArgumentCoder<CFURLRef>::encode<Encoder>(Encoder&, CFURLRef);
+template void ArgumentCoder<CFURLRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, CFURLRef);
+
+bool ArgumentCoder<RetainPtr<CFURLRef>>::decode(Decoder& decoder, RetainPtr<CFURLRef>& result)
{
RetainPtr<CFURLRef> baseURL;
bool hasBaseURL;
@@ -608,7 +654,7 @@
if (!decoder.decode(hasBaseURL))
return false;
if (hasBaseURL) {
- if (!decode(decoder, baseURL))
+ if (!decoder.decode(baseURL))
return false;
}
@@ -631,16 +677,73 @@
return result;
}
-void encode(Encoder& encoder, SecCertificateRef certificate)
+enum class CGColorSpaceEncodingScheme { Name, PropertyList };
+
+template<typename Encoder>
+void ArgumentCoder<CGColorSpaceRef>::encode(Encoder& encoder, CGColorSpaceRef colorSpace)
{
- RetainPtr<CFDataRef> data = ""
- encode(encoder, data.get());
+ if (auto name = CGColorSpaceGetName(colorSpace)) {
+ encoder << CGColorSpaceEncodingScheme::Name << name;
+ return;
+ }
+
+ encoder << CGColorSpaceEncodingScheme::PropertyList << adoptCF(CGColorSpaceCopyPropertyList(colorSpace));
}
-bool decode(Decoder& decoder, RetainPtr<SecCertificateRef>& result)
+template void ArgumentCoder<CGColorSpaceRef>::encode<Encoder>(Encoder&, CGColorSpaceRef);
+template void ArgumentCoder<CGColorSpaceRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, CGColorSpaceRef);
+
+bool ArgumentCoder<RetainPtr<CGColorSpaceRef>>::decode(Decoder& decoder, RetainPtr<CGColorSpaceRef>& result)
{
+ CGColorSpaceEncodingScheme encodingScheme;
+ if (!decoder.decode(encodingScheme))
+ return false;
+
+ switch (encodingScheme) {
+ case CGColorSpaceEncodingScheme::Name: {
+ RetainPtr<CFStringRef> name;
+ if (!decoder.decode(name))
+ return false;
+
+ auto colorSpace = adoptCF(CGColorSpaceCreateWithName(name.get()));
+ if (!colorSpace)
+ return false;
+
+ result = WTFMove(colorSpace);
+ return true;
+ }
+ case CGColorSpaceEncodingScheme::PropertyList: {
+ RetainPtr<CFTypeRef> propertyList;
+ if (!decoder.decode(propertyList))
+ return false;
+
+ auto colorSpace = adoptCF(CGColorSpaceCreateWithPropertyList(propertyList.get()));
+ if (!colorSpace)
+ return false;
+
+ result = WTFMove(colorSpace);
+ return true;
+ }
+ }
+
+ ASSERT_NOT_REACHED();
+ return false;
+}
+
+
+template<typename Encoder>
+void ArgumentCoder<SecCertificateRef>::encode(Encoder& encoder, SecCertificateRef certificate)
+{
+ encoder << adoptCF(SecCertificateCopyData(certificate));
+}
+
+template void ArgumentCoder<SecCertificateRef>::encode<Encoder>(Encoder&, SecCertificateRef);
+template void ArgumentCoder<SecCertificateRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, SecCertificateRef);
+
+bool ArgumentCoder<RetainPtr<SecCertificateRef>>::decode(Decoder& decoder, RetainPtr<SecCertificateRef>& result)
+{
RetainPtr<CFDataRef> data;
- if (!decode(decoder, data))
+ if (!decoder.decode(data))
return false;
result = adoptCF(SecCertificateCreateWithData(0, data.get()));
@@ -648,23 +751,27 @@
}
#if HAVE(SEC_KEYCHAIN)
-void encode(Encoder& encoder, SecKeychainItemRef keychainItem)
+template<typename Encoder>
+void ArgumentCoder<SecKeychainItemRef>::encode(Encoder& encoder, SecKeychainItemRef keychainItem)
{
RELEASE_ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessCredentials));
CFDataRef data;
if (SecKeychainItemCreatePersistentReference(keychainItem, &data) == errSecSuccess) {
- encode(encoder, data);
+ encoder << data;
CFRelease(data);
}
}
-bool decode(Decoder& decoder, RetainPtr<SecKeychainItemRef>& result)
+template void ArgumentCoder<SecKeychainItemRef>::encode<Encoder>(Encoder&, SecKeychainItemRef);
+template void ArgumentCoder<SecKeychainItemRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, SecKeychainItemRef);
+
+bool ArgumentCoder<RetainPtr<SecKeychainItemRef>>::decode(Decoder& decoder, RetainPtr<SecKeychainItemRef>& result)
{
RELEASE_ASSERT(hasProcessPrivilege(ProcessPrivilege::CanAccessCredentials));
RetainPtr<CFDataRef> data;
- if (!IPC::decode(decoder, data))
+ if (!decoder.decode(data))
return false;
CFDataRef dref = data.get();
@@ -682,17 +789,21 @@
#endif
#if HAVE(SEC_ACCESS_CONTROL)
-void encode(Encoder& encoder, SecAccessControlRef accessControl)
+template<typename Encoder>
+void ArgumentCoder<SecAccessControlRef>::encode(Encoder& encoder, SecAccessControlRef accessControl)
{
- RetainPtr<CFDataRef> data = ""
+ auto data = ""
if (data)
- encode(encoder, data.get());
+ encoder << data;
}
-bool decode(Decoder& decoder, RetainPtr<SecAccessControlRef>& result)
+template void ArgumentCoder<SecAccessControlRef>::encode<Encoder>(Encoder&, SecAccessControlRef);
+template void ArgumentCoder<SecAccessControlRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, SecAccessControlRef);
+
+bool ArgumentCoder<RetainPtr<SecAccessControlRef>>::decode(Decoder& decoder, RetainPtr<SecAccessControlRef>& result)
{
RetainPtr<CFDataRef> data;
- if (!decode(decoder, data))
+ if (!decoder.decode(data))
return false;
result = adoptCF(SecAccessControlCreateFromData(kCFAllocatorDefault, data.get(), nullptr));
@@ -704,7 +815,8 @@
#endif
#if HAVE(SEC_TRUST_SERIALIZATION)
-void encode(Encoder& encoder, SecTrustRef trust)
+template<typename Encoder>
+void ArgumentCoder<SecTrustRef>::encode(Encoder& encoder, SecTrustRef trust)
{
auto data = "" nullptr));
if (!data) {
@@ -712,11 +824,13 @@
return;
}
- encoder << true;
- IPC::encode(encoder, data.get());
+ encoder << true << data;
}
-bool decode(Decoder& decoder, RetainPtr<SecTrustRef>& result)
+template void ArgumentCoder<SecTrustRef>::encode<Encoder>(Encoder&, SecTrustRef);
+template void ArgumentCoder<SecTrustRef>::encode<StreamConnectionEncoder>(StreamConnectionEncoder&, SecTrustRef);
+
+bool ArgumentCoder<RetainPtr<SecTrustRef>>::decode(Decoder& decoder, RetainPtr<SecTrustRef>& result)
{
bool hasTrust;
if (!decoder.decode(hasTrust))
@@ -726,7 +840,7 @@
return true;
RetainPtr<CFDataRef> trustData;
- if (!IPC::decode(decoder, trustData))
+ if (!decoder.decode(trustData))
return false;
auto trust = adoptCF(SecTrustDeserialize(trustData.get(), nullptr));
@@ -744,29 +858,38 @@
template<> struct EnumTraits<IPC::CFType> {
using values = EnumValues<
- IPC::CFType,
- IPC::CFType::CFArray,
- IPC::CFType::CFBoolean,
- IPC::CFType::CFData,
- IPC::CFType::CFDate,
- IPC::CFType::CFDictionary,
- IPC::CFType::CFNull,
- IPC::CFType::CFNumber,
- IPC::CFType::CFString,
- IPC::CFType::CFURL,
- IPC::CFType::SecCertificate,
+ IPC::CFType,
+ IPC::CFType::CFArray,
+ IPC::CFType::CFBoolean,
+ IPC::CFType::CFData,
+ IPC::CFType::CFDate,
+ IPC::CFType::CFDictionary,
+ IPC::CFType::CFNull,
+ IPC::CFType::CFNumber,
+ IPC::CFType::CFString,
+ IPC::CFType::CFURL,
+ IPC::CFType::SecCertificate,
#if HAVE(SEC_KEYCHAIN)
- IPC::CFType::SecKeychainItem,
+ IPC::CFType::SecKeychainItem,
#endif
#if HAVE(SEC_ACCESS_CONTROL)
- IPC::CFType::SecAccessControl,
+ IPC::CFType::SecAccessControl,
#endif
#if HAVE(SEC_TRUST_SERIALIZATION)
- IPC::CFType::SecTrust,
+ IPC::CFType::SecTrust,
#endif
- IPC::CFType::Nullptr,
- IPC::CFType::Unknown
+ IPC::CFType::CGColorSpace,
+ IPC::CFType::Nullptr,
+ IPC::CFType::Unknown
>;
};
+template<> struct EnumTraits<IPC::CGColorSpaceEncodingScheme> {
+ using values = EnumValues<
+ IPC::CGColorSpaceEncodingScheme,
+ IPC::CGColorSpaceEncodingScheme::Name,
+ IPC::CGColorSpaceEncodingScheme::PropertyList
+ >;
+};
+
} // namespace WTF
Modified: trunk/Source/WebKit/Shared/cf/ArgumentCodersCF.h (277905 => 277906)
--- trunk/Source/WebKit/Shared/cf/ArgumentCodersCF.h 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/Shared/cf/ArgumentCodersCF.h 2021-05-22 02:23:42 UTC (rev 277906)
@@ -23,9 +23,9 @@
* THE POSSIBILITY OF SUCH DAMAGE.
*/
-#ifndef ArgumentCodersCF_h
-#define ArgumentCodersCF_h
+#pragma once
+#include "ArgumentCoder.h"
#include <Security/SecCertificate.h>
#include <Security/SecTrust.h>
#include <wtf/RetainPtr.h>
@@ -34,71 +34,156 @@
#include <Security/SecKeychainItem.h>
#endif
+typedef struct CGColorSpace* CGColorSpaceRef;
+
namespace IPC {
class Encoder;
class Decoder;
+// NOTE: These coders are structured such that they expose encoder functions for both CFType and RetainPtr<CFType>
+// but only a decoder only for RetainPtr<CFType>.
+
+template<typename T>
+struct CFRetainPtrArgumentCoder {
+ template<typename Encoder> static void encode(Encoder& encoder, const RetainPtr<T>& retainPtr)
+ {
+ ArgumentCoder<T>::encode(encoder, retainPtr.get());
+ }
+};
+
+// CFTypeRef
+template<> struct ArgumentCoder<CFTypeRef> {
+ template<typename Encoder> static void encode(Encoder&, CFTypeRef);
+};
+
+template<> struct ArgumentCoder<RetainPtr<CFTypeRef>> : CFRetainPtrArgumentCoder<CFTypeRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFTypeRef>&);
+};
+
// CFArrayRef
-void encode(Encoder&, CFArrayRef);
-WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFArrayRef>& result);
+template<> struct ArgumentCoder<CFArrayRef> {
+ template<typename Encoder> static void encode(Encoder&, CFArrayRef);
+};
+template<> struct ArgumentCoder<RetainPtr<CFArrayRef>> : CFRetainPtrArgumentCoder<CFArrayRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFArrayRef>&);
+};
+
// CFBooleanRef
-void encode(Encoder&, CFBooleanRef);
-WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFBooleanRef>& result);
+template<> struct ArgumentCoder<CFBooleanRef> {
+ template<typename Encoder> static void encode(Encoder&, CFBooleanRef);
+};
+template<> struct ArgumentCoder<RetainPtr<CFBooleanRef>> : CFRetainPtrArgumentCoder<CFBooleanRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFBooleanRef>&);
+};
+
// CFDataRef
-void encode(Encoder&, CFDataRef);
-WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFDataRef>& result);
+template<> struct ArgumentCoder<CFDataRef> {
+ template<typename Encoder> static void encode(Encoder&, CFDataRef);
+};
+template<> struct ArgumentCoder<RetainPtr<CFDataRef>> : CFRetainPtrArgumentCoder<CFDataRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFDataRef>&);
+};
+
// CFDateRef
-void encode(Encoder&, CFDateRef);
-WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFDateRef>& result);
+template<> struct ArgumentCoder<CFDateRef> {
+ template<typename Encoder> static void encode(Encoder&, CFDateRef);
+};
+template<> struct ArgumentCoder<RetainPtr<CFDateRef>> : CFRetainPtrArgumentCoder<CFDateRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFDateRef>&);
+};
+
// CFDictionaryRef
-void encode(Encoder&, CFDictionaryRef);
-WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFDictionaryRef>& result);
+template<> struct ArgumentCoder<CFDictionaryRef> {
+ template<typename Encoder> static void encode(Encoder&, CFDictionaryRef);
+};
+template<> struct ArgumentCoder<RetainPtr<CFDictionaryRef>> : CFRetainPtrArgumentCoder<CFDictionaryRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFDictionaryRef>&);
+};
+
// CFNumberRef
-void encode(Encoder&, CFNumberRef);
-WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFNumberRef>& result);
+template<> struct ArgumentCoder<CFNumberRef> {
+ template<typename Encoder> static void encode(Encoder&, CFNumberRef);
+};
+template<> struct ArgumentCoder<RetainPtr<CFNumberRef>> : CFRetainPtrArgumentCoder<CFNumberRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFNumberRef>&);
+};
+
// CFStringRef
-void encode(Encoder&, CFStringRef);
-WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFStringRef>& result);
+template<> struct ArgumentCoder<CFStringRef> {
+ template<typename Encoder> static void encode(Encoder&, CFStringRef);
+};
-// CFTypeRef
-void encode(Encoder&, CFTypeRef);
-WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFTypeRef>& result);
+template<> struct ArgumentCoder<RetainPtr<CFStringRef>> : CFRetainPtrArgumentCoder<CFStringRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFStringRef>&);
+};
// CFURLRef
-void encode(Encoder&, CFURLRef);
-WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFURLRef>& result);
+template<> struct ArgumentCoder<CFURLRef> {
+ template<typename Encoder> static void encode(Encoder&, CFURLRef);
+};
+template<> struct ArgumentCoder<RetainPtr<CFURLRef>> : CFRetainPtrArgumentCoder<CFURLRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CFURLRef>&);
+};
+
+// CGColorSpaceRef
+template<> struct ArgumentCoder<CGColorSpaceRef> {
+ template<typename Encoder> static void encode(Encoder&, CGColorSpaceRef);
+};
+
+template<> struct ArgumentCoder<RetainPtr<CGColorSpaceRef>> : CFRetainPtrArgumentCoder<CGColorSpaceRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<CGColorSpaceRef>&);
+};
+
// SecCertificateRef
-void encode(Encoder&, SecCertificateRef);
-WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<SecCertificateRef>& result);
+template<> struct ArgumentCoder<SecCertificateRef> {
+ template<typename Encoder> static void encode(Encoder&, SecCertificateRef);
+};
+template<> struct ArgumentCoder<RetainPtr<SecCertificateRef>> : CFRetainPtrArgumentCoder<SecCertificateRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<SecCertificateRef>&);
+};
+
#if HAVE(SEC_KEYCHAIN)
// SecKeychainItemRef
-void encode(Encoder&, SecKeychainItemRef);
-WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<SecKeychainItemRef>& result);
+template<> struct ArgumentCoder<SecKeychainItemRef> {
+ template<typename Encoder> static void encode(Encoder&, SecKeychainItemRef);
+};
+
+template<> struct ArgumentCoder<RetainPtr<SecKeychainItemRef>> : CFRetainPtrArgumentCoder<SecKeychainItemRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<SecKeychainItemRef>&);
+};
#endif
#if HAVE(SEC_ACCESS_CONTROL)
// SecAccessControlRef
-void encode(Encoder&, SecAccessControlRef);
-WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<SecAccessControlRef>& result);
+template<> struct ArgumentCoder<SecAccessControlRef> {
+ template<typename Encoder> static void encode(Encoder&, SecAccessControlRef);
+};
+
+template<> struct ArgumentCoder<RetainPtr<SecAccessControlRef>> : CFRetainPtrArgumentCoder<SecAccessControlRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<SecAccessControlRef>&);
+};
#endif
#if HAVE(SEC_TRUST_SERIALIZATION)
// SecTrustRef
-void encode(Encoder&, SecTrustRef);
-WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<SecTrustRef>&);
+template<> struct ArgumentCoder<SecTrustRef> {
+ template<typename Encoder> static void encode(Encoder&, SecTrustRef);
+};
+
+template<> struct ArgumentCoder<RetainPtr<SecTrustRef>> : CFRetainPtrArgumentCoder<SecTrustRef> {
+ static WARN_UNUSED_RETURN bool decode(Decoder&, RetainPtr<SecTrustRef>&);
+};
#endif
CFTypeRef tokenNullptrTypeRef();
} // namespace IPC
-
-#endif // ArgumentCodersCF_h
Modified: trunk/Source/WebKit/Shared/mac/ColorSpaceData.mm (277905 => 277906)
--- trunk/Source/WebKit/Shared/mac/ColorSpaceData.mm 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/Shared/mac/ColorSpaceData.mm 2021-05-22 02:23:42 UTC (rev 277906)
@@ -33,77 +33,28 @@
namespace WebKit {
-enum EncodedDataType {
- Null,
- Name,
- Data,
-};
-
void ColorSpaceData::encode(IPC::Encoder& encoder) const
{
- if (cgColorSpace) {
- // Try to encode the name.
- if (RetainPtr<CFStringRef> name = adoptCF(CGColorSpaceCopyName(cgColorSpace.get()))) {
- encoder << Name;
- IPC::encode(encoder, name.get());
- return;
- }
-
- // Failing that, just encode the ICC data.
- if (RetainPtr<CFDataRef> profileData = adoptCF(CGColorSpaceCopyICCData(cgColorSpace.get()))) {
- encoder << Data;
- IPC::encode(encoder, profileData.get());
- return;
- }
- }
-
- // The color space was null or failed to be encoded.
- encoder << Null;
+ encoder << static_cast<bool>(cgColorSpace);
+ if (cgColorSpace)
+ encoder << cgColorSpace;
}
bool ColorSpaceData::decode(IPC::Decoder& decoder, ColorSpaceData& colorSpaceData)
{
- EncodedDataType dataType;
- if (!decoder.decode(dataType))
+ bool hasCGColorSpace;
+ if (!decoder.decode(hasCGColorSpace))
return false;
- switch (dataType) {
- case Null:
- colorSpaceData.cgColorSpace = nullptr;
+ if (!hasCGColorSpace)
return true;
- case Name: {
- RetainPtr<CFStringRef> name;
- if (!IPC::decode(decoder, name))
- return false;
- colorSpaceData.cgColorSpace = adoptCF(CGColorSpaceCreateWithName(name.get()));
- return true;
- }
- case Data: {
- RetainPtr<CFDataRef> data;
- if (!IPC::decode(decoder, data))
- return false;
-
- colorSpaceData.cgColorSpace = adoptCF(CGColorSpaceCreateWithICCData(data.get()));
- return true;
- }
- }
-
- ASSERT_NOT_REACHED();
- return false;
+ RetainPtr<CGColorSpaceRef> colorSpace;
+ if (!decoder.decode(colorSpace))
+ return false;
+
+ colorSpaceData.cgColorSpace = WTFMove(colorSpace);
+ return true;
}
} // namespace WebKit
-
-namespace WTF {
-
-template<> struct EnumTraits<WebKit::EncodedDataType> {
- using values = EnumValues<
- WebKit::EncodedDataType,
- WebKit::EncodedDataType::Null,
- WebKit::EncodedDataType::Name,
- WebKit::EncodedDataType::Data
- >;
-};
-
-} // namespace WTF
Modified: trunk/Source/WebKit/Shared/mac/SecItemRequestData.cpp (277905 => 277906)
--- trunk/Source/WebKit/Shared/mac/SecItemRequestData.cpp 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/Shared/mac/SecItemRequestData.cpp 2021-05-22 02:23:42 UTC (rev 277906)
@@ -50,11 +50,11 @@
encoder << static_cast<bool>(m_queryDictionary);
if (m_queryDictionary)
- IPC::encode(encoder, m_queryDictionary.get());
+ encoder << m_queryDictionary;
encoder << static_cast<bool>(m_attributesToMatch);
if (m_attributesToMatch)
- IPC::encode(encoder, m_attributesToMatch.get());
+ encoder << m_attributesToMatch;
}
bool SecItemRequestData::decode(IPC::Decoder& decoder, SecItemRequestData& secItemRequestData)
@@ -66,7 +66,7 @@
if (!decoder.decode(expectQuery))
return false;
- if (expectQuery && !IPC::decode(decoder, secItemRequestData.m_queryDictionary))
+ if (expectQuery && !decoder.decode(secItemRequestData.m_queryDictionary))
return false;
bool expectAttributes;
@@ -73,7 +73,7 @@
if (!decoder.decode(expectAttributes))
return false;
- if (expectAttributes && !IPC::decode(decoder, secItemRequestData.m_attributesToMatch))
+ if (expectAttributes && !decoder.decode(secItemRequestData.m_attributesToMatch))
return false;
return true;
Modified: trunk/Source/WebKit/Shared/mac/SecItemResponseData.cpp (277905 => 277906)
--- trunk/Source/WebKit/Shared/mac/SecItemResponseData.cpp 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/Shared/mac/SecItemResponseData.cpp 2021-05-22 02:23:42 UTC (rev 277906)
@@ -42,7 +42,7 @@
encoder << static_cast<int64_t>(m_resultCode);
encoder << static_cast<bool>(m_resultObject);
if (m_resultObject)
- IPC::encode(encoder, m_resultObject.get());
+ encoder << m_resultObject;
}
Optional<SecItemResponseData> SecItemResponseData::decode(IPC::Decoder& decoder)
@@ -56,7 +56,7 @@
return WTF::nullopt;
RetainPtr<CFTypeRef> result;
- if (expectResultObject && !IPC::decode(decoder, result))
+ if (expectResultObject && !decoder.decode(result))
return WTF::nullopt;
return {{ static_cast<OSStatus>(resultCode), WTFMove(result) }};
Modified: trunk/Source/WebKit/Shared/mac/WebCoreArgumentCodersMac.mm (277905 => 277906)
--- trunk/Source/WebKit/Shared/mac/WebCoreArgumentCodersMac.mm 2021-05-22 02:07:17 UTC (rev 277905)
+++ trunk/Source/WebKit/Shared/mac/WebCoreArgumentCodersMac.mm 2021-05-22 02:23:42 UTC (rev 277906)
@@ -51,11 +51,11 @@
switch (certificateInfo.type()) {
#if HAVE(SEC_TRUST_SERIALIZATION)
case WebCore::CertificateInfo::Type::Trust:
- IPC::encode(encoder, certificateInfo.trust());
+ encoder << certificateInfo.trust();
break;
#endif
case WebCore::CertificateInfo::Type::CertificateChain:
- IPC::encode(encoder, certificateInfo.certificateChain());
+ encoder << certificateInfo.certificateChain();
break;
case WebCore::CertificateInfo::Type::None:
// Do nothing.
@@ -73,7 +73,7 @@
#if HAVE(SEC_TRUST_SERIALIZATION)
case WebCore::CertificateInfo::Type::Trust: {
RetainPtr<SecTrustRef> trust;
- if (!IPC::decode(decoder, trust) || !trust)
+ if (!decoder.decode(trust) || !trust)
return false;
certificateInfo = WebCore::CertificateInfo(WTFMove(trust));
@@ -82,7 +82,7 @@
#endif
case WebCore::CertificateInfo::Type::CertificateChain: {
RetainPtr<CFArrayRef> certificateChain;
- if (!IPC::decode(decoder, certificateChain) || !certificateChain)
+ if (!decoder.decode(certificateChain) || !certificateChain)
return false;
certificateInfo = WebCore::CertificateInfo(WTFMove(certificateChain));
@@ -166,7 +166,7 @@
CFDictionarySetValue(filteredUserInfo.get(), (__bridge CFStringRef)NSURLErrorFailingURLPeerTrustErrorKey, peerTrust);
#endif
- IPC::encode(encoder, filteredUserInfo.get());
+ encoder << static_cast<CFDictionaryRef>(filteredUserInfo.get());
if (id underlyingError = [userInfo objectForKey:NSUnderlyingErrorKey]) {
ASSERT([underlyingError isKindOfClass:[NSError class]]);
@@ -192,7 +192,7 @@
return nil;
RetainPtr<CFDictionaryRef> userInfo;
- if (!IPC::decode(decoder, userInfo) || !userInfo)
+ if (!decoder.decode(userInfo) || !userInfo)
return nil;
bool hasUnderlyingError = false;
@@ -377,13 +377,13 @@
{
auto archiver = adoptNS([[NSKeyedArchiver alloc] initRequiringSecureCoding:YES]);
contentFilterUnblockHandler.encode(archiver.get());
- IPC::encode(encoder, (__bridge CFDataRef)archiver.get().encodedData);
+ encoder << (__bridge CFDataRef)archiver.get().encodedData;
}
bool ArgumentCoder<WebCore::ContentFilterUnblockHandler>::decode(Decoder& decoder, WebCore::ContentFilterUnblockHandler& contentFilterUnblockHandler)
{
RetainPtr<CFDataRef> data;
- if (!IPC::decode(decoder, data) || !data)
+ if (!decoder.decode(data) || !data)
return false;
auto unarchiver = adoptNS([[NSKeyedUnarchiver alloc] initForReadingFromData:(__bridge NSData *)data.get() error:nullptr]);
