1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "DummyConsumer.h"
18
19#include <gtest/gtest.h>
20
21#include <android/hardware/configstore/1.0/ISurfaceFlingerConfigs.h>
22#include <binder/ProcessState.h>
23#include <configstore/Utils.h>
24#include <cutils/properties.h>
25#include <gui/BufferItemConsumer.h>
26#include <gui/IDisplayEventConnection.h>
27#include <gui/IProducerListener.h>
28#include <gui/ISurfaceComposer.h>
29#include <gui/Surface.h>
30#include <gui/SurfaceComposerClient.h>
31#include <private/gui/ComposerService.h>
32#include <ui/Rect.h>
33#include <utils/String8.h>
34
35#include <limits>
36#include <thread>
37
38namespace android {
39
40using namespace std::chrono_literals;
41// retrieve wide-color and hdr settings from configstore
42using namespace android::hardware::configstore;
43using namespace android::hardware::configstore::V1_0;
44
45static bool hasWideColorDisplay =
46        getBool<ISurfaceFlingerConfigs, &ISurfaceFlingerConfigs::hasWideColorDisplay>(false);
47
48class FakeSurfaceComposer;
49class FakeProducerFrameEventHistory;
50
51static constexpr uint64_t NO_FRAME_INDEX = std::numeric_limits<uint64_t>::max();
52
53class SurfaceTest : public ::testing::Test {
54protected:
55
56    SurfaceTest() {
57        ProcessState::self()->startThreadPool();
58    }
59
60    virtual void SetUp() {
61        mComposerClient = new SurfaceComposerClient;
62        ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
63
64        // TODO(brianderson): The following sometimes fails and is a source of
65        //   test flakiness.
66        mSurfaceControl = mComposerClient->createSurface(
67                String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, 0);
68
69        ASSERT_TRUE(mSurfaceControl != NULL);
70        ASSERT_TRUE(mSurfaceControl->isValid());
71
72        SurfaceComposerClient::openGlobalTransaction();
73        ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7fffffff));
74        ASSERT_EQ(NO_ERROR, mSurfaceControl->show());
75        SurfaceComposerClient::closeGlobalTransaction();
76
77        mSurface = mSurfaceControl->getSurface();
78        ASSERT_TRUE(mSurface != NULL);
79    }
80
81    virtual void TearDown() {
82        mComposerClient->dispose();
83    }
84
85    sp<Surface> mSurface;
86    sp<SurfaceComposerClient> mComposerClient;
87    sp<SurfaceControl> mSurfaceControl;
88};
89
90TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenVisible) {
91    sp<ANativeWindow> anw(mSurface);
92    int result = -123;
93    int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
94            &result);
95    EXPECT_EQ(NO_ERROR, err);
96    EXPECT_EQ(1, result);
97}
98
99TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenPurgatorized) {
100    mSurfaceControl.clear();
101    // Wait for the async clean-up to complete.
102    std::this_thread::sleep_for(50ms);
103
104    sp<ANativeWindow> anw(mSurface);
105    int result = -123;
106    int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
107            &result);
108    EXPECT_EQ(NO_ERROR, err);
109    EXPECT_EQ(1, result);
110}
111
112// This test probably doesn't belong here.
113TEST_F(SurfaceTest, ScreenshotsOfProtectedBuffersSucceed) {
114    sp<ANativeWindow> anw(mSurface);
115
116    // Verify the screenshot works with no protected buffers.
117    sp<IGraphicBufferProducer> producer;
118    sp<IGraphicBufferConsumer> consumer;
119    BufferQueue::createBufferQueue(&producer, &consumer);
120    sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
121    sp<ISurfaceComposer> sf(ComposerService::getComposerService());
122    sp<IBinder> display(sf->getBuiltInDisplay(
123            ISurfaceComposer::eDisplayIdMain));
124    ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(),
125            64, 64, 0, 0x7fffffff, false));
126
127    ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(),
128            NATIVE_WINDOW_API_CPU));
129    // Set the PROTECTED usage bit and verify that the screenshot fails.  Note
130    // that we need to dequeue a buffer in order for it to actually get
131    // allocated in SurfaceFlinger.
132    ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(),
133            GRALLOC_USAGE_PROTECTED));
134    ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(anw.get(), 3));
135    ANativeWindowBuffer* buf = 0;
136
137    status_t err = native_window_dequeue_buffer_and_wait(anw.get(), &buf);
138    if (err) {
139        // we could fail if GRALLOC_USAGE_PROTECTED is not supported.
140        // that's okay as long as this is the reason for the failure.
141        // try again without the GRALLOC_USAGE_PROTECTED bit.
142        ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(), 0));
143        ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
144                &buf));
145        return;
146    }
147    ASSERT_EQ(NO_ERROR, anw->cancelBuffer(anw.get(), buf, -1));
148
149    for (int i = 0; i < 4; i++) {
150        // Loop to make sure SurfaceFlinger has retired a protected buffer.
151        ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
152                &buf));
153        ASSERT_EQ(NO_ERROR, anw->queueBuffer(anw.get(), buf, -1));
154    }
155    ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(),
156            64, 64, 0, 0x7fffffff, false));
157}
158
159TEST_F(SurfaceTest, ConcreteTypeIsSurface) {
160    sp<ANativeWindow> anw(mSurface);
161    int result = -123;
162    int err = anw->query(anw.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result);
163    EXPECT_EQ(NO_ERROR, err);
164    EXPECT_EQ(NATIVE_WINDOW_SURFACE, result);
165}
166
167TEST_F(SurfaceTest, LayerCountIsOne) {
168    sp<ANativeWindow> anw(mSurface);
169    int result = -123;
170    int err = anw->query(anw.get(), NATIVE_WINDOW_LAYER_COUNT, &result);
171    EXPECT_EQ(NO_ERROR, err);
172    EXPECT_EQ(1, result);
173}
174
175TEST_F(SurfaceTest, QueryConsumerUsage) {
176    const int TEST_USAGE_FLAGS =
177            GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_RENDER;
178    sp<IGraphicBufferProducer> producer;
179    sp<IGraphicBufferConsumer> consumer;
180    BufferQueue::createBufferQueue(&producer, &consumer);
181    sp<BufferItemConsumer> c = new BufferItemConsumer(consumer,
182            TEST_USAGE_FLAGS);
183    sp<Surface> s = new Surface(producer);
184
185    sp<ANativeWindow> anw(s);
186
187    int flags = -1;
188    int err = anw->query(anw.get(), NATIVE_WINDOW_CONSUMER_USAGE_BITS, &flags);
189
190    ASSERT_EQ(NO_ERROR, err);
191    ASSERT_EQ(TEST_USAGE_FLAGS, flags);
192}
193
194TEST_F(SurfaceTest, QueryDefaultBuffersDataSpace) {
195    const android_dataspace TEST_DATASPACE = HAL_DATASPACE_SRGB;
196    sp<IGraphicBufferProducer> producer;
197    sp<IGraphicBufferConsumer> consumer;
198    BufferQueue::createBufferQueue(&producer, &consumer);
199    sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
200
201    cpuConsumer->setDefaultBufferDataSpace(TEST_DATASPACE);
202
203    sp<Surface> s = new Surface(producer);
204
205    sp<ANativeWindow> anw(s);
206
207    android_dataspace dataSpace;
208
209    int err = anw->query(anw.get(), NATIVE_WINDOW_DEFAULT_DATASPACE,
210            reinterpret_cast<int*>(&dataSpace));
211
212    ASSERT_EQ(NO_ERROR, err);
213    ASSERT_EQ(TEST_DATASPACE, dataSpace);
214}
215
216TEST_F(SurfaceTest, SettingGenerationNumber) {
217    sp<IGraphicBufferProducer> producer;
218    sp<IGraphicBufferConsumer> consumer;
219    BufferQueue::createBufferQueue(&producer, &consumer);
220    sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
221    sp<Surface> surface = new Surface(producer);
222    sp<ANativeWindow> window(surface);
223
224    // Allocate a buffer with a generation number of 0
225    ANativeWindowBuffer* buffer;
226    int fenceFd;
227    ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
228            NATIVE_WINDOW_API_CPU));
229    ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
230    ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fenceFd));
231
232    // Detach the buffer and check its generation number
233    sp<GraphicBuffer> graphicBuffer;
234    sp<Fence> fence;
235    ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&graphicBuffer, &fence));
236    ASSERT_EQ(0U, graphicBuffer->getGenerationNumber());
237
238    ASSERT_EQ(NO_ERROR, surface->setGenerationNumber(1));
239    buffer = static_cast<ANativeWindowBuffer*>(graphicBuffer.get());
240
241    // This should change the generation number of the GraphicBuffer
242    ASSERT_EQ(NO_ERROR, surface->attachBuffer(buffer));
243
244    // Check that the new generation number sticks with the buffer
245    ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, -1));
246    ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
247    graphicBuffer = static_cast<GraphicBuffer*>(buffer);
248    ASSERT_EQ(1U, graphicBuffer->getGenerationNumber());
249}
250
251TEST_F(SurfaceTest, GetConsumerName) {
252    sp<IGraphicBufferProducer> producer;
253    sp<IGraphicBufferConsumer> consumer;
254    BufferQueue::createBufferQueue(&producer, &consumer);
255
256    sp<DummyConsumer> dummyConsumer(new DummyConsumer);
257    consumer->consumerConnect(dummyConsumer, false);
258    consumer->setConsumerName(String8("TestConsumer"));
259
260    sp<Surface> surface = new Surface(producer);
261    sp<ANativeWindow> window(surface);
262    native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
263
264    EXPECT_STREQ("TestConsumer", surface->getConsumerName().string());
265}
266
267TEST_F(SurfaceTest, GetWideColorSupport) {
268    sp<IGraphicBufferProducer> producer;
269    sp<IGraphicBufferConsumer> consumer;
270    BufferQueue::createBufferQueue(&producer, &consumer);
271
272    sp<DummyConsumer> dummyConsumer(new DummyConsumer);
273    consumer->consumerConnect(dummyConsumer, false);
274    consumer->setConsumerName(String8("TestConsumer"));
275
276    sp<Surface> surface = new Surface(producer);
277    sp<ANativeWindow> window(surface);
278    native_window_api_connect(window.get(), NATIVE_WINDOW_API_CPU);
279
280    bool supported;
281    surface->getWideColorSupport(&supported);
282
283    // NOTE: This test assumes that device that supports
284    // wide-color (as indicated by BoardConfig) must also
285    // have a wide-color primary display.
286    // That assumption allows this test to cover devices
287    // that advertised a wide-color color mode without
288    // actually supporting wide-color to pass this test
289    // as well as the case of a device that does support
290    // wide-color (via BoardConfig) and has a wide-color
291    // primary display.
292    // NOT covered at this time is a device that supports
293    // wide color in the BoardConfig but does not support
294    // a wide-color color mode on the primary display.
295    ASSERT_EQ(hasWideColorDisplay, supported);
296}
297
298TEST_F(SurfaceTest, DynamicSetBufferCount) {
299    sp<IGraphicBufferProducer> producer;
300    sp<IGraphicBufferConsumer> consumer;
301    BufferQueue::createBufferQueue(&producer, &consumer);
302
303    sp<DummyConsumer> dummyConsumer(new DummyConsumer);
304    consumer->consumerConnect(dummyConsumer, false);
305    consumer->setConsumerName(String8("TestConsumer"));
306
307    sp<Surface> surface = new Surface(producer);
308    sp<ANativeWindow> window(surface);
309
310    ASSERT_EQ(NO_ERROR, native_window_api_connect(window.get(),
311            NATIVE_WINDOW_API_CPU));
312    native_window_set_buffer_count(window.get(), 4);
313
314    int fence;
315    ANativeWindowBuffer* buffer;
316    ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
317    native_window_set_buffer_count(window.get(), 3);
318    ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
319    native_window_set_buffer_count(window.get(), 2);
320    ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fence));
321    ASSERT_EQ(NO_ERROR, window->queueBuffer(window.get(), buffer, fence));
322}
323
324TEST_F(SurfaceTest, GetAndFlushRemovedBuffers) {
325    sp<IGraphicBufferProducer> producer;
326    sp<IGraphicBufferConsumer> consumer;
327    BufferQueue::createBufferQueue(&producer, &consumer);
328
329    sp<DummyConsumer> dummyConsumer(new DummyConsumer);
330    consumer->consumerConnect(dummyConsumer, false);
331    consumer->setConsumerName(String8("TestConsumer"));
332
333    sp<Surface> surface = new Surface(producer);
334    sp<ANativeWindow> window(surface);
335    sp<DummyProducerListener> listener = new DummyProducerListener();
336    ASSERT_EQ(OK, surface->connect(
337            NATIVE_WINDOW_API_CPU,
338            /*listener*/listener,
339            /*reportBufferRemoval*/true));
340    const int BUFFER_COUNT = 4;
341    ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(window.get(), BUFFER_COUNT));
342
343    sp<GraphicBuffer> detachedBuffer;
344    sp<Fence> outFence;
345    int fences[BUFFER_COUNT];
346    ANativeWindowBuffer* buffers[BUFFER_COUNT];
347    // Allocate buffers because detachNextBuffer requires allocated buffers
348    for (int i = 0; i < BUFFER_COUNT; i++) {
349        ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
350    }
351    for (int i = 0; i < BUFFER_COUNT; i++) {
352        ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
353    }
354
355    // Test detached buffer is correctly reported
356    ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
357    std::vector<sp<GraphicBuffer>> removedBuffers;
358    ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
359    ASSERT_EQ(1u, removedBuffers.size());
360    ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
361    // Test the list is flushed one getAndFlushRemovedBuffers returns
362    ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
363    ASSERT_EQ(0u, removedBuffers.size());
364
365
366    // Test removed buffer list is cleanup after next dequeueBuffer call
367    ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
368    ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[0], &fences[0]));
369    ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
370    ASSERT_EQ(0u, removedBuffers.size());
371    ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[0], fences[0]));
372
373    // Test removed buffer list is cleanup after next detachNextBuffer call
374    ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
375    ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
376    ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
377    ASSERT_EQ(1u, removedBuffers.size());
378    ASSERT_EQ(detachedBuffer->handle, removedBuffers.at(0)->handle);
379
380    // Re-allocate buffers since all buffers are detached up to now
381    for (int i = 0; i < BUFFER_COUNT; i++) {
382        ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffers[i], &fences[i]));
383    }
384    for (int i = 0; i < BUFFER_COUNT; i++) {
385        ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffers[i], fences[i]));
386    }
387
388    ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&detachedBuffer, &outFence));
389    ASSERT_EQ(NO_ERROR, surface->attachBuffer(detachedBuffer.get()));
390    ASSERT_EQ(OK, surface->getAndFlushRemovedBuffers(&removedBuffers));
391    // Depends on which slot GraphicBufferProducer impl pick, the attach call might
392    // get 0 or 1 buffer removed.
393    ASSERT_LE(removedBuffers.size(), 1u);
394}
395
396TEST_F(SurfaceTest, TestGetLastDequeueStartTime) {
397    sp<ANativeWindow> anw(mSurface);
398    ASSERT_EQ(NO_ERROR, native_window_api_connect(anw.get(), NATIVE_WINDOW_API_CPU));
399
400    ANativeWindowBuffer* buffer = nullptr;
401    int32_t fenceFd = -1;
402
403    nsecs_t before = systemTime(CLOCK_MONOTONIC);
404    anw->dequeueBuffer(anw.get(), &buffer, &fenceFd);
405    nsecs_t after = systemTime(CLOCK_MONOTONIC);
406
407    nsecs_t lastDequeueTime = mSurface->getLastDequeueStartTime();
408    ASSERT_LE(before, lastDequeueTime);
409    ASSERT_GE(after, lastDequeueTime);
410}
411
412class FakeConsumer : public BnConsumerListener {
413public:
414    void onFrameAvailable(const BufferItem& /*item*/) override {}
415    void onBuffersReleased() override {}
416    void onSidebandStreamChanged() override {}
417
418    void addAndGetFrameTimestamps(
419            const NewFrameEventsEntry* newTimestamps,
420            FrameEventHistoryDelta* outDelta) override {
421        if (newTimestamps) {
422            if (mGetFrameTimestampsEnabled) {
423                EXPECT_GT(mNewFrameEntryOverride.frameNumber, 0u) <<
424                        "Test should set mNewFrameEntryOverride before queuing "
425                        "a frame.";
426                EXPECT_EQ(newTimestamps->frameNumber,
427                        mNewFrameEntryOverride.frameNumber) <<
428                        "Test attempting to add NewFrameEntryOverride with "
429                        "incorrect frame number.";
430                mFrameEventHistory.addQueue(mNewFrameEntryOverride);
431                mNewFrameEntryOverride.frameNumber = 0;
432            }
433            mAddFrameTimestampsCount++;
434            mLastAddedFrameNumber = newTimestamps->frameNumber;
435        }
436        if (outDelta) {
437            mFrameEventHistory.getAndResetDelta(outDelta);
438            mGetFrameTimestampsCount++;
439        }
440        mAddAndGetFrameTimestampsCallCount++;
441    }
442
443    bool mGetFrameTimestampsEnabled = false;
444
445    ConsumerFrameEventHistory mFrameEventHistory;
446    int mAddAndGetFrameTimestampsCallCount = 0;
447    int mAddFrameTimestampsCount = 0;
448    int mGetFrameTimestampsCount = 0;
449    uint64_t mLastAddedFrameNumber = NO_FRAME_INDEX;
450
451    NewFrameEventsEntry mNewFrameEntryOverride = { 0, 0, 0, nullptr };
452};
453
454
455class FakeSurfaceComposer : public ISurfaceComposer{
456public:
457    ~FakeSurfaceComposer() override {}
458
459    void setSupportsPresent(bool supportsPresent) {
460        mSupportsPresent = supportsPresent;
461    }
462
463    sp<ISurfaceComposerClient> createConnection() override { return nullptr; }
464    sp<ISurfaceComposerClient> createScopedConnection(
465            const sp<IGraphicBufferProducer>& /* parent */) override {
466        return nullptr;
467    }
468    sp<IDisplayEventConnection> createDisplayEventConnection(ISurfaceComposer::VsyncSource)
469            override {
470        return nullptr;
471    }
472    sp<IBinder> createDisplay(const String8& /*displayName*/,
473            bool /*secure*/) override { return nullptr; }
474    void destroyDisplay(const sp<IBinder>& /*display */) override {}
475    sp<IBinder> getBuiltInDisplay(int32_t /*id*/) override { return nullptr; }
476    void setTransactionState(const Vector<ComposerState>& /*state*/,
477            const Vector<DisplayState>& /*displays*/, uint32_t /*flags*/)
478            override {}
479    void bootFinished() override {}
480    bool authenticateSurfaceTexture(
481            const sp<IGraphicBufferProducer>& /*surface*/) const override {
482        return false;
483    }
484
485    status_t getSupportedFrameTimestamps(std::vector<FrameEvent>* outSupported)
486            const override {
487        *outSupported = {
488                FrameEvent::REQUESTED_PRESENT,
489                FrameEvent::ACQUIRE,
490                FrameEvent::LATCH,
491                FrameEvent::FIRST_REFRESH_START,
492                FrameEvent::LAST_REFRESH_START,
493                FrameEvent::GPU_COMPOSITION_DONE,
494                FrameEvent::DEQUEUE_READY,
495                FrameEvent::RELEASE
496        };
497        if (mSupportsPresent) {
498            outSupported->push_back(
499                        FrameEvent::DISPLAY_PRESENT);
500        }
501        return NO_ERROR;
502    }
503
504    void setPowerMode(const sp<IBinder>& /*display*/, int /*mode*/) override {}
505    status_t getDisplayConfigs(const sp<IBinder>& /*display*/,
506            Vector<DisplayInfo>* /*configs*/) override { return NO_ERROR; }
507    status_t getDisplayStats(const sp<IBinder>& /*display*/,
508            DisplayStatInfo* /*stats*/) override { return NO_ERROR; }
509    int getActiveConfig(const sp<IBinder>& /*display*/) override { return 0; }
510    status_t setActiveConfig(const sp<IBinder>& /*display*/, int /*id*/)
511            override {
512        return NO_ERROR;
513    }
514    status_t getDisplayColorModes(const sp<IBinder>& /*display*/,
515            Vector<android_color_mode_t>* /*outColorModes*/) override {
516        return NO_ERROR;
517    }
518    android_color_mode_t getActiveColorMode(const sp<IBinder>& /*display*/)
519            override {
520        return HAL_COLOR_MODE_NATIVE;
521    }
522    status_t setActiveColorMode(const sp<IBinder>& /*display*/,
523            android_color_mode_t /*colorMode*/) override { return NO_ERROR; }
524    status_t captureScreen(const sp<IBinder>& /*display*/,
525            const sp<IGraphicBufferProducer>& /*producer*/,
526            Rect /*sourceCrop*/, uint32_t /*reqWidth*/, uint32_t /*reqHeight*/,
527            int32_t /*minLayerZ*/, int32_t /*maxLayerZ*/,
528            bool /*useIdentityTransform*/,
529            Rotation /*rotation*/) override { return NO_ERROR; }
530    status_t clearAnimationFrameStats() override { return NO_ERROR; }
531    status_t getAnimationFrameStats(FrameStats* /*outStats*/) const override {
532        return NO_ERROR;
533    }
534    status_t getHdrCapabilities(const sp<IBinder>& /*display*/,
535            HdrCapabilities* /*outCapabilities*/) const override {
536        return NO_ERROR;
537    }
538    status_t enableVSyncInjections(bool /*enable*/) override {
539        return NO_ERROR;
540    }
541    status_t injectVSync(nsecs_t /*when*/) override { return NO_ERROR; }
542
543protected:
544    IBinder* onAsBinder() override { return nullptr; }
545
546private:
547    bool mSupportsPresent{true};
548};
549
550class FakeProducerFrameEventHistory : public ProducerFrameEventHistory {
551public:
552    FakeProducerFrameEventHistory(FenceToFenceTimeMap* fenceMap)
553        : mFenceMap(fenceMap) {}
554
555    ~FakeProducerFrameEventHistory() {}
556
557    void updateAcquireFence(uint64_t frameNumber,
558            std::shared_ptr<FenceTime>&& acquire) override {
559        // Verify the acquire fence being added isn't the one from the consumer.
560        EXPECT_NE(mConsumerAcquireFence, acquire);
561        // Override the fence, so we can verify this was called by the
562        // producer after the frame is queued.
563        ProducerFrameEventHistory::updateAcquireFence(frameNumber,
564                std::shared_ptr<FenceTime>(mAcquireFenceOverride));
565    }
566
567    void setAcquireFenceOverride(
568            const std::shared_ptr<FenceTime>& acquireFenceOverride,
569            const std::shared_ptr<FenceTime>& consumerAcquireFence) {
570        mAcquireFenceOverride = acquireFenceOverride;
571        mConsumerAcquireFence = consumerAcquireFence;
572    }
573
574protected:
575    std::shared_ptr<FenceTime> createFenceTime(const sp<Fence>& fence)
576            const override {
577        return mFenceMap->createFenceTimeForTest(fence);
578    }
579
580    FenceToFenceTimeMap* mFenceMap{nullptr};
581
582    std::shared_ptr<FenceTime> mAcquireFenceOverride{FenceTime::NO_FENCE};
583    std::shared_ptr<FenceTime> mConsumerAcquireFence{FenceTime::NO_FENCE};
584};
585
586
587class TestSurface : public Surface {
588public:
589    TestSurface(const sp<IGraphicBufferProducer>& bufferProducer,
590            FenceToFenceTimeMap* fenceMap)
591        : Surface(bufferProducer),
592          mFakeSurfaceComposer(new FakeSurfaceComposer) {
593        mFakeFrameEventHistory = new FakeProducerFrameEventHistory(fenceMap);
594        mFrameEventHistory.reset(mFakeFrameEventHistory);
595    }
596
597    ~TestSurface() override {}
598
599    sp<ISurfaceComposer> composerService() const override {
600        return mFakeSurfaceComposer;
601    }
602
603    nsecs_t now() const override {
604        return mNow;
605    }
606
607    void setNow(nsecs_t now) {
608        mNow = now;
609    }
610
611public:
612    sp<FakeSurfaceComposer> mFakeSurfaceComposer;
613    nsecs_t mNow = 0;
614
615    // mFrameEventHistory owns the instance of FakeProducerFrameEventHistory,
616    // but this raw pointer gives access to test functionality.
617    FakeProducerFrameEventHistory* mFakeFrameEventHistory;
618};
619
620
621class GetFrameTimestampsTest : public ::testing::Test {
622protected:
623    struct FenceAndFenceTime {
624        explicit FenceAndFenceTime(FenceToFenceTimeMap& fenceMap)
625           : mFence(new Fence),
626             mFenceTime(fenceMap.createFenceTimeForTest(mFence)) {}
627        sp<Fence> mFence { nullptr };
628        std::shared_ptr<FenceTime> mFenceTime { nullptr };
629    };
630
631    struct RefreshEvents {
632        RefreshEvents(FenceToFenceTimeMap& fenceMap, nsecs_t refreshStart)
633          : mFenceMap(fenceMap),
634            kCompositorTiming(
635                {refreshStart, refreshStart + 1, refreshStart + 2 }),
636            kStartTime(refreshStart + 3),
637            kGpuCompositionDoneTime(refreshStart + 4),
638            kPresentTime(refreshStart + 5) {}
639
640        void signalPostCompositeFences() {
641            mFenceMap.signalAllForTest(
642                        mGpuCompositionDone.mFence, kGpuCompositionDoneTime);
643            mFenceMap.signalAllForTest(mPresent.mFence, kPresentTime);
644        }
645
646        FenceToFenceTimeMap& mFenceMap;
647
648        FenceAndFenceTime mGpuCompositionDone { mFenceMap };
649        FenceAndFenceTime mPresent { mFenceMap };
650
651        const CompositorTiming kCompositorTiming;
652
653        const nsecs_t kStartTime;
654        const nsecs_t kGpuCompositionDoneTime;
655        const nsecs_t kPresentTime;
656    };
657
658    struct FrameEvents {
659        FrameEvents(FenceToFenceTimeMap& fenceMap, nsecs_t frameStartTime)
660            : mFenceMap(fenceMap),
661              kPostedTime(frameStartTime + 100),
662              kRequestedPresentTime(frameStartTime + 200),
663              kProducerAcquireTime(frameStartTime + 300),
664              kConsumerAcquireTime(frameStartTime + 301),
665              kLatchTime(frameStartTime + 500),
666              kDequeueReadyTime(frameStartTime + 600),
667              kReleaseTime(frameStartTime + 700),
668              mRefreshes {
669                    { mFenceMap, frameStartTime + 410 },
670                    { mFenceMap, frameStartTime + 420 },
671                    { mFenceMap, frameStartTime + 430 } } {}
672
673        void signalQueueFences() {
674            mFenceMap.signalAllForTest(
675                        mAcquireConsumer.mFence, kConsumerAcquireTime);
676            mFenceMap.signalAllForTest(
677                        mAcquireProducer.mFence, kProducerAcquireTime);
678        }
679
680        void signalRefreshFences() {
681            for (auto& re : mRefreshes) {
682                re.signalPostCompositeFences();
683            }
684        }
685
686        void signalReleaseFences() {
687            mFenceMap.signalAllForTest(mRelease.mFence, kReleaseTime);
688        }
689
690        FenceToFenceTimeMap& mFenceMap;
691
692        FenceAndFenceTime mAcquireConsumer { mFenceMap };
693        FenceAndFenceTime mAcquireProducer { mFenceMap };
694        FenceAndFenceTime mRelease { mFenceMap };
695
696        const nsecs_t kPostedTime;
697        const nsecs_t kRequestedPresentTime;
698        const nsecs_t kProducerAcquireTime;
699        const nsecs_t kConsumerAcquireTime;
700        const nsecs_t kLatchTime;
701        const nsecs_t kDequeueReadyTime;
702        const nsecs_t kReleaseTime;
703
704        RefreshEvents mRefreshes[3];
705    };
706
707    GetFrameTimestampsTest() {}
708
709    virtual void SetUp() {
710        BufferQueue::createBufferQueue(&mProducer, &mConsumer);
711        mFakeConsumer = new FakeConsumer;
712        mCfeh = &mFakeConsumer->mFrameEventHistory;
713        mConsumer->consumerConnect(mFakeConsumer, false);
714        mConsumer->setConsumerName(String8("TestConsumer"));
715        mSurface = new TestSurface(mProducer, &mFenceMap);
716        mWindow = mSurface;
717
718        ASSERT_EQ(NO_ERROR, native_window_api_connect(mWindow.get(),
719                NATIVE_WINDOW_API_CPU));
720        native_window_set_buffer_count(mWindow.get(), 4);
721    }
722
723    void disableFrameTimestamps() {
724        mFakeConsumer->mGetFrameTimestampsEnabled = false;
725        native_window_enable_frame_timestamps(mWindow.get(), 0);
726        mFrameTimestampsEnabled = false;
727    }
728
729    void enableFrameTimestamps() {
730        mFakeConsumer->mGetFrameTimestampsEnabled = true;
731        native_window_enable_frame_timestamps(mWindow.get(), 1);
732        mFrameTimestampsEnabled = true;
733    }
734
735    int getAllFrameTimestamps(uint64_t frameId) {
736        return native_window_get_frame_timestamps(mWindow.get(), frameId,
737                &outRequestedPresentTime, &outAcquireTime, &outLatchTime,
738                &outFirstRefreshStartTime, &outLastRefreshStartTime,
739                &outGpuCompositionDoneTime, &outDisplayPresentTime,
740                &outDequeueReadyTime, &outReleaseTime);
741    }
742
743    void resetTimestamps() {
744        outRequestedPresentTime = -1;
745        outAcquireTime = -1;
746        outLatchTime = -1;
747        outFirstRefreshStartTime = -1;
748        outLastRefreshStartTime = -1;
749        outGpuCompositionDoneTime = -1;
750        outDisplayPresentTime = -1;
751        outDequeueReadyTime = -1;
752        outReleaseTime = -1;
753    }
754
755    uint64_t getNextFrameId() {
756        uint64_t frameId = -1;
757        int status = native_window_get_next_frame_id(mWindow.get(), &frameId);
758        EXPECT_EQ(status, NO_ERROR);
759        return frameId;
760    }
761
762    void dequeueAndQueue(uint64_t frameIndex) {
763        int fence = -1;
764        ANativeWindowBuffer* buffer = nullptr;
765        ASSERT_EQ(NO_ERROR,
766                mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
767
768        int oldAddFrameTimestampsCount =
769                mFakeConsumer->mAddFrameTimestampsCount;
770
771        FrameEvents* frame = &mFrames[frameIndex];
772        uint64_t frameNumber = frameIndex + 1;
773
774        NewFrameEventsEntry fe;
775        fe.frameNumber = frameNumber;
776        fe.postedTime = frame->kPostedTime;
777        fe.requestedPresentTime = frame->kRequestedPresentTime;
778        fe.acquireFence = frame->mAcquireConsumer.mFenceTime;
779        mFakeConsumer->mNewFrameEntryOverride = fe;
780
781        mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
782                    frame->mAcquireProducer.mFenceTime,
783                    frame->mAcquireConsumer.mFenceTime);
784
785        ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
786
787        EXPECT_EQ(frameNumber, mFakeConsumer->mLastAddedFrameNumber);
788
789        EXPECT_EQ(
790                oldAddFrameTimestampsCount + (mFrameTimestampsEnabled ? 1 : 0),
791                mFakeConsumer->mAddFrameTimestampsCount);
792    }
793
794    void addFrameEvents(
795            bool gpuComposited, uint64_t iOldFrame, int64_t iNewFrame) {
796        FrameEvents* oldFrame =
797                (iOldFrame == NO_FRAME_INDEX) ? nullptr : &mFrames[iOldFrame];
798        FrameEvents* newFrame = &mFrames[iNewFrame];
799
800        uint64_t nOldFrame = iOldFrame + 1;
801        uint64_t nNewFrame = iNewFrame + 1;
802
803        // Latch, Composite, and Release the frames in a plausible order.
804        // Note: The timestamps won't necessarily match the order, but
805        // that's okay for the purposes of this test.
806        std::shared_ptr<FenceTime> gpuDoneFenceTime = FenceTime::NO_FENCE;
807
808        // Composite the previous frame one more time, which helps verify
809        // LastRefresh is updated properly.
810        if (oldFrame != nullptr) {
811            mCfeh->addPreComposition(nOldFrame,
812                                     oldFrame->mRefreshes[2].kStartTime);
813            gpuDoneFenceTime = gpuComposited ?
814                    oldFrame->mRefreshes[2].mGpuCompositionDone.mFenceTime :
815                    FenceTime::NO_FENCE;
816            mCfeh->addPostComposition(nOldFrame, gpuDoneFenceTime,
817                    oldFrame->mRefreshes[2].mPresent.mFenceTime,
818                    oldFrame->mRefreshes[2].kCompositorTiming);
819        }
820
821        // Latch the new frame.
822        mCfeh->addLatch(nNewFrame, newFrame->kLatchTime);
823
824        mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[0].kStartTime);
825        gpuDoneFenceTime = gpuComposited ?
826                newFrame->mRefreshes[0].mGpuCompositionDone.mFenceTime :
827                FenceTime::NO_FENCE;
828        // HWC2 releases the previous buffer after a new latch just before
829        // calling postComposition.
830        if (oldFrame != nullptr) {
831            mCfeh->addRelease(nOldFrame, oldFrame->kDequeueReadyTime,
832                    std::shared_ptr<FenceTime>(oldFrame->mRelease.mFenceTime));
833        }
834        mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
835                newFrame->mRefreshes[0].mPresent.mFenceTime,
836                newFrame->mRefreshes[0].kCompositorTiming);
837
838        mCfeh->addPreComposition(nNewFrame, newFrame->mRefreshes[1].kStartTime);
839        gpuDoneFenceTime = gpuComposited ?
840                newFrame->mRefreshes[1].mGpuCompositionDone.mFenceTime :
841                FenceTime::NO_FENCE;
842        mCfeh->addPostComposition(nNewFrame, gpuDoneFenceTime,
843                newFrame->mRefreshes[1].mPresent.mFenceTime,
844                newFrame->mRefreshes[1].kCompositorTiming);
845    }
846
847    sp<IGraphicBufferProducer> mProducer;
848    sp<IGraphicBufferConsumer> mConsumer;
849    sp<FakeConsumer> mFakeConsumer;
850    ConsumerFrameEventHistory* mCfeh;
851    sp<TestSurface> mSurface;
852    sp<ANativeWindow> mWindow;
853
854    FenceToFenceTimeMap mFenceMap;
855
856    bool mFrameTimestampsEnabled = false;
857
858    int64_t outRequestedPresentTime = -1;
859    int64_t outAcquireTime = -1;
860    int64_t outLatchTime = -1;
861    int64_t outFirstRefreshStartTime = -1;
862    int64_t outLastRefreshStartTime = -1;
863    int64_t outGpuCompositionDoneTime = -1;
864    int64_t outDisplayPresentTime = -1;
865    int64_t outDequeueReadyTime = -1;
866    int64_t outReleaseTime = -1;
867
868    FrameEvents mFrames[3] {
869        { mFenceMap, 1000 }, { mFenceMap, 2000 }, { mFenceMap, 3000 } };
870};
871
872
873// This test verifies that the frame timestamps are not retrieved when not
874// explicitly enabled via native_window_enable_frame_timestamps.
875// We want to check this to make sure there's no overhead for users
876// that don't need the timestamp information.
877TEST_F(GetFrameTimestampsTest, DefaultDisabled) {
878    int fence;
879    ANativeWindowBuffer* buffer;
880
881    EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
882    EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
883
884    const uint64_t fId = getNextFrameId();
885
886    // Verify the producer doesn't get frame timestamps piggybacked on dequeue.
887    ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
888    EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
889    EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
890
891    // Verify the producer doesn't get frame timestamps piggybacked on queue.
892    // It is okay that frame timestamps are added in the consumer since it is
893    // still needed for SurfaceFlinger dumps.
894    ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
895    EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
896    EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
897
898    // Verify attempts to get frame timestamps fail.
899    int result = getAllFrameTimestamps(fId);
900    EXPECT_EQ(INVALID_OPERATION, result);
901    EXPECT_EQ(0, mFakeConsumer->mGetFrameTimestampsCount);
902
903    // Verify compositor timing query fails.
904    nsecs_t compositeDeadline = 0;
905    nsecs_t compositeInterval = 0;
906    nsecs_t compositeToPresentLatency = 0;
907    result = native_window_get_compositor_timing(mWindow.get(),
908        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
909    EXPECT_EQ(INVALID_OPERATION, result);
910}
911
912// This test verifies that the frame timestamps are retrieved if explicitly
913// enabled via native_window_enable_frame_timestamps.
914TEST_F(GetFrameTimestampsTest, EnabledSimple) {
915    CompositorTiming initialCompositorTiming {
916        1000000000, // 1s deadline
917        16666667, // 16ms interval
918        50000000, // 50ms present latency
919    };
920    mCfeh->initializeCompositorTiming(initialCompositorTiming);
921
922    enableFrameTimestamps();
923
924    // Verify the compositor timing query gets the initial compositor values
925    // after timststamps are enabled; even before the first frame is queued
926    // or dequeued.
927    nsecs_t compositeDeadline = 0;
928    nsecs_t compositeInterval = 0;
929    nsecs_t compositeToPresentLatency = 0;
930    mSurface->setNow(initialCompositorTiming.deadline - 1);
931    int result = native_window_get_compositor_timing(mWindow.get(),
932        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
933    EXPECT_EQ(NO_ERROR, result);
934    EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
935    EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
936    EXPECT_EQ(initialCompositorTiming.presentLatency,
937              compositeToPresentLatency);
938
939    int fence;
940    ANativeWindowBuffer* buffer;
941
942    EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
943    EXPECT_EQ(1, mFakeConsumer->mGetFrameTimestampsCount);
944
945    const uint64_t fId1 = getNextFrameId();
946
947    // Verify getFrameTimestamps is piggybacked on dequeue.
948    ASSERT_EQ(NO_ERROR, mWindow->dequeueBuffer(mWindow.get(), &buffer, &fence));
949    EXPECT_EQ(0, mFakeConsumer->mAddFrameTimestampsCount);
950    EXPECT_EQ(2, mFakeConsumer->mGetFrameTimestampsCount);
951
952    NewFrameEventsEntry f1;
953    f1.frameNumber = 1;
954    f1.postedTime = mFrames[0].kPostedTime;
955    f1.requestedPresentTime = mFrames[0].kRequestedPresentTime;
956    f1.acquireFence = mFrames[0].mAcquireConsumer.mFenceTime;
957    mSurface->mFakeFrameEventHistory->setAcquireFenceOverride(
958            mFrames[0].mAcquireProducer.mFenceTime,
959            mFrames[0].mAcquireConsumer.mFenceTime);
960    mFakeConsumer->mNewFrameEntryOverride = f1;
961    mFrames[0].signalQueueFences();
962
963    // Verify getFrameTimestamps is piggybacked on queue.
964    ASSERT_EQ(NO_ERROR, mWindow->queueBuffer(mWindow.get(), buffer, fence));
965    EXPECT_EQ(1, mFakeConsumer->mAddFrameTimestampsCount);
966    EXPECT_EQ(1u, mFakeConsumer->mLastAddedFrameNumber);
967    EXPECT_EQ(3, mFakeConsumer->mGetFrameTimestampsCount);
968
969    // Verify queries for timestamps that the producer doesn't know about
970    // triggers a call to see if the consumer has any new timestamps.
971    result = getAllFrameTimestamps(fId1);
972    EXPECT_EQ(NO_ERROR, result);
973    EXPECT_EQ(4, mFakeConsumer->mGetFrameTimestampsCount);
974}
975
976TEST_F(GetFrameTimestampsTest, QueryPresentSupported) {
977    bool displayPresentSupported = true;
978    mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
979
980    // Verify supported bits are forwarded.
981    int supportsPresent = -1;
982    mWindow.get()->query(mWindow.get(),
983            NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
984    EXPECT_EQ(displayPresentSupported, supportsPresent);
985}
986
987TEST_F(GetFrameTimestampsTest, QueryPresentNotSupported) {
988    bool displayPresentSupported = false;
989    mSurface->mFakeSurfaceComposer->setSupportsPresent(displayPresentSupported);
990
991    // Verify supported bits are forwarded.
992    int supportsPresent = -1;
993    mWindow.get()->query(mWindow.get(),
994            NATIVE_WINDOW_FRAME_TIMESTAMPS_SUPPORTS_PRESENT, &supportsPresent);
995    EXPECT_EQ(displayPresentSupported, supportsPresent);
996}
997
998TEST_F(GetFrameTimestampsTest, SnapToNextTickBasic) {
999    nsecs_t phase = 4000;
1000    nsecs_t interval = 1000;
1001
1002    // Timestamp in previous interval.
1003    nsecs_t timestamp = 3500;
1004    EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1005            timestamp, phase, interval));
1006
1007    // Timestamp in next interval.
1008    timestamp = 4500;
1009    EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1010            timestamp, phase, interval));
1011
1012    // Timestamp multiple intervals before.
1013    timestamp = 2500;
1014    EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1015            timestamp, phase, interval));
1016
1017    // Timestamp multiple intervals after.
1018    timestamp = 6500;
1019    EXPECT_EQ(7000, ProducerFrameEventHistory::snapToNextTick(
1020            timestamp, phase, interval));
1021
1022    // Timestamp on previous interval.
1023    timestamp = 3000;
1024    EXPECT_EQ(3000, ProducerFrameEventHistory::snapToNextTick(
1025            timestamp, phase, interval));
1026
1027    // Timestamp on next interval.
1028    timestamp = 5000;
1029    EXPECT_EQ(5000, ProducerFrameEventHistory::snapToNextTick(
1030            timestamp, phase, interval));
1031
1032    // Timestamp equal to phase.
1033    timestamp = 4000;
1034    EXPECT_EQ(4000, ProducerFrameEventHistory::snapToNextTick(
1035            timestamp, phase, interval));
1036}
1037
1038// int(big_timestamp / interval) < 0, which can cause a crash or invalid result
1039// if the number of intervals elapsed is internally stored in an int.
1040TEST_F(GetFrameTimestampsTest, SnapToNextTickOverflow) {
1041      nsecs_t phase = 0;
1042      nsecs_t interval = 4000;
1043      nsecs_t big_timestamp = 8635916564000;
1044      int32_t intervals = big_timestamp / interval;
1045
1046      EXPECT_LT(intervals, 0);
1047      EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1048            big_timestamp, phase, interval));
1049      EXPECT_EQ(8635916564000, ProducerFrameEventHistory::snapToNextTick(
1050            big_timestamp, big_timestamp, interval));
1051}
1052
1053// This verifies the compositor timing is updated by refresh events
1054// and piggy backed on a queue, dequeue, and enabling of timestamps..
1055TEST_F(GetFrameTimestampsTest, CompositorTimingUpdatesBasic) {
1056    CompositorTiming initialCompositorTiming {
1057        1000000000, // 1s deadline
1058        16666667, // 16ms interval
1059        50000000, // 50ms present latency
1060    };
1061    mCfeh->initializeCompositorTiming(initialCompositorTiming);
1062
1063    enableFrameTimestamps();
1064
1065    // We get the initial values before any frames are submitted.
1066    nsecs_t compositeDeadline = 0;
1067    nsecs_t compositeInterval = 0;
1068    nsecs_t compositeToPresentLatency = 0;
1069    mSurface->setNow(initialCompositorTiming.deadline - 1);
1070    int result = native_window_get_compositor_timing(mWindow.get(),
1071        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1072    EXPECT_EQ(NO_ERROR, result);
1073    EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1074    EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1075    EXPECT_EQ(initialCompositorTiming.presentLatency,
1076              compositeToPresentLatency);
1077
1078    const uint64_t fId1 = getNextFrameId();
1079    dequeueAndQueue(0);
1080    addFrameEvents(true, NO_FRAME_INDEX, 0);
1081
1082    // Still get the initial values because the frame events for frame 0
1083    // didn't get a chance to piggyback on a queue or dequeue yet.
1084    result = native_window_get_compositor_timing(mWindow.get(),
1085        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1086    EXPECT_EQ(NO_ERROR, result);
1087    EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1088    EXPECT_EQ(initialCompositorTiming.interval, compositeInterval);
1089    EXPECT_EQ(initialCompositorTiming.presentLatency,
1090              compositeToPresentLatency);
1091
1092    const uint64_t fId2 = getNextFrameId();
1093    dequeueAndQueue(1);
1094    addFrameEvents(true, 0, 1);
1095
1096    // Now expect the composite values associated with frame 1.
1097    mSurface->setNow(mFrames[0].mRefreshes[1].kCompositorTiming.deadline);
1098    result = native_window_get_compositor_timing(mWindow.get(),
1099        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1100    EXPECT_EQ(NO_ERROR, result);
1101    EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.deadline,
1102            compositeDeadline);
1103    EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.interval,
1104            compositeInterval);
1105    EXPECT_EQ(mFrames[0].mRefreshes[1].kCompositorTiming.presentLatency,
1106            compositeToPresentLatency);
1107
1108    dequeueAndQueue(2);
1109    addFrameEvents(true, 1, 2);
1110
1111    // Now expect the composite values associated with frame 2.
1112    mSurface->setNow(mFrames[1].mRefreshes[1].kCompositorTiming.deadline);
1113    result = native_window_get_compositor_timing(mWindow.get(),
1114        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1115    EXPECT_EQ(NO_ERROR, result);
1116    EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.deadline,
1117            compositeDeadline);
1118    EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.interval,
1119            compositeInterval);
1120    EXPECT_EQ(mFrames[1].mRefreshes[1].kCompositorTiming.presentLatency,
1121            compositeToPresentLatency);
1122
1123    // Re-enabling frame timestamps should get the latest values.
1124    disableFrameTimestamps();
1125    enableFrameTimestamps();
1126
1127    // Now expect the composite values associated with frame 3.
1128    mSurface->setNow(mFrames[2].mRefreshes[1].kCompositorTiming.deadline);
1129    result = native_window_get_compositor_timing(mWindow.get(),
1130        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1131    EXPECT_EQ(NO_ERROR, result);
1132    EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.deadline,
1133            compositeDeadline);
1134    EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.interval,
1135            compositeInterval);
1136    EXPECT_EQ(mFrames[2].mRefreshes[1].kCompositorTiming.presentLatency,
1137            compositeToPresentLatency);
1138}
1139
1140// This verifies the compositor deadline properly snaps to the the next
1141// deadline based on the current time.
1142TEST_F(GetFrameTimestampsTest, CompositorTimingDeadlineSnaps) {
1143    CompositorTiming initialCompositorTiming {
1144        1000000000, // 1s deadline
1145        16666667, // 16ms interval
1146        50000000, // 50ms present latency
1147    };
1148    mCfeh->initializeCompositorTiming(initialCompositorTiming);
1149
1150    enableFrameTimestamps();
1151
1152    nsecs_t compositeDeadline = 0;
1153    nsecs_t compositeInterval = 0;
1154    nsecs_t compositeToPresentLatency = 0;
1155
1156    // A "now" just before the deadline snaps to the deadline.
1157    mSurface->setNow(initialCompositorTiming.deadline - 1);
1158    int result = native_window_get_compositor_timing(mWindow.get(),
1159        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1160    EXPECT_EQ(NO_ERROR, result);
1161    EXPECT_EQ(initialCompositorTiming.deadline, compositeDeadline);
1162    nsecs_t expectedDeadline = initialCompositorTiming.deadline;
1163    EXPECT_EQ(expectedDeadline, compositeDeadline);
1164
1165    const uint64_t fId1 = getNextFrameId();
1166    dequeueAndQueue(0);
1167    addFrameEvents(true, NO_FRAME_INDEX, 0);
1168
1169    // A "now" just after the deadline snaps properly.
1170    mSurface->setNow(initialCompositorTiming.deadline + 1);
1171    result = native_window_get_compositor_timing(mWindow.get(),
1172        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1173    EXPECT_EQ(NO_ERROR, result);
1174    expectedDeadline =
1175            initialCompositorTiming.deadline +initialCompositorTiming.interval;
1176    EXPECT_EQ(expectedDeadline, compositeDeadline);
1177
1178    const uint64_t fId2 = getNextFrameId();
1179    dequeueAndQueue(1);
1180    addFrameEvents(true, 0, 1);
1181
1182    // A "now" just after the next interval snaps properly.
1183    mSurface->setNow(
1184            mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1185            mFrames[0].mRefreshes[1].kCompositorTiming.interval + 1);
1186    result = native_window_get_compositor_timing(mWindow.get(),
1187        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1188    EXPECT_EQ(NO_ERROR, result);
1189    expectedDeadline =
1190            mFrames[0].mRefreshes[1].kCompositorTiming.deadline +
1191            mFrames[0].mRefreshes[1].kCompositorTiming.interval * 2;
1192    EXPECT_EQ(expectedDeadline, compositeDeadline);
1193
1194    dequeueAndQueue(2);
1195    addFrameEvents(true, 1, 2);
1196
1197    // A "now" over 1 interval before the deadline snaps properly.
1198    mSurface->setNow(
1199            mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1200            mFrames[1].mRefreshes[1].kCompositorTiming.interval - 1);
1201    result = native_window_get_compositor_timing(mWindow.get(),
1202        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1203    EXPECT_EQ(NO_ERROR, result);
1204    expectedDeadline =
1205            mFrames[1].mRefreshes[1].kCompositorTiming.deadline -
1206            mFrames[1].mRefreshes[1].kCompositorTiming.interval;
1207    EXPECT_EQ(expectedDeadline, compositeDeadline);
1208
1209    // Re-enabling frame timestamps should get the latest values.
1210    disableFrameTimestamps();
1211    enableFrameTimestamps();
1212
1213    // A "now" over 2 intervals before the deadline snaps properly.
1214    mSurface->setNow(
1215            mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1216            mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2 - 1);
1217    result = native_window_get_compositor_timing(mWindow.get(),
1218        &compositeDeadline, &compositeInterval, &compositeToPresentLatency);
1219    EXPECT_EQ(NO_ERROR, result);
1220    expectedDeadline =
1221            mFrames[2].mRefreshes[1].kCompositorTiming.deadline -
1222            mFrames[2].mRefreshes[1].kCompositorTiming.interval * 2;
1223    EXPECT_EQ(expectedDeadline, compositeDeadline);
1224}
1225
1226// This verifies the timestamps recorded in the consumer's
1227// FrameTimestampsHistory are properly retrieved by the producer for the
1228// correct frames.
1229TEST_F(GetFrameTimestampsTest, TimestampsAssociatedWithCorrectFrame) {
1230    enableFrameTimestamps();
1231
1232    const uint64_t fId1 = getNextFrameId();
1233    dequeueAndQueue(0);
1234    mFrames[0].signalQueueFences();
1235
1236    const uint64_t fId2 = getNextFrameId();
1237    dequeueAndQueue(1);
1238    mFrames[1].signalQueueFences();
1239
1240    addFrameEvents(true, NO_FRAME_INDEX, 0);
1241    mFrames[0].signalRefreshFences();
1242    addFrameEvents(true, 0, 1);
1243    mFrames[0].signalReleaseFences();
1244    mFrames[1].signalRefreshFences();
1245
1246    // Verify timestamps are correct for frame 1.
1247    resetTimestamps();
1248    int result = getAllFrameTimestamps(fId1);
1249    EXPECT_EQ(NO_ERROR, result);
1250    EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1251    EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1252    EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1253    EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1254    EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1255    EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1256            outGpuCompositionDoneTime);
1257    EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1258    EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1259    EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1260
1261    // Verify timestamps are correct for frame 2.
1262    resetTimestamps();
1263    result = getAllFrameTimestamps(fId2);
1264    EXPECT_EQ(NO_ERROR, result);
1265    EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1266    EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1267    EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
1268    EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1269    EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
1270    EXPECT_EQ(mFrames[1].mRefreshes[0].kGpuCompositionDoneTime,
1271            outGpuCompositionDoneTime);
1272    EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1273    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
1274    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1275}
1276
1277// This test verifies the acquire fence recorded by the consumer is not sent
1278// back to the producer and the producer saves its own fence.
1279TEST_F(GetFrameTimestampsTest, QueueTimestampsNoSync) {
1280    enableFrameTimestamps();
1281
1282    // Dequeue and queue frame 1.
1283    const uint64_t fId1 = getNextFrameId();
1284    dequeueAndQueue(0);
1285
1286    // Verify queue-related timestamps for f1 are available immediately in the
1287    // producer without asking the consumer again, even before signaling the
1288    // acquire fence.
1289    resetTimestamps();
1290    int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1291    int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1292            &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1293            nullptr, nullptr, nullptr, nullptr, nullptr);
1294    EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1295    EXPECT_EQ(NO_ERROR, result);
1296    EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1297    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
1298
1299    // Signal acquire fences. Verify a sync call still isn't necessary.
1300    mFrames[0].signalQueueFences();
1301
1302    oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1303    result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1304            &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1305            nullptr, nullptr, nullptr, nullptr, nullptr);
1306    EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1307    EXPECT_EQ(NO_ERROR, result);
1308    EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1309    EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1310
1311    // Dequeue and queue frame 2.
1312    const uint64_t fId2 = getNextFrameId();
1313    dequeueAndQueue(1);
1314
1315    // Verify queue-related timestamps for f2 are available immediately in the
1316    // producer without asking the consumer again, even before signaling the
1317    // acquire fence.
1318    resetTimestamps();
1319    oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1320    result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1321            &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1322            nullptr, nullptr, nullptr, nullptr, nullptr);
1323    EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1324    EXPECT_EQ(NO_ERROR, result);
1325    EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1326    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outAcquireTime);
1327
1328    // Signal acquire fences. Verify a sync call still isn't necessary.
1329    mFrames[1].signalQueueFences();
1330
1331    oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1332    result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1333            &outRequestedPresentTime, &outAcquireTime, nullptr, nullptr,
1334            nullptr, nullptr, nullptr, nullptr, nullptr);
1335    EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1336    EXPECT_EQ(NO_ERROR, result);
1337    EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1338    EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1339}
1340
1341TEST_F(GetFrameTimestampsTest, ZeroRequestedTimestampsNoSync) {
1342    enableFrameTimestamps();
1343
1344    // Dequeue and queue frame 1.
1345    dequeueAndQueue(0);
1346    mFrames[0].signalQueueFences();
1347
1348    // Dequeue and queue frame 2.
1349    const uint64_t fId2 = getNextFrameId();
1350    dequeueAndQueue(1);
1351    mFrames[1].signalQueueFences();
1352
1353    addFrameEvents(true, NO_FRAME_INDEX, 0);
1354    mFrames[0].signalRefreshFences();
1355    addFrameEvents(true, 0, 1);
1356    mFrames[0].signalReleaseFences();
1357    mFrames[1].signalRefreshFences();
1358
1359    // Verify a request for no timestamps doesn't result in a sync call.
1360    int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1361    int result = native_window_get_frame_timestamps(mWindow.get(), fId2,
1362            nullptr, nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1363            nullptr, nullptr);
1364    EXPECT_EQ(NO_ERROR, result);
1365    EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1366}
1367
1368// This test verifies that fences can signal and update timestamps producer
1369// side without an additional sync call to the consumer.
1370TEST_F(GetFrameTimestampsTest, FencesInProducerNoSync) {
1371    enableFrameTimestamps();
1372
1373    // Dequeue and queue frame 1.
1374    const uint64_t fId1 = getNextFrameId();
1375    dequeueAndQueue(0);
1376    mFrames[0].signalQueueFences();
1377
1378    // Dequeue and queue frame 2.
1379    dequeueAndQueue(1);
1380    mFrames[1].signalQueueFences();
1381
1382    addFrameEvents(true, NO_FRAME_INDEX, 0);
1383    addFrameEvents(true, 0, 1);
1384
1385    // Verify available timestamps are correct for frame 1, before any
1386    // fence has been signaled.
1387    // Note: A sync call is necessary here since the events triggered by
1388    // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1389    resetTimestamps();
1390    int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1391    int result = getAllFrameTimestamps(fId1);
1392    EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1393    EXPECT_EQ(NO_ERROR, result);
1394    EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1395    EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1396    EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1397    EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1398    EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1399    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1400    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1401    EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1402    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1403
1404    // Verify available timestamps are correct for frame 1 again, before any
1405    // fence has been signaled.
1406    // This time a sync call should not be necessary.
1407    resetTimestamps();
1408    oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1409    result = getAllFrameTimestamps(fId1);
1410    EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1411    EXPECT_EQ(NO_ERROR, result);
1412    EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1413    EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1414    EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1415    EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1416    EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1417    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outGpuCompositionDoneTime);
1418    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1419    EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1420    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1421
1422    // Signal the fences for frame 1.
1423    mFrames[0].signalRefreshFences();
1424    mFrames[0].signalReleaseFences();
1425
1426    // Verify all timestamps are available without a sync call.
1427    resetTimestamps();
1428    oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1429    result = getAllFrameTimestamps(fId1);
1430    EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1431    EXPECT_EQ(NO_ERROR, result);
1432    EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1433    EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1434    EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1435    EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1436    EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1437    EXPECT_EQ(mFrames[0].mRefreshes[0].kGpuCompositionDoneTime,
1438            outGpuCompositionDoneTime);
1439    EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1440    EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1441    EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1442}
1443
1444// This test verifies that if the frame wasn't GPU composited but has a refresh
1445// event a sync call isn't made to get the GPU composite done time since it will
1446// never exist.
1447TEST_F(GetFrameTimestampsTest, NoGpuNoSync) {
1448    enableFrameTimestamps();
1449
1450    // Dequeue and queue frame 1.
1451    const uint64_t fId1 = getNextFrameId();
1452    dequeueAndQueue(0);
1453    mFrames[0].signalQueueFences();
1454
1455    // Dequeue and queue frame 2.
1456    dequeueAndQueue(1);
1457    mFrames[1].signalQueueFences();
1458
1459    addFrameEvents(false, NO_FRAME_INDEX, 0);
1460    addFrameEvents(false, 0, 1);
1461
1462    // Verify available timestamps are correct for frame 1, before any
1463    // fence has been signaled.
1464    // Note: A sync call is necessary here since the events triggered by
1465    // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1466    resetTimestamps();
1467    int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1468    int result = getAllFrameTimestamps(fId1);
1469    EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1470    EXPECT_EQ(NO_ERROR, result);
1471    EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1472    EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1473    EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1474    EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1475    EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1476    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1477    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1478    EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1479    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1480
1481    // Signal the fences for frame 1.
1482    mFrames[0].signalRefreshFences();
1483    mFrames[0].signalReleaseFences();
1484
1485    // Verify all timestamps, except GPU composition, are available without a
1486    // sync call.
1487    resetTimestamps();
1488    oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1489    result = getAllFrameTimestamps(fId1);
1490    EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1491    EXPECT_EQ(NO_ERROR, result);
1492    EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1493    EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1494    EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1495    EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1496    EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1497    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1498    EXPECT_EQ(mFrames[0].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1499    EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1500    EXPECT_EQ(mFrames[0].kReleaseTime, outReleaseTime);
1501}
1502
1503// This test verifies that if the certain timestamps can't possibly exist for
1504// the most recent frame, then a sync call is not done.
1505TEST_F(GetFrameTimestampsTest, NoReleaseNoSync) {
1506    enableFrameTimestamps();
1507
1508    // Dequeue and queue frame 1.
1509    const uint64_t fId1 = getNextFrameId();
1510    dequeueAndQueue(0);
1511    mFrames[0].signalQueueFences();
1512
1513    // Dequeue and queue frame 2.
1514    const uint64_t fId2 = getNextFrameId();
1515    dequeueAndQueue(1);
1516    mFrames[1].signalQueueFences();
1517
1518    addFrameEvents(false, NO_FRAME_INDEX, 0);
1519    addFrameEvents(false, 0, 1);
1520
1521    // Verify available timestamps are correct for frame 1, before any
1522    // fence has been signaled.
1523    // Note: A sync call is necessary here since the events triggered by
1524    // addFrameEvents didn't get to piggyback on the earlier queues/dequeues.
1525    resetTimestamps();
1526    int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1527    int result = getAllFrameTimestamps(fId1);
1528    EXPECT_EQ(oldCount + 1, mFakeConsumer->mGetFrameTimestampsCount);
1529    EXPECT_EQ(NO_ERROR, result);
1530    EXPECT_EQ(mFrames[0].kRequestedPresentTime, outRequestedPresentTime);
1531    EXPECT_EQ(mFrames[0].kProducerAcquireTime, outAcquireTime);
1532    EXPECT_EQ(mFrames[0].kLatchTime, outLatchTime);
1533    EXPECT_EQ(mFrames[0].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1534    EXPECT_EQ(mFrames[0].mRefreshes[2].kStartTime, outLastRefreshStartTime);
1535    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1536    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDisplayPresentTime);
1537    EXPECT_EQ(mFrames[0].kDequeueReadyTime, outDequeueReadyTime);
1538    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1539
1540    mFrames[0].signalRefreshFences();
1541    mFrames[0].signalReleaseFences();
1542    mFrames[1].signalRefreshFences();
1543
1544    // Verify querying for all timestmaps of f2 does not do a sync call. Even
1545    // though the lastRefresh, dequeueReady, and release times aren't
1546    // available, a sync call should not occur because it's not possible for f2
1547    // to encounter the final value for those events until another frame is
1548    // queued.
1549    resetTimestamps();
1550    oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1551    result = getAllFrameTimestamps(fId2);
1552    EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1553    EXPECT_EQ(NO_ERROR, result);
1554    EXPECT_EQ(mFrames[1].kRequestedPresentTime, outRequestedPresentTime);
1555    EXPECT_EQ(mFrames[1].kProducerAcquireTime, outAcquireTime);
1556    EXPECT_EQ(mFrames[1].kLatchTime, outLatchTime);
1557    EXPECT_EQ(mFrames[1].mRefreshes[0].kStartTime, outFirstRefreshStartTime);
1558    EXPECT_EQ(mFrames[1].mRefreshes[1].kStartTime, outLastRefreshStartTime);
1559    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_INVALID, outGpuCompositionDoneTime);
1560    EXPECT_EQ(mFrames[1].mRefreshes[0].kPresentTime, outDisplayPresentTime);
1561    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outDequeueReadyTime);
1562    EXPECT_EQ(NATIVE_WINDOW_TIMESTAMP_PENDING, outReleaseTime);
1563}
1564
1565// This test verifies there are no sync calls for present times
1566// when they aren't supported and that an error is returned.
1567
1568TEST_F(GetFrameTimestampsTest, PresentUnsupportedNoSync) {
1569    enableFrameTimestamps();
1570    mSurface->mFakeSurfaceComposer->setSupportsPresent(false);
1571
1572    // Dequeue and queue frame 1.
1573    const uint64_t fId1 = getNextFrameId();
1574    dequeueAndQueue(0);
1575
1576    // Verify a query for the Present times do not trigger a sync call if they
1577    // are not supported.
1578    resetTimestamps();
1579    int oldCount = mFakeConsumer->mGetFrameTimestampsCount;
1580    int result = native_window_get_frame_timestamps(mWindow.get(), fId1,
1581            nullptr, nullptr, nullptr, nullptr, nullptr, nullptr,
1582            &outDisplayPresentTime, nullptr, nullptr);
1583    EXPECT_EQ(oldCount, mFakeConsumer->mGetFrameTimestampsCount);
1584    EXPECT_EQ(BAD_VALUE, result);
1585    EXPECT_EQ(-1, outDisplayPresentTime);
1586}
1587
1588} // namespace android
1589