Add browser version control in gpu blacklist entry. This allows us to push out an entry for a specific version of chrome.

BUG=78064
TEST=unittest
Review URL: http://codereview.chromium.org/6693080

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

3 files changed, 104 insertions, 17 deletions

diff --git a/content/browser/gpu_blacklist.cc b/content/browser/gpu_blacklist.cc
index c64ddca..ee83df3 100644
--- a/content/browser/gpu_blacklist.cc
+++ b/content/browser/gpu_blacklist.cc
@@ -201,9 +201,7 @@ GpuBlacklist::StringInfo::Op GpuBlacklist::StringInfo::StringToOp(
 GpuBlacklist::GpuBlacklistEntry*
 GpuBlacklist::GpuBlacklistEntry::GetGpuBlacklistEntryFromValue(
     DictionaryValue* value, bool top_level) {
-  if (value == NULL)
-    return NULL;
-
+  DCHECK(value);
   scoped_ptr<GpuBlacklistEntry> entry(new GpuBlacklistEntry());
 
   if (top_level) {
@@ -555,8 +553,10 @@ GpuFeatureFlags GpuBlacklist::GpuBlacklistEntry::GetGpuFeatureFlags() const {
   return *feature_flags_;
 }
 
-GpuBlacklist::GpuBlacklist()
+GpuBlacklist::GpuBlacklist(const std::string& browser_version_string)
     : max_entry_id_(0) {
+  browser_version_.reset(Version::GetVersionFromString(browser_version_string));
+  DCHECK(browser_version_.get() != NULL);
 }
 
 GpuBlacklist::~GpuBlacklist() {
@@ -590,11 +590,25 @@ bool GpuBlacklist::LoadGpuBlacklist(const DictionaryValue& parsed_json,
     return false;
 
   uint32 max_entry_id = 0;
+  size_t entry_count_expectation = list->GetSize();
   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;
+    // 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--;
+      continue;
+    }
+    DCHECK(browser_version_support == kSupported);
     GpuBlacklistEntry* entry =
         GpuBlacklistEntry::GetGpuBlacklistEntryFromValue(list_item, true);
     if (entry == NULL)
@@ -604,7 +618,7 @@ bool GpuBlacklist::LoadGpuBlacklist(const DictionaryValue& parsed_json,
     entries.push_back(entry);
   }
 
-  if (entries.size() < list->GetSize()) {
+  if (entries.size() != entry_count_expectation) {
     for (size_t i = 0; i < entries.size(); ++i)
       delete entries[i];
     return false;
@@ -759,3 +773,28 @@ void GpuBlacklist::Clear() {
   blacklist_.clear();
   active_entries_.clear();
 }
+
+GpuBlacklist::BrowserVersionSupport
+GpuBlacklist::IsEntrySupportedByCurrentBrowserVersion(
+    DictionaryValue* value) {
+  DCHECK(value);
+  DictionaryValue* browser_version_value = NULL;
+  if (value->GetDictionary("browser_version", &browser_version_value)) {
+    std::string version_op = "any";
+    std::string version_string;
+    std::string version_string2;
+    browser_version_value->GetString("op", &version_op);
+    browser_version_value->GetString("number", &version_string);
+    browser_version_value->GetString("number2", &version_string2);
+    scoped_ptr<VersionInfo> browser_version_info;
+    browser_version_info.reset(
+      new VersionInfo(version_op, version_string, version_string2));
+    if (!browser_version_info->IsValid())
+      return kMalformed;
+    if (browser_version_info->Contains(*browser_version_))
+      return kSupported;
+    return kUnsupported;
+  }
+  return kSupported;
+}
+
diff --git a/content/browser/gpu_blacklist.h b/content/browser/gpu_blacklist.h
index 2b8fb7b..54bc9d2 100644
--- a/content/browser/gpu_blacklist.h
+++ b/content/browser/gpu_blacklist.h
@@ -29,7 +29,7 @@ class GpuBlacklist {
     kOsUnknown
   };
 
-  GpuBlacklist();
+  explicit GpuBlacklist(const std::string& browser_version_string);
   ~GpuBlacklist();
 
   // Loads blacklist information from a json file.
@@ -245,14 +245,28 @@ class GpuBlacklist {
     std::vector<GpuBlacklistEntry*> exceptions_;
   };
 
+  enum BrowserVersionSupport {
+    kSupported,
+    kUnsupported,
+    kMalformed
+  };
+
   // Gets the current OS type.
   static OsType GetOsType();
 
   void Clear();
 
+  // Check if the entry is supported by the current version of browser.
+  // By default, if there is no browser version information in the entry,
+  // return kSupported;
+  BrowserVersionSupport IsEntrySupportedByCurrentBrowserVersion(
+      DictionaryValue* value);
+
   scoped_ptr<Version> version_;
   std::vector<GpuBlacklistEntry*> 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().
diff --git a/content/browser/gpu_blacklist_unittest.cc b/content/browser/gpu_blacklist_unittest.cc
index 3ebe544..ebcf6ba6 100644
--- a/content/browser/gpu_blacklist_unittest.cc
+++ b/content/browser/gpu_blacklist_unittest.cc
@@ -56,13 +56,13 @@ TEST_F(GpuBlacklistTest, CurrentBlacklistValidation) {
   ASSERT_EQ(file_util::ReadFile(data_file, data.get(), data_file_size),
             data_file_size);
   std::string json_string(data.get(), data_file_size);
-  GpuBlacklist blacklist;
+  GpuBlacklist blacklist("1.0");
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(json_string, true));
 }
 
 TEST_F(GpuBlacklistTest, DeafaultBlacklistSettings) {
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
-  GpuBlacklist blacklist;
+  GpuBlacklist blacklist("1.0");
   // Default blacklist settings: all feature are allowed.
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
       GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
@@ -79,7 +79,7 @@ TEST_F(GpuBlacklistTest, EmptyBlacklist) {
       "  ]\n"
       "}";
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
-  GpuBlacklist blacklist;
+  GpuBlacklist blacklist("1.0");
 
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(empty_list_json, false));
   uint16 major, minor;
@@ -120,7 +120,7 @@ TEST_F(GpuBlacklistTest, DetailedEntryAndInvalidJson) {
       "  ]\n"
       "}";
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
-  GpuBlacklist blacklist;
+  GpuBlacklist blacklist("1.0");
 
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(exact_list_json, false));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
@@ -167,7 +167,7 @@ TEST_F(GpuBlacklistTest, VendorOnAllOsEntry) {
       "  ]\n"
       "}";
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
-  GpuBlacklist blacklist;
+  GpuBlacklist blacklist("1.0");
 
   // Blacklist entries won't be filtered to the current OS only upon loading.
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(vendor_json, false));
@@ -221,7 +221,7 @@ TEST_F(GpuBlacklistTest, VendorOnLinuxEntry) {
       "  ]\n"
       "}";
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
-  GpuBlacklist blacklist;
+  GpuBlacklist blacklist("1.0");
 
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(vendor_linux_json, false));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
@@ -261,7 +261,7 @@ TEST_F(GpuBlacklistTest, AllExceptNVidiaOnLinuxEntry) {
       "  ]\n"
       "}";
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
-  GpuBlacklist blacklist;
+  GpuBlacklist blacklist("1.0");
 
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(linux_except_nvidia_json, false));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
@@ -299,7 +299,7 @@ TEST_F(GpuBlacklistTest, AllExceptIntelOnLinuxEntry) {
       "  ]\n"
       "}";
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
-  GpuBlacklist blacklist;
+  GpuBlacklist blacklist("1.0");
 
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(linux_except_intel_json, false));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
@@ -338,7 +338,7 @@ TEST_F(GpuBlacklistTest, DateOnWindowsEntry) {
       "  ]\n"
       "}";
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
-  GpuBlacklist blacklist;
+  GpuBlacklist blacklist("1.0");
 
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(date_windows_json, false));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
@@ -371,7 +371,7 @@ TEST_F(GpuBlacklistTest, MultipleDevicesEntry) {
       "  ]\n"
       "}";
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
-  GpuBlacklist blacklist;
+  GpuBlacklist blacklist("1.0");
 
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(devices_json, false));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
@@ -406,7 +406,7 @@ TEST_F(GpuBlacklistTest, ChromeOSEntry) {
       "  ]\n"
       "}";
   scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
-  GpuBlacklist blacklist;
+  GpuBlacklist blacklist("1.0");
 
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(devices_json, false));
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
@@ -418,3 +418,37 @@ TEST_F(GpuBlacklistTest, ChromeOSEntry) {
   EXPECT_EQ(flags.flags(), 0u);
 }
 
+TEST_F(GpuBlacklistTest, ChromeVersionEntry) {
+  const std::string browser_version_json =
+      "{\n"
+      "  \"name\": \"gpu blacklist\",\n"
+      "  \"version\": \"0.1\",\n"
+      "  \"entries\": [\n"
+      "    {\n"
+      "      \"id\": 1,\n"
+      "      \"browser_version\": {\n"
+      "        \"op\": \">=\",\n"
+      "        \"number\": \"10\"\n"
+      "      },\n"
+      "      \"blacklist\": [\n"
+      "        \"webgl\"\n"
+      "      ]\n"
+      "    }\n"
+      "  ]\n"
+      "}";
+  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+
+  GpuBlacklist blacklist9("9.0");
+  EXPECT_TRUE(blacklist9.LoadGpuBlacklist(browser_version_json, false));
+  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));
+  flags = blacklist10.DetermineGpuFeatureFlags(
+      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+  EXPECT_EQ(flags.flags(),
+            static_cast<uint32>(GpuFeatureFlags::kGpuFeatureWebgl));
+}
+