Add exceptions to features in GpuControlList

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 <stddef.h>
 #include <stdint.h>
 
 #include "base/cpu.h"
@@ skipping 720 matching lines @@
   bool in_process_gpu;
   if (value->GetBoolean("in_process_gpu", &in_process_gpu)) {
     entry->SetInProcessGPUInfo(in_process_gpu);
     dictionary_entry_count++;
   }
 
   if (top_level) {
     const base::ListValue* feature_value = NULL;
     if (value->GetList("features", &feature_value)) {
       std::vector<std::string> feature_list;
+      std::vector<std::string> feature_exception_list;
       for (size_t i = 0; i < feature_value->GetSize(); ++i) {
         std::string feature;
+        const base::DictionaryValue* features_info_value = NULL;
         if (feature_value->GetString(i, &feature)) {
           feature_list.push_back(feature);
+        } else if (feature_value->GetDictionary(i, &features_info_value)) {
+          const base::ListValue* exception_list_value = NULL;
+          if (features_info_value->size() > 1) {
+            LOG(WARNING) << "Malformed feature entry " << entry->id();
+            return NULL;
+          }
+          if (features_info_value->GetList("exceptions",
+                                           &exception_list_value)) {
+            for (size_t i = 0; i < exception_list_value->GetSize(); ++i) {
+              std::string exception_feature;
+              if (exception_list_value->GetString(i, &exception_feature)) {
+                feature_exception_list.push_back(exception_feature);
+              } else {
+                LOG(WARNING) << "Malformed feature entry " << entry->id();
+                return NULL;
+              }
+            }
+          } else {
+            LOG(WARNING) << "Malformed feature entry " << entry->id();
+            return NULL;
+          }
         } else {
           LOG(WARNING) << "Malformed feature entry " << entry->id();
           return NULL;
         }
       }
-      if (!entry->SetFeatures(
-              feature_list, feature_map, supports_feature_type_all)) {
+      if (!entry->SetFeatures(feature_list, feature_exception_list, feature_map,
+                              supports_feature_type_all)) {
         LOG(WARNING) << "Malformed feature entry " << entry->id();
         return NULL;
       }
       dictionary_entry_count++;
     }
   }
 
   if (top_level) {
     const base::ListValue* exception_list_value = NULL;
     if (value->GetList("exceptions", &exception_list_value)) {
@@ skipping 228 matching lines @@
 void GpuControlList::GpuControlListEntry::SetDirectRenderingInfo(bool value) {
   direct_rendering_info_.reset(new BoolInfo(value));
 }
 
 void GpuControlList::GpuControlListEntry::SetInProcessGPUInfo(bool value) {
   in_process_gpu_info_.reset(new BoolInfo(value));
 }
 
 bool GpuControlList::GpuControlListEntry::SetFeatures(
     const std::vector<std::string>& feature_strings,
+    const std::vector<std::string>& exception_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;
     if (supports_feature_type_all && feature_strings[i] == "all") {
       for (FeatureMap::const_iterator iter = feature_map.begin();
-           iter != feature_map.end(); ++iter)
-        features_.insert(iter->second);
+           iter != feature_map.end(); ++iter) {
+        if (std::find(exception_strings.begin(), exception_strings.end(),
+                      iter->first) == exception_strings.end())
+          features_.insert(iter->second);
+      }
       continue;
     }
     if (!StringToFeature(feature_strings[i], &feature, feature_map)) {
       features_.clear();
       return false;
     }
-    features_.insert(feature);
+    if (std::find(exception_strings.begin(), exception_strings.end(),
+                  feature_strings[i]) == exception_strings.end())
+      features_.insert(feature);
   }
   return true;
 }
 
 void GpuControlList::GpuControlListEntry::AddException(
     ScopedGpuControlListEntry exception) {
   exceptions_.push_back(exception);
 }
 
 bool GpuControlList::GpuControlListEntry::GLVersionInfoMismatch(
@@ skipping 556 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