diff --git a/libs/input/MouseCursorController.cpp b/libs/input/MouseCursorController.cpp
index 4330f0a..d993b87 100644
--- a/libs/input/MouseCursorController.cpp
+++ b/libs/input/MouseCursorController.cpp
@@ -28,15 +28,13 @@
 #define INDENT "  "
 #define INDENT2 "    "
 
-namespace android {
-
 namespace {
-
 // Time to spend fading out the pointer completely.
 const nsecs_t POINTER_FADE_DURATION = 500 * 1000000LL; // 500 ms
-
 } // namespace
 
+namespace android {
+
 // --- MouseCursorController ---
 
 MouseCursorController::MouseCursorController(PointerControllerContext& context)
@@ -66,21 +64,17 @@
     mLocked.pointerSprite.clear();
 }
 
-vec2 MouseCursorController::move(float deltaX, float deltaY) {
+void MouseCursorController::move(float deltaX, float deltaY) {
 #if DEBUG_MOUSE_CURSOR_UPDATES
     ALOGD("Move pointer by deltaX=%0.3f, deltaY=%0.3f", deltaX, deltaY);
 #endif
     if (deltaX == 0.0f && deltaY == 0.0f) {
-        return {};
+        return;
     }
 
-    // When transition occurs, the MouseCursorController object may or may not be deleted, depending
-    // if there's another display on the other side of the transition. At this point we still need
-    // to move the cursor to the boundary.
     std::scoped_lock lock(mLock);
-    const vec2 pos{mLocked.pointerX + deltaX, mLocked.pointerY + deltaY};
-    setPositionLocked(pos.x, pos.y);
-    return vec2{pos.x - mLocked.pointerX, pos.y - mLocked.pointerY};
+
+    setPositionLocked(mLocked.pointerX + deltaX, mLocked.pointerY + deltaY);
 }
 
 void MouseCursorController::setPosition(float x, float y) {
@@ -88,26 +82,22 @@
     ALOGD("Set pointer position to x=%0.3f, y=%0.3f", x, y);
 #endif
     std::scoped_lock lock(mLock);
-
     setPositionLocked(x, y);
 }
 
-FloatRect MouseCursorController::getBoundsLocked() REQUIRES(mLock) {
+void MouseCursorController::setPositionLocked(float x, float y) REQUIRES(mLock) {
+    const auto& v = mLocked.viewport;
+    if (!v.isValid()) return;
+
     // The valid bounds for a mouse cursor. Since the right and bottom edges are considered outside
     // the display, clip the bounds by one pixel instead of letting the cursor get arbitrarily
     // close to the outside edge.
-    return FloatRect{
+    const FloatRect bounds{
             static_cast<float>(mLocked.viewport.logicalLeft),
             static_cast<float>(mLocked.viewport.logicalTop),
             static_cast<float>(mLocked.viewport.logicalRight - 1),
             static_cast<float>(mLocked.viewport.logicalBottom - 1),
     };
-}
-void MouseCursorController::setPositionLocked(float x, float y) REQUIRES(mLock) {
-    const auto& v = mLocked.viewport;
-    if (!v.isValid()) return;
-
-    const FloatRect bounds = getBoundsLocked();
     mLocked.pointerX = std::max(bounds.left, std::min(bounds.right, x));
     mLocked.pointerY = std::max(bounds.top, std::min(bounds.bottom, y));
 
diff --git a/libs/input/MouseCursorController.h b/libs/input/MouseCursorController.h
index 10f0d76..12b31a8 100644
--- a/libs/input/MouseCursorController.h
+++ b/libs/input/MouseCursorController.h
@@ -20,6 +20,9 @@
 #include <gui/DisplayEventReceiver.h>
 #include <input/DisplayViewport.h>
 #include <input/Input.h>
+#include <utils/BitSet.h>
+#include <utils/Looper.h>
+#include <utils/RefBase.h>
 
 #include <functional>
 #include <map>
@@ -40,8 +43,7 @@
     MouseCursorController(PointerControllerContext& context);
     ~MouseCursorController();
 
-    // Move the pointer and return unconsumed delta
-    vec2 move(float deltaX, float deltaY);
+    void move(float deltaX, float deltaY);
     void setPosition(float x, float y);
     FloatPoint getPosition() const;
     ui::LogicalDisplayId getDisplayId() const;
@@ -111,7 +113,6 @@
     bool doFadingAnimationLocked(nsecs_t timestamp);
 
     void startAnimationLocked();
-    FloatRect getBoundsLocked();
 };
 
 } // namespace android
diff --git a/libs/input/PointerController.cpp b/libs/input/PointerController.cpp
index 59397da..78d7d3a 100644
--- a/libs/input/PointerController.cpp
+++ b/libs/input/PointerController.cpp
@@ -138,18 +138,15 @@
     return mDisplayInfoListener->mLock;
 }
 
-vec2 PointerController::move(float deltaX, float deltaY) {
+void PointerController::move(float deltaX, float deltaY) {
     const ui::LogicalDisplayId displayId = mCursorController.getDisplayId();
-    ui::Transform transform;
+    vec2 transformed;
     {
         std::scoped_lock lock(getLock());
-        transform = getTransformForDisplayLocked(displayId);
+        const auto& transform = getTransformForDisplayLocked(displayId);
+        transformed = transformWithoutTranslation(transform, {deltaX, deltaY});
     }
-
-    vec2 transformed = transformWithoutTranslation(transform, {deltaX, deltaY});
-
-    vec2 unconsumedDelta = mCursorController.move(transformed.x, transformed.y);
-    return transformWithoutTranslation(transform.inverse(), unconsumedDelta);
+    mCursorController.move(transformed.x, transformed.y);
 }
 
 void PointerController::setPosition(float x, float y) {
diff --git a/libs/input/PointerController.h b/libs/input/PointerController.h
index 69bef54..ee8d121 100644
--- a/libs/input/PointerController.h
+++ b/libs/input/PointerController.h
@@ -51,7 +51,7 @@
 
     ~PointerController() override;
 
-    vec2 move(float deltaX, float deltaY) override;
+    void move(float deltaX, float deltaY) override;
     void setPosition(float x, float y) override;
     FloatPoint getPosition() const override;
     ui::LogicalDisplayId getDisplayId() const override;
@@ -165,7 +165,7 @@
 
     ~TouchPointerController() override;
 
-    vec2 move(float, float) override {
+    void move(float, float) override {
         LOG_ALWAYS_FATAL("Should not be called");
     }
     void setPosition(float, float) override {
diff --git a/libs/input/tests/PointerController_test.cpp b/libs/input/tests/PointerController_test.cpp
index 80c934a..5b00fca 100644
--- a/libs/input/tests/PointerController_test.cpp
+++ b/libs/input/tests/PointerController_test.cpp
@@ -40,8 +40,6 @@
     CURSOR_TYPE_CUSTOM = -1,
 };
 
-static constexpr float EPSILON = MotionEvent::ROUNDING_PRECISION;
-
 using ::testing::AllOf;
 using ::testing::Field;
 using ::testing::NiceMock;
@@ -401,135 +399,6 @@
                          testing::Values(PointerControllerInterface::ControllerType::MOUSE,
                                          PointerControllerInterface::ControllerType::STYLUS));
 
-class MousePointerControllerTest : public PointerControllerTest {
-protected:
-    MousePointerControllerTest() {
-        sp<MockSprite> testPointerSprite(new NiceMock<MockSprite>);
-        EXPECT_CALL(*mSpriteController, createSprite).WillOnce(Return(testPointerSprite));
-
-        // create a mouse pointer controller
-        mPointerController =
-                PointerController::create(mPolicy, mLooper, *mSpriteController,
-                                          PointerControllerInterface::ControllerType::MOUSE);
-
-        // set display viewport
-        DisplayViewport viewport;
-        viewport.displayId = ui::LogicalDisplayId::DEFAULT;
-        viewport.logicalRight = 5;
-        viewport.logicalBottom = 5;
-        viewport.physicalRight = 5;
-        viewport.physicalBottom = 5;
-        viewport.deviceWidth = 5;
-        viewport.deviceHeight = 5;
-        mPointerController->setDisplayViewport(viewport);
-    }
-};
-
-struct MousePointerControllerTestParam {
-    vec2 startPosition;
-    vec2 delta;
-    vec2 endPosition;
-    vec2 unconsumedDelta;
-};
-
-class PointerControllerViewportTransitionTest
-      : public MousePointerControllerTest,
-        public testing::WithParamInterface<MousePointerControllerTestParam> {};
-
-TEST_P(PointerControllerViewportTransitionTest, testPointerViewportTransition) {
-    const auto& params = GetParam();
-
-    mPointerController->setPosition(params.startPosition.x, params.startPosition.y);
-    auto unconsumedDelta = mPointerController->move(params.delta.x, params.delta.y);
-
-    auto position = mPointerController->getPosition();
-    EXPECT_NEAR(position.x, params.endPosition.x, EPSILON);
-    EXPECT_NEAR(position.y, params.endPosition.y, EPSILON);
-    EXPECT_NEAR(unconsumedDelta.x, params.unconsumedDelta.x, EPSILON);
-    EXPECT_NEAR(unconsumedDelta.y, params.unconsumedDelta.y, EPSILON);
-}
-
-INSTANTIATE_TEST_SUITE_P(PointerControllerViewportTransitionTest,
-                         PointerControllerViewportTransitionTest,
-                         testing::Values(
-                                 // no transition
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {2.0f, 2.0f},
-                                                                 {4.0f, 4.0f},
-                                                                 {0.0f, 0.0f}},
-                                 // right boundary
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {3.0f, 0.0f},
-                                                                 {4.0f, 2.0f},
-                                                                 {1.0f, 0.0f}},
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {3.0f, -1.0f},
-                                                                 {4.0f, 1.0f},
-                                                                 {1.0f, 0.0f}},
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {3.0f, 1.0f},
-                                                                 {4.0f, 3.0f},
-                                                                 {1.0f, 0.0f}},
-                                 // left boundary
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {-3.0f, 0.0f},
-                                                                 {0.0f, 2.0f},
-                                                                 {-1.0f, 0.0f}},
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {-3.0f, -1.0f},
-                                                                 {0.0f, 1.0f},
-                                                                 {-1.0f, 0.0f}},
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {-3.0f, 1.0f},
-                                                                 {0.0f, 3.0f},
-                                                                 {-1.0f, 0.0f}},
-                                 // bottom boundary
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {0.0f, 3.0f},
-                                                                 {2.0f, 4.0f},
-                                                                 {0.0f, 1.0f}},
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {-1.0f, 3.0f},
-                                                                 {1.0f, 4.0f},
-                                                                 {0.0f, 1.0f}},
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {1.0f, 3.0f},
-                                                                 {3.0f, 4.0f},
-                                                                 {0.0f, 1.0f}},
-                                 // top boundary
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {0.0f, -3.0f},
-                                                                 {2.0f, 0.0f},
-                                                                 {0.0f, -1.0f}},
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {-1.0f, -3.0f},
-                                                                 {1.0f, 0.0f},
-                                                                 {0.0f, -1.0f}},
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {1.0f, -3.0f},
-                                                                 {3.0f, 0.0f},
-                                                                 {0.0f, -1.0f}},
-                                 // top-left corner
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {-3.0f, -3.0f},
-                                                                 {0.0f, 0.0f},
-                                                                 {-1.0f, -1.0f}},
-                                 // top-right corner
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {3.0f, -3.0f},
-                                                                 {4.0f, 0.0f},
-                                                                 {1.0f, -1.0f}},
-                                 // bottom-right corner
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {3.0f, 3.0f},
-                                                                 {4.0f, 4.0f},
-                                                                 {1.0f, 1.0f}},
-                                 // bottom-left corner
-                                 MousePointerControllerTestParam{{2.0f, 2.0f},
-                                                                 {-3.0f, 3.0f},
-                                                                 {0.0f, 4.0f},
-                                                                 {-1.0f, 1.0f}}));
-
 class PointerControllerWindowInfoListenerTest : public Test {};
 
 TEST_F(PointerControllerWindowInfoListenerTest,