mirrors/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity.git synced 2025-01-23 09:51:57 -05:00
Code Issues Projects Releases Packages Wiki Activity

LibIPC+Everywhere: Change IPC::encode's return type to ErrorOr

Browse source 
In doing so, this removes all uses of the Encoder's stream operator,
except for where it is currently still used in the generated IPC code.
So the stream operator currently discards any errors, which is the
existing behavior. A subsequent commit will propagate the errors.
This commit is contained in:
Timothy Flynn 2023-01-01 23:37:35 -05:00 • committed by Andreas Kling
parent d0f3f3d5ff
commit ab99ed5fba
29 changed files with 224 additions and 238 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

64
Userland/DevTools/HackStudio/AutoCompleteResponse.h
View file

@ -16,14 +16,14 @@
namespace IPC {
template<>
inline bool encode(Encoder& encoder, CodeComprehension::AutocompleteResultEntry const& response)
inline ErrorOr<void> encode(Encoder& encoder, CodeComprehension::AutocompleteResultEntry const& response)
{
encoder << response.completion;
encoder << response.partial_input_length;
encoder << response.language;
encoder << response.display_text;
encoder << response.hide_autocomplete_after_applying;
return true;
TRY(encoder.encode(response.completion));
TRY(encoder.encode(response.partial_input_length));
TRY(encoder.encode(response.language));
TRY(encoder.encode(response.display_text));
TRY(encoder.encode(response.hide_autocomplete_after_applying));
return {};
}
template<>
@ -39,12 +39,12 @@ inline ErrorOr<CodeComprehension::AutocompleteResultEntry> decode(Decoder& decod
}
template<>
inline bool encode(Encoder& encoder, CodeComprehension::ProjectLocation const& location)
inline ErrorOr<void> encode(Encoder& encoder, CodeComprehension::ProjectLocation const& location)
{
encoder << location.file;
encoder << location.line;
encoder << location.column;
return true;
TRY(encoder.encode(location.file));
TRY(encoder.encode(location.line));
TRY(encoder.encode(location.column));
return {};
}
template<>
@ -58,14 +58,13 @@ inline ErrorOr<CodeComprehension::ProjectLocation> decode(Decoder& decoder)
}
template<>
inline bool encode(Encoder& encoder, CodeComprehension::Declaration const& declaration)
inline ErrorOr<void> encode(Encoder& encoder, CodeComprehension::Declaration const& declaration)
{
encoder << declaration.name;
if (!encode(encoder, declaration.position))
return false;
encoder << declaration.type;
encoder << declaration.scope;
return true;
TRY(encoder.encode(declaration.name));
TRY(encoder.encode(declaration.position));
TRY(encoder.encode(declaration.type));
TRY(encoder.encode(declaration.scope));
return {};
}
template<>
@ -80,13 +79,13 @@ inline ErrorOr<CodeComprehension::Declaration> decode(Decoder& decoder)
}
template<>
inline bool encode(Encoder& encoder, CodeComprehension::TodoEntry const& entry)
inline ErrorOr<void> encode(Encoder& encoder, CodeComprehension::TodoEntry const& entry)
{
encoder << entry.content;
encoder << entry.filename;
encoder << entry.line;
encoder << entry.column;
return true;
TRY(encoder.encode(entry.content));
TRY(encoder.encode(entry.filename));
TRY(encoder.encode(entry.line));
TRY(encoder.encode(entry.column));
return {};
}
template<>
@ -101,15 +100,14 @@ inline ErrorOr<CodeComprehension::TodoEntry> decode(Decoder& decoder)
}
template<>
inline bool encode(Encoder& encoder, CodeComprehension::TokenInfo const& location)
inline ErrorOr<void> encode(Encoder& encoder, CodeComprehension::TokenInfo const& location)
{
encoder << (u32)location.type;
static_assert(sizeof(location.type) == sizeof(u32));
encoder << location.start_line;
encoder << location.start_column;
encoder << location.end_line;
encoder << location.end_column;
return true;
TRY(encoder.encode(location.type));
TRY(encoder.encode(location.start_line));
TRY(encoder.encode(location.start_column));
TRY(encoder.encode(location.end_line));
TRY(encoder.encode(location.end_column));
return {};
}
template<>

2
Userland/Libraries/LibCore/AnonymousBuffer.h
View file

@ -75,7 +75,7 @@ private:
namespace IPC {
template<>
bool encode(Encoder&, Core::AnonymousBuffer const&);
ErrorOr<void> encode(Encoder&, Core::AnonymousBuffer const&);
template<>
ErrorOr<Core::AnonymousBuffer> decode(Decoder&);

2
Userland/Libraries/LibCore/DateTime.h
View file

@ -69,7 +69,7 @@ struct Formatter<Core::DateTime> : StandardFormatter {
namespace IPC {
template<>
bool encode(Encoder&, Core::DateTime const&);
ErrorOr<void> encode(Encoder&, Core::DateTime const&);
template<>
ErrorOr<Core::DateTime> decode(Decoder&);

2
Userland/Libraries/LibCore/Proxy.h
View file

@ -54,7 +54,7 @@ struct ProxyData {
namespace IPC {
template<>
bool encode(Encoder&, Core::ProxyData const&);
ErrorOr<void> encode(Encoder&, Core::ProxyData const&);
template<>
ErrorOr<Core::ProxyData> decode(Decoder&);

12
Userland/Libraries/LibDNS/Answer.cpp
View file

@ -101,10 +101,16 @@ ErrorOr<void> AK::Formatter<DNS::RecordClass>::format(AK::FormatBuilder& builder
namespace IPC {
template<>
bool encode(Encoder& encoder, DNS::Answer const& answer)
ErrorOr<void> encode(Encoder& encoder, DNS::Answer const& answer)
{
encoder << answer.name().as_string() << (u16)answer.type() << (u16)answer.class_code() << answer.ttl() << answer.record_data() << answer.mdns_cache_flush();
return true;
TRY(encoder.encode(answer.name().as_string()));
TRY(encoder.encode(static_cast<u16>(answer.type())));
TRY(encoder.encode(static_cast<u16>(answer.class_code())));
TRY(encoder.encode(answer.ttl()));
TRY(encoder.encode(answer.record_data()));
TRY(encoder.encode(answer.mdns_cache_flush()));
return {};
}
template<>

2
Userland/Libraries/LibDNS/Answer.h
View file

@ -95,7 +95,7 @@ struct AK::Formatter<DNS::RecordClass> : StandardFormatter {
namespace IPC {
template<>
bool encode(Encoder&, DNS::Answer const&);
ErrorOr<void> encode(Encoder&, DNS::Answer const&);
template<>
ErrorOr<DNS::Answer> decode(Decoder&);

5
Userland/Libraries/LibGfx/Color.cpp
View file

@ -366,10 +366,9 @@ Vector<Color> Color::tints(u32 steps, float max) const
}
template<>
bool IPC::encode(Encoder& encoder, Color const& color)
ErrorOr<void> IPC::encode(Encoder& encoder, Color const& color)
{
encoder << color.value();
return true;
return encoder.encode(color.value());
}
template<>

2
Userland/Libraries/LibGfx/Color.h
View file

@ -574,7 +574,7 @@ struct Formatter<Gfx::Color> : public Formatter<StringView> {
namespace IPC {
template<>
bool encode(Encoder&, Gfx::Color const&);
ErrorOr<void> encode(Encoder&, Gfx::Color const&);
template<>
ErrorOr<Gfx::Color> decode(Decoder&);

7
Userland/Libraries/LibGfx/Point.cpp
View file

@ -52,10 +52,11 @@ DeprecatedString FloatPoint::to_deprecated_string() const
namespace IPC {
template<>
bool encode(Encoder& encoder, Gfx::IntPoint const& point)
ErrorOr<void> encode(Encoder& encoder, Gfx::IntPoint const& point)
{
encoder << point.x() << point.y();
return true;
TRY(encoder.encode(point.x()));
TRY(encoder.encode(point.y()));
return {};
}
template<>

2
Userland/Libraries/LibGfx/Point.h
View file

@ -291,7 +291,7 @@ struct Formatter<Gfx::Point<T>> : Formatter<FormatString> {
namespace IPC {
template<>
bool encode(Encoder&, Gfx::IntPoint const&);
ErrorOr<void> encode(Encoder&, Gfx::IntPoint const&);
template<>
ErrorOr<Gfx::IntPoint> decode(Decoder&);

7
Userland/Libraries/LibGfx/Rect.cpp
View file

@ -30,10 +30,11 @@ DeprecatedString FloatRect::to_deprecated_string() const
namespace IPC {
template<>
bool encode(Encoder& encoder, Gfx::IntRect const& rect)
ErrorOr<void> encode(Encoder& encoder, Gfx::IntRect const& rect)
{
encoder << rect.location() << rect.size();
return true;
TRY(encoder.encode(rect.location()));
TRY(encoder.encode(rect.size()));
return {};
}
template<>

2
Userland/Libraries/LibGfx/Rect.h
View file

@ -1039,7 +1039,7 @@ struct Formatter<Gfx::Rect<T>> : Formatter<FormatString> {
namespace IPC {
template<>
bool encode(Encoder&, Gfx::IntRect const&);
ErrorOr<void> encode(Encoder&, Gfx::IntRect const&);
template<>
ErrorOr<Gfx::IntRect> decode(Decoder&);

20
Userland/Libraries/LibGfx/ShareableBitmap.cpp
View file

@ -23,21 +23,23 @@ ShareableBitmap::ShareableBitmap(NonnullRefPtr<Bitmap> bitmap, Tag)
namespace IPC {
template<>
bool encode(Encoder& encoder, Gfx::ShareableBitmap const& shareable_bitmap)
ErrorOr<void> encode(Encoder& encoder, Gfx::ShareableBitmap const& shareable_bitmap)
{
encoder << shareable_bitmap.is_valid();
TRY(encoder.encode(shareable_bitmap.is_valid()));
if (!shareable_bitmap.is_valid())
return true;
return {};
auto& bitmap = *shareable_bitmap.bitmap();
encoder << IPC::File(bitmap.anonymous_buffer().fd());
encoder << bitmap.size();
encoder << static_cast<u32>(bitmap.scale());
encoder << static_cast<u32>(bitmap.format());
TRY(encoder.encode(IPC::File(bitmap.anonymous_buffer().fd())));
TRY(encoder.encode(bitmap.size()));
TRY(encoder.encode(static_cast<u32>(bitmap.scale())));
TRY(encoder.encode(static_cast<u32>(bitmap.format())));
if (bitmap.is_indexed()) {
auto palette = bitmap.palette_to_vector();
encoder << palette;
TRY(encoder.encode(palette));
}
return true;
return {};
}
template<>

2
Userland/Libraries/LibGfx/ShareableBitmap.h
View file

@ -36,7 +36,7 @@ private:
namespace IPC {
template<>
bool encode(Encoder&, Gfx::ShareableBitmap const&);
ErrorOr<void> encode(Encoder&, Gfx::ShareableBitmap const&);
template<>
ErrorOr<Gfx::ShareableBitmap> decode(Decoder&);

7
Userland/Libraries/LibGfx/Size.cpp
View file

@ -28,10 +28,11 @@ DeprecatedString FloatSize::to_deprecated_string() const
namespace IPC {
template<>
bool encode(Encoder& encoder, Gfx::IntSize const& size)
ErrorOr<void> encode(Encoder& encoder, Gfx::IntSize const& size)
{
encoder << size.width() << size.height();
return true;
TRY(encoder.encode(size.width()));
TRY(encoder.encode(size.height()));
return {};
}
template<>

2
Userland/Libraries/LibGfx/Size.h
View file

@ -214,7 +214,7 @@ struct Formatter<Gfx::Size<T>> : Formatter<FormatString> {
namespace IPC {
template<>
bool encode(Encoder&, Gfx::IntSize const&);
ErrorOr<void> encode(Encoder&, Gfx::IntSize const&);
template<>
ErrorOr<Gfx::IntSize> decode(Decoder&);

102
Userland/Libraries/LibIPC/Encoder.cpp
View file

@ -14,6 +14,7 @@
#include <LibCore/AnonymousBuffer.h>
#include <LibCore/DateTime.h>
#include <LibCore/Proxy.h>
#include <LibCore/System.h>
#include <LibIPC/Dictionary.h>
#include <LibIPC/Encoder.h>
#include <LibIPC/File.h>
@ -21,132 +22,113 @@
namespace IPC {
template<>
bool encode(Encoder& encoder, float const& value)
ErrorOr<void> encode(Encoder& encoder, float const& value)
{
return encoder.encode(bit_cast<u32>(value));
}
template<>
bool encode(Encoder& encoder, double const& value)
ErrorOr<void> encode(Encoder& encoder, double const& value)
{
return encoder.encode(bit_cast<u64>(value));
}
template<>
bool encode(Encoder& encoder, StringView const& value)
ErrorOr<void> encode(Encoder& encoder, StringView const& value)
{
auto result = encoder.append(reinterpret_cast<u8 const*>(value.characters_without_null_termination()), value.length());
return !result.is_error();
TRY(encoder.append(reinterpret_cast<u8 const*>(value.characters_without_null_termination()), value.length()));
return {};
}
template<>
bool encode(Encoder& encoder, DeprecatedString const& value)
ErrorOr<void> encode(Encoder& encoder, DeprecatedString const& value)
{
if (value.is_null())
return encoder.encode(-1);
if (!encoder.encode(static_cast<i32>(value.length())))
return false;
return encoder.encode(value.view());
TRY(encoder.encode(static_cast<i32>(value.length())));
TRY(encoder.encode(value.view()));
return {};
}
template<>
bool encode(Encoder& encoder, ByteBuffer const& value)
ErrorOr<void> encode(Encoder& encoder, ByteBuffer const& value)
{
if (!encoder.encode(static_cast<i32>(value.size())))
return false;
auto result = encoder.append(value.data(), value.size());
return !result.is_error();
TRY(encoder.encode(static_cast<i32>(value.size())));
TRY(encoder.append(value.data(), value.size()));
return {};
}
template<>
bool encode(Encoder& encoder, JsonValue const& value)
ErrorOr<void> encode(Encoder& encoder, JsonValue const& value)
{
return encoder.encode(value.serialized<StringBuilder>());
}
template<>
bool encode(Encoder& encoder, URL const& value)
ErrorOr<void> encode(Encoder& encoder, URL const& value)
{
return encoder.encode(value.to_deprecated_string());
}
template<>
bool encode(Encoder& encoder, Dictionary const& dictionary)
ErrorOr<void> encode(Encoder& encoder, Dictionary const& dictionary)
{
if (!encoder.encode(static_cast<u64>(dictionary.size())))
return false;
TRY(encoder.encode(static_cast<u64>(dictionary.size())));
bool had_error = false;
TRY(dictionary.try_for_each_entry([&](auto const& key, auto const& value) -> ErrorOr<void> {
TRY(encoder.encode(key));
TRY(encoder.encode(value));
return {};
}));
dictionary.for_each_entry([&](auto const& key, auto const& value) {
if (had_error)
return;
if (!encoder.encode(key) || !encoder.encode(value))
had_error = true;
});
return !had_error;
return {};
}
template<>
bool encode(Encoder& encoder, File const& file)
ErrorOr<void> encode(Encoder& encoder, File const& file)
{
int fd = file.fd();
if (fd != -1) {
auto result = dup(fd);
if (result < 0) {
perror("dup");
VERIFY_NOT_REACHED();
}
fd = result;
}
if (fd != -1)
fd = TRY(Core::System::dup(fd));
if (encoder.append_file_descriptor(fd).is_error())
return false;
return true;
TRY(encoder.append_file_descriptor(fd));
return {};
}
template<>
bool encode(Encoder&, Empty const&)
ErrorOr<void> encode(Encoder&, Empty const&)
{
return true;
return {};
}
template<>
bool encode(Encoder& encoder, Core::AnonymousBuffer const& buffer)
ErrorOr<void> encode(Encoder& encoder, Core::AnonymousBuffer const& buffer)
{
if (!encoder.encode(buffer.is_valid()))
return false;
TRY(encoder.encode(buffer.is_valid()));
if (buffer.is_valid()) {
if (!encoder.encode(static_cast<u32>(buffer.size())))
return false;
if (!encoder.encode(IPC::File { buffer.fd() }))
return false;
TRY(encoder.encode(static_cast<u32>(buffer.size())));
TRY(encoder.encode(IPC::File { buffer.fd() }));
}
return true;
return {};
}
template<>
bool encode(Encoder& encoder, Core::DateTime const& datetime)
ErrorOr<void> encode(Encoder& encoder, Core::DateTime const& datetime)
{
return encoder.encode(static_cast<i64>(datetime.timestamp()));
}
template<>
bool encode(Encoder& encoder, Core::ProxyData const& proxy)
ErrorOr<void> encode(Encoder& encoder, Core::ProxyData const& proxy)
{
if (!encoder.encode(proxy.type))
return false;
if (!encoder.encode(proxy.host_ipv4))
return false;
if (!encoder.encode(proxy.port))
return false;
return true;
TRY(encoder.encode(proxy.type));
TRY(encoder.encode(proxy.host_ipv4));
TRY(encoder.encode(proxy.port));
return {};
}
}

80
Userland/Libraries/LibIPC/Encoder.h
View file

@ -18,7 +18,7 @@
namespace IPC {
template<typename T>
bool encode(Encoder&, T const&)
ErrorOr<void> encode(Encoder&, T const&)
{
static_assert(DependentFalse<T>, "Base IPC::encode() was instantiated");
VERIFY_NOT_REACHED();
@ -34,12 +34,12 @@ public:
template<typename T>
Encoder& operator<<(T const& value)
{
encode(value);
(void)encode(value);
return *this;
}
template<typename T>
bool encode(T const& value);
ErrorOr<void> encode(T const& value);
ErrorOr<void> extend_capacity(size_t capacity)
{
@ -72,10 +72,9 @@ private:
};
template<Arithmetic T>
bool encode(Encoder& encoder, T const& value)
ErrorOr<void> encode(Encoder& encoder, T const& value)
{
if (encoder.extend_capacity(sizeof(T)).is_error())
return false;
TRY(encoder.extend_capacity(sizeof(T)));
if constexpr (sizeof(T) == 1) {
encoder.append(static_cast<u8>(value));
@ -100,97 +99,90 @@ bool encode(Encoder& encoder, T const& value)
static_assert(DependentFalse<T>);
}
return true;
return {};
}
template<Enum T>
bool encode(Encoder& encoder, T const& value)
ErrorOr<void> encode(Encoder& encoder, T const& value)
{
return encoder.encode(to_underlying(value));
}
template<>
bool encode(Encoder&, float const&);
ErrorOr<void> encode(Encoder&, float const&);
template<>
bool encode(Encoder&, double const&);
ErrorOr<void> encode(Encoder&, double const&);
template<>
bool encode(Encoder&, StringView const&);
ErrorOr<void> encode(Encoder&, StringView const&);
template<>
bool encode(Encoder&, DeprecatedString const&);
ErrorOr<void> encode(Encoder&, DeprecatedString const&);
template<>
bool encode(Encoder&, ByteBuffer const&);
ErrorOr<void> encode(Encoder&, ByteBuffer const&);
template<>
bool encode(Encoder&, JsonValue const&);
ErrorOr<void> encode(Encoder&, JsonValue const&);
template<>
bool encode(Encoder&, URL const&);
ErrorOr<void> encode(Encoder&, URL const&);
template<>
bool encode(Encoder&, Dictionary const&);
ErrorOr<void> encode(Encoder&, Dictionary const&);
template<>
bool encode(Encoder&, File const&);
ErrorOr<void> encode(Encoder&, File const&);
template<>
bool encode(Encoder&, Empty const&);
ErrorOr<void> encode(Encoder&, Empty const&);
template<Concepts::Vector T>
bool encode(Encoder& encoder, T const& vector)
ErrorOr<void> encode(Encoder& encoder, T const& vector)
{
if (!encoder.encode(static_cast<u64>(vector.size())))
return false;
TRY(encoder.encode(static_cast<u64>(vector.size())));
for (auto const& value : vector) {
if (!encoder.encode(value))
return false;
}
for (auto const& value : vector)
TRY(encoder.encode(value));
return true;
return {};
}
template<Concepts::HashMap T>
bool encode(Encoder& encoder, T const& hashmap)
ErrorOr<void> encode(Encoder& encoder, T const& hashmap)
{
if (!encoder.encode(static_cast<u32>(hashmap.size())))
return false;
TRY(encoder.encode(static_cast<u32>(hashmap.size())));
for (auto it : hashmap) {
if (!encoder.encode(it.key))
return false;
if (!encoder.encode(it.value))
return false;
TRY(encoder.encode(it.key));
TRY(encoder.encode(it.value));
}
return true;
return {};
}
template<Concepts::SharedSingleProducerCircularQueue T>
bool encode(Encoder& encoder, T const& queue)
ErrorOr<void> encode(Encoder& encoder, T const& queue)
{
return encoder.encode(IPC::File { queue.fd() });
}
template<Concepts::Optional T>
bool encode(Encoder& encoder, T const& optional)
ErrorOr<void> encode(Encoder& encoder, T const& optional)
{
if (!encoder.encode(optional.has_value()))
return false;
TRY(encoder.encode(optional.has_value()));
if (optional.has_value())
return encoder.encode(optional.value());
return true;
TRY(encoder.encode(optional.value()));
return {};
}
template<Concepts::Variant T>
bool encode(Encoder& encoder, T const& variant)
ErrorOr<void> encode(Encoder& encoder, T const& variant)
{
if (!encoder.encode(variant.index()))
return false;
TRY(encoder.encode(variant.index()));
return variant.visit([&](auto const& value) {
return encoder.encode(value);
@ -199,7 +191,7 @@ bool encode(Encoder& encoder, T const& variant)
// This must be last so that it knows about the above specializations.
template<typename T>
bool Encoder::encode(T const& value)
ErrorOr<void> Encoder::encode(T const& value)
{
return IPC::encode(*this, value);
}

4
Userland/Libraries/LibIPC/Forward.h
View file

@ -6,6 +6,8 @@
#pragma once
#include <AK/Error.h>
namespace IPC {
class Decoder;
@ -16,7 +18,7 @@ class File;
class Stub;
template<typename T>
bool encode(Encoder&, T const&);
ErrorOr<void> encode(Encoder&, T const&);
template<typename T>
ErrorOr<T> decode(Decoder&);

27
Userland/Libraries/LibSQL/Value.cpp
View file

@ -814,37 +814,32 @@ ResultOr<NonnullRefPtr<TupleDescriptor>> Value::infer_tuple_descriptor(Vector<Va
}
template<>
bool IPC::encode(Encoder& encoder, SQL::Value const& value)
ErrorOr<void> IPC::encode(Encoder& encoder, SQL::Value const& value)
{
auto type_flags = encode_type_flags(value);
encoder << type_flags;
TRY(encoder.encode(type_flags));
if (value.is_null())
return true;
return {};
switch (value.type()) {
case SQL::SQLType::Null:
break;
return {};
case SQL::SQLType::Text:
encoder << value.to_deprecated_string();
break;
return encoder.encode(value.to_deprecated_string());
case SQL::SQLType::Integer:
SQL::downsize_integer(value, [&](auto integer, auto) {
encoder << integer;
return SQL::downsize_integer(value, [&](auto integer, auto) {
return encoder.encode(integer);
});
break;
case SQL::SQLType::Float:
encoder << value.to_double().value();
break;
return encoder.encode(value.to_double().value());
case SQL::SQLType::Boolean:
encoder << value.to_bool().value();
break;
return encoder.encode(value.to_bool().value());
case SQL::SQLType::Tuple:
encoder << value.to_vector().value();
break;
return encoder.encode(value.to_vector().value());
}
return true;
VERIFY_NOT_REACHED();
}
template<>

2
Userland/Libraries/LibSQL/Value.h
View file

@ -191,7 +191,7 @@ struct AK::Formatter<SQL::Value> : Formatter<StringView> {
namespace IPC {
template<>
bool encode(Encoder&, SQL::Value const&);
ErrorOr<void> encode(Encoder&, SQL::Value const&);
template<>
ErrorOr<SQL::Value> decode(Decoder&);

28
Userland/Libraries/LibWeb/Cookie/Cookie.cpp
View file

@ -39,22 +39,22 @@ SameSite same_site_from_string(StringView same_site_mode)
}
template<>
bool IPC::encode(Encoder& encoder, Web::Cookie::Cookie const& cookie)
ErrorOr<void> IPC::encode(Encoder& encoder, Web::Cookie::Cookie const& cookie)
{
encoder << cookie.name;
encoder << cookie.value;
encoder << cookie.domain;
encoder << cookie.path;
encoder << cookie.creation_time;
encoder << cookie.expiry_time;
encoder << cookie.host_only;
encoder << cookie.http_only;
encoder << cookie.last_access_time;
encoder << cookie.persistent;
encoder << cookie.secure;
encoder << cookie.same_site;
TRY(encoder.encode(cookie.name));
TRY(encoder.encode(cookie.value));
TRY(encoder.encode(cookie.domain));
TRY(encoder.encode(cookie.path));
TRY(encoder.encode(cookie.creation_time));
TRY(encoder.encode(cookie.expiry_time));
TRY(encoder.encode(cookie.host_only));
TRY(encoder.encode(cookie.http_only));
TRY(encoder.encode(cookie.last_access_time));
TRY(encoder.encode(cookie.persistent));
TRY(encoder.encode(cookie.secure));
TRY(encoder.encode(cookie.same_site));
return true;
return {};
}
template<>

2
Userland/Libraries/LibWeb/Cookie/Cookie.h
View file

@ -47,7 +47,7 @@ SameSite same_site_from_string(StringView same_site_mode);
namespace IPC {
template<>
bool encode(Encoder&, Web::Cookie::Cookie const&);
ErrorOr<void> encode(Encoder&, Web::Cookie::Cookie const&);
template<>
ErrorOr<Web::Cookie::Cookie> decode(Decoder&);

22
Userland/Libraries/LibWeb/Cookie/ParsedCookie.cpp
View file

@ -348,19 +348,19 @@ Optional<Core::DateTime> parse_date_time(StringView date_string)
}
template<>
bool IPC::encode(Encoder& encoder, Web::Cookie::ParsedCookie const& cookie)
ErrorOr<void> IPC::encode(Encoder& encoder, Web::Cookie::ParsedCookie const& cookie)
{
encoder << cookie.name;
encoder << cookie.value;
encoder << cookie.expiry_time_from_expires_attribute;
encoder << cookie.expiry_time_from_max_age_attribute;
encoder << cookie.domain;
encoder << cookie.path;
encoder << cookie.secure_attribute_present;
encoder << cookie.http_only_attribute_present;
encoder << cookie.same_site_attribute;
TRY(encoder.encode(cookie.name));
TRY(encoder.encode(cookie.value));
TRY(encoder.encode(cookie.expiry_time_from_expires_attribute));
TRY(encoder.encode(cookie.expiry_time_from_max_age_attribute));
TRY(encoder.encode(cookie.domain));
TRY(encoder.encode(cookie.path));
TRY(encoder.encode(cookie.secure_attribute_present));
TRY(encoder.encode(cookie.http_only_attribute_present));
TRY(encoder.encode(cookie.same_site_attribute));
return true;
return {};
}
template<>

2
Userland/Libraries/LibWeb/Cookie/ParsedCookie.h
View file

@ -33,7 +33,7 @@ Optional<ParsedCookie> parse_cookie(DeprecatedString const& cookie_string);
namespace IPC {
template<>
bool encode(Encoder&, Web::Cookie::ParsedCookie const&);
ErrorOr<void> encode(Encoder&, Web::Cookie::ParsedCookie const&);
template<>
ErrorOr<Web::Cookie::ParsedCookie> decode(Decoder&);

28
Userland/Libraries/LibWeb/WebDriver/Response.cpp
View file

@ -28,23 +28,23 @@ Response::Response(Error&& error)
}
template<>
bool IPC::encode(Encoder& encoder, Web::WebDriver::Response const& response)
ErrorOr<void> IPC::encode(Encoder& encoder, Web::WebDriver::Response const& response)
{
response.visit(
[](Empty) { VERIFY_NOT_REACHED(); },
[&](JsonValue const& value) {
encoder << ResponseType::Success;
encoder << value;
return response.visit(
[](Empty) -> ErrorOr<void> { VERIFY_NOT_REACHED(); },
[&](JsonValue const& value) -> ErrorOr<void> {
TRY(encoder.encode(ResponseType::Success));
TRY(encoder.encode(value));
return {};
},
[&](Web::WebDriver::Error const& error) {
encoder << ResponseType::Error;
encoder << error.http_status;
encoder << error.error;
encoder << error.message;
encoder << error.data;
[&](Web::WebDriver::Error const& error) -> ErrorOr<void> {
TRY(encoder.encode(ResponseType::Error));
TRY(encoder.encode(error.http_status));
TRY(encoder.encode(error.error));
TRY(encoder.encode(error.message));
TRY(encoder.encode(error.data));
return {};
});
return true;
}
template<>

2
Userland/Libraries/LibWeb/WebDriver/Response.h
View file

@ -47,7 +47,7 @@ private:
namespace IPC {
template<>
bool encode(Encoder&, Web::WebDriver::Response const&);
ErrorOr<void> encode(Encoder&, Web::WebDriver::Response const&);
template<>
ErrorOr<Web::WebDriver::Response> decode(Decoder&);

4
Userland/Services/WindowServer/ScreenLayout.h
View file

@ -74,13 +74,13 @@ public:
namespace IPC {
template<>
bool encode(Encoder&, WindowServer::ScreenLayout::Screen const&);
ErrorOr<void> encode(Encoder&, WindowServer::ScreenLayout::Screen const&);
template<>
ErrorOr<WindowServer::ScreenLayout::Screen> decode(Decoder&);
template<>
bool encode(Encoder&, WindowServer::ScreenLayout const&);
ErrorOr<void> encode(Encoder&, WindowServer::ScreenLayout const&);
template<>
ErrorOr<WindowServer::ScreenLayout> decode(Decoder&);

19
Userland/Services/WindowServer/ScreenLayout.ipp
View file

@ -393,10 +393,15 @@ bool ScreenLayout::try_auto_add_display_connector(DeprecatedString const& device
namespace IPC {
template<>
bool encode(Encoder& encoder, WindowServer::ScreenLayout::Screen const& screen)
ErrorOr<void> encode(Encoder& encoder, WindowServer::ScreenLayout::Screen const& screen)
{
encoder << screen.mode << screen.device << screen.location << screen.resolution << screen.scale_factor;
return true;
TRY(encoder.encode(screen.mode));
TRY(encoder.encode(screen.device));
TRY(encoder.encode(screen.location));
TRY(encoder.encode(screen.resolution));
TRY(encoder.encode(screen.scale_factor));
return {};
}
template<>
@ -412,10 +417,12 @@ ErrorOr<WindowServer::ScreenLayout::Screen> decode(Decoder& decoder)
}
template<>
bool encode(Encoder& encoder, WindowServer::ScreenLayout const& screen_layout)
ErrorOr<void> encode(Encoder& encoder, WindowServer::ScreenLayout const& screen_layout)
{
encoder << screen_layout.screens << screen_layout.main_screen_index;
return true;
TRY(encoder.encode(screen_layout.screens));
TRY(encoder.encode(screen_layout.main_screen_index));
return {};
}
template<>