LibIPC+IPCCompiler+AK: Make IPC value decoders return ErrorOr<void>

This allows us to use TRY() in decoding helpers, leading to a nice
reduction in line count.

AK/Stream.h

@@ -41,6 +41,13 @@ public:
         return false;
     }
 
+    ErrorOr<void> try_handle_any_error()
+    {
+        if (!handle_any_error())
+            return {};
+        return Error::from_string_literal("Stream error"sv);
+    }
+
     virtual void set_recoverable_error() const { m_recoverable_error = true; }
     virtual void set_fatal_error() const { m_fatal_error = true; }
 

Meta/Lagom/Tools/CodeGenerators/IPCCompiler/main.cpp

@@ -386,7 +386,7 @@ public:
 
                 parameter_generator.append(R"~~~(
         @parameter.type@ @parameter.name@ = @parameter.initial_value@;
-        if (!decoder.decode(@parameter.name@))
+        if (decoder.decode(@parameter.name@).is_error())
             return {};
 )~~~");
 

Userland/DevTools/HackStudio/AutoCompleteResponse.h

@@ -19,59 +19,40 @@ template<>
 inline bool encode(IPC::Encoder& encoder, const GUI::AutocompleteProvider::Entry& response)
 {
     encoder << response.completion;
-    encoder << (u64)response.partial_input_length;
-    encoder << (u32)response.language;
+    encoder << response.partial_input_length;
+    encoder << response.language;
     encoder << response.display_text;
-    encoder << (u32)response.hide_autocomplete_after_applying;
+    encoder << response.hide_autocomplete_after_applying;
     return true;
 }
 
 template<>
-inline bool decode(IPC::Decoder& decoder, GUI::AutocompleteProvider::Entry& response)
+inline ErrorOr<void> decode(IPC::Decoder& decoder, GUI::AutocompleteProvider::Entry& response)
 {
-    u32 language = 0;
-    u64 partial_input_length = 0;
-    u32 hide_autocomplete_after_applying = 0;
-    bool ok = decoder.decode(response.completion)
-        && decoder.decode(partial_input_length)
-        && decoder.decode(language)
-        && decoder.decode(response.display_text)
-        && decoder.decode(hide_autocomplete_after_applying);
-
-    if (ok) {
-        response.language = static_cast<GUI::AutocompleteProvider::Language>(language);
-        response.partial_input_length = partial_input_length;
-        response.hide_autocomplete_after_applying = static_cast<GUI::AutocompleteProvider::Entry::HideAutocompleteAfterApplying>(hide_autocomplete_after_applying);
-    }
-
-    return ok;
+    TRY(decoder.decode(response.completion));
+    TRY(decoder.decode(response.partial_input_length));
+    TRY(decoder.decode(response.language));
+    TRY(decoder.decode(response.display_text));
+    TRY(decoder.decode(response.hide_autocomplete_after_applying));
+    return {};
 }
 
 template<>
 inline bool encode(Encoder& encoder, const GUI::AutocompleteProvider::ProjectLocation& location)
 {
     encoder << location.file;
-    encoder << (u64)location.line;
-    encoder << (u64)location.column;
+    encoder << location.line;
+    encoder << location.column;
     return true;
 }
 
 template<>
-inline bool decode(Decoder& decoder, GUI::AutocompleteProvider::ProjectLocation& location)
+inline ErrorOr<void> decode(Decoder& decoder, GUI::AutocompleteProvider::ProjectLocation& location)
 {
-    u64 line = 0;
-    u64 column = 0;
-    if (!decoder.decode(location.file))
-        return false;
-    if (!decoder.decode(line))
-        return false;
-    if (!decoder.decode(column))
-        return false;
-
-    location.line = line;
-    location.column = column;
-
-    return true;
+    TRY(decoder.decode(location.file));
+    TRY(decoder.decode(location.line));
+    TRY(decoder.decode(location.column));
+    return {};
 }
 
 template<>
@@ -80,29 +61,19 @@ inline bool encode(Encoder& encoder, const GUI::AutocompleteProvider::Declaratio
     encoder << declaration.name;
     if (!encode(encoder, declaration.position))
         return false;
-    encoder << (u32)declaration.type;
+    encoder << declaration.type;
     encoder << declaration.scope;
     return true;
 }
 
 template<>
-inline bool decode(Decoder& decoder, GUI::AutocompleteProvider::Declaration& declaration)
+inline ErrorOr<void> decode(Decoder& decoder, GUI::AutocompleteProvider::Declaration& declaration)
 {
-    if (!decoder.decode(declaration.name))
-        return false;
-
-    if (!decode(decoder, declaration.position))
-        return false;
-
-    u32 type;
-    if (!decoder.decode(type))
-        return false;
-
-    if (!decoder.decode(declaration.scope))
-        return false;
-
-    declaration.type = static_cast<GUI::AutocompleteProvider::DeclarationType>(type);
-    return true;
+    TRY(decoder.decode(declaration.name));
+    TRY(decoder.decode(declaration.position));
+    TRY(decoder.decode(declaration.type));
+    TRY(decoder.decode(declaration.scope));
+    return {};
 }
 
 template<>
@@ -110,28 +81,19 @@ inline bool encode(Encoder& encoder, Cpp::Parser::TodoEntry const& entry)
 {
     encoder << entry.content;
     encoder << entry.filename;
-    encoder << (u64)entry.line;
-    encoder << (u64)entry.column;
+    encoder << entry.line;
+    encoder << entry.column;
     return true;
 }
 
 template<>
-inline bool decode(Decoder& decoder, Cpp::Parser::TodoEntry& entry)
+inline ErrorOr<void> decode(Decoder& decoder, Cpp::Parser::TodoEntry& entry)
 {
-    u64 line = 0;
-    u64 column = 0;
-    if (!decoder.decode(entry.content))
-        return false;
-    if (!decoder.decode(entry.filename))
-        return false;
-    if (!decoder.decode(line))
-        return false;
-    if (!decoder.decode(column))
-        return false;
-
-    entry.line = line;
-    entry.column = column;
-    return true;
+    TRY(decoder.decode(entry.content));
+    TRY(decoder.decode(entry.filename));
+    TRY(decoder.decode(entry.line));
+    TRY(decoder.decode(entry.column));
+    return {};
 }
 
 }

Userland/Libraries/LibCore/AnonymousBuffer.h

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

Userland/Libraries/LibCore/DateTime.h

@@ -54,6 +54,6 @@ private:
 namespace IPC {
 
 bool encode(IPC::Encoder&, const Core::DateTime&);
-bool decode(IPC::Decoder&, Core::DateTime&);
+ErrorOr<void> decode(IPC::Decoder&, Core::DateTime&);
 
 }

Userland/Libraries/LibGfx/Color.cpp

@@ -13,7 +13,6 @@
 #include <LibIPC/Decoder.h>
 #include <LibIPC/Encoder.h>
 #include <ctype.h>
-#include <stdio.h>
 #include <stdlib.h>
 
 namespace Gfx {
@@ -343,13 +342,12 @@ bool IPC::encode(IPC::Encoder& encoder, Color const& color)
     return true;
 }
 
-bool IPC::decode(IPC::Decoder& decoder, Color& color)
+ErrorOr<void> IPC::decode(IPC::Decoder& decoder, Color& color)
 {
-    u32 rgba = 0;
-    if (!decoder.decode(rgba))
-        return false;
+    u32 rgba;
+    TRY(decoder.decode(rgba));
     color = Color::from_rgba(rgba);
-    return true;
+    return {};
 }
 
 ErrorOr<void> AK::Formatter<Gfx::Color>::format(FormatBuilder& builder, Gfx::Color const& value)

Userland/Libraries/LibGfx/Color.h

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

Userland/Libraries/LibGfx/Point.cpp

@@ -57,16 +57,14 @@ bool encode(Encoder& encoder, Gfx::IntPoint const& point)
     return true;
 }
 
-bool decode(Decoder& decoder, Gfx::IntPoint& point)
+ErrorOr<void> decode(Decoder& decoder, Gfx::IntPoint& point)
 {
     int x = 0;
     int y = 0;
-    if (!decoder.decode(x))
-        return false;
-    if (!decoder.decode(y))
-        return false;
+    TRY(decoder.decode(x));
+    TRY(decoder.decode(y));
     point = { x, y };
-    return true;
+    return {};
 }
 
 }

Userland/Libraries/LibGfx/Point.h

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

Userland/Libraries/LibGfx/Rect.cpp

@@ -328,16 +328,14 @@ bool encode(Encoder& encoder, Gfx::IntRect const& rect)
     return true;
 }
 
-bool decode(Decoder& decoder, Gfx::IntRect& rect)
+ErrorOr<void> decode(Decoder& decoder, Gfx::IntRect& rect)
 {
     Gfx::IntPoint point;
     Gfx::IntSize size;
-    if (!decoder.decode(point))
-        return false;
-    if (!decoder.decode(size))
-        return false;
+    TRY(decoder.decode(point));
+    TRY(decoder.decode(size));
     rect = { point, size };
-    return true;
+    return {};
 }
 
 }

Userland/Libraries/LibGfx/Rect.h

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

Userland/Libraries/LibGfx/ShareableBitmap.cpp

@@ -39,43 +39,33 @@ bool encode(Encoder& encoder, const Gfx::ShareableBitmap& shareable_bitmap)
     return true;
 }
 
-bool decode(Decoder& decoder, Gfx::ShareableBitmap& shareable_bitmap)
+ErrorOr<void> decode(Decoder& decoder, Gfx::ShareableBitmap& shareable_bitmap)
 {
     bool valid = false;
-    if (!decoder.decode(valid))
-        return false;
+    TRY(decoder.decode(valid));
     if (!valid) {
         shareable_bitmap = {};
-        return true;
+        return {};
     }
     IPC::File anon_file;
-    if (!decoder.decode(anon_file))
-        return false;
+    TRY(decoder.decode(anon_file));
     Gfx::IntSize size;
-    if (!decoder.decode(size))
-        return false;
+    TRY(decoder.decode(size));
     u32 scale;
-    if (!decoder.decode(scale))
-        return false;
+    TRY(decoder.decode(scale));
     u32 raw_bitmap_format;
-    if (!decoder.decode(raw_bitmap_format))
-        return false;
+    TRY(decoder.decode(raw_bitmap_format));
     if (!Gfx::is_valid_bitmap_format(raw_bitmap_format))
-        return false;
+        return Error::from_string_literal("IPC: Invalid Gfx::ShareableBitmap format"sv);
     auto bitmap_format = (Gfx::BitmapFormat)raw_bitmap_format;
     Vector<Gfx::RGBA32> palette;
     if (Gfx::Bitmap::is_indexed(bitmap_format)) {
-        if (!decoder.decode(palette))
-            return false;
+        TRY(decoder.decode(palette));
     }
-    auto buffer_or_error = Core::AnonymousBuffer::create_from_anon_fd(anon_file.take_fd(), Gfx::Bitmap::size_in_bytes(Gfx::Bitmap::minimum_pitch(size.width(), bitmap_format), size.height()));
-    if (buffer_or_error.is_error())
-        return false;
-    auto bitmap_or_error = Gfx::Bitmap::try_create_with_anonymous_buffer(bitmap_format, buffer_or_error.release_value(), size, scale, palette);
-    if (bitmap_or_error.is_error())
-        return false;
-    shareable_bitmap = Gfx::ShareableBitmap { bitmap_or_error.release_value(), Gfx::ShareableBitmap::ConstructWithKnownGoodBitmap };
-    return true;
+    auto buffer = TRY(Core::AnonymousBuffer::create_from_anon_fd(anon_file.take_fd(), Gfx::Bitmap::size_in_bytes(Gfx::Bitmap::minimum_pitch(size.width(), bitmap_format), size.height())));
+    auto bitmap = TRY(Gfx::Bitmap::try_create_with_anonymous_buffer(bitmap_format, move(buffer), size, scale, palette));
+    shareable_bitmap = Gfx::ShareableBitmap { move(bitmap), Gfx::ShareableBitmap::ConstructWithKnownGoodBitmap };
+    return {};
 }
 
 }

Userland/Libraries/LibGfx/ShareableBitmap.h

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

Userland/Libraries/LibGfx/Size.cpp

@@ -33,16 +33,14 @@ bool encode(Encoder& encoder, Gfx::IntSize const& size)
     return true;
 }
 
-bool decode(Decoder& decoder, Gfx::IntSize& size)
+ErrorOr<void> decode(Decoder& decoder, Gfx::IntSize& size)
 {
     int width = 0;
     int height = 0;
-    if (!decoder.decode(width))
-        return false;
-    if (!decoder.decode(height))
-        return false;
+    TRY(decoder.decode(width));
+    TRY(decoder.decode(height));
     size = { width, height };
-    return true;
+    return {};
 }
 
 }

Userland/Libraries/LibGfx/Size.h

@@ -189,6 +189,6 @@ struct Formatter<Gfx::Size<T>> : Formatter<StringView> {
 namespace IPC {
 
 bool encode(Encoder&, Gfx::IntSize const&);
-bool decode(Decoder&, Gfx::IntSize&);
+ErrorOr<void> decode(Decoder&, Gfx::IntSize&);
 
 }

Userland/Libraries/LibIPC/Decoder.cpp

@@ -8,6 +8,7 @@
 #include <AK/URL.h>
 #include <LibCore/AnonymousBuffer.h>
 #include <LibCore/DateTime.h>
+#include <LibCore/System.h>
 #include <LibIPC/Decoder.h>
 #include <LibIPC/Dictionary.h>
 #include <LibIPC/File.h>
@@ -18,196 +19,175 @@
 
 namespace IPC {
 
-bool Decoder::decode(bool& value)
+ErrorOr<void> Decoder::decode(bool& value)
 {
     m_stream >> value;
-    return !m_stream.handle_any_error();
+    return m_stream.try_handle_any_error();
 }
 
-bool Decoder::decode(u8& value)
+ErrorOr<void> Decoder::decode(u8& value)
 {
     m_stream >> value;
-    return !m_stream.handle_any_error();
+    return m_stream.try_handle_any_error();
 }
 
-bool Decoder::decode(u16& value)
+ErrorOr<void> Decoder::decode(u16& value)
 {
     m_stream >> value;
-    return !m_stream.handle_any_error();
+    return m_stream.try_handle_any_error();
 }
 
-bool Decoder::decode(u32& value)
+ErrorOr<void> Decoder::decode(u32& value)
 {
     m_stream >> value;
-    return !m_stream.handle_any_error();
+    return m_stream.try_handle_any_error();
 }
 
-bool Decoder::decode(u64& value)
+ErrorOr<void> Decoder::decode(u64& value)
 {
     m_stream >> value;
-    return !m_stream.handle_any_error();
+    return m_stream.try_handle_any_error();
 }
 
-bool Decoder::decode(i8& value)
+ErrorOr<void> Decoder::decode(i8& value)
 {
     m_stream >> value;
-    return !m_stream.handle_any_error();
+    return m_stream.try_handle_any_error();
 }
 
-bool Decoder::decode(i16& value)
+ErrorOr<void> Decoder::decode(i16& value)
 {
     m_stream >> value;
-    return !m_stream.handle_any_error();
+    return m_stream.try_handle_any_error();
 }
 
-bool Decoder::decode(i32& value)
+ErrorOr<void> Decoder::decode(i32& value)
 {
     m_stream >> value;
-    return !m_stream.handle_any_error();
+    return m_stream.try_handle_any_error();
 }
 
-bool Decoder::decode(i64& value)
+ErrorOr<void> Decoder::decode(i64& value)
 {
     m_stream >> value;
-    return !m_stream.handle_any_error();
+    return m_stream.try_handle_any_error();
 }
 
-bool Decoder::decode(float& value)
+ErrorOr<void> Decoder::decode(float& value)
 {
     m_stream >> value;
-    return !m_stream.handle_any_error();
+    return m_stream.try_handle_any_error();
 }
 
-bool Decoder::decode(double& value)
+ErrorOr<void> Decoder::decode(double& value)
 {
     m_stream >> value;
-    return !m_stream.handle_any_error();
+    return m_stream.try_handle_any_error();
 }
 
-bool Decoder::decode(String& value)
+ErrorOr<void> Decoder::decode(String& value)
 {
-    i32 length = 0;
-    m_stream >> length;
-    if (m_stream.handle_any_error())
-        return false;
+    i32 length;
+    TRY(decode(length));
+
     if (length < 0) {
         value = {};
-        return true;
+        return {};
     }
     if (length == 0) {
         value = String::empty();
-        return true;
+        return {};
     }
     char* text_buffer = nullptr;
     auto text_impl = StringImpl::create_uninitialized(static_cast<size_t>(length), text_buffer);
     m_stream >> Bytes { text_buffer, static_cast<size_t>(length) };
     value = *text_impl;
-    return !m_stream.handle_any_error();
+    return m_stream.try_handle_any_error();
 }
 
-bool Decoder::decode(ByteBuffer& value)
+ErrorOr<void> Decoder::decode(ByteBuffer& value)
 {
-    i32 length = 0;
-    m_stream >> length;
-    if (m_stream.handle_any_error())
-        return false;
+    i32 length;
+    TRY(decode(length));
+
     if (length < 0) {
         value = {};
-        return true;
+        return {};
     }
     if (length == 0) {
         value = {};
-        return true;
+        return {};
     }
+
     if (auto buffer_result = ByteBuffer::create_uninitialized(length); buffer_result.has_value())
         value = buffer_result.release_value();
     else
-        return false;
+        return Error::from_errno(ENOMEM);
 
     m_stream >> value.bytes();
-    return !m_stream.handle_any_error();
+    return m_stream.try_handle_any_error();
 }
 
-bool Decoder::decode(URL& value)
+ErrorOr<void> Decoder::decode(URL& value)
 {
     String string;
-    if (!decode(string))
-        return false;
+    TRY(decode(string));
     value = URL(string);
-    return true;
+    return {};
 }
 
-bool Decoder::decode(Dictionary& dictionary)
+ErrorOr<void> Decoder::decode(Dictionary& dictionary)
 {
-    u64 size = 0;
-    m_stream >> size;
-    if (m_stream.handle_any_error())
-        return false;
-    if (size >= (size_t)NumericLimits<i32>::max()) {
+    u64 size;
+    TRY(decode(size));
+    if (size >= (size_t)NumericLimits<i32>::max())
         VERIFY_NOT_REACHED();
-    }
 
     for (size_t i = 0; i < size; ++i) {
         String key;
-        if (!decode(key))
-            return false;
+        TRY(decode(key));
         String value;
-        if (!decode(value))
-            return false;
+        TRY(decode(value));
         dictionary.add(move(key), move(value));
     }
 
-    return true;
+    return {};
 }
 
-bool Decoder::decode([[maybe_unused]] File& file)
+ErrorOr<void> Decoder::decode([[maybe_unused]] File& file)
 {
 #ifdef __serenity__
-    int fd = recvfd(m_sockfd, O_CLOEXEC);
-    if (fd < 0) {
-        dbgln("recvfd: {}", strerror(errno));
-        return false;
-    }
+    int fd = TRY(Core::System::recvfd(m_sockfd, O_CLOEXEC));
     file = File(fd, File::ConstructWithReceivedFileDescriptor);
-    return true;
+    return {};
 #else
-    [[maybe_unused]] auto fd = m_sockfd;
-    warnln("fd passing is not supported on this platform, sorry :(");
-    return false;
+    return Error::from_string_literal("File descriptor passing not supported on this platform");
 #endif
 }
 
-bool decode(Decoder& decoder, Core::AnonymousBuffer& buffer)
+ErrorOr<void> decode(Decoder& decoder, Core::AnonymousBuffer& buffer)
 {
-    bool valid = false;
-    if (!decoder.decode(valid))
-        return false;
+    bool valid;
+    TRY(decoder.decode(valid));
     if (!valid) {
         buffer = {};
-        return true;
+        return {};
     }
     u32 size;
-    if (!decoder.decode(size))
-        return false;
+    TRY(decoder.decode(size));
     IPC::File anon_file;
-    if (!decoder.decode(anon_file))
-        return false;
+    TRY(decoder.decode(anon_file));
 
-    auto new_buffer_or_error = Core::AnonymousBuffer::create_from_anon_fd(anon_file.take_fd(), size);
-    if (new_buffer_or_error.is_error())
-        return false;
-    buffer = new_buffer_or_error.release_value();
-    return buffer.is_valid();
+    buffer = TRY(Core::AnonymousBuffer::create_from_anon_fd(anon_file.take_fd(), size));
+    return {};
 }
 
-bool decode(Decoder& decoder, Core::DateTime& datetime)
+ErrorOr<void> decode(Decoder& decoder, Core::DateTime& datetime)
 {
-    i64 timestamp = -1;
-    if (!decoder.decode(timestamp))
-        return false;
-
+    i64 timestamp;
+    TRY(decoder.decode(timestamp));
     datetime = Core::DateTime::from_timestamp(static_cast<time_t>(timestamp));
-    return true;
+    return {};
 }
 
 }

Userland/Libraries/LibIPC/Decoder.h

@@ -17,7 +17,7 @@
 namespace IPC {
 
 template<typename T>
-inline bool decode(Decoder&, T&)
+inline ErrorOr<void> decode(Decoder&, T&)
 {
     static_assert(DependentFalse<T>, "Base IPC::decoder() instantiated");
     VERIFY_NOT_REACHED();
@@ -31,90 +31,85 @@ public:
     {
     }
 
-    bool decode(bool&);
-    bool decode(u8&);
-    bool decode(u16&);
-    bool decode(u32&);
-    bool decode(u64&);
-    bool decode(i8&);
-    bool decode(i16&);
-    bool decode(i32&);
-    bool decode(i64&);
-    bool decode(float&);
-    bool decode(double&);
-    bool decode(String&);
-    bool decode(ByteBuffer&);
-    bool decode(URL&);
-    bool decode(Dictionary&);
-    bool decode(File&);
+    ErrorOr<void> decode(bool&);
+    ErrorOr<void> decode(u8&);
+    ErrorOr<void> decode(u16&);
+    ErrorOr<void> decode(u32&);
+    ErrorOr<void> decode(u64&);
+    ErrorOr<void> decode(i8&);
+    ErrorOr<void> decode(i16&);
+    ErrorOr<void> decode(i32&);
+    ErrorOr<void> decode(i64&);
+    ErrorOr<void> decode(float&);
+    ErrorOr<void> decode(double&);
+    ErrorOr<void> decode(String&);
+    ErrorOr<void> decode(ByteBuffer&);
+    ErrorOr<void> decode(URL&);
+    ErrorOr<void> decode(Dictionary&);
+    ErrorOr<void> decode(File&);
     template<typename K, typename V>
-    bool decode(HashMap<K, V>& hashmap)
+    ErrorOr<void> decode(HashMap<K, V>& hashmap)
     {
         u32 size;
-        if (!decode(size) || size > NumericLimits<i32>::max())
-            return false;
+        TRY(decode(size));
+        if (size > NumericLimits<i32>::max())
+            return Error::from_string_literal("IPC: Invalid HashMap size"sv);
 
         for (size_t i = 0; i < size; ++i) {
             K key;
-            if (!decode(key))
-                return false;
-
+            TRY(decode(key));
             V value;
-            if (!decode(value))
-                return false;
-
-            hashmap.set(move(key), move(value));
+            TRY(decode(value));
+            TRY(hashmap.try_set(move(key), move(value)));
         }
-        return true;
+        return {};
     }
 
     template<Enum T>
-    bool decode(T& enum_value)
+    ErrorOr<void> decode(T& enum_value)
     {
         UnderlyingType<T> inner_value;
-        if (!decode(inner_value))
-            return false;
-
+        TRY(decode(inner_value));
         enum_value = T(inner_value);
-        return true;
+        return {};
     }
 
     template<typename T>
-    bool decode(T& value)
+    ErrorOr<void> decode(T& value)
     {
         return IPC::decode(*this, value);
     }
 
     template<typename T>
-    bool decode(Vector<T>& vector)
+    ErrorOr<void> decode(Vector<T>& vector)
     {
         u64 size;
-        if (!decode(size) || size > NumericLimits<i32>::max())
-            return false;
+        TRY(decode(size));
+        if (size > NumericLimits<i32>::max())
+            return Error::from_string_literal("IPC: Invalid Vector size"sv);
+        VERIFY(vector.is_empty());
+        TRY(vector.try_ensure_capacity(size));
         for (size_t i = 0; i < size; ++i) {
             T value;
-            if (!decode(value))
-                return false;
-            vector.append(move(value));
+            TRY(decode(value));
+            vector.template unchecked_append(move(value));
         }
-        return true;
+        return {};
     }
 
     template<typename T>
-    bool decode(Optional<T>& optional)
+    ErrorOr<void> decode(Optional<T>& optional)
     {
         bool has_value;
-        if (!decode(has_value))
-            return false;
+        TRY(decode(has_value));
         if (!has_value) {
             optional = {};
-            return true;
+            return {};
         }
         T value;
-        if (!decode(value))
-            return false;
+        TRY(decode(value));
         optional = move(value);
-        return true;
+        return {};
     }
 
 private:

Userland/Libraries/LibWeb/Cookie/ParsedCookie.cpp

@@ -348,24 +348,15 @@ bool IPC::encode(IPC::Encoder& encoder, const Web::Cookie::ParsedCookie& cookie)
     return true;
 }
 
-bool IPC::decode(IPC::Decoder& decoder, Web::Cookie::ParsedCookie& cookie)
+ErrorOr<void> IPC::decode(IPC::Decoder& decoder, Web::Cookie::ParsedCookie& cookie)
 {
-    if (!decoder.decode(cookie.name))
-        return false;
-    if (!decoder.decode(cookie.value))
-        return false;
-    if (!decoder.decode(cookie.expiry_time_from_expires_attribute))
-        return false;
-    if (!decoder.decode(cookie.expiry_time_from_max_age_attribute))
-        return false;
-    if (!decoder.decode(cookie.domain))
-        return false;
-    if (!decoder.decode(cookie.path))
-        return false;
-    if (!decoder.decode(cookie.secure_attribute_present))
-        return false;
-    if (!decoder.decode(cookie.http_only_attribute_present))
-        return false;
-
-    return true;
+    TRY(decoder.decode(cookie.name));
+    TRY(decoder.decode(cookie.value));
+    TRY(decoder.decode(cookie.expiry_time_from_expires_attribute));
+    TRY(decoder.decode(cookie.expiry_time_from_max_age_attribute));
+    TRY(decoder.decode(cookie.domain));
+    TRY(decoder.decode(cookie.path));
+    TRY(decoder.decode(cookie.secure_attribute_present));
+    TRY(decoder.decode(cookie.http_only_attribute_present));
+    return {};
 }

Userland/Libraries/LibWeb/Cookie/ParsedCookie.h

@@ -31,6 +31,6 @@ Optional<ParsedCookie> parse_cookie(const String& cookie_string);
 namespace IPC {
 
 bool encode(IPC::Encoder&, const Web::Cookie::ParsedCookie&);
-bool decode(IPC::Decoder&, Web::Cookie::ParsedCookie&);
+ErrorOr<void> decode(IPC::Decoder&, Web::Cookie::ParsedCookie&);
 
 }

Userland/Services/WindowServer/ScreenLayout.h

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

Userland/Services/WindowServer/ScreenLayout.ipp

@@ -383,22 +383,18 @@ bool encode(Encoder& encoder, const WindowServer::ScreenLayout::Screen& screen)
     return true;
 }
 
-bool decode(Decoder& decoder, WindowServer::ScreenLayout::Screen& screen)
+ErrorOr<void> decode(Decoder& decoder, WindowServer::ScreenLayout::Screen& screen)
 {
     String device;
-    if (!decoder.decode(device))
-        return false;
+    TRY(decoder.decode(device));
     Gfx::IntPoint location;
-    if (!decoder.decode(location))
-        return false;
+    TRY(decoder.decode(location));
     Gfx::IntSize resolution;
-    if (!decoder.decode(resolution))
-        return false;
+    TRY(decoder.decode(resolution));
     int scale_factor = 0;
-    if (!decoder.decode(scale_factor))
-        return false;
+    TRY(decoder.decode(scale_factor));
     screen = { device, location, resolution, scale_factor };
-    return true;
+    return {};
 }
 
 bool encode(Encoder& encoder, const WindowServer::ScreenLayout& screen_layout)
@@ -407,16 +403,14 @@ bool encode(Encoder& encoder, const WindowServer::ScreenLayout& screen_layout)
     return true;
 }
 
-bool decode(Decoder& decoder, WindowServer::ScreenLayout& screen_layout)
+ErrorOr<void> decode(Decoder& decoder, WindowServer::ScreenLayout& screen_layout)
 {
     Vector<WindowServer::ScreenLayout::Screen> screens;
-    if (!decoder.decode(screens))
-        return false;
+    TRY(decoder.decode(screens));
     unsigned main_screen_index = 0;
-    if (!decoder.decode(main_screen_index))
-        return false;
+    TRY(decoder.decode(main_screen_index));
     screen_layout = { move(screens), main_screen_index };
-    return true;
+    return {};
 }
 
 }