Relax software rendering list parsing.

At the moment if we fail to process one entry, like encountering an unrecognized field, we fail the whole blacklist loading.  This CL relaxes this behavior, so if we encounter unknown features, ignore them but keep the entry; if we encounter unknown fields in an entry, ignore the entry but keep the rest of the blacklist.

BUG=91872
TEST=unittest
Review URL: http://codereview.chromium.org/7633038

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@98162 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 234 insertions, 81 deletions

diff --git a/content/browser/gpu/gpu_blacklist.cc b/content/browser/gpu/gpu_blacklist.cc
index 255ab4b..0945e96 100644
--- a/content/browser/gpu/gpu_blacklist.cc
+++ b/content/browser/gpu/gpu_blacklist.cc
@@ -206,11 +206,12 @@ GpuBlacklist::StringInfo::Op GpuBlacklist::StringInfo::StringToOp(
   return kUnknown;
 }
 
+// static
 GpuBlacklist::GpuBlacklistEntry*
 GpuBlacklist::GpuBlacklistEntry::GetGpuBlacklistEntryFromValue(
     DictionaryValue* value, bool top_level) {
   DCHECK(value);
-  scoped_ptr<GpuBlacklistEntry> entry(new GpuBlacklistEntry());
+  ScopedGpuBlacklistEntry entry(new GpuBlacklistEntry());
 
   size_t dictionary_entry_count = 0;
 
@@ -393,13 +394,18 @@ GpuBlacklist::GpuBlacklistEntry::GetGpuBlacklistEntryFromValue(
           LOG(WARNING) << "Malformed exceptions entry " << entry->id();
           return NULL;
         }
-        GpuBlacklistEntry* exception = GetGpuBlacklistEntryFromValue(
-            exception_value, false);
+        ScopedGpuBlacklistEntry exception(
+            GetGpuBlacklistEntryFromValue(exception_value, false));
         if (exception == NULL) {
           LOG(WARNING) << "Malformed exceptions entry " << entry->id();
           return NULL;
         }
-        entry->AddException(exception);
+        if (exception->contains_unknown_fields_) {
+          LOG(WARNING) << "Exception with unknown fields " << entry->id();
+          entry->contains_unknown_fields_ = true;
+        } else {
+          entry->AddException(exception);
+        }
       }
       dictionary_entry_count++;
     }
@@ -411,20 +417,17 @@ GpuBlacklist::GpuBlacklistEntry::GetGpuBlacklistEntryFromValue(
   }
 
   if (value->size() != dictionary_entry_count) {
-    LOG(WARNING) << "Malformed entry " << entry->id();
-    return NULL;
+    LOG(WARNING) << "Entry with unknown fields " << entry->id();
+    entry->contains_unknown_fields_ = true;
   }
   return entry.release();
 }
 
-GpuBlacklist::GpuBlacklistEntry::~GpuBlacklistEntry() {
-  for (size_t i = 0; i < exceptions_.size(); ++i)
-    delete exceptions_[i];
-}
-
 GpuBlacklist::GpuBlacklistEntry::GpuBlacklistEntry()
     : id_(0),
-      vendor_id_(0) {
+      vendor_id_(0),
+      contains_unknown_fields_(false),
+      contains_unknown_features_(false) {
 }
 
 bool GpuBlacklist::GpuBlacklistEntry::SetId(uint32 id) {
@@ -514,7 +517,8 @@ bool GpuBlacklist::GpuBlacklistEntry::SetBlacklistedFeatures(
         flags |= type;
         break;
       case GpuFeatureFlags::kGpuFeatureUnknown:
-        return false;
+        contains_unknown_features_ = true;
+        break;
     }
   }
   feature_flags_.reset(new GpuFeatureFlags());
@@ -586,7 +590,8 @@ GpuFeatureFlags GpuBlacklist::GpuBlacklistEntry::GetGpuFeatureFlags() const {
 }
 
 GpuBlacklist::GpuBlacklist(const std::string& browser_version_string)
-    : max_entry_id_(0) {
+    : max_entry_id_(0),
+      contains_unknown_fields_(false) {
   browser_version_.reset(Version::GetVersionFromString(browser_version_string));
   DCHECK(browser_version_.get() != NULL);
 }
@@ -595,8 +600,8 @@ GpuBlacklist::~GpuBlacklist() {
   Clear();
 }
 
-bool GpuBlacklist::LoadGpuBlacklist(const std::string& json_context,
-                                    bool current_os_only) {
+bool GpuBlacklist::LoadGpuBlacklist(
+    const std::string& json_context, GpuBlacklist::OsFilter os_filter) {
   scoped_ptr<Value> root;
   root.reset(base::JSONReader::Read(json_context, false));
   if (root.get() == NULL || !root->IsType(Value::TYPE_DICTIONARY))
@@ -604,12 +609,12 @@ bool GpuBlacklist::LoadGpuBlacklist(const std::string& json_context,
 
   DictionaryValue* root_dictionary = static_cast<DictionaryValue*>(root.get());
   DCHECK(root_dictionary);
-  return LoadGpuBlacklist(*root_dictionary, current_os_only);
+  return LoadGpuBlacklist(*root_dictionary, os_filter);
 }
 
-bool GpuBlacklist::LoadGpuBlacklist(const DictionaryValue& parsed_json,
-                                    bool current_os_only) {
-  std::vector<GpuBlacklistEntry*> entries;
+bool GpuBlacklist::LoadGpuBlacklist(
+    const DictionaryValue& parsed_json, GpuBlacklist::OsFilter os_filter) {
+  std::vector<ScopedGpuBlacklistEntry> entries;
 
   std::string version_string;
   parsed_json.GetString("version", &version_string);
@@ -622,54 +627,48 @@ bool GpuBlacklist::LoadGpuBlacklist(const DictionaryValue& parsed_json,
     return false;
 
   uint32 max_entry_id = 0;
-  size_t entry_count_expectation = list->GetSize();
+  bool contains_unknown_fields = false;
   for (size_t i = 0; i < list->GetSize(); ++i) {
     DictionaryValue* list_item = NULL;
     bool valid = list->GetDictionary(i, &list_item);
-    if (!valid)
-      break;
-    if (list_item == NULL)
-      break;
+    if (!valid || list_item == NULL)
+      return false;
     // Check browser version compatibility: if the entry is not for the
     // current browser version, don't process it.
     BrowserVersionSupport browser_version_support =
         IsEntrySupportedByCurrentBrowserVersion(list_item);
     if (browser_version_support == kMalformed)
-      break;
-    if (browser_version_support == kUnsupported) {
-      entry_count_expectation--;
+      return false;
+    if (browser_version_support == kUnsupported)
       continue;
-    }
     DCHECK(browser_version_support == kSupported);
-    GpuBlacklistEntry* entry =
-        GpuBlacklistEntry::GetGpuBlacklistEntryFromValue(list_item, true);
+    ScopedGpuBlacklistEntry entry(
+        GpuBlacklistEntry::GetGpuBlacklistEntryFromValue(list_item, true));
     if (entry == NULL)
-      break;
+      return false;
     if (entry->id() > max_entry_id)
       max_entry_id = entry->id();
+    // If an unknown field is encountered, skip the entry; if an unknown
+    // feature is encountered, ignore the feature, but keep the entry.
+    if (entry->contains_unknown_fields()) {
+      contains_unknown_fields = true;
+      continue;
+    }
+    if (entry->contains_unknown_features())
+      contains_unknown_fields = true;
     entries.push_back(entry);
   }
 
-  if (entries.size() != entry_count_expectation) {
-    for (size_t i = 0; i < entries.size(); ++i)
-      delete entries[i];
-    return false;
-  }
-
   Clear();
-  // Don't apply GPU blacklist for a non-registered OS.
-  OsType os_filter = GetOsType();
-  if (os_filter != kOsUnknown) {
-    for (size_t i = 0; i < entries.size(); ++i) {
-      OsType entry_os = entries[i]->GetOsType();
-      if (!current_os_only ||
-          entry_os == kOsAny || entry_os == os_filter)
-        blacklist_.push_back(entries[i]);
-      else
-        delete entries[i];
-    }
+  OsType my_os = GetOsType();
+  for (size_t i = 0; i < entries.size(); ++i) {
+    OsType entry_os = entries[i]->GetOsType();
+    if (os_filter == GpuBlacklist::kAllOs ||
+        entry_os == kOsAny || entry_os == my_os)
+      blacklist_.push_back(entries[i]);
   }
   max_entry_id_ = max_entry_id;
+  contains_unknown_fields_ = contains_unknown_fields;
   return true;
 }
 
@@ -865,7 +864,7 @@ Value* GpuBlacklist::GetFeatureStatus(bool gpu_access_allowed,
       problem_list->Append(problem);
     }
     for (size_t i = 0; i < active_entries_.size(); ++i) {
-      GpuBlacklistEntry* entry = active_entries_[i];
+      ScopedGpuBlacklistEntry entry = active_entries_[i];
       DictionaryValue* problem = new DictionaryValue();
 
       problem->SetString("description", entry->description());
@@ -889,6 +888,10 @@ Value* GpuBlacklist::GetFeatureStatus(bool gpu_access_allowed,
   return status;
 }
 
+size_t GpuBlacklist::num_entries() const {
+  return blacklist_.size();
+}
+
 uint32 GpuBlacklist::max_entry_id() const {
   return max_entry_id_;
 }
@@ -941,10 +944,10 @@ GpuBlacklist::OsType GpuBlacklist::GetOsType() {
 }
 
 void GpuBlacklist::Clear() {
-  for (size_t i = 0; i < blacklist_.size(); ++i)
-    delete blacklist_[i];
   blacklist_.clear();
   active_entries_.clear();
+  max_entry_id_ = 0;
+  contains_unknown_fields_ = false;
 }
 
 GpuBlacklist::BrowserVersionSupport
diff --git a/content/browser/gpu/gpu_blacklist.h b/content/browser/gpu/gpu_blacklist.h
index 109c4f8..1dd038b 100644
--- a/content/browser/gpu/gpu_blacklist.h
+++ b/content/browser/gpu/gpu_blacklist.h
@@ -10,6 +10,8 @@
 #include <vector>
 
 #include "base/basictypes.h"
+#include "base/gtest_prod_util.h"
+#include "base/memory/ref_counted.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/values.h"
 #include "content/common/gpu/gpu_feature_flags.h"
@@ -32,18 +34,21 @@ class GpuBlacklist {
     kOsUnknown
   };
 
+  enum OsFilter {
+    // In loading, ignore all entries that belong to other OS.
+    kCurrentOsOnly,
+    // In loading, keep all entries. This is for testing only.
+    kAllOs
+  };
+
   explicit GpuBlacklist(const std::string& browser_version_string);
   ~GpuBlacklist();
 
   // Loads blacklist information from a json file.
-  // current_os_only==true indicates all blacklist entries that don't belong to
-  // the current OS are discarded; current_os_only==false should only be used
-  // for testing purpose.
   // If failed, the current GpuBlacklist is un-touched.
-  bool LoadGpuBlacklist(const std::string& json_context,
-                        bool current_os_only);
+  bool LoadGpuBlacklist(const std::string& json_context, OsFilter os_filter);
   bool LoadGpuBlacklist(const base::DictionaryValue& parsed_json,
-                        bool current_os_only);
+                        OsFilter os_filter);
 
   // Collects system information and combines them with gpu_info and blacklist
   // information to determine gpu feature flags.
@@ -63,7 +68,6 @@ class GpuBlacklist {
   void GetGpuFeatureFlagEntries(GpuFeatureFlags::GpuFeatureType feature,
                                 std::vector<uint32>& entry_ids) const;
 
-
   // Returns status information on the blacklist. This is two parted:
   // {
   //    featureStatus: []
@@ -109,6 +113,11 @@ class GpuBlacklist {
       const base::DictionaryValue& parsed_json, uint16* major, uint16* minor);
 
  private:
+  FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, CurrentBlacklistValidation);
+  FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, UnknownField);
+  FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, UnknownExceptionField);
+  FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, UnknownFeature);
+
   class VersionInfo {
    public:
     VersionInfo(const std::string& version_op,
@@ -192,7 +201,10 @@ class GpuBlacklist {
     std::string value_;
   };
 
-  class GpuBlacklistEntry {
+  class GpuBlacklistEntry;
+  typedef scoped_refptr<GpuBlacklistEntry> ScopedGpuBlacklistEntry;
+
+  class GpuBlacklistEntry : public base::RefCounted<GpuBlacklistEntry> {
    public:
     // Constructs GpuBlacklistEntry from DictionaryValue loaded from json.
     // Top-level entry must have an id number.  Others are exceptions.
@@ -213,17 +225,27 @@ class GpuBlacklist {
     // Returns the description of the entry
     const std::string& description() const { return description_; }
 
-    // Returs a list of Chromium and Webkit bugs applicable to this entry
+    // Returns a list of Chromium and Webkit bugs applicable to this entry
     const std::vector<int>& cr_bugs() const { return cr_bugs_; }
     const std::vector<int>& webkit_bugs() const { return webkit_bugs_; }
 
     // Returns the GpuFeatureFlags.
     GpuFeatureFlags GetGpuFeatureFlags() const;
 
-    ~GpuBlacklistEntry();
+    // Returns true if an unknown field is encountered.
+    bool contains_unknown_fields() const {
+      return contains_unknown_fields_;
+    }
+    // Returns true if an unknown blacklist feature is encountered.
+    bool contains_unknown_features() const {
+      return contains_unknown_features_;
+    }
 
    private:
+    friend class base::RefCounted<GpuBlacklistEntry>;
+
     GpuBlacklistEntry();
+    ~GpuBlacklistEntry() { }
 
     bool SetId(uint32 id);
 
@@ -267,7 +289,9 @@ class GpuBlacklist {
     scoped_ptr<VersionInfo> driver_date_info_;
     scoped_ptr<StringInfo> gl_renderer_info_;
     scoped_ptr<GpuFeatureFlags> feature_flags_;
-    std::vector<GpuBlacklistEntry*> exceptions_;
+    std::vector<ScopedGpuBlacklistEntry> exceptions_;
+    bool contains_unknown_fields_;
+    bool contains_unknown_features_;
   };
 
   enum BrowserVersionSupport {
@@ -289,18 +313,26 @@ class GpuBlacklist {
   BrowserVersionSupport IsEntrySupportedByCurrentBrowserVersion(
       base::DictionaryValue* value);
 
+  // Returns the number of entries.  This is only for tests.
+  size_t num_entries() const;
+
+  // Check if any entries contain unknown fields.  This is only for tests.
+  bool contains_unknown_fields() const { return contains_unknown_fields_; }
+
   scoped_ptr<Version> version_;
-  std::vector<GpuBlacklistEntry*> blacklist_;
+  std::vector<ScopedGpuBlacklistEntry> blacklist_;
 
   scoped_ptr<Version> browser_version_;
 
   // This records all the blacklist entries that are appliable to the current
   // user machine.  It is updated everytime DetermineGpuFeatureFlags() is
   // called and is used later by GetGpuFeatureFlagEntries().
-  std::vector<GpuBlacklistEntry*> active_entries_;
+  std::vector<ScopedGpuBlacklistEntry> active_entries_;
 
   uint32 max_entry_id_;
 
+  bool contains_unknown_fields_;
+
   DISALLOW_COPY_AND_ASSIGN(GpuBlacklist);
 };
 
diff --git a/content/browser/gpu/gpu_blacklist_unittest.cc b/content/browser/gpu/gpu_blacklist_unittest.cc
index 3d6cc9b..55e8de1 100644
--- a/content/browser/gpu/gpu_blacklist_unittest.cc
+++ b/content/browser/gpu/gpu_blacklist_unittest.cc
@@ -57,10 +57,11 @@ TEST_F(GpuBlacklistTest, CurrentBlacklistValidation) {
             data_file_size);
   std::string json_string(data.get(), data_file_size);
   GpuBlacklist blacklist("1.0");
-  EXPECT_TRUE(blacklist.LoadGpuBlacklist(json_string, true));
+  EXPECT_TRUE(blacklist.LoadGpuBlacklist(json_string, GpuBlacklist::kAllOs));
+  EXPECT_FALSE(blacklist.contains_unknown_fields());
 }
 
-TEST_F(GpuBlacklistTest, DeafaultBlacklistSettings) {
+TEST_F(GpuBlacklistTest, DefaultBlacklistSettings) {
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
   GpuBlacklist blacklist("1.0");
   // Default blacklist settings: all feature are allowed.
@@ -81,7 +82,8 @@ TEST_F(GpuBlacklistTest, EmptyBlacklist) {
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
   GpuBlacklist blacklist("1.0");
 
-  EXPECT_TRUE(blacklist.LoadGpuBlacklist(empty_list_json, false));
+  EXPECT_TRUE(
+      blacklist.LoadGpuBlacklist(empty_list_json, GpuBlacklist::kAllOs));
   uint16 major, minor;
   EXPECT_TRUE(blacklist.GetVersion(&major, &minor));
   EXPECT_EQ(major, 2u);
@@ -122,7 +124,8 @@ TEST_F(GpuBlacklistTest, DetailedEntryAndInvalidJson) {
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
   GpuBlacklist blacklist("1.0");
 
-  EXPECT_TRUE(blacklist.LoadGpuBlacklist(exact_list_json, false));
+  EXPECT_TRUE(
+      blacklist.LoadGpuBlacklist(exact_list_json, GpuBlacklist::kAllOs));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
       GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(
@@ -132,7 +135,7 @@ TEST_F(GpuBlacklistTest, DetailedEntryAndInvalidJson) {
   // Invalid json input should not change the current blacklist settings.
   const std::string invalid_json = "invalid";
 
-  EXPECT_FALSE(blacklist.LoadGpuBlacklist(invalid_json, false));
+  EXPECT_FALSE(blacklist.LoadGpuBlacklist(invalid_json, GpuBlacklist::kAllOs));
   flags = blacklist.DetermineGpuFeatureFlags(
       GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(
@@ -170,7 +173,7 @@ TEST_F(GpuBlacklistTest, VendorOnAllOsEntry) {
   GpuBlacklist blacklist("1.0");
 
   // Blacklist entries won't be filtered to the current OS only upon loading.
-  EXPECT_TRUE(blacklist.LoadGpuBlacklist(vendor_json, false));
+  EXPECT_TRUE(blacklist.LoadGpuBlacklist(vendor_json, GpuBlacklist::kAllOs));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
       GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(),
@@ -185,7 +188,8 @@ TEST_F(GpuBlacklistTest, VendorOnAllOsEntry) {
             static_cast<uint32>(GpuFeatureFlags::kGpuFeatureWebgl));
 #if defined(OS_WIN) || defined(OS_LINUX) || defined(OS_MACOSX)
   // Blacklist entries will be filtered to the current OS only upon loading.
-  EXPECT_TRUE(blacklist.LoadGpuBlacklist(vendor_json, true));
+  EXPECT_TRUE(
+      blacklist.LoadGpuBlacklist(vendor_json, GpuBlacklist::kCurrentOsOnly));
   flags = blacklist.DetermineGpuFeatureFlags(
       GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(),
@@ -223,7 +227,8 @@ TEST_F(GpuBlacklistTest, VendorOnLinuxEntry) {
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
   GpuBlacklist blacklist("1.0");
 
-  EXPECT_TRUE(blacklist.LoadGpuBlacklist(vendor_linux_json, false));
+  EXPECT_TRUE(
+      blacklist.LoadGpuBlacklist(vendor_linux_json, GpuBlacklist::kAllOs));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
       GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
@@ -263,7 +268,8 @@ TEST_F(GpuBlacklistTest, AllExceptNVidiaOnLinuxEntry) {
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
   GpuBlacklist blacklist("1.0");
 
-  EXPECT_TRUE(blacklist.LoadGpuBlacklist(linux_except_nvidia_json, false));
+  EXPECT_TRUE(blacklist.LoadGpuBlacklist(linux_except_nvidia_json,
+      GpuBlacklist::kAllOs));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
       GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
@@ -301,7 +307,8 @@ TEST_F(GpuBlacklistTest, AllExceptIntelOnLinuxEntry) {
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
   GpuBlacklist blacklist("1.0");
 
-  EXPECT_TRUE(blacklist.LoadGpuBlacklist(linux_except_intel_json, false));
+  EXPECT_TRUE(blacklist.LoadGpuBlacklist(linux_except_intel_json,
+      GpuBlacklist::kAllOs));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
       GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
@@ -340,7 +347,8 @@ TEST_F(GpuBlacklistTest, DateOnWindowsEntry) {
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
   GpuBlacklist blacklist("1.0");
 
-  EXPECT_TRUE(blacklist.LoadGpuBlacklist(date_windows_json, false));
+  EXPECT_TRUE(
+      blacklist.LoadGpuBlacklist(date_windows_json, GpuBlacklist::kAllOs));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
       GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
@@ -373,7 +381,7 @@ TEST_F(GpuBlacklistTest, MultipleDevicesEntry) {
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
   GpuBlacklist blacklist("1.0");
 
-  EXPECT_TRUE(blacklist.LoadGpuBlacklist(devices_json, false));
+  EXPECT_TRUE(blacklist.LoadGpuBlacklist(devices_json, GpuBlacklist::kAllOs));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
       GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(),
@@ -408,7 +416,7 @@ TEST_F(GpuBlacklistTest, ChromeOSEntry) {
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
   GpuBlacklist blacklist("1.0");
 
-  EXPECT_TRUE(blacklist.LoadGpuBlacklist(devices_json, false));
+  EXPECT_TRUE(blacklist.LoadGpuBlacklist(devices_json, GpuBlacklist::kAllOs));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
       GpuBlacklist::kOsChromeOS, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(),
@@ -439,13 +447,15 @@ TEST_F(GpuBlacklistTest, ChromeVersionEntry) {
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
 
   GpuBlacklist blacklist9("9.0");
-  EXPECT_TRUE(blacklist9.LoadGpuBlacklist(browser_version_json, false));
+  EXPECT_TRUE(
+      blacklist9.LoadGpuBlacklist(browser_version_json, GpuBlacklist::kAllOs));
   GpuFeatureFlags flags = blacklist9.DetermineGpuFeatureFlags(
       GpuBlacklist::kOsWin, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
 
   GpuBlacklist blacklist10("10.0");
-  EXPECT_TRUE(blacklist10.LoadGpuBlacklist(browser_version_json, false));
+  EXPECT_TRUE(
+      blacklist10.LoadGpuBlacklist(browser_version_json, GpuBlacklist::kAllOs));
   flags = blacklist10.DetermineGpuFeatureFlags(
       GpuBlacklist::kOsWin, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(),
@@ -470,6 +480,114 @@ TEST_F(GpuBlacklistTest, MalformedVendor) {
       "}";
   GpuBlacklist blacklist("1.0");
 
-  EXPECT_FALSE(blacklist.LoadGpuBlacklist(malformed_vendor_json, false));
+  EXPECT_FALSE(
+      blacklist.LoadGpuBlacklist(malformed_vendor_json, GpuBlacklist::kAllOs));
+}
+
+TEST_F(GpuBlacklistTest, UnknownField) {
+  const std::string unknown_field_json =
+      "{\n"
+      "  \"name\": \"gpu blacklist\",\n"
+      "  \"version\": \"0.1\",\n"
+      "  \"entries\": [\n"
+      "    {\n"
+      "      \"id\": 1,\n"
+      "      \"unknown_field\": 0,\n"
+      "      \"blacklist\": [\n"
+      "        \"accelerated_2d_canvas\"\n"
+      "      ]\n"
+      "    },\n"
+      "    {\n"
+      "      \"id\": 2,\n"
+      "      \"blacklist\": [\n"
+      "        \"webgl\"\n"
+      "      ]\n"
+      "    }\n"
+      "  ]\n"
+      "}";
+  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  GpuBlacklist blacklist("1.0");
+
+  EXPECT_TRUE(
+      blacklist.LoadGpuBlacklist(unknown_field_json, GpuBlacklist::kAllOs));
+  EXPECT_EQ(1u, blacklist.num_entries());
+  EXPECT_TRUE(blacklist.contains_unknown_fields());
+  GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
+      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+  EXPECT_EQ(flags.flags(),
+            static_cast<uint32>(GpuFeatureFlags::kGpuFeatureWebgl));
+}
+
+TEST_F(GpuBlacklistTest, UnknownExceptionField) {
+  const std::string unknown_exception_field_json =
+      "{\n"
+      "  \"name\": \"gpu blacklist\",\n"
+      "  \"version\": \"0.1\",\n"
+      "  \"entries\": [\n"
+      "    {\n"
+      "      \"id\": 1,\n"
+      "      \"unknown_field\": 0,\n"
+      "      \"blacklist\": [\n"
+      "        \"accelerated_compositing\"\n"
+      "      ]\n"
+      "    },\n"
+      "    {\n"
+      "      \"id\": 2,\n"
+      "      \"exceptions\": [\n"
+      "        {\n"
+      "          \"unknown_field\": 0\n"
+      "        }\n"
+      "      ],\n"
+      "      \"blacklist\": [\n"
+      "        \"accelerated_2d_canvas\"\n"
+      "      ]\n"
+      "    },\n"
+      "    {\n"
+      "      \"id\": 3,\n"
+      "      \"blacklist\": [\n"
+      "        \"webgl\"\n"
+      "      ]\n"
+      "    }\n"
+      "  ]\n"
+      "}";
+  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  GpuBlacklist blacklist("1.0");
+
+  EXPECT_TRUE(blacklist.LoadGpuBlacklist(unknown_exception_field_json,
+      GpuBlacklist::kAllOs));
+  EXPECT_EQ(1u, blacklist.num_entries());
+  EXPECT_TRUE(blacklist.contains_unknown_fields());
+  GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
+      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+  EXPECT_EQ(flags.flags(),
+            static_cast<uint32>(GpuFeatureFlags::kGpuFeatureWebgl));
+}
+
+TEST_F(GpuBlacklistTest, UnknownFeature) {
+  const std::string unknown_feature_json =
+      "{\n"
+      "  \"name\": \"gpu blacklist\",\n"
+      "  \"version\": \"0.1\",\n"
+      "  \"entries\": [\n"
+      "    {\n"
+      "      \"id\": 1,\n"
+      "      \"blacklist\": [\n"
+      "        \"accelerated_something\",\n"
+      "        \"webgl\"\n"
+      "      ]\n"
+      "    }\n"
+      "  ]\n"
+      "}";
+  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  GpuBlacklist blacklist("1.0");
+
+  EXPECT_TRUE(
+      blacklist.LoadGpuBlacklist(unknown_feature_json, GpuBlacklist::kAllOs));
+  EXPECT_EQ(1u, blacklist.num_entries());
+  EXPECT_TRUE(blacklist.contains_unknown_fields());
+  GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
+      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+  EXPECT_EQ(flags.flags(),
+            static_cast<uint32>(GpuFeatureFlags::kGpuFeatureWebgl));
 }