gpu/config: disable partial swaps on Mesa Gallium drivers too.

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 <stddef.h>
 #include <stdint.h>
 
 #include <utility>
@@ skipping 562 matching lines @@
     gl_version_value->GetString("value", &version_string);
     gl_version_value->GetString("value2", &version_string2);
     if (!entry->SetGLVersionInfo(
             version_op, version_string, version_string2)) {
       LOG(WARNING) << "Malformed gl_version entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
+  std::string gl_version_string_value;
+  if (value->GetString("gl_version_string", &gl_version_string_value)) {
+    if (!entry->SetGLVersionStringInfo(gl_version_string_value)) {
+      LOG(WARNING) << "Malformed gl_version_string entry " << entry->id();
+      return NULL;
+    }
+    dictionary_entry_count++;
+  }
+
   std::string gl_vendor_value;
   if (value->GetString("gl_vendor", &gl_vendor_value)) {
     if (!entry->SetGLVendorInfo(gl_vendor_value)) {
       LOG(WARNING) << "Malformed gl_vendor entry " << entry->id();
       return NULL;
     }
     dictionary_entry_count++;
   }
 
   std::string gl_renderer_value;
@@ skipping 330 matching lines @@
 
 bool GpuControlList::GpuControlListEntry::SetGLVersionInfo(
     const std::string& version_op,
     const std::string& version_string,
     const std::string& version_string2) {
   gl_version_info_.reset(new VersionInfo(
       version_op, std::string(), version_string, version_string2));
   return gl_version_info_->IsValid();
 }
 
+bool GpuControlList::GpuControlListEntry::SetGLVersionStringInfo(
+    const std::string& version_string_value) {
+  gl_version_string_info_ = version_string_value;
+  return !gl_version_string_info_.empty();
+}
+
 bool GpuControlList::GpuControlListEntry::SetGLVendorInfo(
     const std::string& vendor_value) {
   gl_vendor_info_ = vendor_value;
   return !gl_vendor_info_.empty();
 }
 
 bool GpuControlList::GpuControlListEntry::SetGLRendererInfo(
     const std::string& renderer_value) {
   gl_renderer_info_ = renderer_value;
   return !gl_renderer_info_.empty();
@@ skipping 307 matching lines @@
   if (driver_version_info_.get() != NULL && !gpu_info.driver_version.empty()) {
     if (!driver_version_info_->Contains(gpu_info.driver_version))
       return false;
   }
   if (driver_date_info_.get() != NULL && !gpu_info.driver_date.empty()) {
     if (!driver_date_info_->Contains(gpu_info.driver_date, '-'))
       return false;
   }
   if (GLVersionInfoMismatch(gpu_info.gl_version))
     return false;
+  if (StringMismatch(gpu_info.gl_version, gl_version_string_info_))
+    return false;
   if (StringMismatch(gpu_info.gl_vendor, gl_vendor_info_))
     return false;
   if (StringMismatch(gpu_info.gl_renderer, gl_renderer_info_))
     return false;
   if (StringMismatch(gpu_info.gl_extensions, gl_extensions_info_))
     return false;
   if (gl_reset_notification_strategy_info_.get() != NULL &&
       !gl_reset_notification_strategy_info_->Contains(
           gpu_info.gl_reset_notification_strategy))
     return false;
@@ skipping 42 matching lines @@
     const GPUInfo& gpu_info,
     bool consider_exceptions) const {
   // We only check for missing info that might be collected with a gl context.
   // If certain info is missing due to some error, say, we fail to collect
   // vendor_id/device_id, then even if we launch GPU process and create a gl
   // context, we won't gather such missing info, so we still return false.
   if (!driver_vendor_info_.empty() && gpu_info.driver_vendor.empty())
     return true;
   if (driver_version_info_.get() && gpu_info.driver_version.empty())
     return true;
+  if (!gl_version_string_info_.empty() && gpu_info.gl_version.empty())
+    return true;
   if (!gl_vendor_info_.empty() && gpu_info.gl_vendor.empty())
     return true;
   if (!gl_renderer_info_.empty() && gpu_info.gl_renderer.empty())
     return true;
 
   if (consider_exceptions) {
     for (size_t i = 0; i < exceptions_.size(); ++i) {
       if (exceptions_[i]->NeedsMoreInfo(gpu_info, consider_exceptions))
         return true;
     }
@@ skipping 281 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