| // Copyright 2013 The Flutter Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "fake_session.h" |
| |
| #include <zircon/types.h> |
| |
| #include <algorithm> // For remove_if |
| #include <iterator> // For make_move_iterator |
| #include <memory> |
| |
| #include "flutter/fml/logging.h" |
| #include "flutter/shell/platform/fuchsia/flutter/tests/fakes/scenic/fake_resources.h" |
| #include "fuchsia/images/cpp/fidl.h" |
| |
| namespace flutter_runner::testing { |
| namespace { |
| |
| template <typename T> |
| constexpr bool is_node_v = std::is_same_v<T, FakeEntityNodeState> || |
| std::is_same_v<T, FakeOpacityNodeState> || |
| std::is_same_v<T, FakeShapeNodeState> || |
| std::is_same_v<T, FakeViewHolderState>; |
| |
| template <typename T> |
| bool ResourceIs(const FakeResourceState& resource) { |
| return std::holds_alternative<T>(resource.state); |
| } |
| |
| bool ResourceIsNode(const FakeResourceState& resource) { |
| return ResourceIs<FakeEntityNodeState>(resource) || |
| ResourceIs<FakeOpacityNodeState>(resource) || |
| ResourceIs<FakeShapeNodeState>(resource) || |
| ResourceIs<FakeViewHolderState>(resource); |
| } |
| |
| zx_koid_t GetKoid(zx_handle_t handle) { |
| if (handle == ZX_HANDLE_INVALID) { |
| return ZX_KOID_INVALID; |
| } |
| |
| zx_info_handle_basic_t info; |
| zx_status_t status = zx_object_get_info(handle, ZX_INFO_HANDLE_BASIC, &info, |
| sizeof(info), nullptr, nullptr); |
| return status == ZX_OK ? info.koid : ZX_KOID_INVALID; |
| } |
| |
| } // namespace |
| |
| FakeSession::FakeSession() : binding_(this) {} |
| |
| FakeSession::SessionAndListenerClientPair FakeSession::Bind( |
| async_dispatcher_t* dispatcher) { |
| FML_CHECK(!listener_.is_bound()); |
| FML_CHECK(!binding_.is_bound()); |
| |
| fidl::InterfaceHandle<fuchsia::ui::scenic::Session> session; |
| auto listener_request = listener_.NewRequest(dispatcher); |
| binding_.Bind(session.NewRequest(), dispatcher); |
| |
| return std::make_pair(std::move(session), std::move(listener_request)); |
| } |
| |
| void FakeSession::SetPresentHandler(PresentHandler present_handler) { |
| present_handler_ = std::move(present_handler); |
| } |
| |
| void FakeSession::SetPresent2Handler(Present2Handler present2_handler) { |
| present2_handler_ = std::move(present2_handler); |
| } |
| |
| void FakeSession::SetRequestPresentationTimesHandler( |
| RequestPresentationTimesHandler request_presentation_times_handler) { |
| request_presentation_times_handler_ = |
| std::move(request_presentation_times_handler); |
| } |
| |
| void FakeSession::FireOnFramePresentedEvent( |
| fuchsia::scenic::scheduling::FramePresentedInfo frame_presented_info) { |
| FML_CHECK(is_bound()); |
| |
| binding_.events().OnFramePresented(std::move(frame_presented_info)); |
| } |
| |
| void FakeSession::DisconnectSession() { |
| // Unbind the channels and drop them on the floor, simulating Scenic behavior. |
| binding_.Unbind(); |
| listener_.Unbind(); |
| } |
| |
| void FakeSession::NotImplemented_(const std::string& name) { |
| FML_LOG(FATAL) << "FakeSession does not implement " << name; |
| } |
| |
| void FakeSession::Enqueue(std::vector<fuchsia::ui::scenic::Command> cmds) { |
| // Append `cmds` to the end of the command queue, preferring to move elements |
| // when possible. |
| command_queue_.insert(command_queue_.end(), |
| std::make_move_iterator(cmds.begin()), |
| std::make_move_iterator(cmds.end())); |
| } |
| |
| void FakeSession::Present(uint64_t presentation_time, |
| std::vector<zx::event> acquire_fences, |
| std::vector<zx::event> release_fences, |
| PresentCallback callback) { |
| ApplyCommands(); |
| |
| PresentHandler present_handler = |
| present_handler_ ? present_handler_ : [](auto... args) -> auto { |
| return fuchsia::images::PresentationInfo{}; |
| }; |
| |
| auto present_info = present_handler_( |
| presentation_time, std::move(acquire_fences), std::move(release_fences)); |
| if (callback) { |
| callback(std::move(present_info)); |
| } |
| } |
| |
| void FakeSession::Present2(fuchsia::ui::scenic::Present2Args args, |
| Present2Callback callback) { |
| ApplyCommands(); |
| |
| Present2Handler present2_handler = |
| present2_handler_ ? present2_handler_ : [](auto args) -> auto { |
| return fuchsia::scenic::scheduling::FuturePresentationTimes{ |
| .future_presentations = {}, |
| .remaining_presents_in_flight_allowed = 1, |
| }; |
| }; |
| |
| auto future_presentation_times = present2_handler(std::move(args)); |
| if (callback) { |
| callback(std::move(future_presentation_times)); |
| } |
| } |
| |
| void FakeSession::RequestPresentationTimes( |
| int64_t requested_prediction_span, |
| RequestPresentationTimesCallback callback) { |
| RequestPresentationTimesHandler request_presentation_times_handler = |
| request_presentation_times_handler_ ? request_presentation_times_handler_ |
| : [](auto args) -> auto { |
| return fuchsia::scenic::scheduling::FuturePresentationTimes{ |
| .future_presentations = {}, |
| .remaining_presents_in_flight_allowed = 1, |
| }; |
| }; |
| |
| auto future_presentation_times = |
| request_presentation_times_handler(requested_prediction_span); |
| if (callback) { |
| callback(std::move(future_presentation_times)); |
| } |
| } |
| |
| void FakeSession::RegisterBufferCollection( |
| uint32_t buffer_id, |
| fidl::InterfaceHandle<fuchsia::sysmem::BufferCollectionToken> token) { |
| zx_koid_t token_koid = GetKoid(token.channel().get()); |
| auto [_, buffer_success] = |
| scene_graph_.buffer_collection_map.emplace(std::make_pair( |
| buffer_id, |
| StateT::HandleT< |
| fidl::InterfaceHandle<fuchsia::sysmem::BufferCollectionToken>>{ |
| std::move(token), token_koid})); |
| FML_CHECK(buffer_success); |
| } |
| |
| void FakeSession::DeregisterBufferCollection(uint32_t buffer_id) { |
| size_t erased = scene_graph_.buffer_collection_map.erase(buffer_id); |
| FML_CHECK(erased == 1); |
| } |
| |
| void FakeSession::SetDebugName(std::string debug_name) { |
| debug_name_ = std::move(debug_name); |
| } |
| |
| std::shared_ptr<FakeResourceState> FakeSession::GetResource(FakeResourceId id) { |
| FML_CHECK(id != kInvalidFakeResourceId); |
| auto resource_it = scene_graph_.resource_map.find(id); |
| FML_CHECK(resource_it != scene_graph_.resource_map.end()); |
| auto resource_ptr = resource_it->second; |
| FML_CHECK(resource_ptr); |
| |
| return resource_ptr; |
| } |
| |
| void FakeSession::AddResource(FakeResourceState&& resource) { |
| const FakeResourceId resource_id = resource.id; |
| FML_CHECK(resource_id != kInvalidFakeResourceId); |
| |
| // Track the view id if the resource is a view. |
| if (ResourceIs<FakeViewState>(resource)) { |
| // If there was already a View in the scene graph, scenic prints a warning |
| // here but doesn't update the "root view" and allows the Session to |
| // continue. See also: fxbug.dev/24450 |
| if (scene_graph_.root_view_id == kInvalidFakeResourceId) { |
| scene_graph_.root_view_id = resource_id; |
| } |
| } |
| |
| // Add to initial spot in parents map. |
| auto resource_ptr = std::make_shared<FakeResourceState>( |
| std::forward<FakeResourceState>(resource)); |
| if (ResourceIsNode(*resource_ptr)) { |
| auto [_, parents_success] = parents_map_.emplace(std::make_pair( |
| resource_ptr.get(), |
| std::make_pair(std::weak_ptr<FakeResourceState>(resource_ptr), |
| std::weak_ptr<FakeResourceState>()))); |
| FML_CHECK(parents_success); |
| } |
| |
| // Add to initial spot in labels map. |
| auto empty_label_it = scene_graph_.label_map.find(""); |
| if (empty_label_it == scene_graph_.label_map.end()) { |
| auto [emplace_it, empty_label_success] = scene_graph_.label_map.emplace( |
| std::make_pair("", std::vector<std::weak_ptr<FakeResourceState>>())); |
| FML_CHECK(empty_label_success); |
| empty_label_it = emplace_it; |
| } |
| empty_label_it->second.emplace_back(resource_ptr); |
| |
| // Add to resource map. |
| auto [__, resource_success] = scene_graph_.resource_map.emplace( |
| std::make_pair(resource_id, std::move(resource_ptr))); |
| FML_CHECK(resource_success); |
| } |
| |
| void FakeSession::DetachResourceFromParent( |
| std::shared_ptr<FakeResourceState> resource_ptr, |
| std::shared_ptr<FakeResourceState> new_parent_ptr) { |
| FML_CHECK(resource_ptr); |
| |
| // Remove reference from the parent's `children` array. |
| auto parent_it = parents_map_.find(resource_ptr.get()); |
| FML_CHECK(parent_it != parents_map_.end()); |
| if (auto parent_ptr = parent_it->second.second.lock()) { |
| std::visit( |
| [&resource_ptr](auto&& state) { |
| using T = std::decay_t<decltype(state)>; |
| if constexpr (is_node_v<T>) { |
| auto erase_it = |
| std::remove_if(state.node_state.children.begin(), |
| state.node_state.children.end(), |
| [&resource_ptr](const auto& resource) { |
| return resource == resource_ptr; |
| }); |
| FML_CHECK(erase_it != state.node_state.children.end()); |
| state.node_state.children.erase(erase_it); |
| } else if constexpr (std::is_same_v<T, FakeViewState>) { |
| auto erase_it = |
| std::remove_if(state.children.begin(), state.children.end(), |
| [&resource_ptr](const auto& resource) { |
| return resource == resource_ptr; |
| }); |
| FML_CHECK(erase_it != state.children.end()); |
| state.children.erase(erase_it); |
| } else { |
| FML_CHECK(false); |
| } |
| }, |
| parent_ptr->state); |
| } |
| |
| // Fix up the parent ptr. |
| if (new_parent_ptr) { |
| parent_it->second.second = new_parent_ptr; |
| } else { |
| parent_it->second.second = std::weak_ptr<FakeResourceState>(); |
| } |
| } |
| |
| void FakeSession::PruneDeletedResourceRefs() { |
| // Remove expired resources from the parents map. |
| for (auto parent_it = parents_map_.begin(), parent_end = parents_map_.end(); |
| parent_it != parent_end;) { |
| if (parent_it->second.first.expired()) { |
| parent_it = parents_map_.erase(parent_it); |
| } else { |
| ++parent_it; |
| } |
| } |
| |
| // Remove expired resurces from the labels map. |
| for (auto scene_it = scene_graph_.label_map.begin(), |
| scene_end = scene_graph_.label_map.end(); |
| scene_it != scene_end;) { |
| auto erase_it = std::remove_if( |
| scene_it->second.begin(), scene_it->second.end(), |
| [](const auto& weak_resource) { return weak_resource.expired(); }); |
| if (erase_it != scene_it->second.end()) { |
| scene_it->second.erase(erase_it); |
| } |
| |
| if (scene_it->second.empty()) { |
| scene_it = scene_graph_.label_map.erase(scene_it); |
| } else { |
| ++scene_it; |
| } |
| } |
| } |
| |
| void FakeSession::ApplyCommands() { |
| while (!command_queue_.empty()) { |
| auto scenic_command = std::move(command_queue_.front()); |
| command_queue_.pop_front(); |
| |
| if (!scenic_command.is_gfx()) { |
| FML_LOG(FATAL) << "FakeSession: Unexpected non-gfx command (type " |
| << scenic_command.Which() << ")"; |
| continue; |
| } |
| |
| auto& command = scenic_command.gfx(); |
| switch (command.Which()) { |
| case fuchsia::ui::gfx::Command::Tag::kCreateResource: |
| ApplyCreateResourceCmd(std::move(command.create_resource())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kReleaseResource: |
| ApplyReleaseResourceCmd(std::move(command.release_resource())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kAddChild: |
| ApplyAddChildCmd(std::move(command.add_child())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kDetach: |
| ApplyDetachCmd(std::move(command.detach())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kDetachChildren: |
| ApplyDetachChildrenCmd(std::move(command.detach_children())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetTranslation: |
| ApplySetTranslationCmd(std::move(command.set_translation())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetScale: |
| ApplySetScaleCmd(std::move(command.set_scale())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetRotation: |
| ApplySetRotationCmd(std::move(command.set_rotation())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetAnchor: |
| ApplySetAnchorCmd(std::move(command.set_anchor())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetOpacity: |
| ApplySetOpacityCmd(command.set_opacity()); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetShape: |
| ApplySetShapeCmd(std::move(command.set_shape())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetMaterial: |
| ApplySetMaterialCmd(std::move(command.set_material())); |
| break; |
| case ::fuchsia::ui::gfx::Command::Tag::kSetClipPlanes: |
| ApplySetClipPlanesCmd(std::move(command.set_clip_planes())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetHitTestBehavior: |
| ApplySetHitTestBehaviorCmd(std::move(command.set_hit_test_behavior())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetSemanticVisibility: |
| ApplySetSemanticVisibilityCmd( |
| std::move(command.set_semantic_visibility())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetViewProperties: |
| ApplySetViewPropertiesCmd(std::move(command.set_view_properties())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetTexture: |
| ApplySetTextureCmd(std::move(command.set_texture())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetColor: |
| ApplySetColorCmd(std::move(command.set_color())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetEventMask: |
| ApplySetEventMaskCmd(std::move(command.set_event_mask())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetLabel: |
| ApplySetLabelCmd(std::move(command.set_label())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetEnableViewDebugBounds: |
| ApplySetEnableViewDebugBoundsCmd( |
| std::move(command.set_enable_view_debug_bounds())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetViewHolderBoundsColor: |
| ApplySetViewHolderBoundsColorCmd( |
| std::move(command.set_view_holder_bounds_color())); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kExportResource: |
| NotImplemented_("ExportResourceCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kImportResource: |
| NotImplemented_("ImportResourceCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetTag: |
| NotImplemented_("SetTagCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetSize: |
| NotImplemented_("SetSizeCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSendSizeChangeHintHack: |
| NotImplemented_("SendSizeChangedHintHackCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kAddPart: |
| NotImplemented_("AddPartCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetClip: |
| NotImplemented_("SetClipCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetCamera: |
| NotImplemented_("SetCameraCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetCameraTransform: |
| NotImplemented_("SetCameraTransformCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetCameraProjection: |
| NotImplemented_("SetCameraProjectionCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetStereoCameraProjection: |
| NotImplemented_("SetStereoCameraProjectionCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetCameraClipSpaceTransform: |
| NotImplemented_("SetCameraClipSpaceTransformCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetCameraPoseBuffer: |
| NotImplemented_("SetCameraPoseBufferCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetLightColor: |
| NotImplemented_("SetLightColorCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetLightDirection: |
| NotImplemented_("SetLightDirectionCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetPointLightPosition: |
| NotImplemented_("SetPointLightPositionCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetPointLightFalloff: |
| NotImplemented_("SetPointLightFalloffCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kAddLight: |
| NotImplemented_("AddLightCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kScene_AddAmbientLight: |
| NotImplemented_("Scene_AddAmbientLightCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kScene_AddDirectionalLight: |
| NotImplemented_("Scene_AddDirectionalLightCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kScene_AddPointLight: |
| NotImplemented_("Scene_AddPointLightCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kDetachLight: |
| NotImplemented_("DetachLightCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kDetachLights: |
| NotImplemented_("DetachLightsCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kBindMeshBuffers: |
| NotImplemented_("BindMeshBuffersCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kAddLayer: |
| NotImplemented_("AddLayerCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kRemoveLayer: |
| NotImplemented_("RemoveLayerCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kRemoveAllLayers: |
| NotImplemented_("RemoveAllLayersCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetLayerStack: |
| NotImplemented_("SetLayerStackCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetRenderer: |
| NotImplemented_("SetRendererCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetRendererParam: |
| NotImplemented_("SetRendererParamCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetDisableClipping: |
| NotImplemented_("SetDisableClippingCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetImportFocus: |
| NotImplemented_("SetImportFocusCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kTakeSnapshotCmd: |
| NotImplemented_("TakeSnapshotCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetDisplayColorConversion: |
| NotImplemented_("SetDisplayColorConversionCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetDisplayRotation: |
| NotImplemented_("SetDisplayRotationCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::kSetDisplayMinimumRgb: |
| NotImplemented_("SetDisplayMinimumRgbCmd"); |
| break; |
| case fuchsia::ui::gfx::Command::Tag::Invalid: |
| FML_LOG(FATAL) << "FakeSession found Invalid gfx command"; |
| break; |
| } |
| } |
| |
| // Clean up resource refs after processing commands. |
| PruneDeletedResourceRefs(); |
| } |
| |
| void FakeSession::ApplyCreateResourceCmd( |
| fuchsia::ui::gfx::CreateResourceCmd command) { |
| const FakeResourceId resource_id = command.id; |
| FML_CHECK(resource_id != 0); |
| |
| switch (command.resource.Which()) { |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kMemory: |
| ApplyCreateMemory(resource_id, std::move(command.resource.memory())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kImage: |
| ApplyCreateImage(resource_id, std::move(command.resource.image())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kImage2: |
| ApplyCreateImage2(resource_id, std::move(command.resource.image2())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kImage3: |
| ApplyCreateImage3(resource_id, std::move(command.resource.image3())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kImagePipe2: |
| ApplyCreateImagePipe2(resource_id, |
| std::move(command.resource.image_pipe2())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kRectangle: |
| ApplyCreateRectangle(resource_id, |
| std::move(command.resource.rectangle())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kRoundedRectangle: |
| ApplyCreateRoundedRectangle( |
| resource_id, std::move(command.resource.rounded_rectangle())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kCircle: |
| ApplyCreateCircle(resource_id, std::move(command.resource.circle())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kMaterial: |
| ApplyCreateMaterial(resource_id, std::move(command.resource.material())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kView: |
| ApplyCreateView(resource_id, std::move(command.resource.view())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kView3: |
| ApplyCreateView(resource_id, std::move(command.resource.view3())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kViewHolder: |
| ApplyCreateViewHolder(resource_id, |
| std::move(command.resource.view_holder())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kOpacityNode: |
| ApplyCreateOpacityNode(resource_id, command.resource.opacity_node()); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kEntityNode: |
| ApplyCreateEntityNode(resource_id, |
| std::move(command.resource.entity_node())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kShapeNode: |
| ApplyCreateShapeNode(resource_id, |
| std::move(command.resource.shape_node())); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kBuffer: |
| NotImplemented_("CreateBufferResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kScene: |
| NotImplemented_("CreateSceneResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kCamera: |
| NotImplemented_("CreateCameraResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kStereoCamera: |
| NotImplemented_("CreateStereoCameraResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kRenderer: |
| NotImplemented_("CreateRendererResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kAmbientLight: |
| NotImplemented_("CreateAmbientLightResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kDirectionalLight: |
| NotImplemented_("CreateDirectionalLightResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kPointLight: |
| NotImplemented_("CreatePointLightResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kMesh: |
| NotImplemented_("CreateMeshResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kClipNode: |
| NotImplemented_("CreateClipNodeResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kCompositor: |
| NotImplemented_("CreateCompositorResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kDisplayCompositor: |
| NotImplemented_("CreateDisplayCompositorResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kLayerStack: |
| NotImplemented_("CreateLayerStackResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kLayer: |
| NotImplemented_("CreateLayerResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::kVariable: |
| NotImplemented_("CreateVariableResource"); |
| break; |
| case fuchsia::ui::gfx::ResourceArgs::Tag::Invalid: |
| FML_LOG(FATAL) << "FakeSession found Invalid CreateResource command"; |
| break; |
| default: |
| FML_UNREACHABLE(); |
| } |
| } |
| |
| void FakeSession::ApplyReleaseResourceCmd( |
| fuchsia::ui::gfx::ReleaseResourceCmd command) { |
| auto resource_ptr = GetResource(command.id); |
| if (ResourceIs<FakeViewState>(*resource_ptr)) { |
| FML_CHECK(scene_graph_.root_view_id == resource_ptr->id); |
| scene_graph_.root_view_id = kInvalidFakeResourceId; |
| } |
| |
| scene_graph_.resource_map.erase(command.id); |
| } |
| |
| void FakeSession::ApplyAddChildCmd(fuchsia::ui::gfx::AddChildCmd command) { |
| auto parent_node_ptr = GetResource(command.node_id); |
| FML_CHECK(ResourceIsNode(*parent_node_ptr) || |
| ResourceIs<FakeViewState>(*parent_node_ptr)); |
| |
| auto child_node_ptr = GetResource(command.child_id); |
| FML_CHECK(ResourceIsNode(*child_node_ptr)); |
| |
| // Add the Node as a child of the new parent. |
| std::visit( |
| [&child_node_ptr](auto&& state) { |
| using T = std::decay_t<decltype(state)>; |
| if constexpr (is_node_v<T>) { |
| state.node_state.children.emplace_back(child_node_ptr); |
| } else if constexpr (std::is_same_v<T, FakeViewState>) { |
| state.children.emplace_back(child_node_ptr); |
| } else { |
| FML_CHECK(false); |
| } |
| }, |
| parent_node_ptr->state); |
| |
| // Remove the Node as a child of the old parent and fix up the parent ptr. |
| DetachResourceFromParent(child_node_ptr, parent_node_ptr); |
| } |
| |
| void FakeSession::ApplyDetachCmd(fuchsia::ui::gfx::DetachCmd command) { |
| auto resource_ptr = GetResource(command.id); |
| FML_CHECK(ResourceIsNode(*resource_ptr)); |
| |
| DetachResourceFromParent(std::move(resource_ptr)); |
| } |
| |
| void FakeSession::ApplyDetachChildrenCmd( |
| fuchsia::ui::gfx::DetachChildrenCmd command) { |
| auto resource_ptr = GetResource(command.node_id); |
| FML_CHECK(ResourceIsNode(*resource_ptr)); |
| |
| std::visit( |
| [this](auto&& state) { |
| using T = std::decay_t<decltype(state)>; |
| if constexpr (is_node_v<T>) { |
| for (auto& child : state.node_state.children) { |
| DetachResourceFromParent(child); |
| } |
| state.node_state.children.clear(); |
| } else { |
| FML_CHECK(false); |
| } |
| }, |
| resource_ptr->state); |
| } |
| |
| void FakeSession::ApplySetTranslationCmd( |
| fuchsia::ui::gfx::SetTranslationCmd command) { |
| auto resource_ptr = GetResource(command.id); |
| FML_CHECK(ResourceIsNode(*resource_ptr)); |
| |
| const std::array<float, 3> translation = { |
| command.value.value.x, command.value.value.y, command.value.value.z}; |
| std::visit( |
| [&translation](auto&& state) { |
| using T = std::decay_t<decltype(state)>; |
| if constexpr (is_node_v<T>) { |
| state.node_state.translation_vector = translation; |
| } else { |
| FML_CHECK(false); |
| } |
| }, |
| resource_ptr->state); |
| } |
| |
| void FakeSession::ApplySetScaleCmd(fuchsia::ui::gfx::SetScaleCmd command) { |
| auto resource_ptr = GetResource(command.id); |
| FML_CHECK(ResourceIsNode(*resource_ptr)); |
| |
| const std::array<float, 3> scale = { |
| command.value.value.x, command.value.value.y, command.value.value.z}; |
| std::visit( |
| [&scale](auto&& state) { |
| using T = std::decay_t<decltype(state)>; |
| if constexpr (is_node_v<T>) { |
| state.node_state.scale_vector = scale; |
| } else { |
| FML_CHECK(false); |
| } |
| }, |
| resource_ptr->state); |
| } |
| |
| void FakeSession::ApplySetRotationCmd( |
| fuchsia::ui::gfx::SetRotationCmd command) { |
| auto resource_ptr = GetResource(command.id); |
| FML_CHECK(ResourceIsNode(*resource_ptr)); |
| |
| const std::array<float, 4> rotation = { |
| command.value.value.x, command.value.value.y, command.value.value.z, |
| command.value.value.w}; |
| std::visit( |
| [&rotation](auto&& state) { |
| using T = std::decay_t<decltype(state)>; |
| if constexpr (is_node_v<T>) { |
| state.node_state.rotation_quaternion = rotation; |
| } else { |
| FML_CHECK(false); |
| } |
| }, |
| resource_ptr->state); |
| } |
| |
| void FakeSession::ApplySetAnchorCmd(fuchsia::ui::gfx::SetAnchorCmd command) { |
| auto resource_ptr = GetResource(command.id); |
| FML_CHECK(ResourceIsNode(*resource_ptr)); |
| |
| const std::array<float, 3> anchor = { |
| command.value.value.x, command.value.value.y, command.value.value.z}; |
| std::visit( |
| [&anchor](auto&& state) { |
| using T = std::decay_t<decltype(state)>; |
| if constexpr (is_node_v<T>) { |
| state.node_state.anchor_vector = anchor; |
| } else { |
| FML_CHECK(false); |
| } |
| }, |
| resource_ptr->state); |
| } |
| |
| void FakeSession::ApplySetOpacityCmd(fuchsia::ui::gfx::SetOpacityCmd command) { |
| auto resource_ptr = GetResource(command.node_id); |
| FML_CHECK(ResourceIs<FakeOpacityNodeState>(*resource_ptr)); |
| |
| const bool opacity = command.opacity; |
| std::visit( |
| [opacity](auto&& state) { |
| using T = std::decay_t<decltype(state)>; |
| if constexpr (std::is_same_v<T, FakeOpacityNodeState>) { |
| state.opacity = opacity; |
| } else { |
| FML_CHECK(false); |
| } |
| }, |
| resource_ptr->state); |
| } |
| |
| void FakeSession::ApplySetShapeCmd(fuchsia::ui::gfx::SetShapeCmd command) { |
| auto shape_node_ptr = GetResource(command.node_id); |
| FML_CHECK(ResourceIs<FakeShapeNodeState>(*shape_node_ptr)); |
| auto* shape_node_state = |
| std::get_if<FakeShapeNodeState>(&shape_node_ptr->state); |
| FML_CHECK(shape_node_state != nullptr); |
| auto shape_ptr = GetResource(command.shape_id); |
| FML_CHECK(ResourceIs<FakeShapeState>(*shape_ptr)); |
| |
| shape_node_state->shape = shape_ptr; |
| } |
| |
| void FakeSession::ApplySetMaterialCmd( |
| fuchsia::ui::gfx::SetMaterialCmd command) { |
| auto shape_node_ptr = GetResource(command.node_id); |
| FML_CHECK(ResourceIs<FakeShapeNodeState>(*shape_node_ptr)); |
| auto* shape_node_state = |
| std::get_if<FakeShapeNodeState>(&shape_node_ptr->state); |
| FML_CHECK(shape_node_state != nullptr); |
| auto material_ptr = GetResource(command.material_id); |
| FML_CHECK(ResourceIs<FakeMaterialState>(*material_ptr)); |
| |
| shape_node_state->material = material_ptr; |
| } |
| |
| void FakeSession::ApplySetClipPlanesCmd( |
| fuchsia::ui::gfx::SetClipPlanesCmd command) { |
| auto node_ptr = GetResource(command.node_id); |
| FML_CHECK(ResourceIs<FakeEntityNodeState>(*node_ptr)); |
| |
| std::vector<FakeEntityNodeState::ClipPlane> clip_planes; |
| for (auto& clip_plane : command.clip_planes) { |
| clip_planes.emplace_back(FakeEntityNodeState::ClipPlane{ |
| .dir = {clip_plane.dir.x, clip_plane.dir.y, clip_plane.dir.z}, |
| .dist = clip_plane.dist, |
| }); |
| } |
| std::visit( |
| [clip_planes = std::move(clip_planes)](auto&& state) { |
| using T = std::decay_t<decltype(state)>; |
| if constexpr (std::is_same_v<T, FakeEntityNodeState>) { |
| state.clip_planes = std::move(clip_planes); |
| } else { |
| FML_CHECK(false); |
| } |
| }, |
| node_ptr->state); |
| } |
| |
| void FakeSession::ApplySetViewPropertiesCmd( |
| fuchsia::ui::gfx::SetViewPropertiesCmd command) { |
| auto view_holder_ptr = GetResource(command.view_holder_id); |
| FML_CHECK(ResourceIs<FakeViewHolderState>(*view_holder_ptr)); |
| auto* view_holder_state = |
| std::get_if<FakeViewHolderState>(&view_holder_ptr->state); |
| FML_CHECK(view_holder_state != nullptr); |
| |
| view_holder_state->properties = command.properties; |
| } |
| |
| void FakeSession::ApplySetHitTestBehaviorCmd( |
| fuchsia::ui::gfx::SetHitTestBehaviorCmd command) { |
| auto node_ptr = GetResource(command.node_id); |
| FML_CHECK(ResourceIsNode(*node_ptr)); |
| |
| const bool hit_testable = |
| command.hit_test_behavior == fuchsia::ui::gfx::HitTestBehavior::kDefault; |
| std::visit( |
| [hit_testable](auto&& state) { |
| using T = std::decay_t<decltype(state)>; |
| if constexpr (is_node_v<T>) { |
| state.node_state.hit_testable = hit_testable; |
| } else { |
| FML_CHECK(false); |
| } |
| }, |
| node_ptr->state); |
| } |
| |
| void FakeSession::ApplySetSemanticVisibilityCmd( |
| fuchsia::ui::gfx::SetSemanticVisibilityCmd command) { |
| auto node_ptr = GetResource(command.node_id); |
| FML_CHECK(ResourceIsNode(*node_ptr)); |
| |
| const bool semantic_visibility = command.visible; |
| std::visit( |
| [semantic_visibility](auto&& state) { |
| using T = std::decay_t<decltype(state)>; |
| if constexpr (is_node_v<T>) { |
| state.node_state.semantically_visible = semantic_visibility; |
| } else { |
| FML_CHECK(false); |
| } |
| }, |
| node_ptr->state); |
| } |
| |
| void FakeSession::ApplySetTextureCmd(fuchsia::ui::gfx::SetTextureCmd command) { |
| auto material_ptr = GetResource(command.material_id); |
| FML_CHECK(ResourceIs<FakeMaterialState>(*material_ptr)); |
| auto* material_state = std::get_if<FakeMaterialState>(&material_ptr->state); |
| FML_CHECK(material_state != nullptr); |
| auto image_ptr = GetResource(command.texture_id); |
| FML_CHECK(ResourceIs<FakeImageState>(*image_ptr)); |
| |
| material_state->image = image_ptr; |
| } |
| |
| void FakeSession::ApplySetColorCmd(fuchsia::ui::gfx::SetColorCmd command) { |
| auto material_ptr = GetResource(command.material_id); |
| FML_CHECK(ResourceIs<FakeMaterialState>(*material_ptr)); |
| auto* material_state = std::get_if<FakeMaterialState>(&material_ptr->state); |
| FML_CHECK(material_state != nullptr); |
| |
| material_state->color = {(command.color.value.red * 1.f) / 255.f, |
| (command.color.value.green * 1.f) / 255.f, |
| (command.color.value.blue * 1.f) / 255.f, |
| (command.color.value.alpha * 1.f) / 255.f}; |
| } |
| |
| void FakeSession::ApplySetEventMaskCmd( |
| fuchsia::ui::gfx::SetEventMaskCmd command) { |
| auto resource_ptr = GetResource(command.id); |
| |
| resource_ptr->event_mask = command.event_mask; |
| } |
| |
| void FakeSession::ApplySetLabelCmd(fuchsia::ui::gfx::SetLabelCmd command) { |
| auto resource_ptr = GetResource(command.id); |
| |
| // Erase from old spot in the labels map. |
| auto current_label_it = scene_graph_.label_map.find(resource_ptr->label); |
| FML_CHECK(current_label_it != scene_graph_.label_map.end()); |
| auto current_erase_it = std::remove_if( |
| current_label_it->second.begin(), current_label_it->second.end(), |
| [&resource_ptr](const auto& weak_resource) { |
| return resource_ptr == weak_resource.lock(); |
| }); |
| FML_CHECK(current_erase_it != current_label_it->second.end()); |
| current_label_it->second.erase(current_erase_it); |
| |
| // Add to new spot in labels map. |
| auto new_label_it = scene_graph_.label_map.find(command.label); |
| if (new_label_it == scene_graph_.label_map.end()) { |
| auto [emplace_it, current_label_success] = |
| scene_graph_.label_map.emplace(std::make_pair( |
| command.label, std::vector<std::weak_ptr<FakeResourceState>>())); |
| FML_CHECK(current_label_success); |
| new_label_it = emplace_it; |
| } |
| new_label_it->second.emplace_back(resource_ptr); |
| |
| resource_ptr->label = std::move(command.label); |
| } |
| |
| void FakeSession::ApplySetEnableViewDebugBoundsCmd( |
| fuchsia::ui::gfx::SetEnableDebugViewBoundsCmd command) { |
| auto view_ptr = GetResource(command.view_id); |
| FML_CHECK(ResourceIs<FakeViewState>(*view_ptr)); |
| auto* view_state = std::get_if<FakeViewState>(&view_ptr->state); |
| FML_CHECK(view_state != nullptr); |
| |
| view_state->enable_debug_bounds = command.enable; |
| } |
| |
| void FakeSession::ApplySetViewHolderBoundsColorCmd( |
| fuchsia::ui::gfx::SetViewHolderBoundsColorCmd command) { |
| auto view_holder_ptr = GetResource(command.view_holder_id); |
| FML_CHECK(ResourceIs<FakeViewHolderState>(*view_holder_ptr)); |
| auto* view_holder_state = |
| std::get_if<FakeViewHolderState>(&view_holder_ptr->state); |
| FML_CHECK(view_holder_state != nullptr); |
| |
| view_holder_state->bounds_color = {command.color.value.red, |
| command.color.value.green, |
| command.color.value.blue, 1.f}; |
| } |
| |
| void FakeSession::ApplyCreateMemory(FakeResourceId id, |
| fuchsia::ui::gfx::MemoryArgs args) { |
| zx_koid_t vmo_koid = GetKoid(args.vmo.get()); |
| AddResource( |
| {.id = id, |
| .state = FakeMemoryState{ |
| .vmo = {std::move(args.vmo), vmo_koid}, |
| .allocation_size = args.allocation_size, |
| .is_device_memory = (args.memory_type == |
| fuchsia::images::MemoryType::VK_DEVICE_MEMORY), |
| }}); |
| } |
| |
| void FakeSession::ApplyCreateImage(FakeResourceId id, |
| fuchsia::ui::gfx::ImageArgs args) { |
| AddResource({.id = id, |
| .state = FakeImageState{ |
| .image_def = |
| FakeImageState::ImageDef{ |
| .info = std::move(args.info), |
| .memory_offset = args.memory_offset, |
| }, |
| }}); |
| |
| // Hook up the memory resource to the image |
| auto image_ptr = GetResource(id); |
| FML_CHECK(ResourceIs<FakeImageState>(*image_ptr)); |
| auto* image_state = std::get_if<FakeImageState>(&image_ptr->state); |
| FML_CHECK(image_state != nullptr); |
| auto memory_ptr = GetResource(args.memory_id); |
| FML_CHECK(ResourceIs<FakeMemoryState>(*memory_ptr)); |
| |
| image_state->memory = memory_ptr; |
| } |
| |
| void FakeSession::ApplyCreateImage2(FakeResourceId id, |
| fuchsia::ui::gfx::ImageArgs2 args) { |
| AddResource( |
| {.id = id, |
| .state = FakeImageState{ |
| .image_def = |
| FakeImageState::Image2Def{ |
| .buffer_collection_id = args.buffer_collection_id, |
| .buffer_collection_index = args.buffer_collection_index, |
| .width = args.width, |
| .height = args.height, |
| }, |
| }}); |
| } |
| |
| void FakeSession::ApplyCreateImage3(FakeResourceId id, |
| fuchsia::ui::gfx::ImageArgs3 args) { |
| zx_koid_t import_token_koid = GetKoid(args.import_token.value.get()); |
| AddResource( |
| {.id = id, |
| .state = FakeImageState{ |
| .image_def = |
| FakeImageState::Image3Def{ |
| .import_token = {std::move(args.import_token), |
| import_token_koid}, |
| .buffer_collection_index = args.buffer_collection_index, |
| .width = args.width, |
| .height = args.height, |
| }, |
| }}); |
| } |
| |
| void FakeSession::ApplyCreateImagePipe2(FakeResourceId id, |
| fuchsia::ui::gfx::ImagePipe2Args args) { |
| zx_koid_t image_pipe_request_koid = |
| GetKoid(args.image_pipe_request.channel().get()); |
| AddResource( |
| {.id = id, |
| .state = FakeImageState{ |
| .image_def = |
| FakeImageState::ImagePipe2Def{ |
| .image_pipe_request = {std::move(args.image_pipe_request), |
| image_pipe_request_koid}, |
| }, |
| }}); |
| } |
| |
| void FakeSession::ApplyCreateRectangle(FakeResourceId id, |
| fuchsia::ui::gfx::RectangleArgs args) { |
| FML_CHECK(args.width.is_vector1()); |
| FML_CHECK(args.height.is_vector1()); |
| |
| AddResource({.id = id, |
| .state = FakeShapeState{ |
| .shape_def = |
| FakeShapeState::RectangleDef{ |
| .width = args.width.vector1(), |
| .height = args.height.vector1(), |
| }, |
| }}); |
| } |
| |
| void FakeSession::ApplyCreateRoundedRectangle( |
| FakeResourceId id, |
| fuchsia::ui::gfx::RoundedRectangleArgs args) { |
| FML_CHECK(args.width.is_vector1()); |
| FML_CHECK(args.height.is_vector1()); |
| FML_CHECK(args.top_left_radius.is_vector1()); |
| FML_CHECK(args.top_right_radius.is_vector1()); |
| FML_CHECK(args.bottom_right_radius.is_vector1()); |
| FML_CHECK(args.bottom_left_radius.is_vector1()); |
| |
| AddResource( |
| {.id = id, |
| .state = FakeShapeState{ |
| .shape_def = |
| FakeShapeState::RoundedRectangleDef{ |
| .width = args.width.vector1(), |
| .height = args.height.vector1(), |
| .top_left_radius = args.top_left_radius.vector1(), |
| .top_right_radius = args.top_right_radius.vector1(), |
| .bottom_right_radius = args.bottom_right_radius.vector1(), |
| .bottom_left_radius = args.bottom_left_radius.vector1(), |
| }, |
| }}); |
| } |
| |
| void FakeSession::ApplyCreateCircle(FakeResourceId id, |
| fuchsia::ui::gfx::CircleArgs args) { |
| FML_CHECK(args.radius.is_vector1()); |
| |
| AddResource({.id = id, |
| .state = FakeShapeState{ |
| .shape_def = |
| FakeShapeState::CircleDef{ |
| .radius = args.radius.vector1(), |
| }, |
| }}); |
| } |
| |
| void FakeSession::ApplyCreateMaterial(FakeResourceId id, |
| fuchsia::ui::gfx::MaterialArgs args) { |
| AddResource({ |
| .id = id, |
| .state = FakeMaterialState{}, |
| }); |
| } |
| |
| void FakeSession::ApplyCreateView(FakeResourceId id, |
| fuchsia::ui::gfx::ViewArgs args) { |
| FML_CHECK(scene_graph_.root_view_id == kInvalidFakeResourceId); |
| |
| zx_koid_t token_koid = GetKoid(args.token.value.get()); |
| AddResource({.id = id, |
| .state = FakeViewState{ |
| .token = {std::move(args.token), token_koid}, |
| .debug_name = std::string(args.debug_name->c_str(), |
| args.debug_name->length()), |
| }}); |
| } |
| |
| void FakeSession::ApplyCreateView(FakeResourceId id, |
| fuchsia::ui::gfx::ViewArgs3 args) { |
| zx_koid_t token_koid = GetKoid(args.token.value.get()); |
| zx_koid_t control_ref_koid = GetKoid(args.control_ref.reference.get()); |
| zx_koid_t view_ref_koid = GetKoid(args.view_ref.reference.get()); |
| AddResource( |
| {.id = id, |
| .state = FakeViewState{ |
| .token = {std::move(args.token), token_koid}, |
| .control_ref = {std::move(args.control_ref), control_ref_koid}, |
| .view_ref = {std::move(args.view_ref), view_ref_koid}, |
| .debug_name = |
| std::string(args.debug_name->c_str(), args.debug_name->length()), |
| }}); |
| } |
| |
| void FakeSession::ApplyCreateViewHolder(FakeResourceId id, |
| fuchsia::ui::gfx::ViewHolderArgs args) { |
| zx_koid_t token_koid = GetKoid(args.token.value.get()); |
| AddResource({ |
| .id = id, |
| .state = |
| FakeViewHolderState{ |
| .token = {std::move(args.token), token_koid}, |
| .debug_name = std::string(args.debug_name->c_str(), |
| args.debug_name->length()), |
| }, |
| }); |
| } |
| |
| void FakeSession::ApplyCreateEntityNode(FakeResourceId id, |
| fuchsia::ui::gfx::EntityNodeArgs args) { |
| AddResource({ |
| .id = id, |
| .state = FakeEntityNodeState{}, |
| }); |
| } |
| |
| void FakeSession::ApplyCreateOpacityNode( |
| FakeResourceId id, |
| fuchsia::ui::gfx::OpacityNodeArgsHACK args) { |
| AddResource({ |
| .id = id, |
| .state = FakeOpacityNodeState{}, |
| }); |
| } |
| |
| void FakeSession::ApplyCreateShapeNode(FakeResourceId id, |
| fuchsia::ui::gfx::ShapeNodeArgs args) { |
| AddResource({ |
| .id = id, |
| .state = FakeShapeNodeState{}, |
| }); |
| } |
| |
| } // namespace flutter_runner::testing |
