Add capability for GPU blacklist to manage GPU switching.

content/browser/gpu/gpu_blacklist.h

 // 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_
 
 #include <string>
 #include <vector>
 
@@ skipping 23 matching lines @@
     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
   };
 
+  struct Decision {
+    content::GpuFeatureType blacklisted_features;
+    content::GpuSwitchingOption gpu_switching;
+
+    Decision()
+        : blacklisted_features(content::GPU_FEATURE_TYPE_UNKNOWN),
+          gpu_switching(content::GPU_SWITCHING_AUTOMATIC) {
+    }
+  };
+
   GpuBlacklist();
   virtual ~GpuBlacklist();
 
   // Loads blacklist information from a json file.
   // If failed, the current GpuBlacklist is un-touched.
   bool LoadGpuBlacklist(const std::string& json_context, OsFilter os_filter);
   bool LoadGpuBlacklist(const std::string& browser_version_string,
                         const std::string& json_context,
                         OsFilter os_filter);
 
   // Collects system information and combines them with gpu_info and blacklist
-  // information to determine gpu feature flags.
+  // information to make the blacklist decision.
   // If os is kOsAny, use the current OS; if os_version is null, use the
   // current OS version.
-  content::GpuFeatureType DetermineGpuFeatureType(
+  Decision MakeBlacklistDecision(

[Ken Russell (switch to Gerrit), 2012/09/12 01:59:04]

Thank you for renaming this. The old name was very confusing.

       OsType os, Version* os_version, const content::GPUInfo& gpu_info);
 
-  // Collects the active entries that set the "feature" flag from the last
-  // DetermineGpuFeatureType() call.  This tells which entries are responsible
-  // for raising a certain flag, i.e, for blacklisting a certain feature.
-  // Examples of "feature":
-  //   GPU_FEATURE_TYPE_ALL - any of the supported features;
-  //   GPU_FEATURE_TYPE_WEBGL - a single feature;
-  //   GPU_FEATURE_TYPE_WEBGL | GPU_FEATURE_TYPE_ACCELERATED_COMPOSITING
-  //       - two features.
+  // Collects the active entries from the last MakeBlacklistDecision() call.
   // If disabled set to true, return entries that are disabled; otherwise,
   // return enabled entries.
-  void GetGpuFeatureTypeEntries(content::GpuFeatureType feature,
-                                std::vector<uint32>& entry_ids,
-                                bool disabled) const;
+  void GetDecisionEntries(std::vector<uint32>& entry_ids,
+                          bool disabled) const;
 
   // Returns the description and bugs from active entries from the last
-  // DetermineGpuFeatureType() call.
+  // MakeBlacklistDecision() call.
   //
   // Each problems has:
   // {
   //    "description": "Your GPU is too old",
   //    "crBugs": [1234],
   //    "webkitBugs": []
   // }
   void GetBlacklistReasons(ListValue* problem_list) const;
 
   // Return the largest entry id.  This is used for histogramming.
@@ skipping 155 matching lines @@
     // 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 GpuFeatureType.
     content::GpuFeatureType GetGpuFeatureType() const;
 
+    // Returns the GpuSwitchingOption.
+    content::GpuSwitchingOption GetGpuSwitchingOption() 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:
@@ skipping 58 matching lines @@
                            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);
 
+    bool SetGpuSwitchingOption(const std::string& switching_string);
+
     void AddException(ScopedGpuBlacklistEntry exception);
 
     static MultiGpuStyle StringToMultiGpuStyle(const std::string& style);
 
     static MultiGpuCategory StringToMultiGpuCategory(
         const std::string& category);
 
     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_;
     MultiGpuStyle multi_gpu_style_;
     MultiGpuCategory multi_gpu_category_;
     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_;
-    content::GpuFeatureType feature_type_;
+    Decision decision_;
     std::vector<ScopedGpuBlacklistEntry> exceptions_;
     bool contains_unknown_fields_;
     bool contains_unknown_features_;
   };
 
   // Gets the current OS type.
   static OsType GetOsType();
 
   bool LoadGpuBlacklist(const base::DictionaryValue& parsed_json,
                         OsFilter os_filter);
@@ skipping 13 matching lines @@
   bool contains_unknown_fields() const { return contains_unknown_fields_; }
 
   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 DetermineGpuFeatureType() is
-  // called and is used later by GetGpuFeatureTypeEntries().
+  // user machine.  It is updated everytime MakeBlacklistDecision() is
+  // called and is used later by GetDecisionEntries() and

[Ken Russell (switch to Gerrit), 2012/09/12 01:59:04]

Incomplete sentence.

[Zhenyao Mo, 2012/09/12 17:41:34]

Done.

   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_