Prevent preliminary blacklisted features from being used too early

content/browser/gpu/gpu_data_manager_impl_private.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 "content/browser/gpu/gpu_data_manager_impl_private.h"
 
 #include <algorithm>
 #include <iterator>
 #include <memory>
 #include <utility>
@@ skipping 347 matching lines @@
       *reason = "GPU access is disabled ";
       base::CommandLine* command_line = base::CommandLine::ForCurrentProcess();
       if (command_line->HasSwitch(switches::kDisableGpu))
         *reason += "through commandline switch --disable-gpu.";
       else
         *reason += "in chrome://settings.";
     }
     return false;
   }
 
-  // We only need to block GPU process if more features are disallowed other
-  // than those in the preliminary gpu feature flags because the latter work
-  // through renderer commandline switches. WebGL and WebGL2 should not matter
-  // because their context creation can always be rejected on the GPU process
-  // side.
-  std::set<int> feature_diffs;
-  std::set_difference(blacklisted_features_.begin(),
-                      blacklisted_features_.end(),
-                      preliminary_blacklisted_features_.begin(),
-                      preliminary_blacklisted_features_.end(),
-                      std::inserter(feature_diffs, feature_diffs.begin()));
-  if (feature_diffs.size()) {
-    // TODO(zmo): Other features might also be OK to ignore here.
-    feature_diffs.erase(gpu::GPU_FEATURE_TYPE_WEBGL);
-    feature_diffs.erase(gpu::GPU_FEATURE_TYPE_WEBGL2);
-  }
-  if (feature_diffs.size()) {
-    if (reason) {
-      *reason = "Features are disabled on full but not preliminary GPU info.";
+  if (preliminary_blacklisted_features_initialized_) {
+    // We only need to block GPU process if more features are disallowed other
+    // than those in the preliminary gpu feature flags because the latter work
+    // through renderer commandline switches. WebGL and WebGL2 should not matter
+    // because their context creation can always be rejected on the GPU process
+    // side.
+    std::set<int> feature_diffs;
+    std::set_difference(blacklisted_features_.begin(),
+                        blacklisted_features_.end(),
+                        preliminary_blacklisted_features_.begin(),
+                        preliminary_blacklisted_features_.end(),
+                        std::inserter(feature_diffs, feature_diffs.begin()));
+    if (feature_diffs.size()) {
+      // TODO(zmo): Other features might also be OK to ignore here.
+      feature_diffs.erase(gpu::GPU_FEATURE_TYPE_WEBGL);
+      feature_diffs.erase(gpu::GPU_FEATURE_TYPE_WEBGL2);
     }
-    return false;
+    if (feature_diffs.size()) {
+      if (reason) {
+        *reason = "Features are disabled on full but not preliminary GPU info.";
+      }
+      return false;
+    }
   }
 
   if (blacklisted_features_.size() == gpu::NUMBER_OF_GPU_FEATURE_TYPES) {
     // On Linux, we use cached GL strings to make blacklist decsions at browser
     // startup time. We need to launch the GPU process to validate these
     // strings even if all features are blacklisted. If all GPU features are
     // disabled, the GPU process will only initialize GL bindings, create a GL
     // context, and collect full GPU info.
 #if !defined(OS_LINUX)
     if (reason) {
@@ skipping 729 matching lines @@
 }
 
 // static
 GpuDataManagerImplPrivate* GpuDataManagerImplPrivate::Create(
     GpuDataManagerImpl* owner) {
   return new GpuDataManagerImplPrivate(owner);
 }
 
 GpuDataManagerImplPrivate::GpuDataManagerImplPrivate(GpuDataManagerImpl* owner)
     : complete_gpu_info_already_requested_(false),
+      preliminary_blacklisted_features_initialized_(false),
       observer_list_(new GpuDataManagerObserverList),
       use_swiftshader_(false),
       card_blacklisted_(false),
       update_histograms_(true),
       domain_blocking_enabled_(true),
       owner_(owner),
       gpu_process_accessible_(true),
       is_initialized_(false),
       finalized_(false),
       in_process_gpu_(false) {
@@ skipping 77 matching lines @@
   if (card_blacklisted_) {
     blacklisted_features_.insert(gpu::GPU_FEATURE_TYPE_GPU_COMPOSITING);
     blacklisted_features_.insert(gpu::GPU_FEATURE_TYPE_WEBGL);
   }
 
   EnableSwiftShaderIfNecessary();
 }
 
 void GpuDataManagerImplPrivate::UpdatePreliminaryBlacklistedFeatures() {
   preliminary_blacklisted_features_ = blacklisted_features_;
+  preliminary_blacklisted_features_initialized_ = true;
 }
 
 void GpuDataManagerImplPrivate::UpdateGpuSwitchingManager(
     const gpu::GPUInfo& gpu_info) {
   // The vendor IDs might be 0 on non-PCI devices (like Android), but
   // the length of the vector is all we care about in most cases.
   std::vector<uint32_t> vendor_ids;
   vendor_ids.push_back(gpu_info.gpu.vendor_id);
   for (const auto& device : gpu_info.secondary_gpus) {
     vendor_ids.push_back(device.vendor_id);
@@ skipping 122 matching lines @@
   gpu_info_.context_info_state = gpu::kCollectInfoFatalFailure;
 #if defined(OS_WIN)
   gpu_info_.dx_diagnostics_info_state = gpu::kCollectInfoFatalFailure;
 #endif
   complete_gpu_info_already_requested_ = true;
   // Some observers might be waiting.
   NotifyGpuInfoUpdate();
 }
 
 }  // namespace content