diff --git a/services/surfaceflinger/Scheduler/Android.bp b/services/surfaceflinger/Scheduler/Android.bp
index 6d2586a..d5d8688 100644
--- a/services/surfaceflinger/Scheduler/Android.bp
+++ b/services/surfaceflinger/Scheduler/Android.bp
@@ -40,7 +40,6 @@
     name: "libscheduler",
     defaults: ["libscheduler_defaults"],
     srcs: [
-        "src/FrameTargeter.cpp",
         "src/PresentLatencyTracker.cpp",
         "src/Timer.cpp",
     ],
@@ -53,7 +52,6 @@
     test_suites: ["device-tests"],
     defaults: ["libscheduler_defaults"],
     srcs: [
-        "tests/FrameTargeterTest.cpp",
         "tests/PresentLatencyTrackerTest.cpp",
         "tests/TimerTest.cpp",
     ],
diff --git a/services/surfaceflinger/Scheduler/Scheduler.cpp b/services/surfaceflinger/Scheduler/Scheduler.cpp
index 41639b6..918d401 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.cpp
+++ b/services/surfaceflinger/Scheduler/Scheduler.cpp
@@ -171,21 +171,14 @@
 
 void Scheduler::onFrameSignal(ICompositor& compositor, VsyncId vsyncId,
                               TimePoint expectedVsyncTime) {
-    mPacesetterFrameTargeter.beginFrame({.frameBeginTime = SchedulerClock::now(),
-                                         .vsyncId = vsyncId,
-                                         .expectedVsyncTime = expectedVsyncTime,
-                                         .sfWorkDuration =
-                                                 mVsyncModulator->getVsyncConfig().sfWorkDuration},
-                                        *getVsyncSchedule());
+    const TimePoint frameTime = SchedulerClock::now();
 
-    if (!compositor.commit(mPacesetterFrameTargeter.target())) {
+    if (!compositor.commit(frameTime, vsyncId, expectedVsyncTime)) {
         return;
     }
 
-    const auto compositeResult = compositor.composite(mPacesetterFrameTargeter);
+    compositor.composite(frameTime, vsyncId);
     compositor.sample();
-
-    mPacesetterFrameTargeter.endFrame(compositeResult);
 }
 
 std::optional<Fps> Scheduler::getFrameRateOverride(uid_t uid) const {
@@ -195,23 +188,23 @@
             .getFrameRateOverrideForUid(uid, supportsFrameRateOverrideByContent);
 }
 
-bool Scheduler::isVsyncValid(TimePoint expectedVsyncTime, uid_t uid) const {
+bool Scheduler::isVsyncValid(TimePoint expectedVsyncTimestamp, uid_t uid) const {
     const auto frameRate = getFrameRateOverride(uid);
     if (!frameRate.has_value()) {
         return true;
     }
 
     ATRACE_FORMAT("%s uid: %d frameRate: %s", __func__, uid, to_string(*frameRate).c_str());
-    return getVsyncSchedule()->getTracker().isVSyncInPhase(expectedVsyncTime.ns(), *frameRate);
+    return getVsyncSchedule()->getTracker().isVSyncInPhase(expectedVsyncTimestamp.ns(), *frameRate);
 }
 
-bool Scheduler::isVsyncInPhase(TimePoint expectedVsyncTime, Fps frameRate) const {
-    return getVsyncSchedule()->getTracker().isVSyncInPhase(expectedVsyncTime.ns(), frameRate);
+bool Scheduler::isVsyncInPhase(TimePoint timePoint, const Fps frameRate) const {
+    return getVsyncSchedule()->getTracker().isVSyncInPhase(timePoint.ns(), frameRate);
 }
 
 impl::EventThread::ThrottleVsyncCallback Scheduler::makeThrottleVsyncCallback() const {
-    return [this](nsecs_t expectedVsyncTime, uid_t uid) {
-        return !isVsyncValid(TimePoint::fromNs(expectedVsyncTime), uid);
+    return [this](nsecs_t expectedVsyncTimestamp, uid_t uid) {
+        return !isVsyncValid(TimePoint::fromNs(expectedVsyncTimestamp), uid);
     };
 }
 
@@ -723,8 +716,6 @@
 
     mFrameRateOverrideMappings.dump(dumper);
     dumper.eol();
-
-    mPacesetterFrameTargeter.dump(dumper);
 }
 
 void Scheduler::dumpVsync(std::string& out) const {
diff --git a/services/surfaceflinger/Scheduler/Scheduler.h b/services/surfaceflinger/Scheduler/Scheduler.h
index 17e9cea..a1354fa 100644
--- a/services/surfaceflinger/Scheduler/Scheduler.h
+++ b/services/surfaceflinger/Scheduler/Scheduler.h
@@ -35,7 +35,6 @@
 #include <ftl/fake_guard.h>
 #include <ftl/optional.h>
 #include <scheduler/Features.h>
-#include <scheduler/FrameTargeter.h>
 #include <scheduler/Time.h>
 #include <scheduler/VsyncConfig.h>
 #include <ui/DisplayId.h>
@@ -250,11 +249,9 @@
         return std::const_pointer_cast<VsyncSchedule>(std::as_const(*this).getVsyncSchedule(idOpt));
     }
 
-    const FrameTarget& pacesetterFrameTarget() { return mPacesetterFrameTargeter.target(); }
-
     // Returns true if a given vsync timestamp is considered valid vsync
     // for a given uid
-    bool isVsyncValid(TimePoint expectedVsyncTime, uid_t uid) const;
+    bool isVsyncValid(TimePoint expectedVsyncTimestamp, uid_t uid) const;
 
     bool isVsyncInPhase(TimePoint expectedVsyncTime, Fps frameRate) const;
 
@@ -449,8 +446,6 @@
     ftl::Optional<PhysicalDisplayId> mPacesetterDisplayId GUARDED_BY(mDisplayLock)
             GUARDED_BY(kMainThreadContext);
 
-    FrameTargeter mPacesetterFrameTargeter{mFeatures.test(Feature::kBackpressureGpuComposition)};
-
     ftl::Optional<DisplayRef> pacesetterDisplayLocked() REQUIRES(mDisplayLock) {
         return static_cast<const Scheduler*>(this)->pacesetterDisplayLocked().transform(
                 [](const Display& display) { return std::ref(const_cast<Display&>(display)); });
diff --git a/services/surfaceflinger/Scheduler/VsyncSchedule.h b/services/surfaceflinger/Scheduler/VsyncSchedule.h
index 0757b57..5eca29a 100644
--- a/services/surfaceflinger/Scheduler/VsyncSchedule.h
+++ b/services/surfaceflinger/Scheduler/VsyncSchedule.h
@@ -20,16 +20,13 @@
 #include <memory>
 #include <string>
 
+#include <ThreadContext.h>
 #include <android-base/thread_annotations.h>
 #include <ftl/enum.h>
 #include <ftl/optional.h>
-#include <ui/DisplayId.h>
-
 #include <scheduler/Features.h>
-#include <scheduler/IVsyncSource.h>
 #include <scheduler/Time.h>
-
-#include "ThreadContext.h"
+#include <ui/DisplayId.h>
 
 namespace android {
 class EventThreadTest;
@@ -51,16 +48,15 @@
 using VsyncTracker = VSyncTracker;
 
 // Schedule that synchronizes to hardware VSYNC of a physical display.
-class VsyncSchedule final : public IVsyncSource {
+class VsyncSchedule {
 public:
     using RequestHardwareVsync = std::function<void(PhysicalDisplayId, bool enabled)>;
 
     VsyncSchedule(PhysicalDisplayId, FeatureFlags, RequestHardwareVsync);
     ~VsyncSchedule();
 
-    // IVsyncSource overrides:
-    Period period() const override;
-    TimePoint vsyncDeadlineAfter(TimePoint) const override;
+    Period period() const;
+    TimePoint vsyncDeadlineAfter(TimePoint) const;
 
     // Inform the schedule that the period is changing and the schedule needs to recalibrate
     // itself. The schedule will end the period transition internally. This will
diff --git a/services/surfaceflinger/Scheduler/include/scheduler/Features.h b/services/surfaceflinger/Scheduler/include/scheduler/Features.h
index 200407d..b3a6a60 100644
--- a/services/surfaceflinger/Scheduler/include/scheduler/Features.h
+++ b/services/surfaceflinger/Scheduler/include/scheduler/Features.h
@@ -23,11 +23,10 @@
 namespace android::scheduler {
 
 enum class Feature : std::uint8_t {
-    kPresentFences = 1 << 0,
-    kKernelIdleTimer = 1 << 1,
-    kContentDetection = 1 << 2,
-    kTracePredictedVsync = 1 << 3,
-    kBackpressureGpuComposition = 1 << 4,
+    kPresentFences = 0b1,
+    kKernelIdleTimer = 0b10,
+    kContentDetection = 0b100,
+    kTracePredictedVsync = 0b1000,
 };
 
 using FeatureFlags = ftl::Flags<Feature>;
diff --git a/services/surfaceflinger/Scheduler/include/scheduler/FrameTargeter.h b/services/surfaceflinger/Scheduler/include/scheduler/FrameTargeter.h
deleted file mode 100644
index 6878370..0000000
--- a/services/surfaceflinger/Scheduler/include/scheduler/FrameTargeter.h
+++ /dev/null
@@ -1,137 +0,0 @@
-/*
- * Copyright 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <array>
-#include <atomic>
-#include <memory>
-
-#include <ui/Fence.h>
-#include <ui/FenceTime.h>
-
-#include <scheduler/Time.h>
-#include <scheduler/VsyncId.h>
-#include <scheduler/interface/CompositeResult.h>
-
-// TODO(b/185536303): Pull to FTL.
-#include "../../../TracedOrdinal.h"
-#include "../../../Utils/Dumper.h"
-
-namespace android::scheduler {
-
-struct IVsyncSource;
-
-// Read-only interface to the metrics computed by FrameTargeter for the latest frame.
-class FrameTarget {
-public:
-    VsyncId vsyncId() const { return mVsyncId; }
-
-    // The time when the frame actually began, as opposed to when it had been scheduled to begin.
-    TimePoint frameBeginTime() const { return mFrameBeginTime; }
-
-    // Relative to when the frame actually began, as opposed to when it had been scheduled to begin.
-    Duration expectedFrameDuration() const { return mExpectedPresentTime - mFrameBeginTime; }
-
-    TimePoint expectedPresentTime() const { return mExpectedPresentTime; }
-
-    // The time of the VSYNC that preceded this frame. See `presentFenceForPastVsync` for details.
-    TimePoint pastVsyncTime(Period vsyncPeriod) const;
-
-    // The present fence for the frame that had targeted the most recent VSYNC before this frame.
-    // If the target VSYNC for any given frame is more than `vsyncPeriod` in the future, then the
-    // VSYNC of at least one previous frame has not yet passed. In other words, this is NOT the
-    // fence of the previous frame if running N VSYNCs ahead, but the one that should have been
-    // signaled by now (unless that frame missed).
-    const FenceTimePtr& presentFenceForPastVsync(Period vsyncPeriod) const;
-
-    bool wouldPresentEarly(Period vsyncPeriod) const;
-
-    bool isFramePending() const { return mFramePending; }
-    bool didMissFrame() const { return mFrameMissed; }
-    bool didMissHwcFrame() const { return mHwcFrameMissed && !mGpuFrameMissed; }
-
-protected:
-    ~FrameTarget() = default;
-
-    VsyncId mVsyncId;
-    TimePoint mFrameBeginTime;
-    TimePoint mExpectedPresentTime;
-
-    TracedOrdinal<bool> mFramePending{"PrevFramePending", false};
-    TracedOrdinal<bool> mFrameMissed{"PrevFrameMissed", false};
-    TracedOrdinal<bool> mHwcFrameMissed{"PrevHwcFrameMissed", false};
-    TracedOrdinal<bool> mGpuFrameMissed{"PrevGpuFrameMissed", false};
-
-    struct FenceWithFenceTime {
-        sp<Fence> fence = Fence::NO_FENCE;
-        FenceTimePtr fenceTime = FenceTime::NO_FENCE;
-    };
-    std::array<FenceWithFenceTime, 2> mPresentFences;
-
-private:
-    template <int N>
-    inline bool targetsVsyncsAhead(Period vsyncPeriod) const {
-        static_assert(N > 1);
-        return expectedFrameDuration() > (N - 1) * vsyncPeriod;
-    }
-};
-
-// Computes a display's per-frame metrics about past/upcoming targeting of present deadlines.
-class FrameTargeter final : private FrameTarget {
-public:
-    explicit FrameTargeter(bool backpressureGpuComposition)
-          : mBackpressureGpuComposition(backpressureGpuComposition) {}
-
-    const FrameTarget& target() const { return *this; }
-
-    struct BeginFrameArgs {
-        TimePoint frameBeginTime;
-        VsyncId vsyncId;
-        TimePoint expectedVsyncTime;
-        Duration sfWorkDuration;
-    };
-
-    void beginFrame(const BeginFrameArgs&, const IVsyncSource&);
-
-    // TODO(b/241285191): Merge with FrameTargeter::endFrame.
-    FenceTimePtr setPresentFence(sp<Fence>);
-
-    void endFrame(const CompositeResult&);
-
-    void dump(utils::Dumper&) const;
-
-private:
-    friend class FrameTargeterTest;
-
-    // For tests.
-    using IsFencePendingFuncPtr = bool (*)(const FenceTimePtr&, int graceTimeMs);
-    void beginFrame(const BeginFrameArgs&, const IVsyncSource&, IsFencePendingFuncPtr);
-    FenceTimePtr setPresentFence(sp<Fence>, FenceTimePtr);
-
-    static bool isFencePending(const FenceTimePtr&, int graceTimeMs);
-
-    const bool mBackpressureGpuComposition;
-
-    TimePoint mScheduledPresentTime;
-    CompositionCoverageFlags mCompositionCoverage;
-
-    std::atomic_uint mFrameMissedCount = 0;
-    std::atomic_uint mHwcFrameMissedCount = 0;
-    std::atomic_uint mGpuFrameMissedCount = 0;
-};
-
-} // namespace android::scheduler
diff --git a/services/surfaceflinger/Scheduler/include/scheduler/IVsyncSource.h b/services/surfaceflinger/Scheduler/include/scheduler/IVsyncSource.h
deleted file mode 100644
index bb2de75..0000000
--- a/services/surfaceflinger/Scheduler/include/scheduler/IVsyncSource.h
+++ /dev/null
@@ -1,31 +0,0 @@
-/*
- * Copyright 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <scheduler/Time.h>
-
-namespace android::scheduler {
-
-struct IVsyncSource {
-    virtual Period period() const = 0;
-    virtual TimePoint vsyncDeadlineAfter(TimePoint) const = 0;
-
-protected:
-    ~IVsyncSource() = default;
-};
-
-} // namespace android::scheduler
diff --git a/services/surfaceflinger/Scheduler/include/scheduler/interface/CompositeResult.h b/services/surfaceflinger/Scheduler/include/scheduler/interface/CompositeResult.h
deleted file mode 100644
index f795f1f..0000000
--- a/services/surfaceflinger/Scheduler/include/scheduler/interface/CompositeResult.h
+++ /dev/null
@@ -1,27 +0,0 @@
-/*
- * Copyright 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#pragma once
-
-#include <scheduler/interface/CompositionCoverage.h>
-
-namespace android {
-
-struct CompositeResult {
-    CompositionCoverageFlags compositionCoverage;
-};
-
-} // namespace android
diff --git a/services/surfaceflinger/Scheduler/include/scheduler/interface/ICompositor.h b/services/surfaceflinger/Scheduler/include/scheduler/interface/ICompositor.h
index 2696076..cc41925 100644
--- a/services/surfaceflinger/Scheduler/include/scheduler/interface/ICompositor.h
+++ b/services/surfaceflinger/Scheduler/include/scheduler/interface/ICompositor.h
@@ -18,15 +18,8 @@
 
 #include <scheduler/Time.h>
 #include <scheduler/VsyncId.h>
-#include <scheduler/interface/CompositeResult.h>
 
 namespace android {
-namespace scheduler {
-
-class FrameTarget;
-class FrameTargeter;
-
-} // namespace scheduler
 
 struct ICompositor {
     // Configures physical displays, processing hotplug and/or mode setting via the Composer HAL.
@@ -34,11 +27,11 @@
 
     // Commits transactions for layers and displays. Returns whether any state has been invalidated,
     // i.e. whether a frame should be composited for each display.
-    virtual bool commit(const scheduler::FrameTarget&) = 0;
+    virtual bool commit(TimePoint frameTime, VsyncId, TimePoint expectedVsyncTime) = 0;
 
     // Composites a frame for each display. CompositionEngine performs GPU and/or HAL composition
     // via RenderEngine and the Composer HAL, respectively.
-    virtual CompositeResult composite(scheduler::FrameTargeter&) = 0;
+    virtual void composite(TimePoint frameTime, VsyncId) = 0;
 
     // Samples the composited frame via RegionSamplingThread.
     virtual void sample() = 0;
diff --git a/services/surfaceflinger/Scheduler/src/FrameTargeter.cpp b/services/surfaceflinger/Scheduler/src/FrameTargeter.cpp
deleted file mode 100644
index cf4c0a0..0000000
--- a/services/surfaceflinger/Scheduler/src/FrameTargeter.cpp
+++ /dev/null
@@ -1,148 +0,0 @@
-/*
- * Copyright 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <gui/TraceUtils.h>
-
-#include <scheduler/FrameTargeter.h>
-#include <scheduler/IVsyncSource.h>
-
-namespace android::scheduler {
-
-TimePoint FrameTarget::pastVsyncTime(Period vsyncPeriod) const {
-    // TODO(b/267315508): Generalize to N VSYNCs.
-    const int shift = static_cast<int>(targetsVsyncsAhead<2>(vsyncPeriod));
-    return mExpectedPresentTime - Period::fromNs(vsyncPeriod.ns() << shift);
-}
-
-const FenceTimePtr& FrameTarget::presentFenceForPastVsync(Period vsyncPeriod) const {
-    // TODO(b/267315508): Generalize to N VSYNCs.
-    const size_t i = static_cast<size_t>(targetsVsyncsAhead<2>(vsyncPeriod));
-    return mPresentFences[i].fenceTime;
-}
-
-bool FrameTarget::wouldPresentEarly(Period vsyncPeriod) const {
-    // TODO(b/267315508): Generalize to N VSYNCs.
-    if (targetsVsyncsAhead<3>(vsyncPeriod)) {
-        return true;
-    }
-
-    const auto fence = presentFenceForPastVsync(vsyncPeriod);
-    return fence->isValid() && fence->getSignalTime() != Fence::SIGNAL_TIME_PENDING;
-}
-
-void FrameTargeter::beginFrame(const BeginFrameArgs& args, const IVsyncSource& vsyncSource) {
-    return beginFrame(args, vsyncSource, &FrameTargeter::isFencePending);
-}
-
-void FrameTargeter::beginFrame(const BeginFrameArgs& args, const IVsyncSource& vsyncSource,
-                               IsFencePendingFuncPtr isFencePendingFuncPtr) {
-    mVsyncId = args.vsyncId;
-    mFrameBeginTime = args.frameBeginTime;
-
-    // The `expectedVsyncTime`, which was predicted when this frame was scheduled, is normally in
-    // the future relative to `frameBeginTime`, but may not be for delayed frames. Adjust
-    // `mExpectedPresentTime` accordingly, but not `mScheduledPresentTime`.
-    const TimePoint lastScheduledPresentTime = mScheduledPresentTime;
-    mScheduledPresentTime = args.expectedVsyncTime;
-
-    const Period vsyncPeriod = vsyncSource.period();
-
-    // Calculate the expected present time once and use the cached value throughout this frame to
-    // make sure all layers are seeing this same value.
-    if (args.expectedVsyncTime >= args.frameBeginTime) {
-        mExpectedPresentTime = args.expectedVsyncTime;
-    } else {
-        mExpectedPresentTime = vsyncSource.vsyncDeadlineAfter(args.frameBeginTime);
-        if (args.sfWorkDuration > vsyncPeriod) {
-            // Inflate the expected present time if we're targeting the next VSYNC.
-            mExpectedPresentTime += vsyncPeriod;
-        }
-    }
-
-    ATRACE_FORMAT("%s %" PRId64 " vsyncIn %.2fms%s", __func__, ftl::to_underlying(args.vsyncId),
-                  ticks<std::milli, float>(mExpectedPresentTime - TimePoint::now()),
-                  mExpectedPresentTime == args.expectedVsyncTime ? "" : " (adjusted)");
-
-    const FenceTimePtr& pastPresentFence = presentFenceForPastVsync(vsyncPeriod);
-
-    // In cases where the present fence is about to fire, give it a small grace period instead of
-    // giving up on the frame.
-    //
-    // TODO(b/280667110): The grace period should depend on `sfWorkDuration` and `vsyncPeriod` being
-    // approximately equal, not whether backpressure propagation is enabled.
-    const int graceTimeForPresentFenceMs = static_cast<int>(
-            mBackpressureGpuComposition || !mCompositionCoverage.test(CompositionCoverage::Gpu));
-
-    // Pending frames may trigger backpressure propagation.
-    const auto& isFencePending = *isFencePendingFuncPtr;
-    mFramePending = pastPresentFence != FenceTime::NO_FENCE &&
-            isFencePending(pastPresentFence, graceTimeForPresentFenceMs);
-
-    // A frame is missed if the prior frame is still pending. If no longer pending, then we still
-    // count the frame as missed if the predicted present time was further in the past than when the
-    // fence actually fired. Add some slop to correct for drift. This should generally be smaller
-    // than a typical frame duration, but should not be so small that it reports reasonable drift as
-    // a missed frame.
-    mFrameMissed = mFramePending || [&] {
-        const nsecs_t pastPresentTime = pastPresentFence->getSignalTime();
-        if (pastPresentTime < 0) return false;
-        const nsecs_t frameMissedSlop = vsyncPeriod.ns() / 2;
-        return lastScheduledPresentTime.ns() < pastPresentTime - frameMissedSlop;
-    }();
-
-    mHwcFrameMissed = mFrameMissed && mCompositionCoverage.test(CompositionCoverage::Hwc);
-    mGpuFrameMissed = mFrameMissed && mCompositionCoverage.test(CompositionCoverage::Gpu);
-
-    if (mFrameMissed) mFrameMissedCount++;
-    if (mHwcFrameMissed) mHwcFrameMissedCount++;
-    if (mGpuFrameMissed) mGpuFrameMissedCount++;
-}
-
-void FrameTargeter::endFrame(const CompositeResult& result) {
-    mCompositionCoverage = result.compositionCoverage;
-}
-
-FenceTimePtr FrameTargeter::setPresentFence(sp<Fence> presentFence) {
-    auto presentFenceTime = std::make_shared<FenceTime>(presentFence);
-    return setPresentFence(std::move(presentFence), std::move(presentFenceTime));
-}
-
-FenceTimePtr FrameTargeter::setPresentFence(sp<Fence> presentFence, FenceTimePtr presentFenceTime) {
-    mPresentFences[1] = mPresentFences[0];
-    mPresentFences[0] = {std::move(presentFence), presentFenceTime};
-    return presentFenceTime;
-}
-
-void FrameTargeter::dump(utils::Dumper& dumper) const {
-    using namespace std::string_view_literals;
-
-    utils::Dumper::Section section(dumper, "Frame Targeting"sv);
-
-    dumper.dump("frameMissedCount"sv, mFrameMissedCount);
-    dumper.dump("hwcFrameMissedCount"sv, mHwcFrameMissedCount);
-    dumper.dump("gpuFrameMissedCount"sv, mGpuFrameMissedCount);
-}
-
-bool FrameTargeter::isFencePending(const FenceTimePtr& fence, int graceTimeMs) {
-    ATRACE_CALL();
-    const status_t status = fence->wait(graceTimeMs);
-
-    // This is the same as Fence::Status::Unsignaled, but it saves a call to getStatus,
-    // which calls wait(0) again internally.
-    return status == -ETIME;
-}
-
-} // namespace android::scheduler
diff --git a/services/surfaceflinger/Scheduler/tests/FrameTargeterTest.cpp b/services/surfaceflinger/Scheduler/tests/FrameTargeterTest.cpp
deleted file mode 100644
index 908f214..0000000
--- a/services/surfaceflinger/Scheduler/tests/FrameTargeterTest.cpp
+++ /dev/null
@@ -1,301 +0,0 @@
-/*
- * Copyright 2023 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-#include <ftl/optional.h>
-#include <gtest/gtest.h>
-
-#include <scheduler/Fps.h>
-#include <scheduler/FrameTargeter.h>
-#include <scheduler/IVsyncSource.h>
-
-using namespace std::chrono_literals;
-
-namespace android::scheduler {
-namespace {
-
-struct VsyncSource final : IVsyncSource {
-    VsyncSource(Period period, TimePoint deadline) : vsyncPeriod(period), vsyncDeadline(deadline) {}
-
-    const Period vsyncPeriod;
-    const TimePoint vsyncDeadline;
-
-    Period period() const override { return vsyncPeriod; }
-    TimePoint vsyncDeadlineAfter(TimePoint) const override { return vsyncDeadline; }
-};
-
-} // namespace
-
-class FrameTargeterTest : public testing::Test {
-public:
-    const auto& target() const { return mTargeter.target(); }
-
-    struct Frame {
-        Frame(FrameTargeterTest* testPtr, VsyncId vsyncId, TimePoint& frameBeginTime,
-              Duration frameDuration, Fps refreshRate,
-              FrameTargeter::IsFencePendingFuncPtr isFencePendingFuncPtr = Frame::fenceSignaled,
-              const ftl::Optional<VsyncSource>& vsyncSourceOpt = std::nullopt)
-              : testPtr(testPtr), frameBeginTime(frameBeginTime), period(refreshRate.getPeriod()) {
-            const FrameTargeter::BeginFrameArgs args{.frameBeginTime = frameBeginTime,
-                                                     .vsyncId = vsyncId,
-                                                     .expectedVsyncTime =
-                                                             frameBeginTime + frameDuration,
-                                                     .sfWorkDuration = 10ms};
-
-            testPtr->mTargeter.beginFrame(args,
-                                          vsyncSourceOpt
-                                                  .or_else([&] {
-                                                      return std::make_optional(
-                                                              VsyncSource(period,
-                                                                          args.expectedVsyncTime));
-                                                  })
-                                                  .value(),
-                                          isFencePendingFuncPtr);
-        }
-
-        FenceTimePtr end(CompositionCoverage coverage = CompositionCoverage::Hwc) {
-            if (ended) return nullptr;
-            ended = true;
-
-            auto [fence, fenceTime] = testPtr->mFenceMap.makePendingFenceForTest();
-            testPtr->mTargeter.setPresentFence(std::move(fence), fenceTime);
-
-            testPtr->mTargeter.endFrame({.compositionCoverage = coverage});
-            return fenceTime;
-        }
-
-        ~Frame() {
-            end();
-            frameBeginTime += period;
-        }
-
-        static bool fencePending(const FenceTimePtr&, int) { return true; }
-        static bool fenceSignaled(const FenceTimePtr&, int) { return false; }
-
-        FrameTargeterTest* const testPtr;
-
-        TimePoint& frameBeginTime;
-        const Period period;
-
-        bool ended = false;
-    };
-
-private:
-    FenceToFenceTimeMap mFenceMap;
-
-    static constexpr bool kBackpressureGpuComposition = true;
-    FrameTargeter mTargeter{kBackpressureGpuComposition};
-};
-
-TEST_F(FrameTargeterTest, targetsFrames) {
-    VsyncId vsyncId{42};
-    {
-        TimePoint frameBeginTime(989ms);
-        const Frame frame(this, vsyncId++, frameBeginTime, 10ms, 60_Hz);
-
-        EXPECT_EQ(target().vsyncId(), VsyncId{42});
-        EXPECT_EQ(target().frameBeginTime(), TimePoint(989ms));
-        EXPECT_EQ(target().expectedPresentTime(), TimePoint(999ms));
-        EXPECT_EQ(target().expectedFrameDuration(), 10ms);
-    }
-    {
-        TimePoint frameBeginTime(1100ms);
-        const Frame frame(this, vsyncId++, frameBeginTime, 11ms, 60_Hz);
-
-        EXPECT_EQ(target().vsyncId(), VsyncId{43});
-        EXPECT_EQ(target().frameBeginTime(), TimePoint(1100ms));
-        EXPECT_EQ(target().expectedPresentTime(), TimePoint(1111ms));
-        EXPECT_EQ(target().expectedFrameDuration(), 11ms);
-    }
-}
-
-TEST_F(FrameTargeterTest, inflatesExpectedPresentTime) {
-    // Negative such that `expectedVsyncTime` is in the past.
-    constexpr Duration kFrameDuration = -3ms;
-    TimePoint frameBeginTime(777ms);
-
-    constexpr Fps kRefreshRate = 120_Hz;
-    const VsyncSource vsyncSource(kRefreshRate.getPeriod(), frameBeginTime + 5ms);
-    const Frame frame(this, VsyncId{123}, frameBeginTime, kFrameDuration, kRefreshRate,
-                      Frame::fenceSignaled, vsyncSource);
-
-    EXPECT_EQ(target().expectedPresentTime(), vsyncSource.vsyncDeadline + vsyncSource.vsyncPeriod);
-}
-
-TEST_F(FrameTargeterTest, recallsPastVsync) {
-    VsyncId vsyncId{111};
-    TimePoint frameBeginTime(1000ms);
-    constexpr Fps kRefreshRate = 60_Hz;
-    constexpr Period kPeriod = kRefreshRate.getPeriod();
-    constexpr Duration kFrameDuration = 13ms;
-
-    for (int n = 5; n-- > 0;) {
-        Frame frame(this, vsyncId++, frameBeginTime, kFrameDuration, kRefreshRate);
-        const auto fence = frame.end();
-
-        EXPECT_EQ(target().pastVsyncTime(kPeriod), frameBeginTime + kFrameDuration - kPeriod);
-        EXPECT_EQ(target().presentFenceForPastVsync(kPeriod), fence);
-    }
-}
-
-TEST_F(FrameTargeterTest, recallsPastVsyncTwoVsyncsAhead) {
-    VsyncId vsyncId{222};
-    TimePoint frameBeginTime(2000ms);
-    constexpr Fps kRefreshRate = 120_Hz;
-    constexpr Period kPeriod = kRefreshRate.getPeriod();
-    constexpr Duration kFrameDuration = 10ms;
-
-    FenceTimePtr previousFence = FenceTime::NO_FENCE;
-
-    for (int n = 5; n-- > 0;) {
-        Frame frame(this, vsyncId++, frameBeginTime, kFrameDuration, kRefreshRate);
-        const auto fence = frame.end();
-
-        EXPECT_EQ(target().pastVsyncTime(kPeriod), frameBeginTime + kFrameDuration - 2 * kPeriod);
-        EXPECT_EQ(target().presentFenceForPastVsync(kPeriod), previousFence);
-
-        previousFence = fence;
-    }
-}
-
-TEST_F(FrameTargeterTest, doesNotDetectEarlyPresentIfNoFence) {
-    constexpr Period kPeriod = (60_Hz).getPeriod();
-    EXPECT_EQ(target().presentFenceForPastVsync(kPeriod), FenceTime::NO_FENCE);
-    EXPECT_FALSE(target().wouldPresentEarly(kPeriod));
-}
-
-TEST_F(FrameTargeterTest, detectsEarlyPresent) {
-    VsyncId vsyncId{333};
-    TimePoint frameBeginTime(3000ms);
-    constexpr Fps kRefreshRate = 60_Hz;
-    constexpr Period kPeriod = kRefreshRate.getPeriod();
-
-    // The target is not early while past present fences are pending.
-    for (int n = 3; n-- > 0;) {
-        const Frame frame(this, vsyncId++, frameBeginTime, 10ms, kRefreshRate);
-        EXPECT_FALSE(target().wouldPresentEarly(kPeriod));
-    }
-
-    // The target is early if the past present fence was signaled.
-    Frame frame(this, vsyncId++, frameBeginTime, 10ms, kRefreshRate);
-    const auto fence = frame.end();
-    fence->signalForTest(frameBeginTime.ns());
-
-    EXPECT_TRUE(target().wouldPresentEarly(kPeriod));
-}
-
-TEST_F(FrameTargeterTest, detectsEarlyPresentTwoVsyncsAhead) {
-    VsyncId vsyncId{444};
-    TimePoint frameBeginTime(4000ms);
-    constexpr Fps kRefreshRate = 120_Hz;
-    constexpr Period kPeriod = kRefreshRate.getPeriod();
-
-    // The target is not early while past present fences are pending.
-    for (int n = 3; n-- > 0;) {
-        const Frame frame(this, vsyncId++, frameBeginTime, 10ms, kRefreshRate);
-        EXPECT_FALSE(target().wouldPresentEarly(kPeriod));
-    }
-
-    Frame frame(this, vsyncId++, frameBeginTime, 10ms, kRefreshRate);
-    const auto fence = frame.end();
-    fence->signalForTest(frameBeginTime.ns());
-
-    // The target is two VSYNCs ahead, so the past present fence is still pending.
-    EXPECT_FALSE(target().wouldPresentEarly(kPeriod));
-
-    { const Frame frame(this, vsyncId++, frameBeginTime, 10ms, kRefreshRate); }
-
-    // The target is early if the past present fence was signaled.
-    EXPECT_TRUE(target().wouldPresentEarly(kPeriod));
-}
-
-TEST_F(FrameTargeterTest, detectsEarlyPresentThreeVsyncsAhead) {
-    TimePoint frameBeginTime(5000ms);
-    constexpr Fps kRefreshRate = 144_Hz;
-    constexpr Period kPeriod = kRefreshRate.getPeriod();
-
-    const Frame frame(this, VsyncId{555}, frameBeginTime, 16ms, kRefreshRate);
-
-    // The target is more than two VSYNCs ahead, but present fences are not tracked that far back.
-    EXPECT_TRUE(target().wouldPresentEarly(kPeriod));
-}
-
-TEST_F(FrameTargeterTest, detectsMissedFrames) {
-    VsyncId vsyncId{555};
-    TimePoint frameBeginTime(5000ms);
-    constexpr Fps kRefreshRate = 60_Hz;
-    constexpr Period kPeriod = kRefreshRate.getPeriod();
-
-    EXPECT_FALSE(target().isFramePending());
-    EXPECT_FALSE(target().didMissFrame());
-    EXPECT_FALSE(target().didMissHwcFrame());
-
-    {
-        const Frame frame(this, vsyncId++, frameBeginTime, 10ms, kRefreshRate);
-        EXPECT_FALSE(target().isFramePending());
-
-        // The frame did not miss if the past present fence is invalid.
-        EXPECT_FALSE(target().didMissFrame());
-        EXPECT_FALSE(target().didMissHwcFrame());
-    }
-    {
-        Frame frame(this, vsyncId++, frameBeginTime, 10ms, kRefreshRate, Frame::fencePending);
-        EXPECT_TRUE(target().isFramePending());
-
-        // The frame missed if the past present fence is pending.
-        EXPECT_TRUE(target().didMissFrame());
-        EXPECT_TRUE(target().didMissHwcFrame());
-
-        frame.end(CompositionCoverage::Gpu);
-    }
-    {
-        const Frame frame(this, vsyncId++, frameBeginTime, 10ms, kRefreshRate, Frame::fencePending);
-        EXPECT_TRUE(target().isFramePending());
-
-        // The GPU frame missed if the past present fence is pending.
-        EXPECT_TRUE(target().didMissFrame());
-        EXPECT_FALSE(target().didMissHwcFrame());
-    }
-    {
-        Frame frame(this, vsyncId++, frameBeginTime, 10ms, kRefreshRate);
-        EXPECT_FALSE(target().isFramePending());
-
-        const auto fence = frame.end();
-        const auto expectedPresentTime = target().expectedPresentTime();
-        fence->signalForTest(expectedPresentTime.ns() + kPeriod.ns() / 2 + 1);
-    }
-    {
-        Frame frame(this, vsyncId++, frameBeginTime, 10ms, kRefreshRate);
-        EXPECT_FALSE(target().isFramePending());
-
-        const auto fence = frame.end();
-        const auto expectedPresentTime = target().expectedPresentTime();
-        fence->signalForTest(expectedPresentTime.ns() + kPeriod.ns() / 2);
-
-        // The frame missed if the past present fence was signaled but not within slop.
-        EXPECT_TRUE(target().didMissFrame());
-        EXPECT_TRUE(target().didMissHwcFrame());
-    }
-    {
-        Frame frame(this, vsyncId++, frameBeginTime, 10ms, kRefreshRate);
-        EXPECT_FALSE(target().isFramePending());
-
-        // The frame did not miss if the past present fence was signaled within slop.
-        EXPECT_FALSE(target().didMissFrame());
-        EXPECT_FALSE(target().didMissHwcFrame());
-    }
-}
-
-} // namespace android::scheduler
diff --git a/services/surfaceflinger/Scheduler/tests/PresentLatencyTrackerTest.cpp b/services/surfaceflinger/Scheduler/tests/PresentLatencyTrackerTest.cpp
index df2ea83..8952ca9 100644
--- a/services/surfaceflinger/Scheduler/tests/PresentLatencyTrackerTest.cpp
+++ b/services/surfaceflinger/Scheduler/tests/PresentLatencyTrackerTest.cpp
@@ -23,6 +23,16 @@
 #include <ui/FenceTime.h>
 
 namespace android::scheduler {
+namespace {
+
+using FencePair = std::pair<sp<Fence>, std::shared_ptr<FenceTime>>;
+
+FencePair makePendingFence(FenceToFenceTimeMap& fenceMap) {
+    const auto fence = sp<Fence>::make();
+    return {fence, fenceMap.createFenceTimeForTest(fence)};
+}
+
+} // namespace
 
 TEST(PresentLatencyTrackerTest, skipsInvalidFences) {
     PresentLatencyTracker tracker;
@@ -33,7 +43,7 @@
     EXPECT_EQ(tracker.trackPendingFrame(kCompositeTime, FenceTime::NO_FENCE), Duration::zero());
 
     FenceToFenceTimeMap fenceMap;
-    const auto [fence, fenceTime] = fenceMap.makePendingFenceForTest();
+    const auto [fence, fenceTime] = makePendingFence(fenceMap);
     EXPECT_EQ(tracker.trackPendingFrame(kCompositeTime, fenceTime), Duration::zero());
 
     fenceTime->signalForTest(9999);
@@ -46,9 +56,8 @@
     PresentLatencyTracker tracker;
 
     FenceToFenceTimeMap fenceMap;
-    std::array<FenceToFenceTimeMap::FencePair, PresentLatencyTracker::kMaxPendingFrames> fences;
-    std::generate(fences.begin(), fences.end(),
-                  [&fenceMap] { return fenceMap.makePendingFenceForTest(); });
+    std::array<FencePair, PresentLatencyTracker::kMaxPendingFrames> fences;
+    std::generate(fences.begin(), fences.end(), [&fenceMap] { return makePendingFence(fenceMap); });
 
     // The present latency is 0 if all fences are pending.
     const TimePoint kCompositeTime = TimePoint::fromNs(1234);
@@ -62,7 +71,7 @@
         fences[i].second->signalForTest(kCompositeTime.ns() + static_cast<nsecs_t>(i));
     }
 
-    const auto fence = fenceMap.makePendingFenceForTest();
+    const auto fence = makePendingFence(fenceMap);
 
     // ...then the present latency is measured using the latest frame.
     constexpr Duration kPresentLatency = Duration::fromNs(static_cast<nsecs_t>(kPresentCount) - 1);