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