Use the cpuid instruction to generate the CPU brand string. And

content/browser/gpu/gpu_blacklist.cc

 // 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.
 
 #include "content/browser/gpu/gpu_blacklist.h"
 
 #include "base/command_line.h"
+#include "base/cpu.h"
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 
 #if defined(OS_MACOSX)
 #include "base/mac/mac_util.h"
 #endif  // OS_MACOSX
 
 #include "base/string_number_conversions.h"
 #include "base/string_split.h"
 #include "base/string_util.h"
@@ skipping 553 matching lines @@
     std::string renderer_value;
     gl_renderer_value->GetString("op", &renderer_op);
     gl_renderer_value->GetString("value", &renderer_value);
     if (!entry->SetGLRendererInfo(renderer_op, renderer_value)) {
       LOG(WARNING) << "Malformed gl_renderer entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
+  const DictionaryValue* cpu_brand_value = NULL;
+  if (value->GetDictionary("cpu_info", &cpu_brand_value)) {
+    std::string cpu_op;
+    std::string cpu_value;
+    cpu_brand_value->GetString("op", &cpu_op);
+    cpu_brand_value->GetString("value", &cpu_value);
+    if (!entry->SetCpuBrand(cpu_op, cpu_value)) {
+      LOG(WARNING) << "Malformed cpu_brand entry " << entry->id();
+      return NULL;
+    }
+    dictionary_entry_count++;
+  }
+
   const DictionaryValue* perf_graphics_value = NULL;
   if (value->GetDictionary("perf_graphics", &perf_graphics_value)) {
     std::string op;
     std::string float_value;
     std::string float_value2;
     perf_graphics_value->GetString("op", &op);
     perf_graphics_value->GetString("value", &float_value);
     perf_graphics_value->GetString("value2", &float_value2);
     if (!entry->SetPerfGraphicsInfo(op, float_value, float_value2)) {
       LOG(WARNING) << "Malformed perf_graphics entry " << entry->id();
@@ skipping 248 matching lines @@
 }
 
 bool GpuBlacklist::GpuBlacklistEntry::SetGLRendererInfo(
     const std::string& renderer_op,
     const std::string& renderer_value) {
   gl_renderer_info_.reset(
       new StringInfo(renderer_op, renderer_value));
   return gl_renderer_info_->IsValid();
 }
 
+bool GpuBlacklist::GpuBlacklistEntry::SetCpuBrand(
+    const std::string& cpu_op,
+    const std::string& cpu_value) {
+  cpu_brand_.reset(
+      new StringInfo(cpu_op, cpu_value));
+  return cpu_brand_->IsValid();
+}
+
 bool GpuBlacklist::GpuBlacklistEntry::SetPerfGraphicsInfo(
     const std::string& op,
     const std::string& float_string,
     const std::string& float_string2) {
   perf_graphics_info_.reset(
       new FloatInfo(op, float_string, float_string2));
   return perf_graphics_info_->IsValid();
 }
 
 bool GpuBlacklist::GpuBlacklistEntry::SetPerfGamingInfo(
@@ skipping 184 matching lines @@
   if (perf_overall_info_.get() != NULL &&
       (gpu_info.performance_stats.overall == 0.0 ||
        !perf_overall_info_->Contains(gpu_info.performance_stats.overall)))
     return false;
   if (machine_model_info_.get() != NULL &&
       !machine_model_info_->Contains(machine_model_name, machine_model_version))
     return false;
   if (gpu_count_info_.get() != NULL &&
       !gpu_count_info_->Contains(gpu_info.secondary_gpus.size() + 1))
     return false;
+  if (cpu_brand_.get() != NULL) {
+    base::CPU cpu_info;
+    if (!cpu_brand_->Contains(cpu_info.cpu_brand()))
+      return false;
+  }
+
   for (size_t i = 0; i < exceptions_.size(); ++i) {
     if (exceptions_[i]->Contains(os_type, os_version, machine_model_name,
                                  machine_model_version, gpu_info))
       return false;
   }
   return true;
 }
 
 GpuBlacklist::OsType GpuBlacklist::GpuBlacklistEntry::GetOsType() const {
   if (os_info_.get() == NULL)
@@ skipping 285 matching lines @@
   if (op == ">")
     return kGT;
   if (op == ">=")
     return kGE;
   if (op == "any")
     return kAny;
   if (op == "between")
     return kBetween;
   return kUnknown;
 }