Merge branch 'development' into cleanup/SPEC-1670

Code/Framework/AzCore/AzCore/Math/MathReflection.cpp

@@ -116,7 +116,7 @@ namespace AZ
                 {
                     const char* uuidString = nullptr;
                     unsigned int uuidStringLength = 0;
-                    if (dc.ReadArg(0, uuidString) && dc.ReadValue(1, uuidStringLength))
+                    if (dc.ReadArg(0, uuidString) && dc.ReadArg(1, uuidStringLength))
                     {
                         dc.PushResult(Uuid(uuidString, uuidStringLength));
                     }

Code/Framework/AzCore/Tests/Serialization/Json/TestCases_Patching.cpp

@@ -6,6 +6,7 @@
  */
 
 #include <AzCore/Math/Vector3.h>
+#include <AzCore/Serialization/Json/JsonSerializationSettings.h>
 #include <AzCore/std/string/string_view.h>
 #include <Tests/Serialization/Json/JsonSerializationTests.h>
 
@@ -43,7 +44,9 @@ namespace JsonSerializationTests
         }
 
         void CheckApplyPatchOutcome(const char* target, const char* patch,
-            AZ::JsonSerializationResult::Outcomes outcome, AZ::JsonSerializationResult::Processing processing)
+            AZ::JsonSerializationResult::Outcomes outcome,
+            AZ::JsonSerializationResult::Processing processing,
+            const AZ::JsonApplyPatchSettings& settings = AZ::JsonApplyPatchSettings{})
         {
             m_jsonDocument->Parse(target);
             ASSERT_FALSE(m_jsonDocument->HasParseError());
@@ -53,12 +56,24 @@ namespace JsonSerializationTests
             ASSERT_FALSE(patchDocument.HasParseError());
 
             AZ::JsonSerializationResult::ResultCode result = AZ::JsonSerialization::ApplyPatch(*m_jsonDocument,
-                m_jsonDocument->GetAllocator(), patchDocument, AZ::JsonMergeApproach::JsonPatch);
+                m_jsonDocument->GetAllocator(), patchDocument, AZ::JsonMergeApproach::JsonPatch, settings);
             EXPECT_EQ(result.GetTask(), AZ::JsonSerializationResult::Tasks::Merge);
             EXPECT_EQ(result.GetOutcome(), outcome);
             EXPECT_EQ(result.GetProcessing(), processing);
         }
 
+        void CheckApplyPatchOutcome(
+            const char* target,
+            const char* patch,
+            const char* expectedPatchedResult,
+            AZ::JsonSerializationResult::Outcomes outcome,
+            AZ::JsonSerializationResult::Processing processing,
+            const AZ::JsonApplyPatchSettings& settings = AZ::JsonApplyPatchSettings{})
+        {
+            CheckApplyPatchOutcome(target, patch, outcome, processing, settings);
+            Expect_DocStrEq(expectedPatchedResult);
+        }
+
         void CheckCreatePatch_Core(const char* source, AZStd::string_view patch, const char* target,
             AZ::JsonMergeApproach approach)
         {
@@ -262,6 +277,36 @@ namespace JsonSerializationTests
             Outcomes::TypeMismatch, Processing::Halted);
     }
 
+    TEST_F(JsonPatchingSerializationTests, ApplyPatch_UseJsonPatchWithCustomReportingCallback_ReportPartialSkip)
+    {
+        using namespace AZ::JsonSerializationResult;
+        auto issueReportingCallback = [](AZStd::string_view, AZ::JsonSerializationResult::ResultCode result,
+                                         AZStd::string_view) -> AZ::JsonSerializationResult::ResultCode
+        {
+            using namespace AZ::JsonSerializationResult;
+            if (result.GetProcessing() == Processing::Halted)
+            {
+                return ResultCode(result.GetTask(), Outcomes::PartialSkip);
+            }
+            return result;
+        };
+
+        AZ::JsonApplyPatchSettings applyPatchSettings;
+        applyPatchSettings.m_reporting = AZStd::move(issueReportingCallback);
+        CheckApplyPatchOutcome(
+            R"({})",
+            R"([
+                { "op": "add", "path": "/nonexistent_key/new_member", "value": "someValue" },
+                { "op": "add", "path": "/test", "value": "someValue" }
+            ])",
+            R"(
+                { "test": "someValue" }
+            )",
+            Outcomes::PartialSkip,
+            Processing::Completed,
+            AZStd::move(applyPatchSettings));
+    }
+
     TEST_F(JsonPatchingSerializationTests, ApplyPatch_UseJsonPatchAddUnnamedMember_ReportsSuccess)
     {
         CheckApplyPatch(

Code/Framework/AzFramework/AzFramework/Windowing/WindowBus.h

@@ -97,6 +97,9 @@ namespace AzFramework
 
         //! This is called when the window is deactivated from code or if the user closes the window.
         virtual void OnWindowClosed() {};
+
+        //! This is called when vsync interval is changed.
+        virtual void OnVsyncIntervalChanged(uint32_t interval) { AZ_UNUSED(interval); };
     };
     using WindowNotificationBus = AZ::EBus<WindowNotifications>;
 

Code/Framework/AzNetworking/AzNetworking/TcpTransport/TcpSocketManager_Select.cpp

@@ -41,7 +41,7 @@ namespace AzNetworking
 
     void TcpSocketManager::ProcessEvents(AZ::TimeMs maxBlockMs, const SocketEventCallback& readCallback, const SocketEventCallback& writeCallback)
     {
-        if(static_cast<int32_t>(m_maxFd) <= 0 && m_socketFds.empty())
+        if(static_cast<int32_t>(m_maxFd) <= 0 || m_socketFds.empty())
         {
             // There are no available sockets to process
             return;

Code/Framework/AzToolsFramework/AzToolsFramework/API/EditorPythonConsoleBus.h

@@ -63,6 +63,9 @@ namespace AzToolsFramework
         //! Signal the Python handler to stop
         virtual bool StopPython(bool silenceWarnings = false) = 0;
 
+        //! Query to determine if the Python VM has been initialized indicating an active state 
+        virtual bool IsPythonActive() = 0;
+
         //! Determines if the caller needs to wait for the Python VM to initialize (non-main thread only)
         virtual void WaitForInitialization() {}
 

Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.cpp

@@ -11,6 +11,7 @@
 
 #include <AzFramework/Input/Buses/Notifications/InputChannelNotificationBus.h>
 #include <AzFramework/Input/Buses/Requests/InputChannelRequestBus.h>
+#include <AzQtComponents/Utilities/QtWindowUtilities.h>
 
 #include <QApplication>
 #include <QCursor>
@@ -187,12 +188,6 @@ namespace AzToolsFramework
 
     bool QtEventToAzInputMapper::HandlesInputEvent(const AzFramework::InputChannel& channel) const
     {
-        const AzFramework::InputChannelId& channelId = channel.GetInputChannelId();
-        if (channelId == AzFramework::InputDeviceMouse::Movement::X || channelId == AzFramework::InputDeviceMouse::Movement::Y)
-        {
-            return false;
-        }
-
         // We map keyboard and mouse events from Qt, so flag all events coming from those devices
         // as handled by our synthetic event system.
         const AzFramework::InputDeviceId& deviceId = channel.GetInputDevice().GetInputDeviceId();
@@ -210,6 +205,22 @@ namespace AzToolsFramework
         }
     }
 
+    void QtEventToAzInputMapper::SetCursorCaptureEnabled(bool enabled)
+    {
+        if (m_capturingCursor != enabled)
+        {
+            m_capturingCursor = enabled;
+            if (m_capturingCursor)
+            {
+                qApp->setOverrideCursor(Qt::BlankCursor);
+            }
+            else
+            {
+                qApp->restoreOverrideCursor();
+            }
+        }
+    }
+
     bool QtEventToAzInputMapper::eventFilter(QObject* object, QEvent* event)
     {
         // Abort if processing isn't enabled.
@@ -284,13 +295,25 @@ namespace AzToolsFramework
     {
         auto systemCursorChannel =
             GetInputChannel<AzFramework::InputChannelDeltaWithSharedPosition2D>(AzFramework::InputDeviceMouse::SystemCursorPosition);
+        auto movementXChannel =
+            GetInputChannel<AzFramework::InputChannelDeltaWithSharedPosition2D>(AzFramework::InputDeviceMouse::Movement::X);
+        auto movementYChannel =
+            GetInputChannel<AzFramework::InputChannelDeltaWithSharedPosition2D>(AzFramework::InputDeviceMouse::Movement::Y);
         auto mouseWheelChannel =
             GetInputChannel<AzFramework::InputChannelDeltaWithSharedPosition2D>(AzFramework::InputDeviceMouse::Movement::Z);
 
         systemCursorChannel->ProcessRawInputEvent(m_cursorPosition->m_normalizedPositionDelta.GetLength());
+        // Generate movement events based on the pixel delta divided by the DPI scaling factor, to calculate a rough approximation
+        // of cursor movement velocity.
+        movementXChannel->ProcessRawInputEvent(
+            m_cursorPosition->m_normalizedPositionDelta.GetX() * aznumeric_cast<float>(m_sourceWidget->width()) / m_sourceWidget->devicePixelRatioF());
+        movementYChannel->ProcessRawInputEvent(
+            m_cursorPosition->m_normalizedPositionDelta.GetY() * aznumeric_cast<float>(m_sourceWidget->height()) / m_sourceWidget->devicePixelRatioF());
         mouseWheelChannel->ProcessRawInputEvent(0.f);
 
         NotifyUpdateChannelIfNotIdle(systemCursorChannel, nullptr);
+        NotifyUpdateChannelIfNotIdle(movementXChannel, nullptr);
+        NotifyUpdateChannelIfNotIdle(movementYChannel, nullptr);
         NotifyUpdateChannelIfNotIdle(mouseWheelChannel, nullptr);
     }
 
@@ -318,16 +341,42 @@ namespace AzToolsFramework
         }
     }
 
+    AZ::Vector2 QtEventToAzInputMapper::WidgetPositionToNormalizedPosition(QPoint position)
+    {
+        const float normalizedX = aznumeric_cast<float>(position.x()) / aznumeric_cast<float>(m_sourceWidget->width());
+        const float normalizedY = aznumeric_cast<float>(position.y()) / aznumeric_cast<float>(m_sourceWidget->height());
+        return AZ::Vector2{normalizedX, normalizedY};
+    }
+
+    QPoint QtEventToAzInputMapper::NormalizedPositionToWidgetPosition(AZ::Vector2 normalizedPosition)
+    {
+        const int denormalizedX = aznumeric_cast<int>(normalizedPosition.GetX() * m_sourceWidget->width());
+        const int denormalizedY = aznumeric_cast<int>(normalizedPosition.GetY() * m_sourceWidget->height());
+        return QPoint{denormalizedX, denormalizedY};
+    }
+
     void QtEventToAzInputMapper::HandleMouseMoveEvent(QMouseEvent* mouseEvent)
     {
+        AZ::Vector2 lastCursorPosition = m_cursorPosition->m_normalizedPosition;
+
         const QPoint mousePos = mouseEvent->pos();
-        const float normalizedX = aznumeric_cast<float>(mousePos.x()) / aznumeric_cast<float>(m_sourceWidget->width());
-        const float normalizedY = aznumeric_cast<float>(mousePos.y()) / aznumeric_cast<float>(m_sourceWidget->height());
-        const AZ::Vector2 normalizedPosition(normalizedX, normalizedY);
+        const AZ::Vector2 normalizedPosition = WidgetPositionToNormalizedPosition(mousePos);
         m_cursorPosition->m_normalizedPositionDelta = normalizedPosition - m_cursorPosition->m_normalizedPosition;
         m_cursorPosition->m_normalizedPosition = normalizedPosition;
         ProcessPendingMouseEvents();
         m_mouseChannelsNeedUpdate = true;
+
+        if (m_capturingCursor)
+        {
+            // Reset our cursor position to the previous point.
+            QPoint targetScreenPosition = m_sourceWidget->mapToGlobal(NormalizedPositionToWidgetPosition(lastCursorPosition));
+            AzQtComponents::SetCursorPos(targetScreenPosition);
+
+            // Even though we just set the cursor position, there are edge cases such as remote desktop that will leave
+            // the cursor position unchanged. For safety, we re-cache our last cursor position for delta generation.
+            QPoint actualWidgetPosition = m_sourceWidget->mapFromGlobal(QCursor::pos());
+            m_cursorPosition->m_normalizedPosition = WidgetPositionToNormalizedPosition(actualWidgetPosition);
+        }
     }
 
     void QtEventToAzInputMapper::HandleKeyEvent(QKeyEvent* keyEvent)

Code/Framework/AzToolsFramework/AzToolsFramework/Input/QtEventToAzInputManager.h

@@ -47,6 +47,12 @@ namespace AzToolsFramework
         //! Sets whether or not this input mapper should be updating its input channels from Qt events.
         void SetEnabled(bool enabled);
 
+        //! Sets whether or not the cursor should be constrained to the source widget and invisible.
+        //! Internally, this will reset the cursor position after each move event to ensure movement
+        //! events don't allow the cursor to escape. This can be used for typical camera controls
+        //! like a dolly or rotation, where mouse movement is important but cursor location is not.
+        void SetCursorCaptureEnabled(bool enabled);
+
         // QObject overrides...
         bool eventFilter(QObject* object, QEvent* event) override;
 
@@ -106,6 +112,11 @@ namespace AzToolsFramework
         // Processes any pending mouse movement events, this allows mouse movement channels to close themselves.
         void ProcessPendingMouseEvents();
 
+        // Converts a point in logical source widget space [0..m_sourceWidget->size()] to normalized [0..1] space.
+        AZ::Vector2 WidgetPositionToNormalizedPosition(QPoint position);
+        // Converts a point in normalized [0..1] space to logical source widget space [0..m_sourceWidget->size()].
+        QPoint NormalizedPositionToWidgetPosition(AZ::Vector2 normalizedPosition);
+
         // Handle mouse click events.
         void HandleMouseButtonEvent(QMouseEvent* mouseEvent);
         // Handle mouse move events.
@@ -144,6 +155,8 @@ namespace AzToolsFramework
         bool m_mouseChannelsNeedUpdate = false;
         // Flags whether or not Qt events should currently be processed.
         bool m_enabled = true;
+        // Flags whether or not the cursor is being constrained to the source widget (for invisible mouse movement).
+        bool m_capturingCursor = false;
 
         // Our viewport-specific AZ devices. We control their internal input channel states.
         AZStd::unique_ptr<EditorQtMouseDevice> m_mouseDevice;

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Instance/InstanceToTemplatePropagator.cpp

@@ -172,20 +172,23 @@ namespace AzToolsFramework
             PrefabDom& templateDomReference = m_prefabSystemComponentInterface->FindTemplateDom(templateId);
 
             //apply patch to template
-            AZ::JsonSerializationResult::ResultCode result = AZ::JsonSerialization::ApplyPatch(templateDomReference,
-                templateDomReference.GetAllocator(), providedPatch, AZ::JsonMergeApproach::JsonPatch);
+            AZ::JsonSerializationResult::ResultCode result =
+                PrefabDomUtils::ApplyPatches(templateDomReference, templateDomReference.GetAllocator(), providedPatch);
 
             //trigger propagation
-            if (result.GetOutcome() == AZ::JsonSerializationResult::Outcomes::Success)
+            if (result.GetOutcome() != AZ::JsonSerializationResult::Outcomes::Success)
             {
-                m_prefabSystemComponentInterface->SetTemplateDirtyFlag(templateId, true);
-                m_prefabSystemComponentInterface->PropagateTemplateChanges(templateId, instanceToExclude);
-                return true;
+                AZ_Error("Prefab", false, "Patch was not successfully applied.");
+                return false; 
             }
             else
             {
-                AZ_Error("Prefab", false, "Patch was not successfully applied");
-                return false;
+                AZ_Error(
+                    "Prefab", result.GetOutcome() != AZ::JsonSerializationResult::Outcomes::PartialSkip,
+                    "Some of the patches are not successfully applied.");
+                m_prefabSystemComponentInterface->SetTemplateDirtyFlag(templateId, true);
+                m_prefabSystemComponentInterface->PropagateTemplateChanges(templateId, instanceToExclude);
+                return true;
             }
         }
 

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/Link/Link.cpp

@@ -176,12 +176,17 @@ namespace AzToolsFramework
             }
             else
             {
-                AZ::JsonSerializationResult::ResultCode applyPatchResult = AZ::JsonSerialization::ApplyPatch(
-                    sourceTemplateDomCopy,
-                    targetTemplatePrefabDom.GetAllocator(),
-                    patchesReference->get(),
-                    AZ::JsonMergeApproach::JsonPatch);
+                AZ::JsonSerializationResult::ResultCode applyPatchResult =
+                    PrefabDomUtils::ApplyPatches(sourceTemplateDomCopy, targetTemplatePrefabDom.GetAllocator(), patchesReference->get());
                 linkedInstanceDom.CopyFrom(sourceTemplateDomCopy, targetTemplatePrefabDom.GetAllocator());
+
+                PrefabDomValueReference sourceTemplateName =
+                    PrefabDomUtils::FindPrefabDomValue(sourceTemplateDomCopy, PrefabDomUtils::SourceName);
+                AZ_Assert(sourceTemplateName && sourceTemplateName->get().IsString(), "A valid source template name couldn't be found");
+                PrefabDomValueReference targetTemplateName =
+                    PrefabDomUtils::FindPrefabDomValue(targetTemplatePrefabDom, PrefabDomUtils::SourceName);
+                AZ_Assert(targetTemplateName && targetTemplateName->get().IsString(), "A valid target template name couldn't be found");
+
                 if (applyPatchResult.GetProcessing() != AZ::JsonSerializationResult::Processing::Completed)
                 {
                     AZ_Error(
@@ -190,6 +195,14 @@ namespace AzToolsFramework
                         m_sourceTemplateId, m_targetTemplateId);
                     return false;
                 }
+                if (applyPatchResult.GetOutcome() == AZ::JsonSerializationResult::Outcomes::PartialSkip)
+                {
+                    AZ_Error(
+                        "Prefab", false,
+                        "Link::UpdateTarget - Some of the patches couldn't be applied on the source template '%s' present under the  "
+                        "target Template '%s'.",
+                        sourceTemplateName->get().GetString(), targetTemplateName->get().GetString());
+                }
             }
 
             // This is a guardrail to ensure the linked instance dom always has the LinkId value

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.cpp

@@ -236,6 +236,26 @@ namespace AzToolsFramework
                 return findInstancesResult->get();
             }
 
+            AZ::JsonSerializationResult::ResultCode ApplyPatches(
+                PrefabDomValue& prefabDomToApplyPatchesOn, PrefabDom::AllocatorType& allocator, const PrefabDomValue& patches)
+            {
+                auto issueReportingCallback = [](AZStd::string_view, AZ::JsonSerializationResult::ResultCode result,
+                                                 AZStd::string_view) -> AZ::JsonSerializationResult::ResultCode
+                {
+                    using namespace AZ::JsonSerializationResult;
+                    if (result.GetProcessing() == Processing::Halted)
+                    {
+                        return ResultCode(result.GetTask(), Outcomes::PartialSkip);
+                    }
+                    return result;
+                };
+
+                AZ::JsonApplyPatchSettings applyPatchSettings;
+                applyPatchSettings.m_reporting = AZStd::move(issueReportingCallback);
+                return AZ::JsonSerialization::ApplyPatch(
+                    prefabDomToApplyPatchesOn, allocator, patches, AZ::JsonMergeApproach::JsonPatch, applyPatchSettings);
+            }
+
             void PrintPrefabDomValue(
                 [[maybe_unused]] const AZStd::string_view printMessage,
                 [[maybe_unused]] const PrefabDomValue& prefabDomValue)

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabDomUtils.h

@@ -7,6 +7,7 @@
 
 #pragma once
 
+#include <AzCore/Serialization/Json/JsonSerializationResult.h>
 #include <AzCore/std/optional.h>
 #include <AzCore/Asset/AssetCommon.h>
 #include <AzToolsFramework/Prefab/Instance/Instance.h>
@@ -122,6 +123,11 @@ namespace AzToolsFramework
              */
             PrefabDomValueConstReference GetInstancesValue(const PrefabDomValue& prefabDom);
 
+            AZ::JsonSerializationResult::ResultCode ApplyPatches(
+                PrefabDomValue& prefabDomToApplyPatchesOn,
+                PrefabDom::AllocatorType& allocator,
+                const PrefabDomValue& patches);
+
             /**
              * Prints the contents of the given prefab DOM value to the debug output console in a readable format.
              * @param printMessage The message that will be printed before printing the PrefabDomValue

Code/Framework/AzToolsFramework/AzToolsFramework/Prefab/PrefabUndo.cpp

@@ -261,8 +261,13 @@ namespace AzToolsFramework
             instanceDom.CopyFrom(instanceDomRef->get(), instanceDom.GetAllocator());
 
             //apply the patch to the template within the target
-            AZ::JsonSerializationResult::ResultCode result = AZ::JsonSerialization::ApplyPatch(instanceDom,
-                instanceDom.GetAllocator(), patch, AZ::JsonMergeApproach::JsonPatch);
+            AZ::JsonSerializationResult::ResultCode result = PrefabDomUtils::ApplyPatches(instanceDom, instanceDom.GetAllocator(), patch);
+
+            AZ_Error(
+                "Prefab",
+                result.GetOutcome() == AZ::JsonSerializationResult::Outcomes::PartialSkip ||
+                    result.GetOutcome() == AZ::JsonSerializationResult::Outcomes::Success,
+                "Some of the patches are not successfully applied.");
 
             //remove the link id placed into the instance
             auto linkIdIter = instanceDom.FindMember(PrefabDomUtils::LinkIdName);

Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/ActionBus.h

@@ -22,11 +22,11 @@ namespace AzToolsFramework
     /// @name Reverse URLs.
     /// Used to identify common actions and override them when necessary.
     //@{
-    static const AZ::Crc32 s_backAction = AZ_CRC("com.amazon.action.common.back", 0xd772a2af);
-    static const AZ::Crc32 s_deleteAction = AZ_CRC("com.amazon.action.common.delete", 0x5731f6cb);
-    static const AZ::Crc32 s_duplicateAction = AZ_CRC("com.amazon.action.common.duplicate", 0x08ccf461);
-    static const AZ::Crc32 s_nextComponentMode = AZ_CRC("com.amazon.action.common.nextComponentMode", 0xcc26094f);
-    static const AZ::Crc32 s_previousComponentMode = AZ_CRC("com.amazon.action.common.previousComponentMode", 0x0d18ff39);
+    static const AZ::Crc32 s_backAction = AZ_CRC("com.o3de.action.common.back", 0xd772a2af);
+    static const AZ::Crc32 s_deleteAction = AZ_CRC("com.o3de.action.common.delete", 0x5731f6cb);
+    static const AZ::Crc32 s_duplicateAction = AZ_CRC("com.o3de.action.common.duplicate", 0x08ccf461);
+    static const AZ::Crc32 s_nextComponentMode = AZ_CRC("com.o3de.action.common.nextComponentMode", 0xcc26094f);
+    static const AZ::Crc32 s_previousComponentMode = AZ_CRC("com.o3de.action.common.previousComponentMode", 0x0d18ff39);
     //@}
 
     /// Specific Action properties to be sent to a type implementing

Code/Framework/AzToolsFramework/AzToolsFramework/Viewport/ViewportMessages.h

@@ -276,11 +276,6 @@ namespace AzToolsFramework
             virtual void EndCursorCapture() = 0;
             //! Gets the most recent recorded cursor position in the viewport in screen space coordinates.
             virtual AzFramework::ScreenPoint ViewportCursorScreenPosition() = 0;
-            //! Gets the cursor position recorded prior to the most recent cursor position.
-            //! Note: The cursor may be captured by the viewport, in which case this may not correspond to the last result
-            //! from ViewportCursorScreenPosition. This method will always return the correct position to generate a mouse
-            //! position delta.
-            virtual AZStd::optional<AzFramework::ScreenPoint> PreviousViewportCursorScreenPosition() = 0;
             //! Is mouse over viewport.
             virtual bool IsMouseOver() const = 0;
 

Code/Framework/AzToolsFramework/AzToolsFramework/ViewportSelection/EditorDefaultSelection.h

@@ -98,7 +98,7 @@ namespace AzToolsFramework
             {
             }
 
-            AZ::Crc32 m_uri; //!< Unique identifier for the Action. (In the form 'com.amazon.action.---").
+            AZ::Crc32 m_uri; //!< Unique identifier for the Action. (In the form 'com.o3de.action.---").
             AZStd::vector<AZStd::function<void()>> m_callbacks; //!< Callbacks associated with this Action (note: with multi-selections
                                                                 //!< there will be a callback per Entity/Component).
             AZStd::unique_ptr<QAction> m_action; //!< The QAction associated with the overrideWidget for all ComponentMode actions.

Code/Framework/AzToolsFramework/Tests/ComponentModeTestDoubles.cpp

@@ -196,7 +196,7 @@ namespace AzToolsFramework
 
         AZStd::vector<AzToolsFramework::ActionOverride> PlaceHolderComponentMode::PopulateActionsImpl()
         {
-            const AZ::Crc32 placeHolderComponentModeAction = AZ_CRC_CE("com.amazon.action.placeholder.test");
+            const AZ::Crc32 placeHolderComponentModeAction = AZ_CRC_CE("com.o3de.action.placeholder.test");
 
             return AZStd::vector<AzToolsFramework::ActionOverride>
             {

Code/Framework/AzToolsFramework/Tests/Prefab/PrefabUndoLinkTests.cpp

@@ -96,8 +96,8 @@ namespace UnitTest
 
         //apply the patch
         PrefabDom& templateDomReference = m_prefabSystemComponent->FindTemplateDom(nestedTemplateId);
-        AZ::JsonSerializationResult::ResultCode result = AZ::JsonSerialization::ApplyPatch(templateDomReference,
-            templateDomReference.GetAllocator(), patch, AZ::JsonMergeApproach::JsonPatch);
+        AZ::JsonSerializationResult::ResultCode result =
+            PrefabDomUtils::ApplyPatches(templateDomReference, templateDomReference.GetAllocator(), patch);
 
         AZ_Error("Prefab", result.GetOutcome() == AZ::JsonSerializationResult::Outcomes::Success,
             "Patch was not successfully applied");