Blacklist GLX indirect rendering

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"
@@ skipping 396 matching lines @@
     return (value >= value_);
   DCHECK(op_ == kBetween);
   return ((value_ <= value && value <= value2_) ||
           (value2_ <= value && value <= value_));
 }
 
 bool GpuControlList::IntInfo::IsValid() const {
   return op_ != kUnknown;
 }
 
+GpuControlList::BoolInfo::BoolInfo(const std::string& bool_value)
+    : valid_(false),
+      value_(false) {
+  if (bool_value == "true") {
+    valid_ = true;
+    value_ = true;
+  } else if (bool_value == "false") {
+    valid_ = true;
+    value_ = false;
+  }
+}
+
+bool GpuControlList::BoolInfo::Contains(bool value) const {
+  if (!valid_)
+    return false;
+  return value_ == value;
+}
+
+bool GpuControlList::BoolInfo::IsValid() const {
+  return valid_;
+}
+
 // static
 GpuControlList::ScopedGpuControlListEntry
 GpuControlList::GpuControlListEntry::GetEntryFromValue(
     const base::DictionaryValue* value, bool top_level,
     const FeatureMap& feature_map,
     bool supports_feature_type_all) {
   DCHECK(value);
   ScopedGpuControlListEntry entry(new GpuControlListEntry());
 
   size_t dictionary_entry_count = 0;
@@ skipping 310 matching lines @@
     gpu_count_value->GetString(kOp, &op);
     gpu_count_value->GetString("value", &int_value);
     gpu_count_value->GetString("value2", &int_value2);
     if (!entry->SetGpuCountInfo(op, int_value, int_value2)) {
       LOG(WARNING) << "Malformed gpu_count entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
+  std::string direct_rendering_string;
+  if (value->GetString("direct_rendering", &direct_rendering_string)) {
+    if (!entry->SetDirectRenderingInfo(direct_rendering_string)) {
+      LOG(WARNING) << "Malformed direct_rendering entry " << entry->id();
+      return NULL;
+    }
+    dictionary_entry_count++;
+  }
+
   if (top_level) {
     const base::ListValue* feature_value = NULL;
     if (value->GetList("features", &feature_value)) {
       std::vector<std::string> feature_list;
       for (size_t i = 0; i < feature_value->GetSize(); ++i) {
         std::string feature;
         if (feature_value->GetString(i, &feature)) {
           feature_list.push_back(feature);
         } else {
           LOG(WARNING) << "Malformed feature entry " << entry->id();
@@ skipping 206 matching lines @@
 }
 
 bool GpuControlList::GpuControlListEntry::SetGpuCountInfo(
     const std::string& op,
     const std::string& int_string,
     const std::string& int_string2) {
   gpu_count_info_.reset(new IntInfo(op, int_string, int_string2));
   return gpu_count_info_->IsValid();
 }
 
+bool GpuControlList::GpuControlListEntry::SetDirectRenderingInfo(
+    const std::string& value) {
+  direct_rendering_info_.reset(new BoolInfo(value));
+  return direct_rendering_info_->IsValid();
+}
+
 bool GpuControlList::GpuControlListEntry::SetFeatures(
     const std::vector<std::string>& feature_strings,
     const FeatureMap& feature_map,
     bool supports_feature_type_all) {
   size_t size = feature_strings.size();
   if (size == 0)
     return false;
   features_.clear();
   for (size_t i = 0; i < size; ++i) {
     int feature = 0;
@@ skipping 129 matching lines @@
   if (machine_model_info_.get() != NULL) {
     std::vector<std::string> name_version;
     base::SplitString(gpu_info.machine_model, ' ', &name_version);
     if (name_version.size() == 2 &&
         !machine_model_info_->Contains(name_version[0], name_version[1]))
       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_.get() != NULL) {
     base::CPU cpu_info;
     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;
@@ skipping 275 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