Add a "disabled" field for GPU Blacklist entries.

content/browser/gpu/gpu_blacklist.h

 // 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.
 
 #ifndef CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_
 #define CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_
 #pragma once
 
 #include <string>
 #include <vector>
@@ skipping 50 matching lines @@
 
   // Collects the entries that set the "feature" flag from the last
   // DetermineGpuFeatureFlags() call.  This tells which entries are responsible
   // for raising a certain flag, i.e, for blacklisting a certain feature.
   // Examples of "feature":
   //   kGpuFeatureAll - any of the supported features;
   //   kGpuFeatureWebgl - a single feature;
   //   kGpuFeatureWebgl | kGpuFeatureAcceleratedCompositing - two features.
   void GetGpuFeatureFlagEntries(GpuFeatureFlags::GpuFeatureType feature,
                                 std::vector<uint32>& entry_ids) const;
+  // Collects the entries that will the "feature" flag from the last
+  // DetermineGpuFeatureFlags() call if not disabled.

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

I don't understand this comment...

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

This comment and its function are removed based on review advice.

+  void GetGpuFeatureFlagDisabledEntries(GpuFeatureFlags::GpuFeatureType feature,
+                                        std::vector<uint32>& entry_ids) const;
 
   // Returns status information on the blacklist. This is two parted:
   // {
   //    featureStatus: []
   //    problems: []
   // }
   //
   // Each entry in feature_status has:
   // {
   //    name:  "name of feature"
@@ skipping 150 matching lines @@
                   const Version& os_version,
                   BrowserChannel channel,
                   const GPUInfo& gpu_info) const;
 
     // Returns the OsType.
     OsType GetOsType() const;
 
     // Returns the entry's unique id.  0 is reserved.
     uint32 id() const;
 
+    // Returns whether the entry is disabled.
+    bool disabled() const;
+
     // Returns the description of the entry
     const std::string& description() const { return description_; }
 
     // 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;
 
     // 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);
 
+    void SetDisabled(bool disabled);
+
     bool SetOsInfo(const std::string& os,
                    const std::string& version_op,
                    const std::string& version_string,
                    const std::string& version_string2);
 
     bool SetVendorId(const std::string& vendor_id_string);
 
     bool AddDeviceId(const std::string& device_id_string);
 
     bool SetDriverVendorInfo(const std::string& vendor_op,
@@ skipping 14 matching lines @@
                            const std::string& renderer_value);
 
     bool SetBlacklistedFeatures(
         const std::vector<std::string>& blacklisted_features);
 
     void AddException(ScopedGpuBlacklistEntry exception);
 
     void AddBrowserChannel(BrowserChannel channel);
 
     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_;
@@ skipping 33 matching lines @@
   scoped_ptr<Version> version_;
   std::vector<ScopedGpuBlacklistEntry> blacklist_;
 
   scoped_ptr<Version> browser_version_;
   BrowserChannel browser_channel_;
 
   // 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_;
+  // This records all the disabled blacklist entries that are appliable to the
+  // current user machine.  It is updated everytime DetermineGpuFeatureFlags()
+  // is called and is used later by GetGpuFeatureFlagDisabledEntries().
+  std::vector<ScopedGpuBlacklistEntry> active_disabled_entries_;
 
   uint32 max_entry_id_;
 
   bool contains_unknown_fields_;
 
   DISALLOW_COPY_AND_ASSIGN(GpuBlacklist);
 };
 
 #endif  // CONTENT_BROWSER_GPU_GPU_BLACKLIST_H_