OLD | NEW |
| (Empty) |
1 // Copyright (c) 2012 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 <vector> | |
6 | |
7 #include "base/base_paths.h" | |
8 #include "base/file_path.h" | |
9 #include "base/file_util.h" | |
10 #include "base/memory/scoped_ptr.h" | |
11 #include "base/path_service.h" | |
12 #include "base/version.h" | |
13 #include "content/browser/gpu/gpu_blacklist.h" | |
14 #include "content/public/common/gpu_info.h" | |
15 #include "testing/gtest/include/gtest/gtest.h" | |
16 | |
17 using content::GpuFeatureType; | |
18 | |
19 class GpuBlacklistTest : public testing::Test { | |
20 public: | |
21 GpuBlacklistTest() { } | |
22 | |
23 virtual ~GpuBlacklistTest() { } | |
24 | |
25 const content::GPUInfo& gpu_info() const { | |
26 return gpu_info_; | |
27 } | |
28 | |
29 GpuBlacklist* Create() { | |
30 return new GpuBlacklist(); | |
31 } | |
32 | |
33 protected: | |
34 void SetUp() { | |
35 gpu_info_.gpu.vendor_id = 0x10de; | |
36 gpu_info_.gpu.device_id = 0x0640; | |
37 gpu_info_.driver_vendor = "NVIDIA"; | |
38 gpu_info_.driver_version = "1.6.18"; | |
39 gpu_info_.driver_date = "7-14-2009"; | |
40 gpu_info_.gl_vendor = "NVIDIA Corporation"; | |
41 gpu_info_.gl_renderer = "NVIDIA GeForce GT 120 OpenGL Engine"; | |
42 gpu_info_.performance_stats.graphics = 5.0; | |
43 gpu_info_.performance_stats.gaming = 5.0; | |
44 gpu_info_.performance_stats.overall = 5.0; | |
45 } | |
46 | |
47 void TearDown() { | |
48 } | |
49 | |
50 private: | |
51 content::GPUInfo gpu_info_; | |
52 }; | |
53 | |
54 TEST_F(GpuBlacklistTest, CurrentBlacklistValidation) { | |
55 FilePath data_file; | |
56 ASSERT_TRUE(PathService::Get(base::DIR_SOURCE_ROOT, &data_file)); | |
57 data_file = | |
58 data_file.Append(FILE_PATH_LITERAL("chrome")) | |
59 .Append(FILE_PATH_LITERAL("browser")) | |
60 .Append(FILE_PATH_LITERAL("resources")) | |
61 .Append(FILE_PATH_LITERAL("software_rendering_list.json")); | |
62 ASSERT_TRUE(file_util::PathExists(data_file)); | |
63 int64 data_file_size64 = 0; | |
64 ASSERT_TRUE(file_util::GetFileSize(data_file, &data_file_size64)); | |
65 int data_file_size = static_cast<int>(data_file_size64); | |
66 scoped_array<char> data(new char[data_file_size]); | |
67 ASSERT_EQ(file_util::ReadFile(data_file, data.get(), data_file_size), | |
68 data_file_size); | |
69 std::string json_string(data.get(), data_file_size); | |
70 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
71 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
72 json_string, GpuBlacklist::kAllOs)); | |
73 EXPECT_FALSE(blacklist->contains_unknown_fields()); | |
74 } | |
75 | |
76 TEST_F(GpuBlacklistTest, DefaultBlacklistSettings) { | |
77 Version os_version("10.6.4"); | |
78 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
79 // Default blacklist settings: all feature are allowed. | |
80 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
81 GpuBlacklist::kOsMacosx, &os_version, gpu_info()); | |
82 EXPECT_EQ(type, 0); | |
83 } | |
84 | |
85 TEST_F(GpuBlacklistTest, EmptyBlacklist) { | |
86 // Empty list: all features are allowed. | |
87 const std::string empty_list_json = | |
88 "{\n" | |
89 " \"name\": \"gpu blacklist\",\n" | |
90 " \"version\": \"2.5\",\n" | |
91 " \"entries\": [\n" | |
92 " ]\n" | |
93 "}"; | |
94 Version os_version("10.6.4"); | |
95 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
96 | |
97 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
98 empty_list_json, GpuBlacklist::kAllOs)); | |
99 EXPECT_EQ(blacklist->GetVersion(), std::string("2.5")); | |
100 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
101 GpuBlacklist::kOsMacosx, &os_version, gpu_info()); | |
102 EXPECT_EQ(type, 0); | |
103 } | |
104 | |
105 TEST_F(GpuBlacklistTest, DetailedEntryAndInvalidJson) { | |
106 // Blacklist accelerated_compositing with exact setting. | |
107 const std::string exact_list_json = | |
108 "{\n" | |
109 " \"name\": \"gpu blacklist\",\n" | |
110 " \"version\": \"0.1\",\n" | |
111 " \"entries\": [\n" | |
112 " {\n" | |
113 " \"id\": 5,\n" | |
114 " \"os\": {\n" | |
115 " \"type\": \"macosx\",\n" | |
116 " \"version\": {\n" | |
117 " \"op\": \"=\",\n" | |
118 " \"number\": \"10.6.4\"\n" | |
119 " }\n" | |
120 " },\n" | |
121 " \"vendor_id\": \"0x10de\",\n" | |
122 " \"device_id\": [\"0x0640\"],\n" | |
123 " \"driver_version\": {\n" | |
124 " \"op\": \"=\",\n" | |
125 " \"number\": \"1.6.18\"\n" | |
126 " },\n" | |
127 " \"blacklist\": [\n" | |
128 " \"accelerated_compositing\"\n" | |
129 " ]\n" | |
130 " }\n" | |
131 " ]\n" | |
132 "}"; | |
133 Version os_version("10.6.4"); | |
134 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
135 | |
136 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
137 exact_list_json, GpuBlacklist::kAllOs)); | |
138 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
139 GpuBlacklist::kOsMacosx, &os_version, gpu_info()); | |
140 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING); | |
141 | |
142 // Invalid json input should not change the current blacklist settings. | |
143 const std::string invalid_json = "invalid"; | |
144 | |
145 EXPECT_FALSE(blacklist->LoadGpuBlacklist( | |
146 invalid_json, GpuBlacklist::kAllOs)); | |
147 type = blacklist->DetermineGpuFeatureType( | |
148 GpuBlacklist::kOsMacosx, &os_version, gpu_info()); | |
149 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING); | |
150 std::vector<uint32> entries; | |
151 bool disabled = false; | |
152 blacklist->GetGpuFeatureTypeEntries( | |
153 content::GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING, entries, disabled); | |
154 EXPECT_EQ(entries.size(), 1u); | |
155 EXPECT_EQ(entries[0], 5u); | |
156 blacklist->GetGpuFeatureTypeEntries( | |
157 content::GPU_FEATURE_TYPE_ALL, entries, disabled); | |
158 EXPECT_EQ(entries.size(), 1u); | |
159 EXPECT_EQ(entries[0], 5u); | |
160 EXPECT_EQ(blacklist->max_entry_id(), 5u); | |
161 } | |
162 | |
163 TEST_F(GpuBlacklistTest, VendorOnAllOsEntry) { | |
164 // Blacklist a vendor on all OS. | |
165 const std::string vendor_json = | |
166 "{\n" | |
167 " \"name\": \"gpu blacklist\",\n" | |
168 " \"version\": \"0.1\",\n" | |
169 " \"entries\": [\n" | |
170 " {\n" | |
171 " \"id\": 1,\n" | |
172 " \"vendor_id\": \"0x10de\",\n" | |
173 " \"blacklist\": [\n" | |
174 " \"webgl\"\n" | |
175 " ]\n" | |
176 " }\n" | |
177 " ]\n" | |
178 "}"; | |
179 Version os_version("10.6.4"); | |
180 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
181 | |
182 // Blacklist entries won't be filtered to the current OS only upon loading. | |
183 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
184 vendor_json, GpuBlacklist::kAllOs)); | |
185 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
186 GpuBlacklist::kOsMacosx, &os_version, gpu_info()); | |
187 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
188 type = blacklist->DetermineGpuFeatureType( | |
189 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
190 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
191 type = blacklist->DetermineGpuFeatureType( | |
192 GpuBlacklist::kOsLinux, &os_version, gpu_info()); | |
193 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
194 #if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_MACOSX) || \ | |
195 defined(OS_OPENBSD) | |
196 // Blacklist entries will be filtered to the current OS only upon loading. | |
197 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
198 vendor_json, GpuBlacklist::kCurrentOsOnly)); | |
199 type = blacklist->DetermineGpuFeatureType( | |
200 GpuBlacklist::kOsMacosx, &os_version, gpu_info()); | |
201 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
202 type = blacklist->DetermineGpuFeatureType( | |
203 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
204 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
205 type = blacklist->DetermineGpuFeatureType( | |
206 GpuBlacklist::kOsLinux, &os_version, gpu_info()); | |
207 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
208 #endif | |
209 } | |
210 | |
211 TEST_F(GpuBlacklistTest, VendorOnLinuxEntry) { | |
212 // Blacklist a vendor on Linux only. | |
213 const std::string vendor_linux_json = | |
214 "{\n" | |
215 " \"name\": \"gpu blacklist\",\n" | |
216 " \"version\": \"0.1\",\n" | |
217 " \"entries\": [\n" | |
218 " {\n" | |
219 " \"id\": 1,\n" | |
220 " \"os\": {\n" | |
221 " \"type\": \"linux\"\n" | |
222 " },\n" | |
223 " \"vendor_id\": \"0x10de\",\n" | |
224 " \"blacklist\": [\n" | |
225 " \"accelerated_2d_canvas\"\n" | |
226 " ]\n" | |
227 " }\n" | |
228 " ]\n" | |
229 "}"; | |
230 Version os_version("10.6.4"); | |
231 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
232 | |
233 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
234 vendor_linux_json, GpuBlacklist::kAllOs)); | |
235 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
236 GpuBlacklist::kOsMacosx, &os_version, gpu_info()); | |
237 EXPECT_EQ(type, 0); | |
238 type = blacklist->DetermineGpuFeatureType( | |
239 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
240 EXPECT_EQ(type, 0); | |
241 type = blacklist->DetermineGpuFeatureType( | |
242 GpuBlacklist::kOsLinux, &os_version, gpu_info()); | |
243 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS); | |
244 } | |
245 | |
246 TEST_F(GpuBlacklistTest, AllExceptNVidiaOnLinuxEntry) { | |
247 // Blacklist all cards in Linux except NVIDIA. | |
248 const std::string linux_except_nvidia_json = | |
249 "{\n" | |
250 " \"name\": \"gpu blacklist\",\n" | |
251 " \"version\": \"0.1\",\n" | |
252 " \"entries\": [\n" | |
253 " {\n" | |
254 " \"id\": 1,\n" | |
255 " \"os\": {\n" | |
256 " \"type\": \"linux\"\n" | |
257 " },\n" | |
258 " \"exceptions\": [\n" | |
259 " {\n" | |
260 " \"vendor_id\": \"0x10de\"\n" | |
261 " }\n" | |
262 " ],\n" | |
263 " \"blacklist\": [\n" | |
264 " \"accelerated_2d_canvas\"\n" | |
265 " ]\n" | |
266 " }\n" | |
267 " ]\n" | |
268 "}"; | |
269 Version os_version("10.6.4"); | |
270 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
271 | |
272 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
273 linux_except_nvidia_json, GpuBlacklist::kAllOs)); | |
274 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
275 GpuBlacklist::kOsMacosx, &os_version, gpu_info()); | |
276 EXPECT_EQ(type, 0); | |
277 type = blacklist->DetermineGpuFeatureType( | |
278 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
279 EXPECT_EQ(type, 0); | |
280 type = blacklist->DetermineGpuFeatureType( | |
281 GpuBlacklist::kOsLinux, &os_version, gpu_info()); | |
282 EXPECT_EQ(type, 0); | |
283 } | |
284 | |
285 TEST_F(GpuBlacklistTest, AllExceptIntelOnLinuxEntry) { | |
286 // Blacklist all cards in Linux except Intel. | |
287 const std::string linux_except_intel_json = | |
288 "{\n" | |
289 " \"name\": \"gpu blacklist\",\n" | |
290 " \"version\": \"0.1\",\n" | |
291 " \"entries\": [\n" | |
292 " {\n" | |
293 " \"id\": 1,\n" | |
294 " \"os\": {\n" | |
295 " \"type\": \"linux\"\n" | |
296 " },\n" | |
297 " \"exceptions\": [\n" | |
298 " {\n" | |
299 " \"vendor_id\": \"0x8086\"\n" | |
300 " }\n" | |
301 " ],\n" | |
302 " \"blacklist\": [\n" | |
303 " \"accelerated_2d_canvas\"\n" | |
304 " ]\n" | |
305 " }\n" | |
306 " ]\n" | |
307 "}"; | |
308 Version os_version("10.6.4"); | |
309 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
310 | |
311 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
312 linux_except_intel_json, GpuBlacklist::kAllOs)); | |
313 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
314 GpuBlacklist::kOsMacosx, &os_version, gpu_info()); | |
315 EXPECT_EQ(type, 0); | |
316 type = blacklist->DetermineGpuFeatureType( | |
317 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
318 EXPECT_EQ(type, 0); | |
319 type = blacklist->DetermineGpuFeatureType( | |
320 GpuBlacklist::kOsLinux, &os_version, gpu_info()); | |
321 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS); | |
322 } | |
323 | |
324 TEST_F(GpuBlacklistTest, DateOnWindowsEntry) { | |
325 // Blacklist all drivers earlier than 2010-01 in Windows. | |
326 const std::string date_windows_json = | |
327 "{\n" | |
328 " \"name\": \"gpu blacklist\",\n" | |
329 " \"version\": \"0.1\",\n" | |
330 " \"entries\": [\n" | |
331 " {\n" | |
332 " \"id\": 1,\n" | |
333 " \"os\": {\n" | |
334 " \"type\": \"win\"\n" | |
335 " },\n" | |
336 " \"driver_date\": {\n" | |
337 " \"op\": \"<\",\n" | |
338 " \"number\": \"2010.1\"\n" | |
339 " },\n" | |
340 " \"blacklist\": [\n" | |
341 " \"accelerated_2d_canvas\"\n" | |
342 " ]\n" | |
343 " }\n" | |
344 " ]\n" | |
345 "}"; | |
346 Version os_version("10.6.4"); | |
347 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
348 | |
349 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
350 date_windows_json, GpuBlacklist::kAllOs)); | |
351 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
352 GpuBlacklist::kOsMacosx, &os_version, gpu_info()); | |
353 EXPECT_EQ(type, 0); | |
354 type = blacklist->DetermineGpuFeatureType( | |
355 GpuBlacklist::kOsLinux, &os_version, gpu_info()); | |
356 EXPECT_EQ(type, 0); | |
357 type = blacklist->DetermineGpuFeatureType( | |
358 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
359 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_2D_CANVAS); | |
360 } | |
361 | |
362 TEST_F(GpuBlacklistTest, MultipleDevicesEntry) { | |
363 const std::string devices_json = | |
364 "{\n" | |
365 " \"name\": \"gpu blacklist\",\n" | |
366 " \"version\": \"0.1\",\n" | |
367 " \"entries\": [\n" | |
368 " {\n" | |
369 " \"id\": 1,\n" | |
370 " \"vendor_id\": \"0x10de\",\n" | |
371 " \"device_id\": [\"0x1023\", \"0x0640\"],\n" | |
372 " \"blacklist\": [\n" | |
373 " \"multisampling\"\n" | |
374 " ]\n" | |
375 " }\n" | |
376 " ]\n" | |
377 "}"; | |
378 Version os_version("10.6.4"); | |
379 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
380 | |
381 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
382 devices_json, GpuBlacklist::kAllOs)); | |
383 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
384 GpuBlacklist::kOsMacosx, &os_version, gpu_info()); | |
385 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_MULTISAMPLING); | |
386 type = blacklist->DetermineGpuFeatureType( | |
387 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
388 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_MULTISAMPLING); | |
389 type = blacklist->DetermineGpuFeatureType( | |
390 GpuBlacklist::kOsLinux, &os_version, gpu_info()); | |
391 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_MULTISAMPLING); | |
392 } | |
393 | |
394 TEST_F(GpuBlacklistTest, ChromeOSEntry) { | |
395 const std::string devices_json = | |
396 "{\n" | |
397 " \"name\": \"gpu blacklist\",\n" | |
398 " \"version\": \"0.1\",\n" | |
399 " \"entries\": [\n" | |
400 " {\n" | |
401 " \"id\": 1,\n" | |
402 " \"os\": {\n" | |
403 " \"type\": \"chromeos\"\n" | |
404 " },\n" | |
405 " \"blacklist\": [\n" | |
406 " \"webgl\"\n" | |
407 " ]\n" | |
408 " }\n" | |
409 " ]\n" | |
410 "}"; | |
411 Version os_version("10.6.4"); | |
412 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
413 | |
414 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
415 devices_json, GpuBlacklist::kAllOs)); | |
416 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
417 GpuBlacklist::kOsChromeOS, &os_version, gpu_info()); | |
418 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
419 type = blacklist->DetermineGpuFeatureType( | |
420 GpuBlacklist::kOsLinux, &os_version, gpu_info()); | |
421 EXPECT_EQ(type, 0); | |
422 } | |
423 | |
424 TEST_F(GpuBlacklistTest, ChromeVersionEntry) { | |
425 const std::string browser_version_json = | |
426 "{\n" | |
427 " \"name\": \"gpu blacklist\",\n" | |
428 " \"version\": \"0.1\",\n" | |
429 " \"entries\": [\n" | |
430 " {\n" | |
431 " \"id\": 1,\n" | |
432 " \"browser_version\": {\n" | |
433 " \"op\": \">=\",\n" | |
434 " \"number\": \"10\"\n" | |
435 " },\n" | |
436 " \"blacklist\": [\n" | |
437 " \"webgl\"\n" | |
438 " ]\n" | |
439 " }\n" | |
440 " ]\n" | |
441 "}"; | |
442 Version os_version("10.6.4"); | |
443 | |
444 scoped_ptr<GpuBlacklist> blacklist9(Create()); | |
445 EXPECT_TRUE(blacklist9->LoadGpuBlacklist( | |
446 "9.0", browser_version_json, GpuBlacklist::kAllOs)); | |
447 GpuFeatureType type = blacklist9->DetermineGpuFeatureType( | |
448 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
449 EXPECT_EQ(type, 0); | |
450 | |
451 scoped_ptr<GpuBlacklist> blacklist10(Create()); | |
452 EXPECT_TRUE(blacklist10->LoadGpuBlacklist( | |
453 "10.0", browser_version_json, GpuBlacklist::kAllOs)); | |
454 type = blacklist10->DetermineGpuFeatureType( | |
455 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
456 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
457 } | |
458 | |
459 TEST_F(GpuBlacklistTest, MalformedVendor) { | |
460 // vendor_id is defined as list instead of string. | |
461 const std::string malformed_vendor_json = | |
462 "{\n" | |
463 " \"name\": \"gpu blacklist\",\n" | |
464 " \"version\": \"0.1\",\n" | |
465 " \"entries\": [\n" | |
466 " {\n" | |
467 " \"id\": 1,\n" | |
468 " \"vendor_id\": \"[0x10de]\",\n" | |
469 " \"blacklist\": [\n" | |
470 " \"accelerated_2d_canvas\"\n" | |
471 " ]\n" | |
472 " }\n" | |
473 " ]\n" | |
474 "}"; | |
475 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
476 | |
477 EXPECT_FALSE(blacklist->LoadGpuBlacklist( | |
478 malformed_vendor_json, GpuBlacklist::kAllOs)); | |
479 } | |
480 | |
481 TEST_F(GpuBlacklistTest, UnknownField) { | |
482 const std::string unknown_field_json = | |
483 "{\n" | |
484 " \"name\": \"gpu blacklist\",\n" | |
485 " \"version\": \"0.1\",\n" | |
486 " \"entries\": [\n" | |
487 " {\n" | |
488 " \"id\": 1,\n" | |
489 " \"unknown_field\": 0,\n" | |
490 " \"blacklist\": [\n" | |
491 " \"accelerated_2d_canvas\"\n" | |
492 " ]\n" | |
493 " },\n" | |
494 " {\n" | |
495 " \"id\": 2,\n" | |
496 " \"blacklist\": [\n" | |
497 " \"webgl\"\n" | |
498 " ]\n" | |
499 " }\n" | |
500 " ]\n" | |
501 "}"; | |
502 Version os_version("10.6.4"); | |
503 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
504 | |
505 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
506 unknown_field_json, GpuBlacklist::kAllOs)); | |
507 EXPECT_EQ(1u, blacklist->num_entries()); | |
508 EXPECT_TRUE(blacklist->contains_unknown_fields()); | |
509 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
510 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
511 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
512 } | |
513 | |
514 TEST_F(GpuBlacklistTest, UnknownExceptionField) { | |
515 const std::string unknown_exception_field_json = | |
516 "{\n" | |
517 " \"name\": \"gpu blacklist\",\n" | |
518 " \"version\": \"0.1\",\n" | |
519 " \"entries\": [\n" | |
520 " {\n" | |
521 " \"id\": 1,\n" | |
522 " \"unknown_field\": 0,\n" | |
523 " \"blacklist\": [\n" | |
524 " \"accelerated_compositing\"\n" | |
525 " ]\n" | |
526 " },\n" | |
527 " {\n" | |
528 " \"id\": 2,\n" | |
529 " \"exceptions\": [\n" | |
530 " {\n" | |
531 " \"unknown_field\": 0\n" | |
532 " }\n" | |
533 " ],\n" | |
534 " \"blacklist\": [\n" | |
535 " \"accelerated_2d_canvas\"\n" | |
536 " ]\n" | |
537 " },\n" | |
538 " {\n" | |
539 " \"id\": 3,\n" | |
540 " \"blacklist\": [\n" | |
541 " \"webgl\"\n" | |
542 " ]\n" | |
543 " }\n" | |
544 " ]\n" | |
545 "}"; | |
546 Version os_version("10.6.4"); | |
547 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
548 | |
549 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
550 unknown_exception_field_json, GpuBlacklist::kAllOs)); | |
551 EXPECT_EQ(1u, blacklist->num_entries()); | |
552 EXPECT_TRUE(blacklist->contains_unknown_fields()); | |
553 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
554 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
555 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
556 } | |
557 | |
558 TEST_F(GpuBlacklistTest, UnknownFeature) { | |
559 const std::string unknown_feature_json = | |
560 "{\n" | |
561 " \"name\": \"gpu blacklist\",\n" | |
562 " \"version\": \"0.1\",\n" | |
563 " \"entries\": [\n" | |
564 " {\n" | |
565 " \"id\": 1,\n" | |
566 " \"blacklist\": [\n" | |
567 " \"accelerated_something\",\n" | |
568 " \"webgl\"\n" | |
569 " ]\n" | |
570 " }\n" | |
571 " ]\n" | |
572 "}"; | |
573 Version os_version("10.6.4"); | |
574 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
575 | |
576 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
577 unknown_feature_json, GpuBlacklist::kAllOs)); | |
578 EXPECT_EQ(1u, blacklist->num_entries()); | |
579 EXPECT_TRUE(blacklist->contains_unknown_fields()); | |
580 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
581 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
582 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
583 } | |
584 | |
585 TEST_F(GpuBlacklistTest, GlVendor) { | |
586 const std::string gl_vendor_json = | |
587 "{\n" | |
588 " \"name\": \"gpu blacklist\",\n" | |
589 " \"version\": \"0.1\",\n" | |
590 " \"entries\": [\n" | |
591 " {\n" | |
592 " \"id\": 1,\n" | |
593 " \"gl_vendor\": {\n" | |
594 " \"op\": \"beginwith\",\n" | |
595 " \"value\": \"NVIDIA\"\n" | |
596 " },\n" | |
597 " \"blacklist\": [\n" | |
598 " \"webgl\"\n" | |
599 " ]\n" | |
600 " }\n" | |
601 " ]\n" | |
602 "}"; | |
603 Version os_version("10.6.4"); | |
604 | |
605 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
606 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
607 gl_vendor_json, GpuBlacklist::kAllOs)); | |
608 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
609 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
610 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
611 } | |
612 | |
613 TEST_F(GpuBlacklistTest, GlRenderer) { | |
614 const std::string gl_renderer_json = | |
615 "{\n" | |
616 " \"name\": \"gpu blacklist\",\n" | |
617 " \"version\": \"0.1\",\n" | |
618 " \"entries\": [\n" | |
619 " {\n" | |
620 " \"id\": 1,\n" | |
621 " \"gl_renderer\": {\n" | |
622 " \"op\": \"contains\",\n" | |
623 " \"value\": \"GeForce\"\n" | |
624 " },\n" | |
625 " \"blacklist\": [\n" | |
626 " \"webgl\"\n" | |
627 " ]\n" | |
628 " }\n" | |
629 " ]\n" | |
630 "}"; | |
631 Version os_version("10.6.4"); | |
632 | |
633 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
634 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
635 gl_renderer_json, GpuBlacklist::kAllOs)); | |
636 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
637 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
638 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
639 } | |
640 | |
641 TEST_F(GpuBlacklistTest, PerfGraphics) { | |
642 const std::string json = | |
643 "{\n" | |
644 " \"name\": \"gpu blacklist\",\n" | |
645 " \"version\": \"0.1\",\n" | |
646 " \"entries\": [\n" | |
647 " {\n" | |
648 " \"id\": 1,\n" | |
649 " \"perf_graphics\": {\n" | |
650 " \"op\": \"<\",\n" | |
651 " \"value\": \"6.0\"\n" | |
652 " },\n" | |
653 " \"blacklist\": [\n" | |
654 " \"webgl\"\n" | |
655 " ]\n" | |
656 " }\n" | |
657 " ]\n" | |
658 "}"; | |
659 Version os_version("10.6.4"); | |
660 | |
661 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
662 EXPECT_TRUE(blacklist->LoadGpuBlacklist(json, GpuBlacklist::kAllOs)); | |
663 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
664 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
665 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
666 } | |
667 | |
668 TEST_F(GpuBlacklistTest, PerfGaming) { | |
669 const std::string json = | |
670 "{\n" | |
671 " \"name\": \"gpu blacklist\",\n" | |
672 " \"version\": \"0.1\",\n" | |
673 " \"entries\": [\n" | |
674 " {\n" | |
675 " \"id\": 1,\n" | |
676 " \"perf_gaming\": {\n" | |
677 " \"op\": \"<=\",\n" | |
678 " \"value\": \"4.0\"\n" | |
679 " },\n" | |
680 " \"blacklist\": [\n" | |
681 " \"webgl\"\n" | |
682 " ]\n" | |
683 " }\n" | |
684 " ]\n" | |
685 "}"; | |
686 Version os_version("10.6.4"); | |
687 | |
688 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
689 EXPECT_TRUE(blacklist->LoadGpuBlacklist(json, GpuBlacklist::kAllOs)); | |
690 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
691 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
692 EXPECT_EQ(type, 0); | |
693 } | |
694 | |
695 TEST_F(GpuBlacklistTest, PerfOverall) { | |
696 const std::string json = | |
697 "{\n" | |
698 " \"name\": \"gpu blacklist\",\n" | |
699 " \"version\": \"0.1\",\n" | |
700 " \"entries\": [\n" | |
701 " {\n" | |
702 " \"id\": 1,\n" | |
703 " \"perf_overall\": {\n" | |
704 " \"op\": \"between\",\n" | |
705 " \"value\": \"1.0\",\n" | |
706 " \"value2\": \"9.0\"\n" | |
707 " },\n" | |
708 " \"blacklist\": [\n" | |
709 " \"webgl\"\n" | |
710 " ]\n" | |
711 " }\n" | |
712 " ]\n" | |
713 "}"; | |
714 Version os_version("10.6.4"); | |
715 | |
716 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
717 EXPECT_TRUE(blacklist->LoadGpuBlacklist(json, GpuBlacklist::kAllOs)); | |
718 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
719 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
720 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
721 } | |
722 | |
723 TEST_F(GpuBlacklistTest, DisabledEntry) { | |
724 const std::string disabled_json = | |
725 "{\n" | |
726 " \"name\": \"gpu blacklist\",\n" | |
727 " \"version\": \"0.1\",\n" | |
728 " \"entries\": [\n" | |
729 " {\n" | |
730 " \"id\": 1,\n" | |
731 " \"disabled\": true,\n" | |
732 " \"blacklist\": [\n" | |
733 " \"webgl\"\n" | |
734 " ]\n" | |
735 " }\n" | |
736 " ]\n" | |
737 "}"; | |
738 Version os_version("10.6.4"); | |
739 | |
740 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
741 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
742 disabled_json, GpuBlacklist::kAllOs)); | |
743 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
744 GpuBlacklist::kOsWin, &os_version, gpu_info()); | |
745 EXPECT_EQ(type, 0); | |
746 std::vector<uint32> flag_entries; | |
747 bool disabled = false; | |
748 blacklist->GetGpuFeatureTypeEntries( | |
749 content::GPU_FEATURE_TYPE_ALL, flag_entries, disabled); | |
750 EXPECT_EQ(flag_entries.size(), 0u); | |
751 disabled = true; | |
752 blacklist->GetGpuFeatureTypeEntries( | |
753 content::GPU_FEATURE_TYPE_ALL, flag_entries, disabled); | |
754 EXPECT_EQ(flag_entries.size(), 1u); | |
755 } | |
756 | |
757 TEST_F(GpuBlacklistTest, Optimus) { | |
758 const std::string optimus_json = | |
759 "{\n" | |
760 " \"name\": \"gpu blacklist\",\n" | |
761 " \"version\": \"0.1\",\n" | |
762 " \"entries\": [\n" | |
763 " {\n" | |
764 " \"id\": 1,\n" | |
765 " \"os\": {\n" | |
766 " \"type\": \"linux\"\n" | |
767 " },\n" | |
768 " \"multi_gpu_style\": \"optimus\",\n" | |
769 " \"blacklist\": [\n" | |
770 " \"webgl\"\n" | |
771 " ]\n" | |
772 " }\n" | |
773 " ]\n" | |
774 "}"; | |
775 Version os_version("10.6.4"); | |
776 | |
777 content::GPUInfo gpu_info; | |
778 gpu_info.optimus = true; | |
779 | |
780 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
781 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
782 optimus_json, GpuBlacklist::kAllOs)); | |
783 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
784 GpuBlacklist::kOsLinux, &os_version, gpu_info); | |
785 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
786 } | |
787 | |
788 TEST_F(GpuBlacklistTest, AMDSwitchable) { | |
789 const std::string amd_switchable_json = | |
790 "{\n" | |
791 " \"name\": \"gpu blacklist\",\n" | |
792 " \"version\": \"0.1\",\n" | |
793 " \"entries\": [\n" | |
794 " {\n" | |
795 " \"id\": 1,\n" | |
796 " \"os\": {\n" | |
797 " \"type\": \"macosx\"\n" | |
798 " },\n" | |
799 " \"multi_gpu_style\": \"amd_switchable\",\n" | |
800 " \"blacklist\": [\n" | |
801 " \"webgl\"\n" | |
802 " ]\n" | |
803 " }\n" | |
804 " ]\n" | |
805 "}"; | |
806 Version os_version("10.6.4"); | |
807 | |
808 content::GPUInfo gpu_info; | |
809 gpu_info.amd_switchable = true; | |
810 | |
811 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
812 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
813 amd_switchable_json, GpuBlacklist::kAllOs)); | |
814 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
815 GpuBlacklist::kOsMacosx, &os_version, gpu_info); | |
816 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
817 } | |
818 | |
819 TEST_F(GpuBlacklistTest, LexicalDriverVersion) { | |
820 const std::string lexical_json = | |
821 "{\n" | |
822 " \"name\": \"gpu blacklist\",\n" | |
823 " \"version\": \"0.1\",\n" | |
824 " \"entries\": [\n" | |
825 " {\n" | |
826 " \"id\": 1,\n" | |
827 " \"os\": {\n" | |
828 " \"type\": \"linux\"\n" | |
829 " },\n" | |
830 " \"vendor_id\": \"0x1002\",\n" | |
831 " \"driver_version\": {\n" | |
832 " \"op\": \"<\",\n" | |
833 " \"style\": \"lexical\",\n" | |
834 " \"number\": \"8.201\"\n" | |
835 " },\n" | |
836 " \"blacklist\": [\n" | |
837 " \"webgl\"\n" | |
838 " ]\n" | |
839 " }\n" | |
840 " ]\n" | |
841 "}"; | |
842 Version os_version("10.6.4"); | |
843 | |
844 content::GPUInfo gpu_info; | |
845 gpu_info.gpu.vendor_id = 0x1002; | |
846 | |
847 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
848 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
849 lexical_json, GpuBlacklist::kAllOs)); | |
850 | |
851 gpu_info.driver_version = "8.109"; | |
852 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
853 GpuBlacklist::kOsLinux, &os_version, gpu_info); | |
854 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
855 | |
856 gpu_info.driver_version = "8.2"; | |
857 type = blacklist->DetermineGpuFeatureType( | |
858 GpuBlacklist::kOsLinux, &os_version, gpu_info); | |
859 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
860 | |
861 gpu_info.driver_version = "8.21"; | |
862 type = blacklist->DetermineGpuFeatureType( | |
863 GpuBlacklist::kOsLinux, &os_version, gpu_info); | |
864 EXPECT_EQ(type, 0); | |
865 | |
866 gpu_info.driver_version = "8.2010"; | |
867 type = blacklist->DetermineGpuFeatureType( | |
868 GpuBlacklist::kOsLinux, &os_version, gpu_info); | |
869 EXPECT_EQ(type, 0); | |
870 } | |
871 | |
872 TEST_F(GpuBlacklistTest, MultipleGPUsAny) { | |
873 const std::string multi_gpu_json = | |
874 "{\n" | |
875 " \"name\": \"gpu blacklist\",\n" | |
876 " \"version\": \"0.1\",\n" | |
877 " \"entries\": [\n" | |
878 " {\n" | |
879 " \"id\": 1,\n" | |
880 " \"os\": {\n" | |
881 " \"type\": \"macosx\"\n" | |
882 " },\n" | |
883 " \"vendor_id\": \"0x8086\",\n" | |
884 " \"device_id\": [\"0x0166\"],\n" | |
885 " \"multi_gpu_category\": \"any\",\n" | |
886 " \"blacklist\": [\n" | |
887 " \"webgl\"\n" | |
888 " ]\n" | |
889 " }\n" | |
890 " ]\n" | |
891 "}"; | |
892 Version os_version("10.6.4"); | |
893 | |
894 content::GPUInfo gpu_info; | |
895 gpu_info.gpu.vendor_id = 0x10de; | |
896 gpu_info.gpu.device_id = 0x0fd5; | |
897 | |
898 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
899 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
900 multi_gpu_json, GpuBlacklist::kAllOs)); | |
901 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
902 GpuBlacklist::kOsMacosx, &os_version, gpu_info); | |
903 EXPECT_EQ(type, 0); | |
904 | |
905 content::GPUInfo::GPUDevice gpu_device; | |
906 gpu_device.vendor_id = 0x8086; | |
907 gpu_device.device_id = 0x0166; | |
908 gpu_info.secondary_gpus.push_back(gpu_device); | |
909 type = blacklist->DetermineGpuFeatureType( | |
910 GpuBlacklist::kOsMacosx, &os_version, gpu_info); | |
911 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
912 } | |
913 | |
914 TEST_F(GpuBlacklistTest, MultipleGPUsSecondary) { | |
915 const std::string multi_gpu_json = | |
916 "{\n" | |
917 " \"name\": \"gpu blacklist\",\n" | |
918 " \"version\": \"0.1\",\n" | |
919 " \"entries\": [\n" | |
920 " {\n" | |
921 " \"id\": 1,\n" | |
922 " \"os\": {\n" | |
923 " \"type\": \"macosx\"\n" | |
924 " },\n" | |
925 " \"vendor_id\": \"0x8086\",\n" | |
926 " \"device_id\": [\"0x0166\"],\n" | |
927 " \"multi_gpu_category\": \"secondary\",\n" | |
928 " \"blacklist\": [\n" | |
929 " \"webgl\"\n" | |
930 " ]\n" | |
931 " }\n" | |
932 " ]\n" | |
933 "}"; | |
934 Version os_version("10.6.4"); | |
935 | |
936 content::GPUInfo gpu_info; | |
937 gpu_info.gpu.vendor_id = 0x10de; | |
938 gpu_info.gpu.device_id = 0x0fd5; | |
939 | |
940 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
941 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
942 multi_gpu_json, GpuBlacklist::kAllOs)); | |
943 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
944 GpuBlacklist::kOsMacosx, &os_version, gpu_info); | |
945 EXPECT_EQ(type, 0); | |
946 | |
947 content::GPUInfo::GPUDevice gpu_device; | |
948 gpu_device.vendor_id = 0x8086; | |
949 gpu_device.device_id = 0x0166; | |
950 gpu_info.secondary_gpus.push_back(gpu_device); | |
951 type = blacklist->DetermineGpuFeatureType( | |
952 GpuBlacklist::kOsMacosx, &os_version, gpu_info); | |
953 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_WEBGL); | |
954 } | |
955 | |
956 TEST_F(GpuBlacklistTest, VideoDecode) { | |
957 const std::string video_decode_json = | |
958 "{\n" | |
959 " \"name\": \"gpu blacklist\",\n" | |
960 " \"version\": \"0.1\",\n" | |
961 " \"entries\": [\n" | |
962 " {\n" | |
963 " \"id\": 1,\n" | |
964 " \"os\": {\n" | |
965 " \"type\": \"macosx\"\n" | |
966 " },\n" | |
967 " \"vendor_id\": \"0x10de\",\n" | |
968 " \"device_id\": [\"0x0640\"],\n" | |
969 " \"blacklist\": [\n" | |
970 " \"accelerated_video_decode\"\n" | |
971 " ]\n" | |
972 " }\n" | |
973 " ]\n" | |
974 "}"; | |
975 Version os_version("10.6.4"); | |
976 | |
977 scoped_ptr<GpuBlacklist> blacklist(Create()); | |
978 EXPECT_TRUE(blacklist->LoadGpuBlacklist( | |
979 video_decode_json, GpuBlacklist::kAllOs)); | |
980 GpuFeatureType type = blacklist->DetermineGpuFeatureType( | |
981 GpuBlacklist::kOsMacosx, &os_version, gpu_info()); | |
982 EXPECT_EQ(type, content::GPU_FEATURE_TYPE_ACCELERATED_VIDEO_DECODE); | |
983 } | |
984 | |
OLD | NEW |