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());
-      active_entries_.push_back(blacklist_[i]);
+      if (blacklist_[i]->disabled()) {
+        active_disabled_entries_.push_back(blacklist_[i]);

[vangelis, 2011/09/21 21:27:17]

nit: active_disabled_ is somewhat contradicting.  How about using
disabled_entries_ instead? 

[Zhenyao Mo, 2011/09/22 17:10:39]

removed active_disabled_emtries_

+      } else {
+        flags.Combine(blacklist_[i]->GetGpuFeatureFlags());

[vangelis, 2011/09/21 21:27:17]

Wouldn't it be simpler to add a disabled_ field in each entry instead of
creating a new array of entries for disabled features?  That way,
GetGpuFeatureFlagEntries could take an additional boolean parameter on whether
to return disabled entries or not.

[Zhenyao Mo, 2011/09/22 17:10:39]

Done.

+        active_entries_.push_back(blacklist_[i]);
+      }
     }
   }
   return flags;
 }
 
 void GpuBlacklist::GetGpuFeatureFlagEntries(
     GpuFeatureFlags::GpuFeatureType feature,
     std::vector<uint32>& entry_ids) const {
   entry_ids.clear();
   for (size_t i = 0; i < active_entries_.size(); ++i) {
     if ((feature & active_entries_[i]->GetGpuFeatureFlags().flags()) != 0)
       entry_ids.push_back(active_entries_[i]->id());
   }
 }
 
+void GpuBlacklist::GetGpuFeatureFlagDisabledEntries(

[vangelis, 2011/09/21 21:27:17]

Instead of replicating the code here, this function could be consolidated with
the one above it by passing the entries array (disabled or active) as a
parameter. 

[Zhenyao Mo, 2011/09/22 17:10:39]

Done.  I used a consolidated array to store the entries and use the disabled()
entry field and the passed in boolean parameter to decide if an entry should be
added or not.

+    GpuFeatureFlags::GpuFeatureType feature,
+    std::vector<uint32>& entry_ids) const {
+  entry_ids.clear();
+  for (size_t i = 0; i < active_disabled_entries_.size(); ++i) {
+    if ((feature &
+         active_disabled_entries_[i]->GetGpuFeatureFlags().flags()) != 0)
+      entry_ids.push_back(active_disabled_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;
   }
   return false;
 }
 
@@ skipping 272 matching lines @@
     return kStable;
   if (value == "beta")
     return kBeta;
   if (value == "dev")
     return kDev;
   if (value == "canary")
     return kCanary;
   return kUnknown;
 }