Add the capability to put drivers older than a certain date to software rendering list. Also, refactor the one single large unittest into multiple smaller ones. Also, add an entry to the software_rendering_list.json that all drivers older than 01/2009 are in software rendering.

BUG=72977,72979
TEST=unittest
 
Review URL: http://codereview.chromium.org/6592073

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

3 files changed, 180 insertions, 34 deletions

diff --git a/content/browser/gpu_blacklist.cc b/content/browser/gpu_blacklist.cc
index d9b934f..2d5e133 100644
--- a/content/browser/gpu_blacklist.cc
+++ b/content/browser/gpu_blacklist.cc
@@ -7,6 +7,8 @@
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
+#include "base/string_piece.h"
+#include "base/string_split.h"
 #include "base/string_util.h"
 #include "base/stringprintf.h"
 #include "base/sys_info.h"
@@ -14,6 +16,26 @@
 #include "base/version.h"
 #include "chrome/common/gpu_info.h"
 
+namespace {
+
+// Encode a date as Version, where [0] is year, [1] is month, and [2] is day.
+Version* GetDateFromString(const std::string& date_string) {
+  // TODO(zmo): verify if in Windows registry, driver dates are always in the
+  // format of "mm-dd-yyyy".
+  std::vector<std::string> pieces;
+  base::SplitString(date_string, '-', &pieces);
+  if (pieces.size() > 3 || pieces.size() == 0)
+    return NULL;
+  std::string date_as_version_string = pieces[0];
+  for (size_t i = 1; i < pieces.size(); ++i) {
+    date_as_version_string += ".";
+    date_as_version_string += pieces[i];
+  }
+  return Version::GetVersionFromString(date_as_version_string);
+}
+
+}  // namespace anonymous
+
 GpuBlacklist::VersionInfo::VersionInfo(const std::string& version_op,
                                        const std::string& version_string,
                                        const std::string& version_string2) {
@@ -253,6 +275,21 @@ GpuBlacklist::GpuBlacklistEntry::GetGpuBlacklistEntryFromValue(
     }
   }
 
+  DictionaryValue* driver_date_value = NULL;
+  if (value->GetDictionary("driver_date", &driver_date_value)) {
+    std::string driver_date_op = "any";
+    std::string driver_date_string;
+    std::string driver_date_string2;
+    driver_date_value->GetString("op", &driver_date_op);
+    driver_date_value->GetString("number", &driver_date_string);
+    driver_date_value->GetString("number2", &driver_date_string2);
+    if (!entry->SetDriverDateInfo(driver_date_op, driver_date_string,
+                                  driver_date_string2)) {
+      delete entry;
+      return NULL;
+    }
+  }
+
   DictionaryValue* gl_renderer_value = NULL;
   if (value->GetDictionary("gl_renderer", &gl_renderer_value)) {
     std::string renderer_op;
@@ -366,6 +403,15 @@ bool GpuBlacklist::GpuBlacklistEntry::SetDriverVersionInfo(
   return driver_version_info_->IsValid();
 }
 
+bool GpuBlacklist::GpuBlacklistEntry::SetDriverDateInfo(
+    const std::string& date_op,
+    const std::string& date_string,
+    const std::string& date_string2) {
+  driver_date_info_.reset(
+      new VersionInfo(date_op, date_string, date_string2));
+  return driver_date_info_->IsValid();
+}
+
 bool GpuBlacklist::GpuBlacklistEntry::SetGLRendererInfo(
     const std::string& renderer_op,
     const std::string& renderer_value) {
@@ -423,6 +469,13 @@ bool GpuBlacklist::GpuBlacklistEntry::Contains(
         !driver_version_info_->Contains(*driver_version))
       return false;
   }
+  if (driver_date_info_.get() != NULL) {
+    scoped_ptr<Version> driver_date(GetDateFromString(
+        gpu_info.driver_date()));
+    if (driver_date.get() == NULL ||
+        !driver_date_info_->Contains(*driver_date))
+      return false;
+  }
   if (gl_renderer_info_.get() != NULL &&
       !gl_renderer_info_->Contains(gpu_info.gl_renderer()))
     return false;
diff --git a/content/browser/gpu_blacklist.h b/content/browser/gpu_blacklist.h
index f2fdfe5..10063ff 100644
--- a/content/browser/gpu_blacklist.h
+++ b/content/browser/gpu_blacklist.h
@@ -198,6 +198,10 @@ class GpuBlacklist {
                               const std::string& version_string,
                               const std::string& version_string2);
 
+    bool SetDriverDateInfo(const std::string& date_op,
+                           const std::string& date_string,
+                           const std::string& date_string2);
+
     bool SetGLRendererInfo(const std::string& renderer_op,
                            const std::string& renderer_value);
 
@@ -212,6 +216,7 @@ class GpuBlacklist {
     uint32 device_id_;
     scoped_ptr<StringInfo> driver_vendor_info_;
     scoped_ptr<VersionInfo> driver_version_info_;
+    scoped_ptr<VersionInfo> driver_date_info_;
     scoped_ptr<StringInfo> gl_renderer_info_;
     scoped_ptr<GpuFeatureFlags> feature_flags_;
     std::vector<GpuBlacklistEntry*> exceptions_;
diff --git a/content/browser/gpu_blacklist_unittest.cc b/content/browser/gpu_blacklist_unittest.cc
index 1b20e1b..961880f 100644
--- a/content/browser/gpu_blacklist_unittest.cc
+++ b/content/browser/gpu_blacklist_unittest.cc
@@ -9,23 +9,43 @@
 #include "content/browser/gpu_blacklist.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
-TEST(GpuBlacklistTest, BlacklistLogic) {
-  GPUInfo gpu_info;
-  gpu_info.SetVideoCardInfo(0x10de,  // Vendor ID
-                            0x0640);  // Device ID
-  gpu_info.SetDriverInfo("NVIDIA",  // Driver vendor
-                         "1.6.18",  // Driver Version
-                         "7-14-2009");  // Driver date
-  gpu_info.SetLevel(GPUInfo::kComplete);
-  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+class GpuBlacklistTest : public testing::Test {
+ public:
+  GpuBlacklistTest() { }
 
-  GpuBlacklist blacklist;
+  virtual ~GpuBlacklistTest() { }
+
+  const GPUInfo& gpu_info() const {
+    return gpu_info_;
+  }
+
+ protected:
+  void SetUp() {
+    gpu_info_.SetVideoCardInfo(0x10de,  // Vendor ID
+                               0x0640);  // Device ID
+    gpu_info_.SetDriverInfo("NVIDIA",  // Driver vendor
+                            "1.6.18",  // Driver Version
+                            "7-14-2009");  // Driver date
+    gpu_info_.SetLevel(GPUInfo::kComplete);
+  }
+
+  void TearDown() {
+  }
 
+ private:
+  GPUInfo gpu_info_;
+};
+
+TEST_F(GpuBlacklistTest, DeafaultBlacklistSettings) {
+  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  GpuBlacklist blacklist;
   // Default blacklist settings: all feature are allowed.
   GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info);
+      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
+}
 
+TEST_F(GpuBlacklistTest, EmptyBlacklist) {
   // Empty list: all features are allowed.
   const std::string empty_list_json =
       "{\n"
@@ -34,15 +54,20 @@ TEST(GpuBlacklistTest, BlacklistLogic) {
       "  \"entries\": [\n"
       "  ]\n"
       "}";
+  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  GpuBlacklist blacklist;
+
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(empty_list_json, false));
   uint16 major, minor;
   EXPECT_TRUE(blacklist.GetVersion(&major, &minor));
   EXPECT_EQ(major, 2u);
   EXPECT_EQ(minor, 5u);
-  flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info);
+  GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
+      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
+}
 
+TEST_F(GpuBlacklistTest, DetailedEntryAndInvalidJson) {
   // Blacklist accelerated_compositing with exact setting.
   const std::string exact_list_json =
       "{\n"
@@ -70,18 +95,22 @@ TEST(GpuBlacklistTest, BlacklistLogic) {
       "    }\n"
       "  ]\n"
       "}";
+  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  GpuBlacklist blacklist;
+
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(exact_list_json, false));
-  flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info);
+  GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
+      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(
       flags.flags(),
       static_cast<uint32>(GpuFeatureFlags::kGpuFeatureAcceleratedCompositing));
 
   // Invalid json input should not change the current blacklist settings.
   const std::string invalid_json = "invalid";
+
   EXPECT_FALSE(blacklist.LoadGpuBlacklist(invalid_json, false));
   flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info);
+      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(
       flags.flags(),
       static_cast<uint32>(GpuFeatureFlags::kGpuFeatureAcceleratedCompositing));
@@ -95,7 +124,9 @@ TEST(GpuBlacklistTest, BlacklistLogic) {
   EXPECT_EQ(entries.size(), 1u);
   EXPECT_EQ(entries[0], 5u);
   EXPECT_EQ(blacklist.max_entry_id(), 5u);
+}
 
+TEST_F(GpuBlacklistTest, VendorOnAllOsEntry) {
   // Blacklist a vendor on all OS.
   const std::string vendor_json =
       "{\n"
@@ -111,37 +142,42 @@ TEST(GpuBlacklistTest, BlacklistLogic) {
       "    }\n"
       "  ]\n"
       "}";
+  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  GpuBlacklist blacklist;
+
   // Blacklist entries won't be filtered to the current OS only upon loading.
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(vendor_json, false));
-  flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info);
+  GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
+      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(),
             static_cast<uint32>(GpuFeatureFlags::kGpuFeatureWebgl));
   flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info);
+      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(),
             static_cast<uint32>(GpuFeatureFlags::kGpuFeatureWebgl));
   flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info);
+      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(),
             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));
   flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info);
+      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(),
             static_cast<uint32>(GpuFeatureFlags::kGpuFeatureWebgl));
   flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info);
+      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(),
             static_cast<uint32>(GpuFeatureFlags::kGpuFeatureWebgl));
   flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info);
+      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(),
             static_cast<uint32>(GpuFeatureFlags::kGpuFeatureWebgl));
 #endif
+}
 
+TEST_F(GpuBlacklistTest, VendorOnLinuxEntry) {
   // Blacklist a vendor on Linux only.
   const std::string vendor_linux_json =
       "{\n"
@@ -160,19 +196,24 @@ TEST(GpuBlacklistTest, BlacklistLogic) {
       "    }\n"
       "  ]\n"
       "}";
+  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  GpuBlacklist blacklist;
+
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(vendor_linux_json, false));
-  flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info);
+  GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
+      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
   flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info);
+      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
   flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info);
+      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
   EXPECT_EQ(
       flags.flags(),
       static_cast<uint32>(GpuFeatureFlags::kGpuFeatureAccelerated2dCanvas));
+}
 
+TEST_F(GpuBlacklistTest, AllExceptNVidiaOnLinuxEntry) {
   // Blacklist all cards in Linux except NVIDIA.
   const std::string linux_except_nvidia_json =
       "{\n"
@@ -195,17 +236,22 @@ TEST(GpuBlacklistTest, BlacklistLogic) {
       "    }\n"
       "  ]\n"
       "}";
+  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  GpuBlacklist blacklist;
+
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(linux_except_nvidia_json, false));
-  flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info);
+  GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
+      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
   flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info);
+      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
   flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info);
+      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
+}
 
+TEST_F(GpuBlacklistTest, AllExceptIntelOnLinuxEntry) {
   // Blacklist all cards in Linux except Intel.
   const std::string linux_except_intel_json =
       "{\n"
@@ -228,15 +274,57 @@ TEST(GpuBlacklistTest, BlacklistLogic) {
       "    }\n"
       "  ]\n"
       "}";
+  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  GpuBlacklist blacklist;
+
   EXPECT_TRUE(blacklist.LoadGpuBlacklist(linux_except_intel_json, false));
+  GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
+      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
+  EXPECT_EQ(flags.flags(), 0u);
   flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info);
+      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
+  EXPECT_EQ(flags.flags(), 0u);
+  flags = blacklist.DetermineGpuFeatureFlags(
+      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
+  EXPECT_EQ(
+      flags.flags(),
+      static_cast<uint32>(GpuFeatureFlags::kGpuFeatureAccelerated2dCanvas));
+}
+
+TEST_F(GpuBlacklistTest, DateOnWindowsEntry) {
+  // Blacklist all drivers earlier than 2010-01 in Windows.
+  const std::string date_windows_json =
+      "{\n"
+      "  \"name\": \"gpu blacklist\",\n"
+      "  \"version\": \"0.1\",\n"
+      "  \"entries\": [\n"
+      "    {\n"
+      "      \"id\": \"1\",\n"
+      "      \"os\": {\n"
+      "        \"type\": \"win\"\n"
+      "      },\n"
+      "      \"driver_date\": {\n"
+      "        \"op\": \"<\",\n"
+      "        \"number\": \"2010.1\"\n"
+      "      },\n"
+      "      \"blacklist\": [\n"
+      "        \"accelerated_2d_canvas\"\n"
+      "      ]\n"
+      "    }\n"
+      "  ]\n"
+      "}";
+  scoped_ptr<Version> os_version(Version::GetVersionFromString("10.6.4"));
+  GpuBlacklist blacklist;
+
+  EXPECT_TRUE(blacklist.LoadGpuBlacklist(date_windows_json, false));
+  GpuFeatureFlags flags = blacklist.DetermineGpuFeatureFlags(
+      GpuBlacklist::kOsMacosx, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
   flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsWin, os_version.get(), gpu_info);
+      GpuBlacklist::kOsLinux, os_version.get(), gpu_info());
   EXPECT_EQ(flags.flags(), 0u);
   flags = blacklist.DetermineGpuFeatureFlags(
-      GpuBlacklist::kOsLinux, os_version.get(), gpu_info);
+      GpuBlacklist::kOsWin, os_version.get(), gpu_info());
   EXPECT_EQ(
       flags.flags(),
       static_cast<uint32>(GpuFeatureFlags::kGpuFeatureAccelerated2dCanvas));