1 // Copyright (c) 2013 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 <stddef.h>
6 
7 #include "base/stl_util.h"
8 #include "build/build_config.h"
9 #include "gpu/config/gpu_control_list.h"
10 #include "gpu/config/gpu_control_list_testing_data.h"
11 #include "gpu/config/gpu_info.h"
12 #include "testing/gtest/include/gtest/gtest.h"
13 
14 namespace gpu {
15 
16 namespace {
17 
18 constexpr auto kOsLinux = GpuControlList::kOsLinux;
19 constexpr auto kOsMacosx = GpuControlList::kOsMacosx;
20 constexpr auto kOsWin = GpuControlList::kOsWin;
21 constexpr auto kOsChromeOS = GpuControlList::kOsChromeOS;
22 constexpr auto kOsAndroid = GpuControlList::kOsAndroid;
23 constexpr auto kOsAny = GpuControlList::kOsAny;
24 
25 }  // namespace anonymous
26 
27 class GpuControlListEntryTest : public testing::Test {
28  public:
29   typedef GpuControlList::Entry Entry;
30 
31   GpuControlListEntryTest() = default;
32   ~GpuControlListEntryTest() override = default;
33 
gpu_info() const34   const GPUInfo& gpu_info() const {
35     return gpu_info_;
36   }
37 
GetEntry(size_t index)38   const Entry& GetEntry(size_t index) {
39     EXPECT_LT(index, kGpuControlListTestingEntryCount);
40     EXPECT_EQ(index + 1, kGpuControlListTestingEntries[index].id);
41     return kGpuControlListTestingEntries[index];
42   }
43 
CountFeature(const Entry & entry,int feature)44   size_t CountFeature(const Entry& entry, int feature) {
45     size_t count = 0;
46     for (size_t ii = 0; ii < entry.feature_size; ++ii) {
47       if (entry.features[ii] == feature) {
48         ++count;
49       }
50     }
51     return count;
52   }
53 
54  protected:
SetUp()55   void SetUp() override {
56     gpu_info_.gpu.vendor_id = 0x10de;
57     gpu_info_.gpu.device_id = 0x0640;
58     gpu_info_.gpu.active = true;
59     gpu_info_.gpu.driver_vendor = "NVIDIA";
60     gpu_info_.gpu.driver_version = "1.6.18";
61     gpu_info_.gl_version = "2.1 NVIDIA-8.24.11 310.90.9b01";
62     gpu_info_.gl_vendor = "NVIDIA Corporation";
63     gpu_info_.gl_renderer = "NVIDIA GeForce GT 120 OpenGL Engine";
64   }
65 
66   GPUInfo gpu_info_;
67 };
68 
TEST_F(GpuControlListEntryTest,DetailedEntry)69 TEST_F(GpuControlListEntryTest, DetailedEntry) {
70   const Entry& entry = GetEntry(kGpuControlListEntryTest_DetailedEntry);
71   EXPECT_EQ(kOsMacosx, entry.conditions.os_type);
72   EXPECT_STREQ("GpuControlListEntryTest.DetailedEntry", entry.description);
73   EXPECT_EQ(2u, entry.cr_bug_size);
74   EXPECT_EQ(1024u, entry.cr_bugs[0]);
75   EXPECT_EQ(678u, entry.cr_bugs[1]);
76   EXPECT_EQ(1u, entry.feature_size);
77   EXPECT_EQ(1u, CountFeature(entry, TEST_FEATURE_0));
78   EXPECT_FALSE(entry.NeedsMoreInfo(gpu_info(), true));
79   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.6.4", gpu_info()));
80   EXPECT_EQ(2u, entry.disabled_extension_size);
81   EXPECT_STREQ("test_extension1", entry.disabled_extensions[0]);
82   EXPECT_STREQ("test_extension2", entry.disabled_extensions[1]);
83 }
84 
TEST_F(GpuControlListEntryTest,VendorOnAllOsEntry)85 TEST_F(GpuControlListEntryTest, VendorOnAllOsEntry) {
86   const Entry& entry = GetEntry(kGpuControlListEntryTest_VendorOnAllOsEntry);
87   EXPECT_EQ(kOsAny, entry.conditions.os_type);
88   const GpuControlList::OsType os_type[] = {kOsMacosx, kOsWin, kOsLinux,
89                                             kOsChromeOS, kOsAndroid};
90   for (size_t i = 0; i < base::size(os_type); ++i)
91     EXPECT_TRUE(entry.Contains(os_type[i], "10.6", gpu_info()));
92 }
93 
TEST_F(GpuControlListEntryTest,VendorOnLinuxEntry)94 TEST_F(GpuControlListEntryTest, VendorOnLinuxEntry) {
95   const Entry& entry = GetEntry(kGpuControlListEntryTest_VendorOnLinuxEntry);
96   EXPECT_EQ(kOsLinux, entry.conditions.os_type);
97   const GpuControlList::OsType os_type[] = {kOsMacosx, kOsWin, kOsChromeOS,
98                                             kOsAndroid};
99   for (size_t i = 0; i < base::size(os_type); ++i)
100     EXPECT_FALSE(entry.Contains(os_type[i], "10.6", gpu_info()));
101   EXPECT_TRUE(entry.Contains(kOsLinux, "10.6", gpu_info()));
102 }
103 
TEST_F(GpuControlListEntryTest,AllExceptNVidiaOnLinuxEntry)104 TEST_F(GpuControlListEntryTest, AllExceptNVidiaOnLinuxEntry) {
105   const Entry& entry =
106       GetEntry(kGpuControlListEntryTest_AllExceptNVidiaOnLinuxEntry);
107   EXPECT_EQ(kOsLinux, entry.conditions.os_type);
108   const GpuControlList::OsType os_type[] = {kOsMacosx, kOsWin, kOsLinux,
109                                             kOsChromeOS, kOsAndroid};
110   for (size_t i = 0; i < base::size(os_type); ++i)
111     EXPECT_FALSE(entry.Contains(os_type[i], "10.6", gpu_info()));
112 }
113 
TEST_F(GpuControlListEntryTest,AllExceptIntelOnLinuxEntry)114 TEST_F(GpuControlListEntryTest, AllExceptIntelOnLinuxEntry) {
115   const Entry& entry =
116       GetEntry(kGpuControlListEntryTest_AllExceptIntelOnLinuxEntry);
117   EXPECT_EQ(kOsLinux, entry.conditions.os_type);
118   const GpuControlList::OsType os_type[] = {kOsMacosx, kOsWin, kOsChromeOS,
119                                             kOsAndroid};
120   for (size_t i = 0; i < base::size(os_type); ++i)
121     EXPECT_FALSE(entry.Contains(os_type[i], "10.6", gpu_info()));
122   EXPECT_TRUE(entry.Contains(kOsLinux, "10.6", gpu_info()));
123 }
124 
TEST_F(GpuControlListEntryTest,MultipleDevicesEntry)125 TEST_F(GpuControlListEntryTest, MultipleDevicesEntry) {
126   const Entry& entry = GetEntry(kGpuControlListEntryTest_MultipleDevicesEntry);
127   EXPECT_EQ(kOsAny, entry.conditions.os_type);
128   const GpuControlList::OsType os_type[] = {kOsMacosx, kOsWin, kOsLinux,
129                                             kOsChromeOS, kOsAndroid};
130   for (size_t i = 0; i < base::size(os_type); ++i)
131     EXPECT_TRUE(entry.Contains(os_type[i], "10.6", gpu_info()));
132 }
133 
TEST_F(GpuControlListEntryTest,ChromeOSEntry)134 TEST_F(GpuControlListEntryTest, ChromeOSEntry) {
135   const Entry& entry = GetEntry(kGpuControlListEntryTest_ChromeOSEntry);
136   EXPECT_EQ(kOsChromeOS, entry.conditions.os_type);
137   const GpuControlList::OsType os_type[] = {kOsMacosx, kOsWin, kOsLinux,
138                                             kOsAndroid};
139   for (size_t i = 0; i < base::size(os_type); ++i)
140     EXPECT_FALSE(entry.Contains(os_type[i], "10.6", gpu_info()));
141   EXPECT_TRUE(entry.Contains(kOsChromeOS, "10.6", gpu_info()));
142 }
143 
TEST_F(GpuControlListEntryTest,GlVersionGLESEntry)144 TEST_F(GpuControlListEntryTest, GlVersionGLESEntry) {
145   const Entry& entry = GetEntry(kGpuControlListEntryTest_GlVersionGLESEntry);
146   GPUInfo gpu_info;
147   gpu_info.gl_version = "OpenGL ES 3.0 V@66.0 AU@ (CL@)";
148   EXPECT_TRUE(entry.Contains(kOsAndroid, "4.4.2", gpu_info));
149   gpu_info.gl_version = "OpenGL ES 3.0V@66.0 AU@ (CL@)";
150   EXPECT_TRUE(entry.Contains(kOsAndroid, "4.4.2", gpu_info));
151   gpu_info.gl_version = "OpenGL ES 3.1 V@66.0 AU@ (CL@)";
152   EXPECT_FALSE(entry.Contains(kOsAndroid, "4.4.2", gpu_info));
153   gpu_info.gl_version = "3.0 NVIDIA-8.24.11 310.90.9b01";
154   EXPECT_FALSE(entry.Contains(kOsMacosx, "10.9", gpu_info));
155   gpu_info.gl_version = "OpenGL ES 3.0 (ANGLE 1.2.0.2450)";
156   EXPECT_FALSE(entry.Contains(kOsWin, "6.1", gpu_info));
157 }
158 
TEST_F(GpuControlListEntryTest,GlVersionANGLEEntry)159 TEST_F(GpuControlListEntryTest, GlVersionANGLEEntry) {
160   const Entry& entry = GetEntry(kGpuControlListEntryTest_GlVersionANGLEEntry);
161   GPUInfo gpu_info;
162   gpu_info.gl_version = "OpenGL ES 3.0 V@66.0 AU@ (CL@)";
163   EXPECT_FALSE(entry.Contains(kOsAndroid, "4.4.2", gpu_info));
164   gpu_info.gl_version = "3.0 NVIDIA-8.24.11 310.90.9b01";
165   EXPECT_FALSE(entry.Contains(kOsMacosx, "10.9", gpu_info));
166   gpu_info.gl_version = "OpenGL ES 3.0 (ANGLE 1.2.0.2450)";
167   EXPECT_TRUE(entry.Contains(kOsWin, "6.1", gpu_info));
168   gpu_info.gl_version = "OpenGL ES 2.0 (ANGLE 1.2.0.2450)";
169   EXPECT_FALSE(entry.Contains(kOsWin, "6.1", gpu_info));
170 }
171 
TEST_F(GpuControlListEntryTest,GlVersionGLEntry)172 TEST_F(GpuControlListEntryTest, GlVersionGLEntry) {
173   const Entry& entry = GetEntry(kGpuControlListEntryTest_GlVersionGLEntry);
174   GPUInfo gpu_info;
175   gpu_info.gl_version = "OpenGL ES 3.0 V@66.0 AU@ (CL@)";
176   EXPECT_FALSE(entry.Contains(kOsAndroid, "4.4.2", gpu_info));
177   gpu_info.gl_version = "3.0 NVIDIA-8.24.11 310.90.9b01";
178   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.9", gpu_info));
179   gpu_info.gl_version = "4.0 NVIDIA-8.24.11 310.90.9b01";
180   EXPECT_FALSE(entry.Contains(kOsMacosx, "10.9", gpu_info));
181   gpu_info.gl_version = "OpenGL ES 3.0 (ANGLE 1.2.0.2450)";
182   EXPECT_FALSE(entry.Contains(kOsWin, "6.1", gpu_info));
183 }
184 
TEST_F(GpuControlListEntryTest,GlVendorEqual)185 TEST_F(GpuControlListEntryTest, GlVendorEqual) {
186   const Entry& entry = GetEntry(kGpuControlListEntryTest_GlVendorEqual);
187   GPUInfo gpu_info;
188   gpu_info.gl_vendor = "NVIDIA";
189   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.9", gpu_info));
190   // Case sensitive.
191   gpu_info.gl_vendor = "NVidia";
192   EXPECT_FALSE(entry.Contains(kOsMacosx, "10.9", gpu_info));
193   gpu_info.gl_vendor = "NVIDIA-x";
194   EXPECT_FALSE(entry.Contains(kOsMacosx, "10.9", gpu_info));
195 }
196 
TEST_F(GpuControlListEntryTest,GlVendorWithDot)197 TEST_F(GpuControlListEntryTest, GlVendorWithDot) {
198   const Entry& entry = GetEntry(kGpuControlListEntryTest_GlVendorWithDot);
199   GPUInfo gpu_info;
200   gpu_info.gl_vendor = "X.Org R300 Project";
201   EXPECT_TRUE(entry.Contains(kOsLinux, "", gpu_info));
202   gpu_info.gl_vendor = "X.Org";
203   EXPECT_TRUE(entry.Contains(kOsLinux, "", gpu_info));
204 }
205 
TEST_F(GpuControlListEntryTest,GlRendererContains)206 TEST_F(GpuControlListEntryTest, GlRendererContains) {
207   const Entry& entry = GetEntry(kGpuControlListEntryTest_GlRendererContains);
208   GPUInfo gpu_info;
209   gpu_info.gl_renderer = "NVIDIA GeForce GT 120 OpenGL Engine";
210   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.9", gpu_info));
211   // Case sensitive.
212   gpu_info.gl_renderer = "NVIDIA GEFORCE GT 120 OpenGL Engine";
213   EXPECT_FALSE(entry.Contains(kOsMacosx, "10.9", gpu_info));
214   gpu_info.gl_renderer = "GeForce GT 120 OpenGL Engine";
215   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.9", gpu_info));
216   gpu_info.gl_renderer = "NVIDIA GeForce";
217   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.9", gpu_info));
218   gpu_info.gl_renderer = "NVIDIA Ge Force";
219   EXPECT_FALSE(entry.Contains(kOsMacosx, "10.9", gpu_info));
220 }
221 
TEST_F(GpuControlListEntryTest,GlRendererCaseInsensitive)222 TEST_F(GpuControlListEntryTest, GlRendererCaseInsensitive) {
223   const Entry& entry =
224       GetEntry(kGpuControlListEntryTest_GlRendererCaseInsensitive);
225   GPUInfo gpu_info;
226   gpu_info.gl_renderer = "software rasterizer";
227   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.9", gpu_info));
228   gpu_info.gl_renderer = "Software Rasterizer";
229   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.9", gpu_info));
230 }
231 
TEST_F(GpuControlListEntryTest,GlExtensionsEndWith)232 TEST_F(GpuControlListEntryTest, GlExtensionsEndWith) {
233   const Entry& entry = GetEntry(kGpuControlListEntryTest_GlExtensionsEndWith);
234   GPUInfo gpu_info;
235   gpu_info.gl_extensions = "GL_SGIS_generate_mipmap "
236                            "GL_SGIX_shadow "
237                            "GL_SUN_slice_accum";
238   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.9", gpu_info));
239   gpu_info.gl_extensions = "GL_SGIS_generate_mipmap "
240                            "GL_SUN_slice_accum "
241                            "GL_SGIX_shadow";
242   EXPECT_FALSE(entry.Contains(kOsMacosx, "10.9", gpu_info));
243 }
244 
TEST_F(GpuControlListEntryTest,OptimusEntry)245 TEST_F(GpuControlListEntryTest, OptimusEntry) {
246   const Entry& entry = GetEntry(kGpuControlListEntryTest_OptimusEntry);
247   EXPECT_EQ(kOsLinux, entry.conditions.os_type);
248   GPUInfo gpu_info;
249   gpu_info.optimus = true;
250   EXPECT_TRUE(entry.Contains(kOsLinux, "10.6", gpu_info));
251 }
252 
TEST_F(GpuControlListEntryTest,AMDSwitchableEntry)253 TEST_F(GpuControlListEntryTest, AMDSwitchableEntry) {
254   const Entry& entry = GetEntry(kGpuControlListEntryTest_AMDSwitchableEntry);
255   EXPECT_EQ(kOsMacosx, entry.conditions.os_type);
256   GPUInfo gpu_info;
257   gpu_info.amd_switchable = true;
258   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.6", gpu_info));
259 }
260 
TEST_F(GpuControlListEntryTest,DriverVendorBeginWith)261 TEST_F(GpuControlListEntryTest, DriverVendorBeginWith) {
262   const Entry& entry = GetEntry(kGpuControlListEntryTest_DriverVendorBeginWith);
263   GPUInfo gpu_info;
264   gpu_info.gpu.driver_vendor = "NVIDIA Corporation";
265   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.9", gpu_info));
266   // Case sensitive.
267   gpu_info.gpu.driver_vendor = "NVidia Corporation";
268   EXPECT_FALSE(entry.Contains(kOsMacosx, "10.9", gpu_info));
269   gpu_info.gpu.driver_vendor = "NVIDIA";
270   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.9", gpu_info));
271   gpu_info.gpu.driver_vendor = "USA NVIDIA";
272   EXPECT_FALSE(entry.Contains(kOsMacosx, "10.9", gpu_info));
273 }
274 
TEST_F(GpuControlListEntryTest,LexicalDriverVersionEntry)275 TEST_F(GpuControlListEntryTest, LexicalDriverVersionEntry) {
276   const Entry& entry =
277       GetEntry(kGpuControlListEntryTest_LexicalDriverVersionEntry);
278   EXPECT_EQ(kOsLinux, entry.conditions.os_type);
279   GPUInfo gpu_info;
280   gpu_info.gpu.vendor_id = 0x1002;
281   gpu_info.gpu.driver_version = "8.76";
282   EXPECT_TRUE(entry.Contains(kOsLinux, "10.6", gpu_info));
283   gpu_info.gpu.driver_version = "8.768";
284   EXPECT_TRUE(entry.Contains(kOsLinux, "10.6", gpu_info));
285   gpu_info.gpu.driver_version = "8.76.8";
286   EXPECT_TRUE(entry.Contains(kOsLinux, "10.6", gpu_info));
287 }
288 
TEST_F(GpuControlListEntryTest,NeedsMoreInfoEntry)289 TEST_F(GpuControlListEntryTest, NeedsMoreInfoEntry) {
290   const Entry& entry = GetEntry(kGpuControlListEntryTest_NeedsMoreInfoEntry);
291   GPUInfo gpu_info;
292   gpu_info.gpu.vendor_id = 0x8086;
293   EXPECT_TRUE(entry.NeedsMoreInfo(gpu_info, true));
294   gpu_info.gpu.driver_version = "10.6";
295   EXPECT_FALSE(entry.NeedsMoreInfo(gpu_info, true));
296 }
297 
TEST_F(GpuControlListEntryTest,NeedsMoreInfoForExceptionsEntry)298 TEST_F(GpuControlListEntryTest, NeedsMoreInfoForExceptionsEntry) {
299   const Entry& entry =
300       GetEntry(kGpuControlListEntryTest_NeedsMoreInfoForExceptionsEntry);
301   GPUInfo gpu_info;
302   gpu_info.gpu.vendor_id = 0x8086;
303   EXPECT_TRUE(entry.NeedsMoreInfo(gpu_info, true));
304   EXPECT_FALSE(entry.NeedsMoreInfo(gpu_info, false));
305   gpu_info.gl_renderer = "mesa";
306   EXPECT_FALSE(entry.NeedsMoreInfo(gpu_info, true));
307 }
308 
TEST_F(GpuControlListEntryTest,NeedsMoreInfoForGlVersionEntry)309 TEST_F(GpuControlListEntryTest, NeedsMoreInfoForGlVersionEntry) {
310   const Entry& entry =
311       GetEntry(kGpuControlListEntryTest_NeedsMoreInfoForGlVersionEntry);
312   GPUInfo gpu_info;
313   EXPECT_TRUE(entry.NeedsMoreInfo(gpu_info, true));
314   EXPECT_TRUE(entry.Contains(kOsLinux, std::string(), gpu_info));
315   gpu_info.gl_version = "3.1 Mesa 11.1.0";
316   EXPECT_FALSE(entry.NeedsMoreInfo(gpu_info, false));
317   EXPECT_TRUE(entry.Contains(kOsLinux, std::string(), gpu_info));
318   gpu_info.gl_version = "4.1 Mesa 12.1.0";
319   EXPECT_FALSE(entry.NeedsMoreInfo(gpu_info, false));
320   EXPECT_FALSE(entry.Contains(kOsLinux, std::string(), gpu_info));
321   gpu_info.gl_version = "OpenGL ES 2.0 Mesa 12.1.0";
322   EXPECT_FALSE(entry.NeedsMoreInfo(gpu_info, false));
323   EXPECT_FALSE(entry.Contains(kOsLinux, std::string(), gpu_info));
324 }
325 
TEST_F(GpuControlListEntryTest,FeatureTypeAllEntry)326 TEST_F(GpuControlListEntryTest, FeatureTypeAllEntry) {
327   const Entry& entry = GetEntry(kGpuControlListEntryTest_FeatureTypeAllEntry);
328 
329   EXPECT_EQ(3u, entry.feature_size);
330   EXPECT_EQ(1u, CountFeature(entry, TEST_FEATURE_0));
331   EXPECT_EQ(1u, CountFeature(entry, TEST_FEATURE_1));
332   EXPECT_EQ(1u, CountFeature(entry, TEST_FEATURE_2));
333 }
334 
TEST_F(GpuControlListEntryTest,FeatureTypeAllEntryWithExceptions)335 TEST_F(GpuControlListEntryTest, FeatureTypeAllEntryWithExceptions) {
336   const Entry& entry =
337       GetEntry(kGpuControlListEntryTest_FeatureTypeAllEntryWithExceptions);
338   EXPECT_EQ(2u, entry.feature_size);
339   EXPECT_EQ(1u, CountFeature(entry, TEST_FEATURE_1));
340   EXPECT_EQ(1u, CountFeature(entry, TEST_FEATURE_2));
341 }
342 
TEST_F(GpuControlListEntryTest,SingleActiveGPU)343 TEST_F(GpuControlListEntryTest, SingleActiveGPU) {
344   const Entry& entry = GetEntry(kGpuControlListEntryTest_SingleActiveGPU);
345   EXPECT_EQ(kOsMacosx, entry.conditions.os_type);
346   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.6", gpu_info()));
347 }
348 
TEST_F(GpuControlListEntryTest,MachineModelName)349 TEST_F(GpuControlListEntryTest, MachineModelName) {
350   const Entry& entry = GetEntry(kGpuControlListEntryTest_MachineModelName);
351   EXPECT_EQ(kOsAndroid, entry.conditions.os_type);
352   GPUInfo gpu_info;
353   gpu_info.machine_model_name = "Nexus 4";
354   EXPECT_TRUE(entry.Contains(kOsAndroid, "4.1", gpu_info));
355   gpu_info.machine_model_name = "XT1032";
356   EXPECT_TRUE(entry.Contains(kOsAndroid, "4.1", gpu_info));
357   gpu_info.machine_model_name = "XT1032i";
358   EXPECT_FALSE(entry.Contains(kOsAndroid, "4.1", gpu_info));
359   gpu_info.machine_model_name = "Nexus 5";
360   EXPECT_FALSE(entry.Contains(kOsAndroid, "4.1", gpu_info));
361   gpu_info.machine_model_name = "Nexus";
362   EXPECT_FALSE(entry.Contains(kOsAndroid, "4.1", gpu_info));
363   gpu_info.machine_model_name = "";
364   EXPECT_FALSE(entry.Contains(kOsAndroid, "4.1", gpu_info));
365   gpu_info.machine_model_name = "GT-N7100";
366   EXPECT_TRUE(entry.Contains(kOsAndroid, "4.1", gpu_info));
367   gpu_info.machine_model_name = "GT-I9300";
368   EXPECT_TRUE(entry.Contains(kOsAndroid, "4.1", gpu_info));
369   gpu_info.machine_model_name = "SCH-I545";
370   EXPECT_TRUE(entry.Contains(kOsAndroid, "4.1", gpu_info));
371 }
372 
TEST_F(GpuControlListEntryTest,MachineModelNameException)373 TEST_F(GpuControlListEntryTest, MachineModelNameException) {
374   const Entry& entry =
375       GetEntry(kGpuControlListEntryTest_MachineModelNameException);
376   EXPECT_EQ(kOsAny, entry.conditions.os_type);
377   GPUInfo gpu_info;
378   gpu_info.machine_model_name = "Nexus 4";
379   EXPECT_FALSE(entry.Contains(kOsAndroid, "4.1", gpu_info));
380   EXPECT_TRUE(entry.Contains(kOsLinux, "4.1", gpu_info));
381   gpu_info.machine_model_name = "Nexus 7";
382   EXPECT_FALSE(entry.Contains(kOsAndroid, "4.1", gpu_info));
383   EXPECT_TRUE(entry.Contains(kOsLinux, "4.1", gpu_info));
384   gpu_info.machine_model_name = "";
385   EXPECT_TRUE(entry.Contains(kOsAndroid, "4.1", gpu_info));
386   EXPECT_TRUE(entry.Contains(kOsLinux, "4.1", gpu_info));
387 }
388 
TEST_F(GpuControlListEntryTest,MachineModelVersion)389 TEST_F(GpuControlListEntryTest, MachineModelVersion) {
390   const Entry& entry = GetEntry(kGpuControlListEntryTest_MachineModelVersion);
391   GPUInfo gpu_info;
392   gpu_info.machine_model_name = "MacBookPro";
393   gpu_info.machine_model_version = "7.1";
394   EXPECT_EQ(kOsMacosx, entry.conditions.os_type);
395   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.6", gpu_info));
396 }
397 
TEST_F(GpuControlListEntryTest,MachineModelVersionException)398 TEST_F(GpuControlListEntryTest, MachineModelVersionException) {
399   const Entry& entry =
400       GetEntry(kGpuControlListEntryTest_MachineModelVersionException);
401   EXPECT_EQ(kOsMacosx, entry.conditions.os_type);
402   GPUInfo gpu_info;
403   gpu_info.machine_model_name = "MacBookPro";
404   gpu_info.machine_model_version = "7.0";
405   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.6", gpu_info));
406   gpu_info.machine_model_version = "7.2";
407   EXPECT_FALSE(entry.Contains(kOsMacosx, "10.6", gpu_info));
408   gpu_info.machine_model_version = "";
409   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.6", gpu_info));
410 }
411 
412 class GpuControlListEntryDualGPUTest : public GpuControlListEntryTest {
413  public:
414   GpuControlListEntryDualGPUTest() = default;
415   ~GpuControlListEntryDualGPUTest() override = default;
416 
SetUp()417   void SetUp() override {
418     // Set up a NVIDIA/Intel dual, with NVIDIA as primary and Intel as
419     // secondary, and initially Intel is active.
420     gpu_info_.gpu.vendor_id = 0x10de;
421     gpu_info_.gpu.device_id = 0x0640;
422     gpu_info_.gpu.active = false;
423     GPUInfo::GPUDevice second_gpu;
424     second_gpu.vendor_id = 0x8086;
425     second_gpu.device_id = 0x0166;
426     second_gpu.active = true;
427     gpu_info_.secondary_gpus.push_back(second_gpu);
428   }
429 
ActivatePrimaryGPU()430   void ActivatePrimaryGPU() {
431     gpu_info_.gpu.active = true;
432     gpu_info_.secondary_gpus[0].active = false;
433   }
434 
EntryShouldApply(const Entry & entry) const435   void EntryShouldApply(const Entry& entry) const {
436     EXPECT_TRUE(EntryApplies(entry));
437   }
438 
EntryShouldNotApply(const Entry & entry) const439   void EntryShouldNotApply(const Entry& entry) const {
440     EXPECT_FALSE(EntryApplies(entry));
441   }
442 
443  private:
EntryApplies(const Entry & entry) const444   bool EntryApplies(const Entry& entry) const {
445     EXPECT_EQ(kOsMacosx, entry.conditions.os_type);
446     return entry.Contains(kOsMacosx, "10.6", gpu_info());
447   }
448 };
449 
TEST_F(GpuControlListEntryDualGPUTest,CategoryAny)450 TEST_F(GpuControlListEntryDualGPUTest, CategoryAny) {
451   const Entry& entry_intel =
452       GetEntry(kGpuControlListEntryDualGPUTest_CategoryAny_Intel);
453   EntryShouldApply(entry_intel);
454   const Entry& entry_nvidia =
455       GetEntry(kGpuControlListEntryDualGPUTest_CategoryAny_NVidia);
456   EntryShouldApply(entry_nvidia);
457 }
458 
TEST_F(GpuControlListEntryDualGPUTest,CategoryPrimarySecondary)459 TEST_F(GpuControlListEntryDualGPUTest, CategoryPrimarySecondary) {
460   const Entry& entry_secondary =
461       GetEntry(kGpuControlListEntryDualGPUTest_CategorySecondary);
462   EntryShouldApply(entry_secondary);
463   const Entry& entry_primary =
464       GetEntry(kGpuControlListEntryDualGPUTest_CategoryPrimary);
465   EntryShouldNotApply(entry_primary);
466   const Entry& entry_default =
467       GetEntry(kGpuControlListEntryDualGPUTest_CategoryDefault);
468   // Default is active, and the secondary Intel GPU is active.
469   EntryShouldApply(entry_default);
470 }
471 
TEST_F(GpuControlListEntryDualGPUTest,ActiveSecondaryGPU)472 TEST_F(GpuControlListEntryDualGPUTest, ActiveSecondaryGPU) {
473   const Entry& entry =
474       GetEntry(kGpuControlListEntryDualGPUTest_ActiveSecondaryGPU);
475   // By default, secondary GPU is active.
476   EntryShouldApply(entry);
477   ActivatePrimaryGPU();
478   EntryShouldNotApply(entry);
479 }
480 
TEST_F(GpuControlListEntryDualGPUTest,VendorOnlyActiveSecondaryGPU)481 TEST_F(GpuControlListEntryDualGPUTest, VendorOnlyActiveSecondaryGPU) {
482   const Entry& entry =
483       GetEntry(kGpuControlListEntryDualGPUTest_VendorOnlyActiveSecondaryGPU);
484   // By default, secondary GPU is active.
485   EntryShouldApply(entry);
486   ActivatePrimaryGPU();
487   EntryShouldNotApply(entry);
488 }
489 
TEST_F(GpuControlListEntryDualGPUTest,ActivePrimaryGPU)490 TEST_F(GpuControlListEntryDualGPUTest, ActivePrimaryGPU) {
491   const Entry& entry =
492       GetEntry(kGpuControlListEntryDualGPUTest_ActivePrimaryGPU);
493   // By default, secondary GPU is active.
494   EntryShouldNotApply(entry);
495   ActivatePrimaryGPU();
496   EntryShouldApply(entry);
497 }
498 
TEST_F(GpuControlListEntryDualGPUTest,VendorOnlyActivePrimaryGPU)499 TEST_F(GpuControlListEntryDualGPUTest, VendorOnlyActivePrimaryGPU) {
500   const Entry& entry =
501       GetEntry(kGpuControlListEntryDualGPUTest_VendorOnlyActivePrimaryGPU);
502   // By default, secondary GPU is active.
503   EntryShouldNotApply(entry);
504   ActivatePrimaryGPU();
505   EntryShouldApply(entry);
506 }
507 
TEST_F(GpuControlListEntryTest,PixelShaderVersion)508 TEST_F(GpuControlListEntryTest, PixelShaderVersion) {
509   const Entry& entry = GetEntry(kGpuControlListEntryTest_PixelShaderVersion);
510   EXPECT_EQ(kOsAny, entry.conditions.os_type);
511   GPUInfo gpu_info;
512   gpu_info.pixel_shader_version = "3.2";
513   EXPECT_TRUE(entry.Contains(kOsMacosx, "10.9", gpu_info));
514   gpu_info.pixel_shader_version = "4.9";
515   EXPECT_FALSE(entry.Contains(kOsMacosx, "10.9", gpu_info));
516 }
517 
TEST_F(GpuControlListEntryTest,OsVersionZero)518 TEST_F(GpuControlListEntryTest, OsVersionZero) {
519   {
520     const Entry& entry = GetEntry(kGpuControlListEntryTest_OsVersionZeroLT);
521     // All forms of version 0 is considered invalid.
522     EXPECT_FALSE(entry.Contains(kOsAndroid, "0", gpu_info()));
523     EXPECT_FALSE(entry.Contains(kOsAndroid, "0.0", gpu_info()));
524     EXPECT_FALSE(entry.Contains(kOsAndroid, "0.00.0", gpu_info()));
525   }
526   {
527     const Entry& entry = GetEntry(kGpuControlListEntryTest_OsVersionZeroAny);
528     EXPECT_TRUE(entry.Contains(kOsAndroid, "0", gpu_info()));
529     EXPECT_TRUE(entry.Contains(kOsAndroid, "0.0", gpu_info()));
530     EXPECT_TRUE(entry.Contains(kOsAndroid, "0.00.0", gpu_info()));
531   }
532 }
533 
TEST_F(GpuControlListEntryTest,OsComparison)534 TEST_F(GpuControlListEntryTest, OsComparison) {
535   {
536     const Entry& entry = GetEntry(kGpuControlListEntryTest_OsComparisonAny);
537     const GpuControlList::OsType os_type[] = {kOsWin, kOsLinux, kOsMacosx,
538                                               kOsChromeOS, kOsAndroid};
539     for (size_t i = 0; i < base::size(os_type); ++i) {
540       EXPECT_TRUE(entry.Contains(os_type[i], std::string(), gpu_info()));
541       EXPECT_TRUE(entry.Contains(os_type[i], "7.8", gpu_info()));
542     }
543   }
544   {
545     const Entry& entry = GetEntry(kGpuControlListEntryTest_OsComparisonGE);
546     EXPECT_FALSE(entry.Contains(kOsMacosx, "10.8.3", gpu_info()));
547     EXPECT_FALSE(entry.Contains(kOsLinux, "10", gpu_info()));
548     EXPECT_FALSE(entry.Contains(kOsChromeOS, "13", gpu_info()));
549     EXPECT_FALSE(entry.Contains(kOsAndroid, "7", gpu_info()));
550     EXPECT_FALSE(entry.Contains(kOsWin, std::string(), gpu_info()));
551     EXPECT_TRUE(entry.Contains(kOsWin, "6", gpu_info()));
552     EXPECT_TRUE(entry.Contains(kOsWin, "6.1", gpu_info()));
553     EXPECT_TRUE(entry.Contains(kOsWin, "7", gpu_info()));
554     EXPECT_FALSE(entry.Contains(kOsWin, "5", gpu_info()));
555   }
556 }
557 
TEST_F(GpuControlListEntryTest,ExceptionWithoutVendorId)558 TEST_F(GpuControlListEntryTest, ExceptionWithoutVendorId) {
559   const Entry& entry =
560       GetEntry(kGpuControlListEntryTest_ExceptionWithoutVendorId);
561   EXPECT_EQ(0x8086u, entry.exceptions[0].vendor_id);
562   EXPECT_EQ(0x8086u, entry.exceptions[1].vendor_id);
563   GPUInfo gpu_info;
564   gpu_info.gpu.vendor_id = 0x8086;
565   gpu_info.gpu.device_id = 0x2a02;
566   gpu_info.gpu.driver_version = "9.1";
567   EXPECT_FALSE(entry.Contains(kOsLinux, "2.1", gpu_info));
568   gpu_info.gpu.driver_version = "9.0";
569   EXPECT_TRUE(entry.Contains(kOsLinux, "2.1", gpu_info));
570 }
571 
TEST_F(GpuControlListEntryTest,MultiGpuStyleAMDSwitchable)572 TEST_F(GpuControlListEntryTest, MultiGpuStyleAMDSwitchable) {
573   GPUInfo gpu_info;
574   gpu_info.amd_switchable = true;
575   gpu_info.gpu.vendor_id = 0x1002;
576   gpu_info.gpu.device_id = 0x6760;
577   GPUInfo::GPUDevice integrated_gpu;
578   integrated_gpu.vendor_id = 0x8086;
579   integrated_gpu.device_id = 0x0116;
580   gpu_info.secondary_gpus.push_back(integrated_gpu);
581 
582   {  // amd_switchable_discrete entry
583     const Entry& entry =
584         GetEntry(kGpuControlListEntryTest_MultiGpuStyleAMDSwitchableDiscrete);
585     // Integrated GPU is active
586     gpu_info.gpu.active = false;
587     gpu_info.secondary_gpus[0].active = true;
588     EXPECT_FALSE(entry.Contains(kOsWin, "6.0", gpu_info));
589     // Discrete GPU is active
590     gpu_info.gpu.active = true;
591     gpu_info.secondary_gpus[0].active = false;
592     EXPECT_TRUE(entry.Contains(kOsWin, "6.0", gpu_info));
593   }
594 
595   {  // amd_switchable_integrated entry
596     const Entry& entry =
597         GetEntry(kGpuControlListEntryTest_MultiGpuStyleAMDSwitchableIntegrated);
598     // Discrete GPU is active
599     gpu_info.gpu.active = true;
600     gpu_info.secondary_gpus[0].active = false;
601     EXPECT_FALSE(entry.Contains(kOsWin, "6.0", gpu_info));
602     // Integrated GPU is active
603     gpu_info.gpu.active = false;
604     gpu_info.secondary_gpus[0].active = true;
605     EXPECT_TRUE(entry.Contains(kOsWin, "6.0", gpu_info));
606     // For non AMD switchable
607     gpu_info.amd_switchable = false;
608     EXPECT_FALSE(entry.Contains(kOsWin, "6.0", gpu_info));
609   }
610 }
611 
TEST_F(GpuControlListEntryTest,InProcessGPU)612 TEST_F(GpuControlListEntryTest, InProcessGPU) {
613   const Entry& entry = GetEntry(kGpuControlListEntryTest_InProcessGPU);
614   GPUInfo gpu_info;
615   gpu_info.in_process_gpu = true;
616   EXPECT_TRUE(entry.Contains(kOsWin, "6.1", gpu_info));
617   gpu_info.in_process_gpu = false;
618   EXPECT_FALSE(entry.Contains(kOsWin, "6.1", gpu_info));
619 }
620 
TEST_F(GpuControlListEntryTest,SameGPUTwiceTest)621 TEST_F(GpuControlListEntryTest, SameGPUTwiceTest) {
622   const Entry& entry = GetEntry(kGpuControlListEntryTest_SameGPUTwiceTest);
623   GPUInfo gpu_info;
624   gpu_info.gpu.vendor_id = 0x8086;
625   // Real case on Intel GMA* on Windows
626   gpu_info.secondary_gpus.push_back(gpu_info.gpu);
627   EXPECT_TRUE(entry.Contains(kOsWin, "6.1", gpu_info));
628 }
629 
TEST_F(GpuControlListEntryTest,NVidiaNumberingScheme)630 TEST_F(GpuControlListEntryTest, NVidiaNumberingScheme) {
631   const Entry& entry = GetEntry(kGpuControlListEntryTest_NVidiaNumberingScheme);
632   GPUInfo gpu_info;
633   gpu_info.gl_vendor = "NVIDIA";
634   gpu_info.gl_renderer = "NVIDIA GeForce GT 120 OpenGL Engine";
635   gpu_info.gpu.vendor_id = 0x10de;
636   gpu_info.gpu.device_id = 0x0640;
637   // test the same driver version number
638   gpu_info.gpu.driver_version = "8.17.12.6973";
639   EXPECT_TRUE(entry.Contains(kOsWin, "7.0", gpu_info));
640   // test a lower driver version number
641   gpu_info.gpu.driver_version = "8.15.11.8647";
642   EXPECT_TRUE(entry.Contains(kOsWin, "7.0", gpu_info));
643   // test a higher driver version number
644   gpu_info.gpu.driver_version = "9.18.13.2723";
645   EXPECT_FALSE(entry.Contains(kOsWin, "7.0", gpu_info));
646 }
647 
TEST_F(GpuControlListEntryTest,DirectRendering)648 TEST_F(GpuControlListEntryTest, DirectRendering) {
649   const Entry& entry = GetEntry(kGpuControlListEntryTest_DirectRendering);
650   GPUInfo gpu_info;
651   // No info does not match.
652   gpu_info.direct_rendering_version = "";
653   EXPECT_FALSE(entry.Contains(kOsLinux, "7.0", gpu_info));
654 
655   // Indirect rendering does not match.
656   gpu_info.direct_rendering_version = "1";
657   EXPECT_FALSE(entry.Contains(kOsLinux, "7.0", gpu_info));
658 
659   gpu_info.direct_rendering_version = "2";
660   EXPECT_TRUE(entry.Contains(kOsLinux, "7.0", gpu_info));
661   gpu_info.direct_rendering_version = "2.3";
662   EXPECT_TRUE(entry.Contains(kOsLinux, "7.0", gpu_info));
663 }
664 
TEST_F(GpuControlListEntryTest,GpuSeries)665 TEST_F(GpuControlListEntryTest, GpuSeries) {
666   const Entry& entry = GetEntry(kGpuControlListEntryTest_GpuSeries);
667   GPUInfo gpu_info;
668   gpu_info.gpu.vendor_id = 0x8086;
669   // Intel KabyLake
670   gpu_info.gpu.device_id = 0x5916;
671   EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
672   // Intel SandyBridge
673   gpu_info.gpu.device_id = 0x0116;
674   EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
675   // Intel SkyLake
676   gpu_info.gpu.device_id = 0x1916;
677   EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
678   // Non-Intel GPU
679   gpu_info.gpu.vendor_id = 0x10de;
680   gpu_info.gpu.device_id = 0x0df8;
681   EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
682 }
683 
TEST_F(GpuControlListEntryTest,GpuSeriesActive)684 TEST_F(GpuControlListEntryTest, GpuSeriesActive) {
685   const Entry& entry = GetEntry(kGpuControlListEntryTest_GpuSeriesActive);
686 
687   GPUInfo::GPUDevice intel_gpu;
688   intel_gpu.vendor_id = 0x8086;
689   intel_gpu.device_id = 0x5916;
690   GPUInfo::GPUDevice nvidia_gpu;
691   nvidia_gpu.vendor_id = 0x10de;
692   nvidia_gpu.device_id = 0x0df8;
693 
694   {  // Single GPU
695     GPUInfo gpu_info;
696     gpu_info.gpu = intel_gpu;
697     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
698   }
699 
700   {  // Dual GPU, Intel is primary and active
701     GPUInfo gpu_info;
702     gpu_info.gpu = intel_gpu;
703     gpu_info.gpu.active = true;
704     gpu_info.secondary_gpus.push_back(nvidia_gpu);
705     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
706   }
707 
708   {  // Dual GPU, Intel is secondary and active
709     GPUInfo gpu_info;
710     gpu_info.gpu = nvidia_gpu;
711     gpu_info.secondary_gpus.push_back(intel_gpu);
712     gpu_info.secondary_gpus[0].active = true;
713     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
714   }
715 
716   {  // Dual GPU, NVidia is primary and active
717     GPUInfo gpu_info;
718     gpu_info.gpu = nvidia_gpu;
719     gpu_info.gpu.active = true;
720     gpu_info.secondary_gpus.push_back(intel_gpu);
721     EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
722   }
723 
724   {  // Dual GPU, NVidia is secondary and active
725     GPUInfo gpu_info;
726     gpu_info.gpu = intel_gpu;
727     gpu_info.secondary_gpus.push_back(nvidia_gpu);
728     gpu_info.secondary_gpus[0].active = true;
729     EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
730   }
731 }
732 
TEST_F(GpuControlListEntryTest,GpuSeriesAny)733 TEST_F(GpuControlListEntryTest, GpuSeriesAny) {
734   const Entry& entry = GetEntry(kGpuControlListEntryTest_GpuSeriesAny);
735 
736   GPUInfo::GPUDevice intel_gpu;
737   intel_gpu.vendor_id = 0x8086;
738   intel_gpu.device_id = 0x5916;
739   GPUInfo::GPUDevice nvidia_gpu;
740   nvidia_gpu.vendor_id = 0x10de;
741   nvidia_gpu.device_id = 0x0df8;
742 
743   {  // Single GPU Intel
744     GPUInfo gpu_info;
745     gpu_info.gpu = intel_gpu;
746     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
747   }
748 
749   {  // Single GPU NVidia
750     GPUInfo gpu_info;
751     gpu_info.gpu = nvidia_gpu;
752     EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
753   }
754 
755   {  // Dual GPU, Intel is primary
756     GPUInfo gpu_info;
757     gpu_info.gpu = intel_gpu;
758     gpu_info.secondary_gpus.push_back(nvidia_gpu);
759     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
760   }
761 
762   {  // Dual GPU, Intel is secondary
763     GPUInfo gpu_info;
764     gpu_info.gpu = nvidia_gpu;
765     gpu_info.secondary_gpus.push_back(intel_gpu);
766     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
767   }
768 }
769 
TEST_F(GpuControlListEntryTest,GpuSeriesPrimary)770 TEST_F(GpuControlListEntryTest, GpuSeriesPrimary) {
771   const Entry& entry = GetEntry(kGpuControlListEntryTest_GpuSeriesPrimary);
772 
773   GPUInfo::GPUDevice intel_gpu;
774   intel_gpu.vendor_id = 0x8086;
775   intel_gpu.device_id = 0x5916;
776   GPUInfo::GPUDevice nvidia_gpu;
777   nvidia_gpu.vendor_id = 0x10de;
778   nvidia_gpu.device_id = 0x0df8;
779 
780   {  // Single GPU
781     GPUInfo gpu_info;
782     gpu_info.gpu = intel_gpu;
783     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
784   }
785 
786   {  // Dual GPU, Intel is primary
787     GPUInfo gpu_info;
788     gpu_info.gpu = intel_gpu;
789     gpu_info.secondary_gpus.push_back(nvidia_gpu);
790     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
791   }
792 
793   {  // Dual GPU, Intel is secondary
794     GPUInfo gpu_info;
795     gpu_info.gpu = nvidia_gpu;
796     gpu_info.secondary_gpus.push_back(intel_gpu);
797     EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
798   }
799 }
800 
TEST_F(GpuControlListEntryTest,GpuSeriesSecondary)801 TEST_F(GpuControlListEntryTest, GpuSeriesSecondary) {
802   const Entry& entry = GetEntry(kGpuControlListEntryTest_GpuSeriesSecondary);
803 
804   GPUInfo::GPUDevice intel_gpu;
805   intel_gpu.vendor_id = 0x8086;
806   intel_gpu.device_id = 0x5916;
807   GPUInfo::GPUDevice nvidia_gpu;
808   nvidia_gpu.vendor_id = 0x10de;
809   nvidia_gpu.device_id = 0x0df8;
810 
811   {  // Single GPU
812     GPUInfo gpu_info;
813     gpu_info.gpu = intel_gpu;
814     EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
815   }
816 
817   {  // Dual GPU, Intel is primary
818     GPUInfo gpu_info;
819     gpu_info.gpu = intel_gpu;
820     gpu_info.secondary_gpus.push_back(nvidia_gpu);
821     EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
822   }
823 
824   {  // Dual GPU, Intel is secondary
825     GPUInfo gpu_info;
826     gpu_info.gpu = nvidia_gpu;
827     gpu_info.secondary_gpus.push_back(intel_gpu);
828     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
829   }
830 }
831 
TEST_F(GpuControlListEntryTest,GpuSeriesInException)832 TEST_F(GpuControlListEntryTest, GpuSeriesInException) {
833   const Entry& entry = GetEntry(kGpuControlListEntryTest_GpuSeriesInException);
834 
835   GPUInfo gpu_info;
836   // Intel KabyLake
837   gpu_info.gpu.vendor_id = 0x8086;
838   gpu_info.gpu.device_id = 0x5916;
839   EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
840   // Intel SandyBridge
841   gpu_info.gpu.vendor_id = 0x8086;
842   gpu_info.gpu.device_id = 0x0116;
843   EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
844 }
845 
TEST_F(GpuControlListEntryTest,MultipleDrivers)846 TEST_F(GpuControlListEntryTest, MultipleDrivers) {
847   const Entry& entry = GetEntry(kGpuControlListEntryTest_MultipleDrivers);
848   // The GPUInfo data came from https://crbug.com/810713#c58.
849   GPUInfo gpu_info;
850   gpu_info.gpu.vendor_id = 0x1002;
851   gpu_info.gpu.device_id = 0x6741;
852   gpu_info.gpu.driver_version = "8.951.0.0";
853   GPUInfo::GPUDevice intel_device;
854   intel_device.vendor_id = 0x8086;
855   intel_device.device_id = 0x0116;
856   intel_device.driver_version = "8.15.0010.2476";
857   gpu_info.secondary_gpus.push_back(intel_device);
858 
859   gpu_info.gpu.active = true;
860   gpu_info.secondary_gpus[0].active = false;
861   EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
862 
863   gpu_info.gpu.active = false;
864   gpu_info.secondary_gpus[0].active = true;
865   EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
866 }
867 
TEST_F(GpuControlListEntryTest,GpuGeneration)868 TEST_F(GpuControlListEntryTest, GpuGeneration) {
869   const Entry& entry = GetEntry(kGpuControlListEntryTest_GpuGeneration);
870   GPUInfo gpu_info;
871   gpu_info.gpu.vendor_id = 0x8086;
872   // Intel SandyBridge
873   gpu_info.gpu.device_id = 0x0116;
874   EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
875   // Intel Haswell
876   gpu_info.gpu.device_id = 0x0416;
877   EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
878   // Intel Broadwell
879   gpu_info.gpu.device_id = 0x1616;
880   EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
881   // Intel KabyLake
882   gpu_info.gpu.device_id = 0x5916;
883   EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
884   // Intel IceLake
885   gpu_info.gpu.device_id = 0x8A56;
886   EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
887   // Non-Intel GPU
888   gpu_info.gpu.vendor_id = 0x10de;
889   gpu_info.gpu.device_id = 0x0df8;
890   EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
891 }
892 
TEST_F(GpuControlListEntryTest,GpuGenerationActive)893 TEST_F(GpuControlListEntryTest, GpuGenerationActive) {
894   const Entry& entry = GetEntry(kGpuControlListEntryTest_GpuGenerationActive);
895 
896   // Intel Broadwell
897   GPUInfo::GPUDevice intel_gpu;
898   intel_gpu.vendor_id = 0x8086;
899   intel_gpu.device_id = 0x1616;
900   // NVidia GPU
901   GPUInfo::GPUDevice nvidia_gpu;
902   nvidia_gpu.vendor_id = 0x10de;
903   nvidia_gpu.device_id = 0x0df8;
904 
905   {  // Single GPU
906     GPUInfo gpu_info;
907     gpu_info.gpu = intel_gpu;
908     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
909   }
910 
911   {  // Dual GPU, Intel is primary and active
912     GPUInfo gpu_info;
913     gpu_info.gpu = intel_gpu;
914     gpu_info.gpu.active = true;
915     gpu_info.secondary_gpus.push_back(nvidia_gpu);
916     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
917   }
918 
919   {  // Dual GPU, Intel is secondary and active
920     GPUInfo gpu_info;
921     gpu_info.gpu = nvidia_gpu;
922     gpu_info.secondary_gpus.push_back(intel_gpu);
923     gpu_info.secondary_gpus[0].active = true;
924     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
925   }
926 
927   {  // Dual GPU, NVidia is primary and active
928     GPUInfo gpu_info;
929     gpu_info.gpu = nvidia_gpu;
930     gpu_info.gpu.active = true;
931     gpu_info.secondary_gpus.push_back(intel_gpu);
932     EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
933   }
934 
935   {  // Dual GPU, NVidia is secondary and active
936     GPUInfo gpu_info;
937     gpu_info.gpu = intel_gpu;
938     gpu_info.secondary_gpus.push_back(nvidia_gpu);
939     gpu_info.secondary_gpus[0].active = true;
940     EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
941   }
942 }
943 
TEST_F(GpuControlListEntryTest,GpuGenerationAny)944 TEST_F(GpuControlListEntryTest, GpuGenerationAny) {
945   const Entry& entry = GetEntry(kGpuControlListEntryTest_GpuGenerationAny);
946 
947   // Intel Broadwell
948   GPUInfo::GPUDevice intel_gpu;
949   intel_gpu.vendor_id = 0x8086;
950   intel_gpu.device_id = 0x1616;
951   // NVidia GPU
952   GPUInfo::GPUDevice nvidia_gpu;
953   nvidia_gpu.vendor_id = 0x10de;
954   nvidia_gpu.device_id = 0x0df8;
955 
956   {  // Single GPU Intel
957     GPUInfo gpu_info;
958     gpu_info.gpu = intel_gpu;
959     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
960   }
961 
962   {  // Single GPU Nvidia
963     GPUInfo gpu_info;
964     gpu_info.gpu = nvidia_gpu;
965     EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
966   }
967 
968   {  // Dual GPU, Intel is primary
969     GPUInfo gpu_info;
970     gpu_info.gpu = intel_gpu;
971     gpu_info.secondary_gpus.push_back(nvidia_gpu);
972     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
973   }
974 
975   {  // Dual GPU, Intel is secondary
976     GPUInfo gpu_info;
977     gpu_info.gpu = nvidia_gpu;
978     gpu_info.secondary_gpus.push_back(intel_gpu);
979     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
980   }
981 }
982 
TEST_F(GpuControlListEntryTest,GpuGenerationPrimary)983 TEST_F(GpuControlListEntryTest, GpuGenerationPrimary) {
984   const Entry& entry = GetEntry(kGpuControlListEntryTest_GpuGenerationPrimary);
985 
986   // Intel Broadwell
987   GPUInfo::GPUDevice intel_gpu;
988   intel_gpu.vendor_id = 0x8086;
989   intel_gpu.device_id = 0x1616;
990   // NVidia GPU
991   GPUInfo::GPUDevice nvidia_gpu;
992   nvidia_gpu.vendor_id = 0x10de;
993   nvidia_gpu.device_id = 0x0df8;
994 
995   {  // Single GPU
996     GPUInfo gpu_info;
997     gpu_info.gpu = intel_gpu;
998     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
999   }
1000 
1001   {  // Dual GPU, Intel is primary
1002     GPUInfo gpu_info;
1003     gpu_info.gpu = intel_gpu;
1004     gpu_info.secondary_gpus.push_back(nvidia_gpu);
1005     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
1006   }
1007 
1008   {  // Dual GPU, Intel is secondary
1009     GPUInfo gpu_info;
1010     gpu_info.gpu = nvidia_gpu;
1011     gpu_info.secondary_gpus.push_back(intel_gpu);
1012     EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
1013   }
1014 }
1015 
TEST_F(GpuControlListEntryTest,GpuGenerationSecondary)1016 TEST_F(GpuControlListEntryTest, GpuGenerationSecondary) {
1017   const Entry& entry = GetEntry(kGpuControlListEntryTest_GpuGenerationSecondary);
1018 
1019   // Intel Broadwell
1020   GPUInfo::GPUDevice intel_gpu;
1021   intel_gpu.vendor_id = 0x8086;
1022   intel_gpu.device_id = 0x1616;
1023   // NVidia GPU
1024   GPUInfo::GPUDevice nvidia_gpu;
1025   nvidia_gpu.vendor_id = 0x10de;
1026   nvidia_gpu.device_id = 0x0df8;
1027 
1028 
1029   {  // Single GPU
1030     GPUInfo gpu_info;
1031     gpu_info.gpu = intel_gpu;
1032     EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
1033   }
1034 
1035   {  // Dual GPU, Intel is primary
1036     GPUInfo gpu_info;
1037     gpu_info.gpu = intel_gpu;
1038     gpu_info.secondary_gpus.push_back(nvidia_gpu);
1039     EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
1040   }
1041 
1042   {  // Dual GPU, Intel is secondary
1043     GPUInfo gpu_info;
1044     gpu_info.gpu = nvidia_gpu;
1045     gpu_info.secondary_gpus.push_back(intel_gpu);
1046     EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
1047   }
1048 }
1049 
1050 #if defined(OS_WIN)
TEST_F(GpuControlListEntryTest,HardwareOverlay)1051 TEST_F(GpuControlListEntryTest, HardwareOverlay) {
1052   const Entry& entry = GetEntry(kGpuControlListEntryTest_HardwareOverlay);
1053   GPUInfo gpu_info;
1054   gpu_info.gpu.vendor_id = 0x8086;
1055   gpu_info.overlay_info.supports_overlays = true;
1056   EXPECT_FALSE(entry.Contains(kOsWin, "10.0", gpu_info));
1057 
1058   gpu_info.overlay_info.supports_overlays = false;
1059   EXPECT_TRUE(entry.Contains(kOsWin, "10.0", gpu_info));
1060 }
1061 #endif  // OS_WIN
1062 
TEST_F(GpuControlListEntryTest,TestSubpixelFontRendering)1063 TEST_F(GpuControlListEntryTest, TestSubpixelFontRendering) {
1064   const Entry& entry = GetEntry(kGpuControlListEntryTest_SubpixelFontRendering);
1065 
1066   GPUInfo gpu_info;
1067   gpu_info.subpixel_font_rendering = true;
1068   gpu_info.gl_renderer = "Mali0xx";
1069 
1070   EXPECT_TRUE(entry.Contains(kOsChromeOS, "10.0", gpu_info));
1071 
1072   gpu_info.subpixel_font_rendering = false;
1073   gpu_info.gl_renderer = "Mali1xx";
1074   EXPECT_FALSE(entry.Contains(kOsChromeOS, "10.0", gpu_info));
1075 
1076   gpu_info.subpixel_font_rendering = false;
1077   gpu_info.gl_renderer = "DontCare";
1078   EXPECT_FALSE(entry.Contains(kOsChromeOS, "10.0", gpu_info));
1079 
1080   gpu_info.subpixel_font_rendering = true;
1081   gpu_info.gl_renderer = "DontCare";
1082   EXPECT_FALSE(entry.Contains(kOsChromeOS, "10.0", gpu_info));
1083 
1084   gpu_info.subpixel_font_rendering = false;
1085   gpu_info.gl_renderer = "Supported";
1086   EXPECT_TRUE(entry.Contains(kOsChromeOS, "10.0", gpu_info));
1087 
1088   gpu_info.subpixel_font_rendering = true;
1089   gpu_info.gl_renderer = "Supported";
1090   EXPECT_FALSE(entry.Contains(kOsChromeOS, "10.0", gpu_info));
1091 
1092   gpu_info.subpixel_font_rendering = true;
1093   gpu_info.gl_renderer = "Others";
1094   EXPECT_TRUE(entry.Contains(kOsChromeOS, "10.0", gpu_info));
1095 
1096   // Not ChromeOS
1097   EXPECT_FALSE(entry.Contains(kOsLinux, "10.0", gpu_info));
1098 }
1099 
TEST_F(GpuControlListEntryTest,TestSubpixelFontRenderingDontCare)1100 TEST_F(GpuControlListEntryTest, TestSubpixelFontRenderingDontCare) {
1101   const Entry& entry =
1102       GetEntry(kGpuControlListEntryTest_SubpixelFontRenderingDontCare);
1103 
1104   GPUInfo gpu_info;
1105   gpu_info.subpixel_font_rendering = true;
1106   gpu_info.gl_renderer = "Mali0xx";
1107 
1108   EXPECT_TRUE(entry.Contains(kOsChromeOS, "10.0", gpu_info));
1109 
1110   gpu_info.subpixel_font_rendering = false;
1111   EXPECT_TRUE(entry.Contains(kOsChromeOS, "10.0", gpu_info));
1112 }
1113 
TEST_F(GpuControlListEntryTest,IntelDriverVendorEntry)1114 TEST_F(GpuControlListEntryTest, IntelDriverVendorEntry) {
1115   const Entry& entry =
1116       GetEntry(kGpuControlListEntryTest_IntelDriverVendorEntry);
1117   GPUInfo gpu_info;
1118   gpu_info.gpu.driver_vendor = "Intel(R) UHD Graphics 630";
1119   gpu_info.gpu.driver_version = "25.20.100.5000";
1120   EXPECT_TRUE(entry.Contains(kOsLinux, "", gpu_info));
1121   gpu_info.gpu.driver_version = "23.20.100.6500";
1122   EXPECT_FALSE(entry.Contains(kOsLinux, "", gpu_info));
1123 
1124   gpu_info.gpu.driver_version = "25.20.100.5000";
1125   EXPECT_FALSE(entry.Contains(kOsWin, "", gpu_info));
1126   gpu_info.gpu.driver_version = "23.20.100.6500";
1127   EXPECT_TRUE(entry.Contains(kOsWin, "", gpu_info));
1128 }
1129 
TEST_F(GpuControlListEntryTest,IntelDriverVersionEntry)1130 TEST_F(GpuControlListEntryTest, IntelDriverVersionEntry) {
1131   const Entry& entry =
1132       GetEntry(kGpuControlListEntryTest_IntelDriverVersionEntry);
1133   GPUInfo gpu_info;
1134   gpu_info.gpu.vendor_id = 0x8086;
1135   gpu_info.gpu.driver_version = "23.20.100.8000";
1136   EXPECT_TRUE(entry.Contains(kOsLinux, "", gpu_info));
1137   gpu_info.gpu.driver_version = "25.20.100.6000";
1138   EXPECT_FALSE(entry.Contains(kOsLinux, "", gpu_info));
1139 
1140   gpu_info.gpu.driver_version = "23.20.100.8000";
1141   EXPECT_FALSE(entry.Contains(kOsWin, "", gpu_info));
1142   gpu_info.gpu.driver_version = "25.20.100.6000";
1143   EXPECT_TRUE(entry.Contains(kOsWin, "", gpu_info));
1144   gpu_info.gpu.driver_version = "24.20.99.6000";
1145   EXPECT_FALSE(entry.Contains(kOsWin, "", gpu_info));
1146   gpu_info.gpu.driver_version = "24.20.101.6000";
1147   EXPECT_FALSE(entry.Contains(kOsWin, "", gpu_info));
1148   gpu_info.gpu.driver_version = "25.20.100.7000";
1149   EXPECT_TRUE(entry.Contains(kOsWin, "", gpu_info));
1150 }
1151 
TEST_F(GpuControlListEntryTest,IntelOldDriverVersionEntry)1152 TEST_F(GpuControlListEntryTest, IntelOldDriverVersionEntry) {
1153   const Entry& entry =
1154       GetEntry(kGpuControlListEntryTest_IntelOldDriverVersionEntry);
1155   GPUInfo gpu_info;
1156   gpu_info.gpu.vendor_id = 0x8086;
1157   gpu_info.gpu.driver_version = "23.20.10.8000";
1158   EXPECT_FALSE(entry.Contains(kOsWin, "", gpu_info));
1159   gpu_info.gpu.driver_version = "25.20.10.6000";
1160   EXPECT_TRUE(entry.Contains(kOsWin, "", gpu_info));
1161   gpu_info.gpu.driver_version = "24.20.100.6000";
1162   EXPECT_FALSE(entry.Contains(kOsWin, "", gpu_info));
1163   gpu_info.gpu.driver_version = "24.20.11.6000";
1164   EXPECT_TRUE(entry.Contains(kOsWin, "", gpu_info));
1165   gpu_info.gpu.driver_version = "25.20.9.7000";
1166   EXPECT_TRUE(entry.Contains(kOsWin, "", gpu_info));
1167 }
1168 
1169 }  // namespace gpu
1170