OLD | NEW |
| (Empty) |
1 // Copyright (c) 2015 The Chromium Authors. All rights reserved. | |
2 // Use of this source code is governed by a BSD-style license that can be | |
3 // found in the LICENSE file. | |
4 | |
5 #include <stdint.h> | |
6 | |
7 #include "base/test/test_simple_task_runner.h" | |
8 #include "content/common/gpu/gpu_channel.h" | |
9 #include "content/common/gpu/gpu_channel_manager.h" | |
10 #include "content/common/gpu/gpu_channel_test_common.h" | |
11 #include "gpu/ipc/common/gpu_messages.h" | |
12 #include "ipc/ipc_test_sink.h" | |
13 | |
14 namespace content { | |
15 | |
16 class GpuChannelTest : public GpuChannelTestCommon { | |
17 public: | |
18 GpuChannelTest() : GpuChannelTestCommon() {} | |
19 ~GpuChannelTest() override {} | |
20 | |
21 GpuChannel* CreateChannel(int32_t client_id, | |
22 bool allow_view_command_buffers, | |
23 bool allow_real_time_streams) { | |
24 DCHECK(channel_manager()); | |
25 uint64_t kClientTracingId = 1; | |
26 channel_manager()->EstablishChannel( | |
27 client_id, kClientTracingId, false /* preempts */, | |
28 allow_view_command_buffers, allow_real_time_streams); | |
29 return channel_manager()->LookupChannel(client_id); | |
30 } | |
31 | |
32 void HandleMessage(GpuChannel* channel, IPC::Message* msg) { | |
33 TestGpuChannel* test_channel = static_cast<TestGpuChannel*>(channel); | |
34 test_channel->HandleMessageForTesting(*msg); | |
35 | |
36 if (msg->is_sync()) { | |
37 const IPC::Message* reply_msg = test_channel->sink()->GetMessageAt(0); | |
38 ASSERT_TRUE(reply_msg); | |
39 | |
40 EXPECT_TRUE(IPC::SyncMessage::IsMessageReplyTo( | |
41 *reply_msg, IPC::SyncMessage::GetMessageId(*msg))); | |
42 | |
43 IPC::MessageReplyDeserializer* deserializer = | |
44 static_cast<IPC::SyncMessage*>(msg)->GetReplyDeserializer(); | |
45 ASSERT_TRUE(deserializer); | |
46 deserializer->SerializeOutputParameters(*reply_msg); | |
47 | |
48 delete deserializer; | |
49 | |
50 test_channel->sink()->ClearMessages(); | |
51 } | |
52 | |
53 delete msg; | |
54 } | |
55 }; | |
56 | |
57 #if defined(OS_WIN) | |
58 const gpu::SurfaceHandle kFakeSurfaceHandle = | |
59 reinterpret_cast<gpu::SurfaceHandle>(1); | |
60 #else | |
61 const gpu::SurfaceHandle kFakeSurfaceHandle = 1; | |
62 #endif | |
63 | |
64 TEST_F(GpuChannelTest, CreateViewCommandBufferAllowed) { | |
65 int32_t kClientId = 1; | |
66 bool allow_view_command_buffers = true; | |
67 GpuChannel* channel = | |
68 CreateChannel(kClientId, allow_view_command_buffers, false); | |
69 ASSERT_TRUE(channel); | |
70 | |
71 gpu::SurfaceHandle surface_handle = kFakeSurfaceHandle; | |
72 DCHECK_NE(surface_handle, gpu::kNullSurfaceHandle); | |
73 | |
74 int32_t kRouteId = 1; | |
75 GPUCreateCommandBufferConfig init_params; | |
76 init_params.share_group_id = MSG_ROUTING_NONE; | |
77 init_params.stream_id = 0; | |
78 init_params.stream_priority = gpu::GpuStreamPriority::NORMAL; | |
79 init_params.attribs = std::vector<int>(); | |
80 init_params.active_url = GURL(); | |
81 init_params.gpu_preference = gfx::PreferIntegratedGpu; | |
82 bool succeeded = false; | |
83 HandleMessage(channel, new GpuChannelMsg_CreateCommandBuffer( | |
84 surface_handle, gfx::Size(), init_params, kRouteId, | |
85 &succeeded)); | |
86 EXPECT_TRUE(succeeded); | |
87 | |
88 GpuCommandBufferStub* stub = channel->LookupCommandBuffer(kRouteId); | |
89 ASSERT_TRUE(stub); | |
90 } | |
91 | |
92 TEST_F(GpuChannelTest, CreateViewCommandBufferDisallowed) { | |
93 int32_t kClientId = 1; | |
94 bool allow_view_command_buffers = false; | |
95 GpuChannel* channel = | |
96 CreateChannel(kClientId, allow_view_command_buffers, false); | |
97 ASSERT_TRUE(channel); | |
98 | |
99 gpu::SurfaceHandle surface_handle = kFakeSurfaceHandle; | |
100 DCHECK_NE(surface_handle, gpu::kNullSurfaceHandle); | |
101 | |
102 int32_t kRouteId = 1; | |
103 GPUCreateCommandBufferConfig init_params; | |
104 init_params.share_group_id = MSG_ROUTING_NONE; | |
105 init_params.stream_id = 0; | |
106 init_params.stream_priority = gpu::GpuStreamPriority::NORMAL; | |
107 init_params.attribs = std::vector<int>(); | |
108 init_params.active_url = GURL(); | |
109 init_params.gpu_preference = gfx::PreferIntegratedGpu; | |
110 bool succeeded = false; | |
111 HandleMessage(channel, new GpuChannelMsg_CreateCommandBuffer( | |
112 surface_handle, gfx::Size(), init_params, kRouteId, | |
113 &succeeded)); | |
114 EXPECT_FALSE(succeeded); | |
115 | |
116 GpuCommandBufferStub* stub = channel->LookupCommandBuffer(kRouteId); | |
117 EXPECT_FALSE(stub); | |
118 } | |
119 | |
120 TEST_F(GpuChannelTest, CreateOffscreenCommandBuffer) { | |
121 int32_t kClientId = 1; | |
122 GpuChannel* channel = CreateChannel(kClientId, true, false); | |
123 ASSERT_TRUE(channel); | |
124 | |
125 int32_t kRouteId = 1; | |
126 GPUCreateCommandBufferConfig init_params; | |
127 init_params.share_group_id = MSG_ROUTING_NONE; | |
128 init_params.stream_id = 0; | |
129 init_params.stream_priority = gpu::GpuStreamPriority::NORMAL; | |
130 init_params.attribs = std::vector<int>(); | |
131 init_params.active_url = GURL(); | |
132 init_params.gpu_preference = gfx::PreferIntegratedGpu; | |
133 bool succeeded = false; | |
134 HandleMessage(channel, new GpuChannelMsg_CreateCommandBuffer( | |
135 gpu::kNullSurfaceHandle, gfx::Size(1, 1), | |
136 init_params, kRouteId, &succeeded)); | |
137 EXPECT_TRUE(succeeded); | |
138 | |
139 GpuCommandBufferStub* stub = channel->LookupCommandBuffer(kRouteId); | |
140 EXPECT_TRUE(stub); | |
141 } | |
142 | |
143 TEST_F(GpuChannelTest, IncompatibleStreamIds) { | |
144 int32_t kClientId = 1; | |
145 GpuChannel* channel = CreateChannel(kClientId, true, false); | |
146 ASSERT_TRUE(channel); | |
147 | |
148 // Create first context. | |
149 int32_t kRouteId1 = 1; | |
150 int32_t kStreamId1 = 1; | |
151 GPUCreateCommandBufferConfig init_params; | |
152 init_params.share_group_id = MSG_ROUTING_NONE; | |
153 init_params.stream_id = kStreamId1; | |
154 init_params.stream_priority = gpu::GpuStreamPriority::NORMAL; | |
155 init_params.attribs = std::vector<int>(); | |
156 init_params.active_url = GURL(); | |
157 init_params.gpu_preference = gfx::PreferIntegratedGpu; | |
158 bool succeeded = false; | |
159 HandleMessage(channel, new GpuChannelMsg_CreateCommandBuffer( | |
160 gpu::kNullSurfaceHandle, gfx::Size(1, 1), | |
161 init_params, kRouteId1, &succeeded)); | |
162 EXPECT_TRUE(succeeded); | |
163 | |
164 GpuCommandBufferStub* stub = channel->LookupCommandBuffer(kRouteId1); | |
165 EXPECT_TRUE(stub); | |
166 | |
167 // Create second context in same share group but different stream. | |
168 int32_t kRouteId2 = 2; | |
169 int32_t kStreamId2 = 2; | |
170 | |
171 init_params.share_group_id = kRouteId1; | |
172 init_params.stream_id = kStreamId2; | |
173 init_params.stream_priority = gpu::GpuStreamPriority::NORMAL; | |
174 init_params.attribs = std::vector<int>(); | |
175 init_params.active_url = GURL(); | |
176 init_params.gpu_preference = gfx::PreferIntegratedGpu; | |
177 succeeded = false; | |
178 HandleMessage(channel, new GpuChannelMsg_CreateCommandBuffer( | |
179 gpu::kNullSurfaceHandle, gfx::Size(1, 1), | |
180 init_params, kRouteId2, &succeeded)); | |
181 EXPECT_FALSE(succeeded); | |
182 | |
183 stub = channel->LookupCommandBuffer(kRouteId2); | |
184 EXPECT_FALSE(stub); | |
185 } | |
186 | |
187 TEST_F(GpuChannelTest, StreamLifetime) { | |
188 int32_t kClientId = 1; | |
189 GpuChannel* channel = CreateChannel(kClientId, true, false); | |
190 ASSERT_TRUE(channel); | |
191 | |
192 // Create first context. | |
193 int32_t kRouteId1 = 1; | |
194 int32_t kStreamId1 = 1; | |
195 gpu::GpuStreamPriority kStreamPriority1 = gpu::GpuStreamPriority::NORMAL; | |
196 GPUCreateCommandBufferConfig init_params; | |
197 init_params.share_group_id = MSG_ROUTING_NONE; | |
198 init_params.stream_id = kStreamId1; | |
199 init_params.stream_priority = kStreamPriority1; | |
200 init_params.attribs = std::vector<int>(); | |
201 init_params.active_url = GURL(); | |
202 init_params.gpu_preference = gfx::PreferIntegratedGpu; | |
203 bool succeeded = false; | |
204 HandleMessage(channel, new GpuChannelMsg_CreateCommandBuffer( | |
205 gpu::kNullSurfaceHandle, gfx::Size(1, 1), | |
206 init_params, kRouteId1, &succeeded)); | |
207 EXPECT_TRUE(succeeded); | |
208 | |
209 GpuCommandBufferStub* stub = channel->LookupCommandBuffer(kRouteId1); | |
210 EXPECT_TRUE(stub); | |
211 | |
212 HandleMessage(channel, new GpuChannelMsg_DestroyCommandBuffer(kRouteId1)); | |
213 stub = channel->LookupCommandBuffer(kRouteId1); | |
214 EXPECT_FALSE(stub); | |
215 | |
216 // Create second context in same share group but different stream. | |
217 int32_t kRouteId2 = 2; | |
218 int32_t kStreamId2 = 2; | |
219 gpu::GpuStreamPriority kStreamPriority2 = gpu::GpuStreamPriority::LOW; | |
220 | |
221 init_params.share_group_id = MSG_ROUTING_NONE; | |
222 init_params.stream_id = kStreamId2; | |
223 init_params.stream_priority = kStreamPriority2; | |
224 init_params.attribs = std::vector<int>(); | |
225 init_params.active_url = GURL(); | |
226 init_params.gpu_preference = gfx::PreferIntegratedGpu; | |
227 succeeded = false; | |
228 HandleMessage(channel, new GpuChannelMsg_CreateCommandBuffer( | |
229 gpu::kNullSurfaceHandle, gfx::Size(1, 1), | |
230 init_params, kRouteId2, &succeeded)); | |
231 EXPECT_TRUE(succeeded); | |
232 | |
233 stub = channel->LookupCommandBuffer(kRouteId2); | |
234 EXPECT_TRUE(stub); | |
235 } | |
236 | |
237 TEST_F(GpuChannelTest, RealTimeStreamsDisallowed) { | |
238 int32_t kClientId = 1; | |
239 bool allow_real_time_streams = false; | |
240 GpuChannel* channel = CreateChannel(kClientId, true, allow_real_time_streams); | |
241 ASSERT_TRUE(channel); | |
242 | |
243 // Create first context. | |
244 int32_t kRouteId = 1; | |
245 int32_t kStreamId = 1; | |
246 gpu::GpuStreamPriority kStreamPriority = gpu::GpuStreamPriority::REAL_TIME; | |
247 GPUCreateCommandBufferConfig init_params; | |
248 init_params.share_group_id = MSG_ROUTING_NONE; | |
249 init_params.stream_id = kStreamId; | |
250 init_params.stream_priority = kStreamPriority; | |
251 init_params.attribs = std::vector<int>(); | |
252 init_params.active_url = GURL(); | |
253 init_params.gpu_preference = gfx::PreferIntegratedGpu; | |
254 bool succeeded = false; | |
255 HandleMessage(channel, new GpuChannelMsg_CreateCommandBuffer( | |
256 gpu::kNullSurfaceHandle, gfx::Size(1, 1), | |
257 init_params, kRouteId, &succeeded)); | |
258 EXPECT_FALSE(succeeded); | |
259 | |
260 GpuCommandBufferStub* stub = channel->LookupCommandBuffer(kRouteId); | |
261 EXPECT_FALSE(stub); | |
262 } | |
263 | |
264 TEST_F(GpuChannelTest, RealTimeStreamsAllowed) { | |
265 int32_t kClientId = 1; | |
266 bool allow_real_time_streams = true; | |
267 GpuChannel* channel = CreateChannel(kClientId, true, allow_real_time_streams); | |
268 ASSERT_TRUE(channel); | |
269 | |
270 // Create first context. | |
271 int32_t kRouteId = 1; | |
272 int32_t kStreamId = 1; | |
273 gpu::GpuStreamPriority kStreamPriority = gpu::GpuStreamPriority::REAL_TIME; | |
274 GPUCreateCommandBufferConfig init_params; | |
275 init_params.share_group_id = MSG_ROUTING_NONE; | |
276 init_params.stream_id = kStreamId; | |
277 init_params.stream_priority = kStreamPriority; | |
278 init_params.attribs = std::vector<int>(); | |
279 init_params.active_url = GURL(); | |
280 init_params.gpu_preference = gfx::PreferIntegratedGpu; | |
281 bool succeeded = false; | |
282 HandleMessage(channel, new GpuChannelMsg_CreateCommandBuffer( | |
283 gpu::kNullSurfaceHandle, gfx::Size(1, 1), | |
284 init_params, kRouteId, &succeeded)); | |
285 EXPECT_TRUE(succeeded); | |
286 | |
287 GpuCommandBufferStub* stub = channel->LookupCommandBuffer(kRouteId); | |
288 EXPECT_TRUE(stub); | |
289 } | |
290 | |
291 } // namespace content | |
OLD | NEW |