Move GPU blacklist calculation to GPU proc

cc/trees/layer_tree_host.cc

 // Copyright 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 "cc/trees/layer_tree_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 281 matching lines @@
   if (needs_full_tree_sync_)
     TreeSynchronizer::SynchronizeTrees(root_layer(), sync_tree);
 
   PushPropertiesTo(sync_tree);
 
   sync_tree->PassSwapPromises(swap_promise_manager_.TakeSwapPromises());
 
   host_impl->SetHasGpuRasterizationTrigger(has_gpu_rasterization_trigger_);
   host_impl->SetContentIsSuitableForGpuRasterization(
       content_is_suitable_for_gpu_rasterization_);
-  RecordGpuRasterizationHistogram();
+  RecordGpuRasterizationHistogram(host_impl);
 
   host_impl->SetViewportSize(device_viewport_size_);
   sync_tree->SetDeviceScaleFactor(device_scale_factor_);
   host_impl->SetDebugState(debug_state_);
 
   sync_tree->set_ui_resource_request_queue(
       ui_resource_manager_->TakeUIResourcesRequests());
 
   {
     TRACE_EVENT0("cc", "LayerTreeHostInProcess::PushProperties");
@@ skipping 258 matching lines @@
         ->Add(timer.Elapsed().InMicroseconds());
   }
 
   return result || next_commit_forces_redraw_;
 }
 
 void LayerTreeHost::DidCompletePageScaleAnimation() {
   did_complete_scale_animation_ = true;
 }
 
-void LayerTreeHost::RecordGpuRasterizationHistogram() {
+void LayerTreeHost::RecordGpuRasterizationHistogram(
+    const LayerTreeHostImpl* host_impl) {
   // Gpu rasterization is only supported for Renderer compositors.
   // Checking for IsSingleThreaded() to exclude Browser compositors.
   if (gpu_rasterization_histogram_recorded_ || IsSingleThreaded())
     return;
 
+  bool gpu_rasterization_enabled = false;
+  if (host_impl->compositor_frame_sink()) {
+    ContextProvider* compositor_context_provider =
+        host_impl->compositor_frame_sink()->context_provider();
+    if (compositor_context_provider) {
+      gpu_rasterization_enabled =
+          compositor_context_provider->ContextCapabilities().gpu_rasterization;
+    }
+  }
+
   // Record how widely gpu rasterization is enabled.
   // This number takes device/gpu whitelisting/backlisting into account.
   // Note that we do not consider the forced gpu rasterization mode, which is
   // mostly used for debugging purposes.
   UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationEnabled",
-                        settings_.gpu_rasterization_enabled);
-  if (settings_.gpu_rasterization_enabled) {
+                        gpu_rasterization_enabled);
+  if (gpu_rasterization_enabled) {
     UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationTriggered",
                           has_gpu_rasterization_trigger_);
     UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationSuitableContent",
                           content_is_suitable_for_gpu_rasterization_);
     // Record how many pages actually get gpu rasterization when enabled.
     UMA_HISTOGRAM_BOOLEAN("Renderer4.GpuRasterizationUsed",
                           (has_gpu_rasterization_trigger_ &&
                            content_is_suitable_for_gpu_rasterization_));
   }
 
@@ skipping 648 matching lines @@
 LayerListReverseIterator<Layer> LayerTreeHost::rend() {
   return LayerListReverseIterator<Layer>(nullptr);
 }
 
 void LayerTreeHost::SetNeedsDisplayOnAllLayers() {
   for (auto* layer : *this)
     layer->SetNeedsDisplay();
 }
 
 }  // namespace cc