Add a "disabled" field for GPU Blacklist entries.

content/browser/gpu/gpu_blacklist.cc

 // Copyright (c) 2011 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 "content/browser/gpu/gpu_blacklist.h"
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_piece.h"
@@ skipping 205 matching lines @@
   size_t dictionary_entry_count = 0;
 
   if (top_level) {
     uint32 id;
     if (!value->GetInteger("id", reinterpret_cast<int*>(&id)) ||
         !entry->SetId(id)) {
       LOG(WARNING) << "Malformed id entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
+
+    bool disabled;
+    if (value->GetBoolean("disabled", &disabled)) {
+      entry->SetDisabled(disabled);
+      dictionary_entry_count++;
+    }
   }
 
   std::string description;
   if (value->GetString("description", &description)) {
     entry->description_ = description;
     dictionary_entry_count++;
   } else {
     entry->description_ = "The GPU is unavailable for an unexplained reason.";
   }
 
@@ skipping 213 matching lines @@
 
   if (value->size() != dictionary_entry_count) {
     LOG(WARNING) << "Entry with unknown fields " << entry->id();
     entry->contains_unknown_fields_ = true;
   }
   return entry;
 }
 
 GpuBlacklist::GpuBlacklistEntry::GpuBlacklistEntry()
     : id_(0),
+      disabled_(false),
       vendor_id_(0),
       contains_unknown_fields_(false),
       contains_unknown_features_(false) {
 }
 
 bool GpuBlacklist::GpuBlacklistEntry::SetId(uint32 id) {
   if (id != 0) {
     id_ = id;
     return true;
   }
   return false;
 }
 
+void GpuBlacklist::GpuBlacklistEntry::SetDisabled(bool disabled) {
+  disabled_ = disabled;
+}
+
 bool GpuBlacklist::GpuBlacklistEntry::SetOsInfo(
     const std::string& os,
     const std::string& version_op,
     const std::string& version_string,
     const std::string& version_string2) {
   os_info_.reset(new OsInfo(os, version_op, version_string, version_string2));
   return os_info_->IsValid();
 }
 
 bool GpuBlacklist::GpuBlacklistEntry::SetVendorId(
@@ skipping 155 matching lines @@
 GpuBlacklist::OsType GpuBlacklist::GpuBlacklistEntry::GetOsType() const {
   if (os_info_.get() == NULL)
     return kOsAny;
   return os_info_->type();
 }
 
 uint32 GpuBlacklist::GpuBlacklistEntry::id() const {
   return id_;
 }
 
+bool GpuBlacklist::GpuBlacklistEntry::disabled() const {
+  return disabled_;
+}
+
 GpuFeatureFlags GpuBlacklist::GpuBlacklistEntry::GetGpuFeatureFlags() const {
   return *feature_flags_;
 }
 
 GpuBlacklist::GpuBlacklist(const std::string& browser_info_string)
     : max_entry_id_(0),
       contains_unknown_fields_(false) {
   SetBrowserInfo(browser_info_string);
 }
 
@@ skipping 88 matching lines @@
     size_t pos = version_string.find_first_not_of("0123456789.");
     if (pos != std::string::npos)
       version_string = version_string.substr(0, pos);
     my_os_version.reset(Version::GetVersionFromString(version_string));
     os_version = my_os_version.get();
   }
   DCHECK(os_version != NULL);
 
   for (size_t i = 0; i < blacklist_.size(); ++i) {
     if (blacklist_[i]->Contains(os, *os_version, browser_channel_, gpu_info)) {
-      flags.Combine(blacklist_[i]->GetGpuFeatureFlags());
+      if (!blacklist_[i]->disabled())
+        flags.Combine(blacklist_[i]->GetGpuFeatureFlags());
       active_entries_.push_back(blacklist_[i]);
     }
   }
   return flags;
 }
 
 void GpuBlacklist::GetGpuFeatureFlagEntries(
     GpuFeatureFlags::GpuFeatureType feature,
-    std::vector<uint32>& entry_ids) const {
+    std::vector<uint32>& entry_ids,
+    bool disabled) const {
   entry_ids.clear();
   for (size_t i = 0; i < active_entries_.size(); ++i) {
-    if ((feature & active_entries_[i]->GetGpuFeatureFlags().flags()) != 0)
+    if (((feature & active_entries_[i]->GetGpuFeatureFlags().flags()) != 0) &&
+        disabled == active_entries_[i]->disabled())
       entry_ids.push_back(active_entries_[i]->id());
   }
 }
 
 bool GpuBlacklist::IsFeatureBlacklisted(
     GpuFeatureFlags::GpuFeatureType feature) const
 {
   for (size_t i = 0; i < active_entries_.size(); ++i) {
     if (active_entries_[i]->GetGpuFeatureFlags().flags() & feature)
       return true;
@@ skipping 276 matching lines @@
     return kStable;
   if (value == "beta")
     return kBeta;
   if (value == "dev")
     return kDev;
   if (value == "canary")
     return kCanary;
   return kUnknown;
 }