Use RE string pattern matching for blacklist strings.

gpu/config/gpu_control_list_entry_unittest.cc

 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "base/json/json_reader.h"
 #include "gpu/config/gpu_control_list.h"
 #include "gpu/config/gpu_info.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 #define LONG_STRING_CONST(...) #__VA_ARGS__
@@ skipping 452 matching lines @@
   gpu_info.gl_version = "3.0 NVIDIA-8.24.11 310.90.9b01";
   EXPECT_TRUE(entry->Contains(GpuControlList::kOsMacosx, "10.9", gpu_info));
 
   gpu_info.gl_version = "4.0 NVIDIA-8.24.11 310.90.9b01";
   EXPECT_FALSE(entry->Contains(GpuControlList::kOsMacosx, "10.9", gpu_info));
 
   gpu_info.gl_version = "OpenGL ES 3.0 (ANGLE 1.2.0.2450)";
   EXPECT_FALSE(entry->Contains(GpuControlList::kOsWin, "6.1", gpu_info));
 }
 
-TEST_F(GpuControlListEntryTest, GlVendorEntry) {
+TEST_F(GpuControlListEntryTest, GlVendorEqual) {
   const std::string json = LONG_STRING_CONST(
       {
         "id": 1,
-        "gl_vendor": {
-          "op": "beginwith",
-          "value": "NVIDIA"
-        },
+        "gl_vendor": "NVIDIA",
         "features": [
           "test_feature_0"
         ]
       }
   );
   ScopedEntry entry(GetEntryFromString(json));
   EXPECT_TRUE(entry.get() != NULL);
 
-  const GpuControlList::OsType os_type[] = {
-    GpuControlList::kOsMacosx,
-    GpuControlList::kOsWin,
-    GpuControlList::kOsLinux,
-    GpuControlList::kOsChromeOS,
-    GpuControlList::kOsAndroid
-  };
-  for (size_t i = 0; i < arraysize(os_type); ++i)
-    EXPECT_TRUE(entry->Contains(os_type[i], "10.6", gpu_info()));
+  GPUInfo gpu_info;
+  gpu_info.gl_vendor = "NVIDIA";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
+
+  // Case insensitive.
+  gpu_info.gl_vendor = "NVidia";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
+
+  gpu_info.gl_vendor = "NVIDIA-x";
+  EXPECT_FALSE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
 }
 
-TEST_F(GpuControlListEntryTest, GlRendererEntry) {
+TEST_F(GpuControlListEntryTest, GlVendorWithDot) {
   const std::string json = LONG_STRING_CONST(
       {
         "id": 1,
-        "gl_renderer": {
-          "op": "contains",
-          "value": "GeForce"
-        },
+        "gl_vendor": "X\\.Org.*",
         "features": [
           "test_feature_0"
         ]
       }
   );
   ScopedEntry entry(GetEntryFromString(json));
   EXPECT_TRUE(entry.get() != NULL);
 
-  const GpuControlList::OsType os_type[] = {
-    GpuControlList::kOsMacosx,
-    GpuControlList::kOsWin,
-    GpuControlList::kOsLinux,
-    GpuControlList::kOsChromeOS,
-    GpuControlList::kOsAndroid
-  };
-  for (size_t i = 0; i < arraysize(os_type); ++i)
-    EXPECT_TRUE(entry->Contains(os_type[i], "10.6", gpu_info()));
+  GPUInfo gpu_info;
+  gpu_info.gl_vendor = "X.Org R300 Project";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsLinux, "", gpu_info));
+
+  gpu_info.gl_vendor = "X.Org";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsLinux, "", gpu_info));
+}
+
+TEST_F(GpuControlListEntryTest, GlRendererContains) {
+  const std::string json = LONG_STRING_CONST(
+      {
+        "id": 1,
+        "gl_renderer": ".*GeForce.*",
+        "features": [
+          "test_feature_0"
+        ]
+      }
+  );
+  ScopedEntry entry(GetEntryFromString(json));
+  EXPECT_TRUE(entry.get() != NULL);
+
+  GPUInfo gpu_info;
+  gpu_info.gl_renderer = "NVIDIA GeForce GT 120 OpenGL Engine";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
+
+  // Case insensitive.
+  gpu_info.gl_renderer = "NVIDIA GEFORCE GT 120 OpenGL Engine";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
+
+  gpu_info.gl_renderer = "GeForce GT 120 OpenGL Engine";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
+
+  gpu_info.gl_renderer = "NVIDIA GeForce";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
+
+  gpu_info.gl_renderer = "NVIDIA Ge Force";
+  EXPECT_FALSE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
+}
+
+TEST_F(GpuControlListEntryTest, GlExtensionsEndWith) {
+  const std::string json = LONG_STRING_CONST(
+      {
+        "id": 1,
+        "gl_extensions": ".*GL_SUN_slice_accum",
+        "features": [
+          "test_feature_0"
+        ]
+      }
+  );
+  ScopedEntry entry(GetEntryFromString(json));
+  EXPECT_TRUE(entry.get() != NULL);
+
+  GPUInfo gpu_info;
+  gpu_info.gl_extensions = "GL_SGIS_generate_mipmap "
+                           "GL_SGIX_shadow "
+                           "GL_SUN_slice_accum";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
+
+  gpu_info.gl_extensions = "GL_SGIS_generate_mipmap "
+                           "GL_SUN_slice_accum "
+                           "GL_SGIX_shadow";
+  EXPECT_FALSE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
 }
 
 TEST_F(GpuControlListEntryTest, PerfGraphicsEntry) {
   const std::string json = LONG_STRING_CONST(
       {
         "id": 1,
         "perf_graphics": {
           "op": "<",
           "value": "6.0"
         },
@@ skipping 98 matching lines @@
   GPUInfo gpu_info;
   gpu_info.amd_switchable = true;
 
   ScopedEntry entry(GetEntryFromString(json));
   EXPECT_TRUE(entry.get() != NULL);
   EXPECT_EQ(GpuControlList::kOsMacosx, entry->GetOsType());
   EXPECT_TRUE(entry->Contains(
       GpuControlList::kOsMacosx, "10.6", gpu_info));
 }
 
+TEST_F(GpuControlListEntryTest, DriverVendorBeginWith) {
+  const std::string json = LONG_STRING_CONST(
+      {
+        "id": 1,
+        "driver_vendor": "NVIDIA.*",
+        "features": [
+          "test_feature_0"
+        ]
+      }
+  );
+  ScopedEntry entry(GetEntryFromString(json));
+  EXPECT_TRUE(entry.get() != NULL);
+
+  GPUInfo gpu_info;
+  gpu_info.driver_vendor = "NVIDIA Corporation";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
+
+  // Case insensitive.
+  gpu_info.driver_vendor = "NVidia Corporation";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
+
+  gpu_info.driver_vendor = "NVIDIA";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
+
+  gpu_info.driver_vendor = "USA NVIDIA";
+  EXPECT_FALSE(entry->Contains(
+      GpuControlList::kOsMacosx, "10.9", gpu_info));
+}
+
 TEST_F(GpuControlListEntryTest, LexicalDriverVersionEntry) {
   const std::string json = LONG_STRING_CONST(
       {
         "id": 1,
         "os": {
           "type": "linux"
         },
         "vendor_id": "0x1002",
         "driver_version": {
           "op": "=",
@@ skipping 50 matching lines @@
   EXPECT_FALSE(entry->NeedsMoreInfo(gpu_info));
 }
 
 TEST_F(GpuControlListEntryTest, NeedsMoreInfoForExceptionsEntry) {
   const std::string json = LONG_STRING_CONST(
       {
         "id": 1,
         "vendor_id": "0x8086",
         "exceptions": [
           {
-            "gl_renderer": {
-              "op": "contains",
-              "value": "mesa"
-            }
+            "gl_renderer": ".*mesa.*"
           }
         ],
         "features": [
           "test_feature_1"
         ]
       }
   );
   ScopedEntry entry(GetEntryFromString(json));
   EXPECT_TRUE(entry.get() != NULL);
 
@@ skipping 73 matching lines @@
       GpuControlList::kOsMacosx, "10.6", gpu_info()));
 }
 
 TEST_F(GpuControlListEntryTest, MachineModelName) {
   const std::string json = LONG_STRING_CONST(
       {
         "id": 1,
         "os": {
           "type": "android"
         },
-        "machine_model_name": ["Nexus 4", "XT1032"],
+        "machine_model_name": [
+          "Nexus 4", "XT1032", "GT-.*", "SCH-.*"
+        ],
         "features": [
           "test_feature_0"
         ]
       }
   );
   ScopedEntry entry(GetEntryFromString(json));
   EXPECT_TRUE(entry.get() != NULL);
   EXPECT_EQ(GpuControlList::kOsAndroid, entry->GetOsType());
   GPUInfo gpu_info;
 
@@ skipping 13 matching lines @@
   EXPECT_FALSE(entry->Contains(
       GpuControlList::kOsAndroid, "4.1", gpu_info));
 
   gpu_info.machine_model_name = "Nexus";
   EXPECT_FALSE(entry->Contains(
       GpuControlList::kOsAndroid, "4.1", gpu_info));
 
   gpu_info.machine_model_name = "";
   EXPECT_FALSE(entry->Contains(
       GpuControlList::kOsAndroid, "4.1", gpu_info));
+
+  gpu_info.machine_model_name = "GT-N7100";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsAndroid, "4.1", gpu_info));
+
+  gpu_info.machine_model_name = "GT-I9300";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsAndroid, "4.1", gpu_info));
+
+  gpu_info.machine_model_name = "SCH-I545";
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsAndroid, "4.1", gpu_info));
 }
 
 TEST_F(GpuControlListEntryTest, MachineModelNameException) {
   const std::string json = LONG_STRING_CONST(
       {
         "id": 1,
         "exceptions": [
           {
             "os": {
               "type": "android"
             },
-            "machine_model_name": ["Nexus 4"]
+            "machine_model_name": ["Nexus.*"]
           }
         ],
         "features": [
           "test_feature_0"
         ]
       }
   );
   ScopedEntry entry(GetEntryFromString(json));
   EXPECT_TRUE(entry.get() != NULL);
   EXPECT_EQ(GpuControlList::kOsAny, entry->GetOsType());
   GPUInfo gpu_info;
 
   gpu_info.machine_model_name = "Nexus 4";
   EXPECT_FALSE(entry->Contains(
       GpuControlList::kOsAndroid, "4.1", gpu_info));
   EXPECT_TRUE(entry->Contains(
       GpuControlList::kOsLinux, "4.1", gpu_info));
 
+  gpu_info.machine_model_name = "Nexus 7";
+  EXPECT_FALSE(entry->Contains(
+      GpuControlList::kOsAndroid, "4.1", gpu_info));
+  EXPECT_TRUE(entry->Contains(
+      GpuControlList::kOsLinux, "4.1", gpu_info));
+
   gpu_info.machine_model_name = "";
   EXPECT_TRUE(entry->Contains(
       GpuControlList::kOsAndroid, "4.1", gpu_info));
   EXPECT_TRUE(entry->Contains(
       GpuControlList::kOsLinux, "4.1", gpu_info));
 }
 
 TEST_F(GpuControlListEntryTest, MachineModelVersion) {
   const std::string json = LONG_STRING_CONST(
       {
@@ skipping 266 matching lines @@
   );
   // By default, secondary GPU is active.
   EntryShouldNotApply(json);
 
   ActivatePrimaryGPU();
   EntryShouldApply(json);
 }
 
 }  // namespace gpu