Revert 289067 "Use RE string pattern matching for blacklist stri..."

trunk/src/gpu/config/gpu_control_list.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 "gpu/config/gpu_control_list.h"
 
 #include "base/cpu.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "gpu/config/gpu_info.h"
 #include "gpu/config/gpu_util.h"
-#include "third_party/re2/re2/re2.h"
 
 namespace gpu {
 namespace {
 
 // Break a version string into segments.  Return true if each segment is
 // a valid number, and not all segment is 0.
 bool ProcessVersionString(const std::string& version_string,
                           char splitter,
                           std::vector<std::string>* version) {
   DCHECK(version);
@@ skipping 55 matching lines @@
       value1 = number[i] - '0';
     unsigned value2 = number_ref[i] - '0';
     if (value1 > value2)
       return 1;
     if (value1 < value2)
       return -1;
   }
   return 0;
 }
 
-// A mismatch is identified only if both |input| and |pattern| are not empty.
-bool StringMismatch(const std::string& input, const std::string& pattern) {
-  if (input.empty() || pattern.empty())
-    return false;
-  return !RE2::FullMatch(input, pattern);
-}
-
 const char kMultiGpuStyleStringAMDSwitchable[] = "amd_switchable";
 const char kMultiGpuStyleStringAMDSwitchableDiscrete[] =
     "amd_switchable_discrete";
 const char kMultiGpuStyleStringAMDSwitchableIntegrated[] =
     "amd_switchable_integrated";
 const char kMultiGpuStyleStringOptimus[] = "optimus";
 
 const char kMultiGpuCategoryStringPrimary[] = "primary";
 const char kMultiGpuCategoryStringSecondary[] = "secondary";
 const char kMultiGpuCategoryStringActive[] = "active";
@@ skipping 152 matching lines @@
     return kOsAndroid;
   else if (os == "linux")
     return kOsLinux;
   else if (os == "chromeos")
     return kOsChromeOS;
   else if (os == "any")
     return kOsAny;
   return kOsUnknown;
 }
 
+GpuControlList::StringInfo::StringInfo(const std::string& string_op,
+                                     const std::string& string_value) {
+  op_ = StringToOp(string_op);
+  value_ = base::StringToLowerASCII(string_value);
+}
+
+bool GpuControlList::StringInfo::Contains(const std::string& value) const {
+  std::string my_value = base::StringToLowerASCII(value);
+  switch (op_) {
+    case kContains:
+      return strstr(my_value.c_str(), value_.c_str()) != NULL;
+    case kBeginWith:
+      return StartsWithASCII(my_value, value_, false);
+    case kEndWith:
+      return EndsWith(my_value, value_, false);
+    case kEQ:
+      return value_ == my_value;
+    default:
+      return false;
+  }
+}
+
+bool GpuControlList::StringInfo::IsValid() const {
+  return op_ != kUnknown;
+}
+
+GpuControlList::StringInfo::Op GpuControlList::StringInfo::StringToOp(
+    const std::string& string_op) {
+  if (string_op == "=")
+    return kEQ;
+  else if (string_op == "contains")
+    return kContains;
+  else if (string_op == "beginwith")
+    return kBeginWith;
+  else if (string_op == "endwith")
+    return kEndWith;
+  return kUnknown;
+}
+
 GpuControlList::FloatInfo::FloatInfo(const std::string& float_op,
                                      const std::string& float_value,
                                      const std::string& float_value2)
     : op_(kUnknown),
       value_(0.f),
       value2_(0.f) {
   op_ = StringToNumericOp(float_op);
   if (op_ == kAny)
     return;
   double dvalue = 0;
@@ skipping 200 matching lines @@
 
   std::string multi_gpu_category;
   if (value->GetString("multi_gpu_category", &multi_gpu_category)) {
     if (!entry->SetMultiGpuCategory(multi_gpu_category)) {
       LOG(WARNING) << "Malformed multi_gpu_category entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  std::string driver_vendor_value;
-  if (value->GetString("driver_vendor", &driver_vendor_value)) {
-    if (!entry->SetDriverVendorInfo(driver_vendor_value)) {
+  const base::DictionaryValue* driver_vendor_value = NULL;
+  if (value->GetDictionary("driver_vendor", &driver_vendor_value)) {
+    std::string vendor_op;
+    std::string vendor_value;
+    driver_vendor_value->GetString(kOp, &vendor_op);
+    driver_vendor_value->GetString("value", &vendor_value);
+    if (!entry->SetDriverVendorInfo(vendor_op, vendor_value)) {
       LOG(WARNING) << "Malformed driver_vendor entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
   const base::DictionaryValue* driver_version_value = NULL;
   if (value->GetDictionary("driver_version", &driver_version_value)) {
     std::string driver_version_op = "any";
     std::string driver_version_style;
@@ skipping 47 matching lines @@
     gl_version_value->GetString("value", &version_string);
     gl_version_value->GetString("value2", &version_string2);
     if (!entry->SetGLVersionInfo(
             version_op, version_string, version_string2)) {
       LOG(WARNING) << "Malformed gl_version entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  std::string gl_vendor_value;
-  if (value->GetString("gl_vendor", &gl_vendor_value)) {
-    if (!entry->SetGLVendorInfo(gl_vendor_value)) {
+  const base::DictionaryValue* gl_vendor_value = NULL;
+  if (value->GetDictionary("gl_vendor", &gl_vendor_value)) {
+    std::string vendor_op;
+    std::string vendor_value;
+    gl_vendor_value->GetString(kOp, &vendor_op);
+    gl_vendor_value->GetString("value", &vendor_value);
+    if (!entry->SetGLVendorInfo(vendor_op, vendor_value)) {
       LOG(WARNING) << "Malformed gl_vendor entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  std::string gl_renderer_value;
-  if (value->GetString("gl_renderer", &gl_renderer_value)) {
-    if (!entry->SetGLRendererInfo(gl_renderer_value)) {
+  const base::DictionaryValue* gl_renderer_value = NULL;
+  if (value->GetDictionary("gl_renderer", &gl_renderer_value)) {
+    std::string renderer_op;
+    std::string renderer_value;
+    gl_renderer_value->GetString(kOp, &renderer_op);
+    gl_renderer_value->GetString("value", &renderer_value);
+    if (!entry->SetGLRendererInfo(renderer_op, renderer_value)) {
       LOG(WARNING) << "Malformed gl_renderer entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  std::string gl_extensions_value;
-  if (value->GetString("gl_extensions", &gl_extensions_value)) {
-    if (!entry->SetGLExtensionsInfo(gl_extensions_value)) {
+  const base::DictionaryValue* gl_extensions_value = NULL;
+  if (value->GetDictionary("gl_extensions", &gl_extensions_value)) {
+    std::string extensions_op;
+    std::string extensions_value;
+    gl_extensions_value->GetString(kOp, &extensions_op);
+    gl_extensions_value->GetString("value", &extensions_value);
+    if (!entry->SetGLExtensionsInfo(extensions_op, extensions_value)) {
       LOG(WARNING) << "Malformed gl_extensions entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
   const base::DictionaryValue* gl_reset_notification_strategy_value = NULL;
   if (value->GetDictionary("gl_reset_notification_strategy",
                            &gl_reset_notification_strategy_value)) {
     std::string op;
     std::string int_value;
     std::string int_value2;
     gl_reset_notification_strategy_value->GetString(kOp, &op);
     gl_reset_notification_strategy_value->GetString("value", &int_value);
     gl_reset_notification_strategy_value->GetString("value2", &int_value2);
     if (!entry->SetGLResetNotificationStrategyInfo(
             op, int_value, int_value2)) {
       LOG(WARNING) << "Malformed gl_reset_notification_strategy entry "
                    << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
-  std::string cpu_brand_value;
-  if (value->GetString("cpu_info", &cpu_brand_value)) {
-    if (!entry->SetCpuBrand(cpu_brand_value)) {
+  const base::DictionaryValue* cpu_brand_value = NULL;
+  if (value->GetDictionary("cpu_info", &cpu_brand_value)) {
+    std::string cpu_op;
+    std::string cpu_value;
+    cpu_brand_value->GetString(kOp, &cpu_op);
+    cpu_brand_value->GetString("value", &cpu_value);
+    if (!entry->SetCpuBrand(cpu_op, cpu_value)) {
       LOG(WARNING) << "Malformed cpu_brand entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
   const base::DictionaryValue* perf_graphics_value = NULL;
   if (value->GetDictionary("perf_graphics", &perf_graphics_value)) {
     std::string op;
     std::string float_value;
@@ skipping 220 matching lines @@
 bool GpuControlList::GpuControlListEntry::SetGLType(
     const std::string& gl_type_string) {
   GLType gl_type = StringToGLType(gl_type_string);
   if (gl_type == kGLTypeNone)
     return false;
   gl_type_ = gl_type;
   return true;
 }
 
 bool GpuControlList::GpuControlListEntry::SetDriverVendorInfo(
+    const std::string& vendor_op,
     const std::string& vendor_value) {
-  driver_vendor_info_ = vendor_value;
-  return !driver_vendor_info_.empty();
+  driver_vendor_info_.reset(new StringInfo(vendor_op, vendor_value));
+  return driver_vendor_info_->IsValid();
 }
 
 bool GpuControlList::GpuControlListEntry::SetDriverVersionInfo(
     const std::string& version_op,
     const std::string& version_style,
     const std::string& version_string,
     const std::string& version_string2) {
   driver_version_info_.reset(new VersionInfo(
       version_op, version_style, version_string, version_string2));
   return driver_version_info_->IsValid();
@@ skipping 11 matching lines @@
 bool GpuControlList::GpuControlListEntry::SetGLVersionInfo(
     const std::string& version_op,
     const std::string& version_string,
     const std::string& version_string2) {
   gl_version_info_.reset(new VersionInfo(
       version_op, std::string(), version_string, version_string2));
   return gl_version_info_->IsValid();
 }
 
 bool GpuControlList::GpuControlListEntry::SetGLVendorInfo(
+    const std::string& vendor_op,
     const std::string& vendor_value) {
-  gl_vendor_info_ = vendor_value;
-  return !gl_vendor_info_.empty();
+  gl_vendor_info_.reset(new StringInfo(vendor_op, vendor_value));
+  return gl_vendor_info_->IsValid();
 }
 
 bool GpuControlList::GpuControlListEntry::SetGLRendererInfo(
+    const std::string& renderer_op,
     const std::string& renderer_value) {
-  gl_renderer_info_ = renderer_value;
-  return !gl_renderer_info_.empty();
+  gl_renderer_info_.reset(new StringInfo(renderer_op, renderer_value));
+  return gl_renderer_info_->IsValid();
 }
 
 bool GpuControlList::GpuControlListEntry::SetGLExtensionsInfo(
+    const std::string& extensions_op,
     const std::string& extensions_value) {
-  gl_extensions_info_ = extensions_value;
-  return !gl_extensions_info_.empty();
+  gl_extensions_info_.reset(new StringInfo(extensions_op, extensions_value));
+  return gl_extensions_info_->IsValid();
 }
 
 bool GpuControlList::GpuControlListEntry::SetGLResetNotificationStrategyInfo(
     const std::string& op,
     const std::string& int_string,
     const std::string& int_string2) {
   gl_reset_notification_strategy_info_.reset(
       new IntInfo(op, int_string, int_string2));
   return gl_reset_notification_strategy_info_->IsValid();
 }
 
 bool GpuControlList::GpuControlListEntry::SetCpuBrand(
+    const std::string& cpu_op,
     const std::string& cpu_value) {
-  cpu_brand_ = cpu_value;
-  return !cpu_brand_.empty();
+  cpu_brand_.reset(new StringInfo(cpu_op, cpu_value));
+  return cpu_brand_->IsValid();
 }
 
 bool GpuControlList::GpuControlListEntry::SetPerfGraphicsInfo(
     const std::string& op,
     const std::string& float_string,
     const std::string& float_string2) {
   perf_graphics_info_.reset(new FloatInfo(op, float_string, float_string2));
   return perf_graphics_info_->IsValid();
 }
 
@@ skipping 249 matching lines @@
       if (!gpu_info.amd_switchable)
         return false;
       // Assume the integrated GPU is the first in the secondary GPU list.
       if (gpu_info.secondary_gpus.size() == 0 ||
           !gpu_info.secondary_gpus[0].active)
         return false;
       break;
     case kMultiGpuStyleNone:
       break;
   }
-  if (StringMismatch(gpu_info.driver_vendor, driver_vendor_info_))
+  if (driver_vendor_info_.get() != NULL && !gpu_info.driver_vendor.empty() &&
+      !driver_vendor_info_->Contains(gpu_info.driver_vendor))
     return false;
   if (driver_version_info_.get() != NULL && !gpu_info.driver_version.empty()) {
     if (!driver_version_info_->Contains(gpu_info.driver_version))
       return false;
   }
   if (driver_date_info_.get() != NULL && !gpu_info.driver_date.empty()) {
     if (!driver_date_info_->Contains(gpu_info.driver_date, '-'))
       return false;
   }
   if (GLVersionInfoMismatch(gpu_info.gl_version))
     return false;
-  if (StringMismatch(gpu_info.gl_vendor, gl_vendor_info_))
+  if (gl_vendor_info_.get() != NULL && !gpu_info.gl_vendor.empty() &&
+      !gl_vendor_info_->Contains(gpu_info.gl_vendor))
     return false;
-  if (StringMismatch(gpu_info.gl_renderer, gl_renderer_info_))
+  if (gl_renderer_info_.get() != NULL && !gpu_info.gl_renderer.empty() &&
+      !gl_renderer_info_->Contains(gpu_info.gl_renderer))
     return false;
-  if (StringMismatch(gpu_info.gl_extensions, gl_extensions_info_))
+  if (gl_extensions_info_.get() != NULL && !gpu_info.gl_extensions.empty() &&
+      !gl_extensions_info_->Contains(gpu_info.gl_extensions))
     return false;
   if (gl_reset_notification_strategy_info_.get() != NULL &&
       !gl_reset_notification_strategy_info_->Contains(
           gpu_info.gl_reset_notification_strategy))
     return false;
   if (perf_graphics_info_.get() != NULL &&
       (gpu_info.performance_stats.graphics == 0.0 ||
        !perf_graphics_info_->Contains(gpu_info.performance_stats.graphics)))
     return false;
   if (perf_gaming_info_.get() != NULL &&
       (gpu_info.performance_stats.gaming == 0.0 ||
        !perf_gaming_info_->Contains(gpu_info.performance_stats.gaming)))
     return false;
   if (perf_overall_info_.get() != NULL &&
       (gpu_info.performance_stats.overall == 0.0 ||
        !perf_overall_info_->Contains(gpu_info.performance_stats.overall)))
     return false;
   if (!machine_model_name_list_.empty()) {
     if (gpu_info.machine_model_name.empty())
       return false;
     bool found_match = false;
     for (size_t ii = 0; ii < machine_model_name_list_.size(); ++ii) {
-      if (RE2::FullMatch(gpu_info.machine_model_name,
-                         machine_model_name_list_[ii])) {
+      if (machine_model_name_list_[ii] == gpu_info.machine_model_name) {
         found_match = true;
         break;
       }
     }
     if (!found_match)
       return false;
   }
   if (machine_model_version_info_.get() != NULL &&
       (gpu_info.machine_model_version.empty() ||
        !machine_model_version_info_->Contains(gpu_info.machine_model_version)))
     return false;
   if (gpu_count_info_.get() != NULL &&
       !gpu_count_info_->Contains(gpu_info.secondary_gpus.size() + 1))
     return false;
   if (direct_rendering_info_.get() != NULL &&
       !direct_rendering_info_->Contains(gpu_info.direct_rendering))
     return false;
-  if (!cpu_brand_.empty()) {
+  if (cpu_brand_.get() != NULL) {
     base::CPU cpu_info;
-    if (StringMismatch(cpu_info.cpu_brand(), cpu_brand_))
+    if (!cpu_brand_->Contains(cpu_info.cpu_brand()))
       return false;
   }
 
   for (size_t i = 0; i < exceptions_.size(); ++i) {
     if (exceptions_[i]->Contains(os_type, os_version, gpu_info) &&
         !exceptions_[i]->NeedsMoreInfo(gpu_info))
       return false;
   }
   return true;
 }
 
 bool GpuControlList::GpuControlListEntry::NeedsMoreInfo(
     const GPUInfo& gpu_info) const {
   // We only check for missing info that might be collected with a gl context.
   // If certain info is missing due to some error, say, we fail to collect
   // vendor_id/device_id, then even if we launch GPU process and create a gl
   // context, we won't gather such missing info, so we still return false.
-  if (!driver_vendor_info_.empty() && gpu_info.driver_vendor.empty())
+  if (driver_vendor_info_.get() && gpu_info.driver_vendor.empty())
     return true;
   if (driver_version_info_.get() && gpu_info.driver_version.empty())
     return true;
-  if (!gl_vendor_info_.empty() && gpu_info.gl_vendor.empty())
+  if (gl_vendor_info_.get() && gpu_info.gl_vendor.empty())
     return true;
-  if (!gl_renderer_info_.empty() && gpu_info.gl_renderer.empty())
+  if (gl_renderer_info_.get() && gpu_info.gl_renderer.empty())
     return true;
   for (size_t i = 0; i < exceptions_.size(); ++i) {
     if (exceptions_[i]->NeedsMoreInfo(gpu_info))
       return true;
   }
   return false;
 }
 
 GpuControlList::OsType GpuControlList::GpuControlListEntry::GetOsType() const {
   if (os_info_.get() == NULL)
@@ skipping 241 matching lines @@
     const std::string& feature_name, int feature_id) {
   feature_map_[feature_name] = feature_id;
 }
 
 void GpuControlList::set_supports_feature_type_all(bool supported) {
   supports_feature_type_all_ = supported;
 }
 
 }  // namespace gpu