Make it possible to blacklist gpu's based on the Windows experience index.

content/browser/gpu/gpu_blacklist.h

-// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Copyright (c) 2012 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.
 
 #ifndef CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_
 #define CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_
 #pragma once
 
 #include <string>
 #include <vector>
 
@@ skipping 91 matching lines @@
   FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, UnknownField);
   FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, UnknownExceptionField);
   FRIEND_TEST_ALL_PREFIXES(GpuBlacklistTest, UnknownFeature);
 
   enum BrowserVersionSupport {
     kSupported,
     kUnsupported,
     kMalformed
   };
 
+  enum NumericOp {
+    kBetween,  // <= * <=
+    kEQ,  // =
+    kLT,  // <
+    kLE,  // <=
+    kGT,  // >
+    kGE,  // >=
+    kAny,
+    kUnknown  // Indicates the data is invalid.
+  };
+
   class VersionInfo {
    public:
     VersionInfo(const std::string& version_op,
                 const std::string& version_string,
                 const std::string& version_string2);
     ~VersionInfo();
 
     // Determines if a given version is included in the VersionInfo range.
     bool Contains(const Version& version) const;
 
     // Determines if the VersionInfo contains valid information.
     bool IsValid() const;
 
    private:
-    enum Op {
-      kBetween,  // <= * <=
-      kEQ,  // =
-      kLT,  // <
-      kLE,  // <=
-      kGT,  // >
-      kGE,  // >=
-      kAny,
-      kUnknown  // Indicates VersionInfo data is invalid.
-    };
-
-    // Maps string to Op; returns kUnknown if it's not a valid Op.
-    static Op StringToOp(const std::string& version_op);
-
-    Op op_;
+    NumericOp op_;
     scoped_ptr<Version> version_;
     scoped_ptr<Version> version2_;
   };
 
   class OsInfo {
    public:
     OsInfo(const std::string& os,
            const std::string& version_op,
            const std::string& version_string,
            const std::string& version_string2);
@@ skipping 34 matching lines @@
       kUnknown  // Indicates StringInfo data is invalid.
     };
 
     // Maps string to Op; returns kUnknown if it's not a valid Op.
     static Op StringToOp(const std::string& string_op);
 
     Op op_;
     std::string value_;
   };
 
+  class FloatInfo {
+   public:
+    FloatInfo(const std::string& float_op,
+              const std::string& float_value,
+              const std::string& float_value2);
+
+    // Determines if a given float is included in the FloatInfo.
+    bool Contains(float value) const;
+
+    // Determines if the FloatInfo contains valid information.
+    bool IsValid() const;
+
+   private:
+    NumericOp op_;
+    float value_;
+    float value2_;
+  };
+
   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.
     static ScopedGpuBlacklistEntry GetGpuBlacklistEntryFromValue(
         base::DictionaryValue* value, bool top_level);
 
@@ skipping 59 matching lines @@
     bool SetDriverDateInfo(const std::string& date_op,
                            const std::string& date_string,
                            const std::string& date_string2);
 
     bool SetGLVendorInfo(const std::string& vendor_op,
                          const std::string& vendor_value);
 
     bool SetGLRendererInfo(const std::string& renderer_op,
                            const std::string& renderer_value);
 
+    bool SetPerfGraphicsInfo(const std::string& op,
+                             const std::string& float_string,
+                             const std::string& float_string2);
+
+    bool SetPerfGamingInfo(const std::string& op,
+                           const std::string& float_string,
+                           const std::string& float_string2);
+
+    bool SetPerfOverallInfo(const std::string& op,
+                            const std::string& float_string,
+                            const std::string& float_string2);
+
     bool SetBlacklistedFeatures(
         const std::vector<std::string>& blacklisted_features);
 
     void AddException(ScopedGpuBlacklistEntry exception);
 
     uint32 id_;
     bool disabled_;
     std::string description_;
     std::vector<int> cr_bugs_;
     std::vector<int> webkit_bugs_;
     scoped_ptr<OsInfo> os_info_;
     uint32 vendor_id_;
     std::vector<uint32> device_id_list_;
     scoped_ptr<StringInfo> driver_vendor_info_;
     scoped_ptr<VersionInfo> driver_version_info_;
     scoped_ptr<VersionInfo> driver_date_info_;
     scoped_ptr<StringInfo> gl_vendor_info_;
     scoped_ptr<StringInfo> gl_renderer_info_;
+    scoped_ptr<FloatInfo> perf_graphics_info_;
+    scoped_ptr<FloatInfo> perf_gaming_info_;
+    scoped_ptr<FloatInfo> perf_overall_info_;
     scoped_ptr<GpuFeatureFlags> feature_flags_;
     std::vector<ScopedGpuBlacklistEntry> exceptions_;
     bool contains_unknown_fields_;
     bool contains_unknown_features_;
   };
 
   // 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(
       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_; }
 
   void SetBrowserVersion(const std::string& version_string);
 
+  static NumericOp StringToNumericOp(const std::string& op);
+
   scoped_ptr<Version> version_;
   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<ScopedGpuBlacklistEntry> active_entries_;
 
   uint32 max_entry_id_;
 
   bool contains_unknown_fields_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuBlacklist);
 };
 
 #endif  // CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_