Surface_test.cpp revision 812ed0644f8f8f71ca403f4e5793f0dbc1fcf9b2 
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 <gtest/gtest.h>
18
19#include <binder/IMemory.h>
20#include <gui/ISurfaceComposer.h>
21#include <gui/Surface.h>
22#include <gui/SurfaceComposerClient.h>
23#include <gui/BufferItemConsumer.h>
24#include <ui/Rect.h>
25#include <utils/String8.h>
26
27#include <private/gui/ComposerService.h>
28#include <binder/ProcessState.h>
29
30namespace android {
31
32class SurfaceTest : public ::testing::Test {
33protected:
34
35    SurfaceTest() {
36        ProcessState::self()->startThreadPool();
37    }
38
39    virtual void SetUp() {
40        mComposerClient = new SurfaceComposerClient;
41        ASSERT_EQ(NO_ERROR, mComposerClient->initCheck());
42
43        mSurfaceControl = mComposerClient->createSurface(
44                String8("Test Surface"), 32, 32, PIXEL_FORMAT_RGBA_8888, 0);
45
46        ASSERT_TRUE(mSurfaceControl != NULL);
47        ASSERT_TRUE(mSurfaceControl->isValid());
48
49        SurfaceComposerClient::openGlobalTransaction();
50        ASSERT_EQ(NO_ERROR, mSurfaceControl->setLayer(0x7fffffff));
51        ASSERT_EQ(NO_ERROR, mSurfaceControl->show());
52        SurfaceComposerClient::closeGlobalTransaction();
53
54        mSurface = mSurfaceControl->getSurface();
55        ASSERT_TRUE(mSurface != NULL);
56    }
57
58    virtual void TearDown() {
59        mComposerClient->dispose();
60    }
61
62    sp<Surface> mSurface;
63    sp<SurfaceComposerClient> mComposerClient;
64    sp<SurfaceControl> mSurfaceControl;
65};
66
67TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenVisible) {
68    sp<ANativeWindow> anw(mSurface);
69    int result = -123;
70    int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
71            &result);
72    EXPECT_EQ(NO_ERROR, err);
73    EXPECT_EQ(1, result);
74}
75
76TEST_F(SurfaceTest, QueuesToWindowComposerIsTrueWhenPurgatorized) {
77    mSurfaceControl.clear();
78
79    sp<ANativeWindow> anw(mSurface);
80    int result = -123;
81    int err = anw->query(anw.get(), NATIVE_WINDOW_QUEUES_TO_WINDOW_COMPOSER,
82            &result);
83    EXPECT_EQ(NO_ERROR, err);
84    EXPECT_EQ(1, result);
85}
86
87// This test probably doesn't belong here.
88TEST_F(SurfaceTest, ScreenshotsOfProtectedBuffersSucceed) {
89    sp<ANativeWindow> anw(mSurface);
90
91    // Verify the screenshot works with no protected buffers.
92    sp<IGraphicBufferProducer> producer;
93    sp<IGraphicBufferConsumer> consumer;
94    BufferQueue::createBufferQueue(&producer, &consumer);
95    sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
96    sp<ISurfaceComposer> sf(ComposerService::getComposerService());
97    sp<IBinder> display(sf->getBuiltInDisplay(ISurfaceComposer::eDisplayIdMain));
98    ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(),
99            64, 64, 0, 0x7fffffff, false));
100
101    // Set the PROTECTED usage bit and verify that the screenshot fails.  Note
102    // that we need to dequeue a buffer in order for it to actually get
103    // allocated in SurfaceFlinger.
104    ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(),
105            GRALLOC_USAGE_PROTECTED));
106    ASSERT_EQ(NO_ERROR, native_window_set_buffer_count(anw.get(), 3));
107    ANativeWindowBuffer* buf = 0;
108
109    status_t err = native_window_dequeue_buffer_and_wait(anw.get(), &buf);
110    if (err) {
111        // we could fail if GRALLOC_USAGE_PROTECTED is not supported.
112        // that's okay as long as this is the reason for the failure.
113        // try again without the GRALLOC_USAGE_PROTECTED bit.
114        ASSERT_EQ(NO_ERROR, native_window_set_usage(anw.get(), 0));
115        ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
116                &buf));
117        return;
118    }
119    ASSERT_EQ(NO_ERROR, anw->cancelBuffer(anw.get(), buf, -1));
120
121    for (int i = 0; i < 4; i++) {
122        // Loop to make sure SurfaceFlinger has retired a protected buffer.
123        ASSERT_EQ(NO_ERROR, native_window_dequeue_buffer_and_wait(anw.get(),
124                &buf));
125        ASSERT_EQ(NO_ERROR, anw->queueBuffer(anw.get(), buf, -1));
126    }
127    ASSERT_EQ(NO_ERROR, sf->captureScreen(display, producer, Rect(),
128            64, 64, 0, 0x7fffffff, false));
129}
130
131TEST_F(SurfaceTest, ConcreteTypeIsSurface) {
132    sp<ANativeWindow> anw(mSurface);
133    int result = -123;
134    int err = anw->query(anw.get(), NATIVE_WINDOW_CONCRETE_TYPE, &result);
135    EXPECT_EQ(NO_ERROR, err);
136    EXPECT_EQ(NATIVE_WINDOW_SURFACE, result);
137}
138
139TEST_F(SurfaceTest, QueryConsumerUsage) {
140    const int TEST_USAGE_FLAGS =
141            GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_HW_RENDER;
142    sp<IGraphicBufferProducer> producer;
143    sp<IGraphicBufferConsumer> consumer;
144    BufferQueue::createBufferQueue(&producer, &consumer);
145    sp<BufferItemConsumer> c = new BufferItemConsumer(consumer,
146            TEST_USAGE_FLAGS);
147    sp<Surface> s = new Surface(producer);
148
149    sp<ANativeWindow> anw(s);
150
151    int flags = -1;
152    int err = anw->query(anw.get(), NATIVE_WINDOW_CONSUMER_USAGE_BITS, &flags);
153
154    ASSERT_EQ(NO_ERROR, err);
155    ASSERT_EQ(TEST_USAGE_FLAGS, flags);
156}
157
158TEST_F(SurfaceTest, QueryDefaultBuffersDataSpace) {
159    const android_dataspace TEST_DATASPACE = HAL_DATASPACE_SRGB;
160    sp<IGraphicBufferProducer> producer;
161    sp<IGraphicBufferConsumer> consumer;
162    BufferQueue::createBufferQueue(&producer, &consumer);
163    sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
164
165    cpuConsumer->setDefaultBufferDataSpace(TEST_DATASPACE);
166
167    sp<Surface> s = new Surface(producer);
168
169    sp<ANativeWindow> anw(s);
170
171    android_dataspace dataSpace;
172
173    int err = anw->query(anw.get(), NATIVE_WINDOW_DEFAULT_DATASPACE,
174            reinterpret_cast<int*>(&dataSpace));
175
176    ASSERT_EQ(NO_ERROR, err);
177    ASSERT_EQ(TEST_DATASPACE, dataSpace);
178}
179
180TEST_F(SurfaceTest, SettingGenerationNumber) {
181    sp<IGraphicBufferProducer> producer;
182    sp<IGraphicBufferConsumer> consumer;
183    BufferQueue::createBufferQueue(&producer, &consumer);
184    sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
185    sp<Surface> surface = new Surface(producer);
186    sp<ANativeWindow> window(surface);
187
188    // Allocate a buffer with a generation number of 0
189    ANativeWindowBuffer* buffer;
190    int fenceFd;
191    ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
192    ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, fenceFd));
193
194    // Detach the buffer and check its generation number
195    sp<GraphicBuffer> graphicBuffer;
196    sp<Fence> fence;
197    ASSERT_EQ(NO_ERROR, surface->detachNextBuffer(&graphicBuffer, &fence));
198    ASSERT_EQ(0U, graphicBuffer->getGenerationNumber());
199
200    ASSERT_EQ(NO_ERROR, surface->setGenerationNumber(1));
201    buffer = static_cast<ANativeWindowBuffer*>(graphicBuffer.get());
202
203    // This should change the generation number of the GraphicBuffer
204    ASSERT_EQ(NO_ERROR, surface->attachBuffer(buffer));
205
206    // Check that the new generation number sticks with the buffer
207    ASSERT_EQ(NO_ERROR, window->cancelBuffer(window.get(), buffer, -1));
208    ASSERT_EQ(NO_ERROR, window->dequeueBuffer(window.get(), &buffer, &fenceFd));
209    graphicBuffer = static_cast<GraphicBuffer*>(buffer);
210    ASSERT_EQ(1U, graphicBuffer->getGenerationNumber());
211}
212
213}
214