dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

LibImageDecoderClient: Remove sync id fetch from async decode request

Browse source
This commit is contained in:
Jonathan Gamble 2026-02-21 14:48:14 -06:00 committed by Gregory Bertilson
parent 1477d86b3e
commit 7d902c2a89
6 changed files with 41 additions and 47 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

36
Libraries/LibImageDecoderClient/Client.cpp
View file

@ -17,10 +17,10 @@ Client::Client(NonnullOwnPtr<IPC::Transport> transport)
void Client::die() void Client::die()
{ {
verify_event_loop(); verify_event_loop();
for (auto& [_, promise] : m_pending_decoded_images) { auto pending_promises = move(m_token_promises);
promise->reject(Error::from_string_literal("ImageDecoder disconnected"));
} for (auto& promise : pending_promises)
m_pending_decoded_images.clear(); promise.value->reject(Error::from_string_literal("ImageDecoder disconnected"));
} }
NonnullRefPtr<Core::Promise<DecodedImage>> Client::decode_image(ReadonlyBytes encoded_data, Function<ErrorOr<void>(DecodedImage&)> on_resolved, Function<void(Error&)> on_rejected, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type) NonnullRefPtr<Core::Promise<DecodedImage>> Client::decode_image(ReadonlyBytes encoded_data, Function<ErrorOr<void>(DecodedImage&)> on_resolved, Function<void(Error&)> on_rejected, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type)
@ -47,27 +47,24 @@ NonnullRefPtr<Core::Promise<DecodedImage>> Client::decode_image(ReadonlyBytes en
memcpy(encoded_buffer.data<void>(), encoded_data.data(), encoded_data.size()); memcpy(encoded_buffer.data<void>(), encoded_data.data(), encoded_data.size());
auto response = send_sync_but_allow_failure<Messages::ImageDecoderServer::DecodeImage>(move(encoded_buffer), ideal_size, mime_type); i64 request_id = m_next_request_id++;
if (!response) { m_token_promises.set(request_id, promise);
dbgln("ImageDecoder disconnected trying to decode image");
promise->reject(Error::from_string_literal("ImageDecoder disconnected"));
return promise;
}
m_pending_decoded_images.set(response->image_id(), promise); async_decode_image(encoded_buffer, ideal_size, mime_type, request_id);
return promise; return promise;
} }
void Client::did_decode_image(i64 image_id, bool is_animated, u32 loop_count, Gfx::BitmapSequence bitmap_sequence, Vector<u32> durations, Gfx::FloatPoint scale, Gfx::ColorSpace color_space, i64 session_id) void Client::did_decode_image(i64 request_id, bool is_animated, u32 loop_count, Gfx::BitmapSequence bitmap_sequence, Vector<u32> durations, Gfx::FloatPoint scale, Gfx::ColorSpace color_space, i64 session_id)
{ {
verify_event_loop(); verify_event_loop();
auto bitmaps = move(bitmap_sequence.bitmaps); auto bitmaps = move(bitmap_sequence.bitmaps);
VERIFY(!bitmaps.is_empty()); VERIFY(!bitmaps.is_empty());
auto maybe_promise = m_pending_decoded_images.take(image_id); Optional<NonnullRefPtr<Core::Promise<DecodedImage>>> maybe_promise = m_token_promises.take(request_id);
if (!maybe_promise.has_value()) { if (!maybe_promise.has_value()) {
dbgln("ImageDecoderClient: No pending image with ID {}", image_id); dbgln("ImageDecoderClient: No pending image with request token {}", request_id);
return; return;
} }
auto promise = maybe_promise.release_value(); auto promise = maybe_promise.release_value();
@ -89,7 +86,7 @@ void Client::did_decode_image(i64 image_id, bool is_animated, u32 loop_count, Gf
for (size_t i = 0; i < bitmaps.size(); ++i) { for (size_t i = 0; i < bitmaps.size(); ++i) {
if (!bitmaps[i]) { if (!bitmaps[i]) {
dbgln("ImageDecoderClient: Invalid bitmap for request {} at index {}", image_id, i); dbgln("ImageDecoderClient: Invalid bitmap for request {} at index {}", request_id, i);
promise->reject(Error::from_string_literal("Invalid bitmap")); promise->reject(Error::from_string_literal("Invalid bitmap"));
return; return;
} }
@ -101,17 +98,18 @@ void Client::did_decode_image(i64 image_id, bool is_animated, u32 loop_count, Gf
promise->resolve(move(image)); promise->resolve(move(image));
} }
void Client::did_fail_to_decode_image(i64 image_id, String error_message) void Client::did_fail_to_decode_image(i64 request_id, String error_message)
{ {
verify_event_loop(); verify_event_loop();
auto maybe_promise = m_pending_decoded_images.take(image_id); Optional<NonnullRefPtr<Core::Promise<DecodedImage>>> maybe_promise = m_token_promises.take(request_id);
if (!maybe_promise.has_value()) { if (!maybe_promise.has_value()) {
dbgln("ImageDecoderClient: No pending image with ID {}", image_id); dbgln("ImageDecoderClient: No pending image with request token {}", request_id);
return; return;
} }
auto promise = maybe_promise.release_value(); auto promise = maybe_promise.release_value();
dbgln("ImageDecoderClient: Failed to decode image with ID {}: {}", image_id, error_message); dbgln("ImageDecoderClient: Failed to decode image with request token {}: {}", request_id, error_message);
// FIXME: Include the error message in the Error object when Errors are allowed to hold Strings // FIXME: Include the error message in the Error object when Errors are allowed to hold Strings
promise->reject(Error::from_string_literal("Image decoding failed or aborted")); promise->reject(Error::from_string_literal("Image decoding failed or aborted"));
} }

7
Libraries/LibImageDecoderClient/Client.h
View file

@ -55,14 +55,15 @@ private:
void verify_event_loop() const; void verify_event_loop() const;
virtual void die() override; virtual void die() override;
virtual void did_decode_image(i64 image_id, bool is_animated, u32 loop_count, Gfx::BitmapSequence bitmap_sequence, Vector<u32> durations, Gfx::FloatPoint scale, Gfx::ColorSpace color_space, i64 session_id) override; virtual void did_decode_image(i64 request_id, bool is_animated, u32 loop_count, Gfx::BitmapSequence bitmap_sequence, Vector<u32> durations, Gfx::FloatPoint scale, Gfx::ColorSpace color_space, i64 session_id) override;
virtual void did_fail_to_decode_image(i64 image_id, String error_message) override; virtual void did_fail_to_decode_image(i64 request_id, String error_message) override;
virtual void did_decode_animation_frames(i64 session_id, Gfx::BitmapSequence bitmaps) override; virtual void did_decode_animation_frames(i64 session_id, Gfx::BitmapSequence bitmaps) override;
virtual void did_fail_animation_decode(i64 session_id, String error_message) override; virtual void did_fail_animation_decode(i64 session_id, String error_message) override;
Core::EventLoop* m_creation_event_loop { &Core::EventLoop::current() }; Core::EventLoop* m_creation_event_loop { &Core::EventLoop::current() };
HashMap<i64, NonnullRefPtr<Core::Promise<DecodedImage>>> m_pending_decoded_images; i64 m_next_request_id { 0 };
HashMap<i64, NonnullRefPtr<Core::Promise<DecodedImage>>> m_token_promises;
}; };
} }

30
Services/ImageDecoder/ConnectionFromClient.cpp
View file

@ -183,13 +183,13 @@ static ErrorOr<ConnectionFromClient::DecodeResult> decode_image_to_details(Core:
return result; return result;
} }
NonnullRefPtr<ConnectionFromClient::Job> ConnectionFromClient::make_decode_image_job(i64 image_id, Core::AnonymousBuffer encoded_buffer, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type) NonnullRefPtr<ConnectionFromClient::Job> ConnectionFromClient::make_decode_image_job(i64 request_id, Core::AnonymousBuffer encoded_buffer, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type)
{ {
return Job::construct( return Job::construct(
[encoded_buffer = move(encoded_buffer), ideal_size = move(ideal_size), mime_type = move(mime_type)](auto&) mutable -> ErrorOr<DecodeResult> { [encoded_buffer = move(encoded_buffer), ideal_size = move(ideal_size), mime_type = move(mime_type)](auto&) mutable -> ErrorOr<DecodeResult> {
return TRY(decode_image_to_details(move(encoded_buffer), ideal_size, mime_type)); return TRY(decode_image_to_details(move(encoded_buffer), ideal_size, mime_type));
}, },
[strong_this = NonnullRefPtr(*this), image_id](DecodeResult result) -> ErrorOr<void> { [strong_this = NonnullRefPtr(*this), request_id](DecodeResult result) -> ErrorOr<void> {
i64 session_id = 0; i64 session_id = 0;
if (result.decoder) { if (result.decoder) {
@ -202,35 +202,31 @@ NonnullRefPtr<ConnectionFromClient::Job> ConnectionFromClient::make_decode_image
strong_this->m_animation_sessions.set(session_id, move(session)); strong_this->m_animation_sessions.set(session_id, move(session));
} }
strong_this->async_did_decode_image(image_id, result.is_animated, result.loop_count, move(result.bitmaps), move(result.durations), result.scale, move(result.color_profile), session_id); strong_this->async_did_decode_image(request_id, result.is_animated, result.loop_count, move(result.bitmaps), move(result.durations), result.scale, move(result.color_profile), session_id);
strong_this->m_pending_jobs.remove(image_id); strong_this->m_pending_jobs.remove(request_id);
return {}; return {};
}, },
[strong_this = NonnullRefPtr(*this), image_id](Error error) -> void { [strong_this = NonnullRefPtr(*this), request_id](Error error) -> void {
if (strong_this->is_open()) if (strong_this->is_open())
strong_this->async_did_fail_to_decode_image(image_id, MUST(String::formatted("Decoding failed: {}", error))); strong_this->async_did_fail_to_decode_image(request_id, MUST(String::formatted("Decoding failed: {}", error)));
strong_this->m_pending_jobs.remove(image_id); strong_this->m_pending_jobs.remove(request_id);
}); });
} }
Messages::ImageDecoderServer::DecodeImageResponse ConnectionFromClient::decode_image(Core::AnonymousBuffer encoded_buffer, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type) void ConnectionFromClient::decode_image(Core::AnonymousBuffer encoded_buffer, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type, i64 request_id)
{ {
auto image_id = m_next_image_id++;
if (!encoded_buffer.is_valid()) { if (!encoded_buffer.is_valid()) {
dbgln_if(IMAGE_DECODER_DEBUG, "Encoded data is invalid"); dbgln_if(IMAGE_DECODER_DEBUG, "Encoded data is invalid");
async_did_fail_to_decode_image(image_id, "Encoded data is invalid"_string); async_did_fail_to_decode_image(request_id, "Encoded data is invalid"_string);
return image_id; return;
} }
m_pending_jobs.set(image_id, make_decode_image_job(image_id, move(encoded_buffer), ideal_size, move(mime_type))); m_pending_jobs.set(request_id, make_decode_image_job(request_id, move(encoded_buffer), ideal_size, move(mime_type)));
return image_id;
} }
void ConnectionFromClient::cancel_decoding(i64 image_id) void ConnectionFromClient::cancel_decoding(i64 request_id)
{ {
if (auto job = m_pending_jobs.take(image_id); job.has_value()) { if (auto job = m_pending_jobs.take(request_id); job.has_value()) {
job.value()->cancel(); job.value()->cancel();
} }
} }

7
Services/ImageDecoder/ConnectionFromClient.h
View file

@ -55,8 +55,8 @@ private:
explicit ConnectionFromClient(NonnullOwnPtr<IPC::Transport>); explicit ConnectionFromClient(NonnullOwnPtr<IPC::Transport>);
virtual Messages::ImageDecoderServer::DecodeImageResponse decode_image(Core::AnonymousBuffer, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type) override; virtual void decode_image(Core::AnonymousBuffer, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type, i64 request_id) override;
virtual void cancel_decoding(i64 image_id) override; virtual void cancel_decoding(i64 request_id) override;
virtual void request_animation_frames(i64 session_id, u32 start_frame_index, u32 count) override; virtual void request_animation_frames(i64 session_id, u32 start_frame_index, u32 count) override;
virtual void stop_animation_decode(i64 session_id) override; virtual void stop_animation_decode(i64 session_id) override;
virtual Messages::ImageDecoderServer::ConnectNewClientsResponse connect_new_clients(size_t count) override; virtual Messages::ImageDecoderServer::ConnectNewClientsResponse connect_new_clients(size_t count) override;
@ -64,9 +64,8 @@ private:
ErrorOr<IPC::File> connect_new_client(); ErrorOr<IPC::File> connect_new_client();
NonnullRefPtr<Job> make_decode_image_job(i64 image_id, Core::AnonymousBuffer, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type); NonnullRefPtr<Job> make_decode_image_job(i64 request_id, Core::AnonymousBuffer, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type);
i64 m_next_image_id { 0 };
i64 m_next_session_id { 1 }; i64 m_next_session_id { 1 };
HashMap<i64, NonnullRefPtr<Job>> m_pending_jobs; HashMap<i64, NonnullRefPtr<Job>> m_pending_jobs;
HashMap<i64, NonnullOwnPtr<AnimationSession>> m_animation_sessions; HashMap<i64, NonnullOwnPtr<AnimationSession>> m_animation_sessions;

4
Services/ImageDecoder/ImageDecoderClient.ipc
View file

@ -3,8 +3,8 @@
endpoint ImageDecoderClient endpoint ImageDecoderClient
{ {
did_decode_image(i64 image_id, bool is_animated, u32 loop_count, Gfx::BitmapSequence bitmaps, Vector<u32> durations, Gfx::FloatPoint scale, Gfx::ColorSpace color_profile, i64 session_id) =| did_decode_image(i64 request_id, bool is_animated, u32 loop_count, Gfx::BitmapSequence bitmaps, Vector<u32> durations, Gfx::FloatPoint scale, Gfx::ColorSpace color_profile, i64 session_id) =|
did_fail_to_decode_image(i64 image_id, String error_message) =| did_fail_to_decode_image(i64 request_id, String error_message) =|
did_decode_animation_frames(i64 session_id, Gfx::BitmapSequence bitmaps) =| did_decode_animation_frames(i64 session_id, Gfx::BitmapSequence bitmaps) =|
did_fail_animation_decode(i64 session_id, String error_message) =| did_fail_animation_decode(i64 session_id, String error_message) =|

4
Services/ImageDecoder/ImageDecoderServer.ipc
View file

@ -3,8 +3,8 @@
endpoint ImageDecoderServer endpoint ImageDecoderServer
{ {
init_transport(int peer_pid) => (int peer_pid) init_transport(int peer_pid) => (int peer_pid)
decode_image(Core::AnonymousBuffer data, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type) => (i64 image_id) decode_image(Core::AnonymousBuffer data, Optional<Gfx::IntSize> ideal_size, Optional<ByteString> mime_type, i64 request_id) =|
cancel_decoding(i64 image_id) =| cancel_decoding(i64 request_id) =|
request_animation_frames(i64 session_id, u32 start_frame_index, u32 count) =| request_animation_frames(i64 session_id, u32 start_frame_index, u32 count) =|
stop_animation_decode(i64 session_id) =| stop_animation_decode(i64 session_id) =|