Enable GPU blacklist in tests.

gpu/config/gpu_control_list.cc

 // Copyright (c) 2013 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.
 
 #include "gpu/config/gpu_control_list.h"
 
 #include "base/cpu.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
+#include "base/strings/stringprintf.h"
 #include "base/sys_info.h"
 #include "gpu/config/gpu_info.h"
 #include "gpu/config/gpu_util.h"
 
 namespace gpu {
 namespace {
 
 // Break a version string into segments.  Return true if each segment is
 // a valid number.
 bool ProcessVersionString(const std::string& version_string,
@@ skipping 1006 matching lines @@
     const std::string& category) {
   if (category == kMultiGpuCategoryStringPrimary)
     return kMultiGpuCategoryPrimary;
   if (category == kMultiGpuCategoryStringSecondary)
     return kMultiGpuCategorySecondary;
   if (category == kMultiGpuCategoryStringAny)
     return kMultiGpuCategoryAny;
   return kMultiGpuCategoryNone;
 }
 
+void GpuControlList::GpuControlListEntry::LogControlListMatch() const {
+  static const char kControlListMatchMessage[] =
+      "Control list match for rule #%u.";
+  LOG(INFO) << base::StringPrintf(kControlListMatchMessage, id_);
+}
+
 bool GpuControlList::GpuControlListEntry::Contains(
     OsType os_type, const std::string& os_version,
     const GPUInfo& gpu_info) const {
   DCHECK(os_type != kOsAny);
   if (os_info_.get() != NULL && !os_info_->Contains(os_type, os_version))
     return false;
   bool is_not_primary_gpu =
       GpuUnmatched(vendor_id_, device_id_list_, gpu_info.gpu);
   bool is_not_secondary_gpu = true;
   for (size_t i = 0; i < gpu_info.secondary_gpus.size(); ++i) {
@@ skipping 136 matching lines @@
     *feature_id = iter->second;
     return true;
   }
   return false;
 }
 
 GpuControlList::GpuControlList()
     : max_entry_id_(0),
       contains_unknown_fields_(false),
       needs_more_info_(false),
-      supports_feature_type_all_(false) {
+      supports_feature_type_all_(false),
+      control_list_logging_enabled_(false) {
 }
 
 GpuControlList::~GpuControlList() {
   Clear();
 }
 
 bool GpuControlList::LoadList(
     const std::string& json_context, GpuControlList::OsFilter os_filter) {
   const std::string browser_version_string = "0";
   return LoadList(browser_version_string, json_context, os_filter);
@@ skipping 96 matching lines @@
     if (pos != std::string::npos)
       os_version = os_version.substr(0, pos);
   }
   std::vector<std::string> pieces;
   if (!ProcessVersionString(os_version, '.', &pieces))
     os_version = "0";
 
   for (size_t i = 0; i < entries_.size(); ++i) {
     if (entries_[i]->Contains(os, os_version, gpu_info)) {
       if (!entries_[i]->disabled()) {
+        if (control_list_logging_enabled_)
+          entries_[i]->LogControlListMatch();
         MergeFeatureSets(&possible_features, entries_[i]->features());
         if (!entries_[i]->NeedsMoreInfo(gpu_info))
           MergeFeatureSets(&features, entries_[i]->features());
       }
       active_entries_.push_back(entries_[i]);
     }
   }
 
   if (possible_features.size() > features.size())
     needs_more_info_ = true;
@@ skipping 119 matching lines @@
     const std::string& feature_name, int feature_id) {
   feature_map_[feature_name] = feature_id;
 }
 
 void GpuControlList::set_supports_feature_type_all(bool supported) {
   supports_feature_type_all_ = supported;
 }
 
 }  // namespace gpu