Merge part of r75473....

chrome/browser/gpu_blacklist.cc

 // 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.
 
 #include "chrome/browser/gpu_blacklist.h"
 
 #include "base/json/json_reader.h"
 #include "base/logging.h"
 #include "base/string_number_conversions.h"
 #include "base/string_util.h"
@@ skipping 360 matching lines @@
       case GpuFeatureFlags::kGpuFeatureUnknown:
         return false;
     }
   }
   feature_flags_.reset(new GpuFeatureFlags());
   feature_flags_->set_flags(flags);
   return true;
 }
 
 bool GpuBlacklist::GpuBlacklistEntry::Contains(
-    OsType os_type, const Version& os_version,
-    uint32 vendor_id, uint32 device_id,
-    const std::string& driver_vendor,
-    const Version& driver_version,
-    const std::string& gl_renderer) const {
+    OsType os_type, const Version& 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;
-  if (vendor_id_ != 0 && vendor_id_ != vendor_id)
+  if (vendor_id_ != 0 && vendor_id_ != gpu_info.vendor_id())
     return false;
-  if (device_id_ != 0 && device_id_ != device_id)
+  if (device_id_ != 0 && device_id_ != gpu_info.device_id())
     return false;
   if (driver_vendor_info_.get() != NULL &&
-      !driver_vendor_info_->Contains(driver_vendor))
+      !driver_vendor_info_->Contains(gpu_info.driver_vendor()))
     return false;
-  if (driver_version_info_.get() != NULL &&
-      !driver_version_info_->Contains(driver_version))
-    return false;
+  if (driver_version_info_.get() != NULL) {
+    scoped_ptr<Version> driver_version(
+        Version::GetVersionFromString(gpu_info.driver_version()));
+    if (driver_version.get() == NULL ||
+        !driver_version_info_->Contains(*driver_version))
+      return false;
+  }
   if (gl_renderer_info_.get() != NULL &&
-      !gl_renderer_info_->Contains(gl_renderer))
+      !gl_renderer_info_->Contains(gpu_info.gl_renderer()))
     return false;
   return true;
 }
 
 GpuBlacklist::OsType GpuBlacklist::GpuBlacklistEntry::GetOsType() const {
   if (os_info_.get() == NULL)
     return kOsUnknown;
   return os_info_->type();
 }
 
@@ skipping 74 matching lines @@
 
 GpuFeatureFlags GpuBlacklist::DetermineGpuFeatureFlags(
     GpuBlacklist::OsType os,
     Version* os_version,
     const GPUInfo& gpu_info) {
   active_entries_.clear();
   GpuFeatureFlags flags;
   // No need to go through blacklist entries if GPUInfo isn't available.
   if (gpu_info.progress() == GPUInfo::kUninitialized)
     return flags;
-  scoped_ptr<Version> driver_version(
-      Version::GetVersionFromString(gpu_info.driver_version()));
-  if (driver_version.get() == NULL)
-    return flags;
 
   if (os == kOsAny)
     os = GetOsType();
   scoped_ptr<Version> my_os_version;
   if (os_version == NULL) {
     std::string version_string;
 #if defined(OS_MACOSX)
     // Seems like base::SysInfo::OperatingSystemVersion() returns the wrong
     // version in MacOsx.
     int32 version_major, version_minor, version_bugfix;
     base::SysInfo::OperatingSystemVersionNumbers(
         &version_major, &version_minor, &version_bugfix);
     version_string = base::StringPrintf("%d.%d.%d",
                                         version_major,
                                         version_minor,
                                         version_bugfix);
 #else
     version_string = base::SysInfo::OperatingSystemVersion();
     size_t pos = version_string.find_first_not_of("0123456789.");
     if (pos != std::string::npos)
       version_string = version_string.substr(0, pos);
 #endif
     my_os_version.reset(Version::GetVersionFromString(version_string));
     os_version = my_os_version.get();
   }
   DCHECK(os_version != NULL);
 
   for (size_t i = 0; i < blacklist_.size(); ++i) {
-    if (blacklist_[i]->Contains(os, *os_version,
-                                gpu_info.vendor_id(), gpu_info.device_id(),
-                                gpu_info.driver_vendor(),
-                                *driver_version,
-                                gpu_info.gl_renderer())) {
+    if (blacklist_[i]->Contains(os, *os_version, gpu_info)) {
       flags.Combine(blacklist_[i]->GetGpuFeatureFlags());
       active_entries_.push_back(blacklist_[i]);
     }
   }
   return flags;
 }
 
 void GpuBlacklist::GetGpuFeatureFlagEntries(
     GpuFeatureFlags::GpuFeatureType feature,
     std::vector<uint32>& entry_ids) const {
@@ skipping 34 matching lines @@
 #endif
 }
 
 void GpuBlacklist::Clear() {
   for (size_t i = 0; i < blacklist_.size(); ++i)
     delete blacklist_[i];
   blacklist_.clear();
   active_entries_.clear();
 }