Move GPU blacklist calculation to GPU proc

cc/trees/layer_tree_host_unittest.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 449 matching lines @@
                 SetAggressivelyFreeResources(false));
     EXPECT_CALL(*mock_worker_context_support_,
                 SetAggressivelyFreeResources(false));
 
     return LayerTreeHostTest::CreateCompositorFrameSink(
         std::move(test_main_context_provider),
         std::move(test_worker_context_provider));
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
-    settings->gpu_rasterization_enabled = true;
     settings->gpu_rasterization_forced = true;
   }
 
   void BeginTest() override {}
   void AfterTest() override {}
 
  protected:
   class MockContextSupport : public TestContextSupport {
    public:
     MockContextSupport() {}
@@ skipping 1171 matching lines @@
     root_layer_->SetTransform(transform);
     root_layer_->SetBounds(bounds_);
     layer_tree_host()->SetRootLayer(root_layer_);
     layer_tree_host()->SetViewportSize(bounds_);
 
     PostSetNeedsCommitToMainThread();
     client_.set_bounds(root_layer_->bounds());
   }
 
   void InitializeSettings(LayerTreeSettings* settings) override {
-    settings->gpu_rasterization_enabled = true;
     settings->gpu_rasterization_forced = true;
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     if (num_draws_ == 2) {
       auto* pending_tree = host_impl->pending_tree();
       auto* pending_layer_impl = static_cast<FakePictureLayerImpl*>(
           pending_tree->root_layer_for_testing());
       EXPECT_NE(pending_layer_impl, nullptr);
 
@@ skipping 3484 matching lines @@
   FakeContentLayerClient client_;
   std::unique_ptr<FakeScopedUIResource> ui_resource_;
 };
 
 // This test is flaky, see http://crbug.com/386199
 // MULTI_THREAD_TEST_F(LayerTreeHostTestHighResRequiredAfterEvictingUIResources)
 
 class LayerTreeHostTestGpuRasterizationDefault : public LayerTreeHostTest {
  protected:
   void InitializeSettings(LayerTreeSettings* settings) override {
-    EXPECT_FALSE(settings->gpu_rasterization_enabled);
     EXPECT_FALSE(settings->gpu_rasterization_forced);
   }
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     std::unique_ptr<FakeRecordingSource> recording_source(
         new FakeRecordingSource);
     recording_source_ = recording_source.get();
 
@@ skipping 86 matching lines @@
 
   void AfterTest() override {}
 
   FakeContentLayerClient layer_client_;
   FakePictureLayer* layer_;
   FakeRecordingSource* recording_source_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestEmptyLayerGpuRasterization);
 
-class LayerTreeHostTestGpuRasterizationEnabled : public LayerTreeHostTest {
+class LayerTreeHostWithGpuRasterizationTest : public LayerTreeHostTest {
  protected:
-  void InitializeSettings(LayerTreeSettings* settings) override {
-    EXPECT_FALSE(settings->gpu_rasterization_enabled);
-    settings->gpu_rasterization_enabled = true;
+  std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+      scoped_refptr<ContextProvider> compositor_context_provider,
+      scoped_refptr<ContextProvider> worker_context_provider) override {
+    auto context = TestWebGraphicsContext3D::Create();
+    context->set_gpu_rasterization(true);
+    auto context_provider = TestContextProvider::Create(std::move(context));
+    return LayerTreeHostTest::CreateCompositorFrameSink(
+        std::move(context_provider), std::move(worker_context_provider));
   }
+};
 
+class LayerTreeHostTestGpuRasterizationEnabled
+    : public LayerTreeHostWithGpuRasterizationTest {
+ protected:
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     std::unique_ptr<FakeRecordingSource> recording_source(
         new FakeRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
             &layer_client_, std::move(recording_source));
@@ skipping 41 matching lines @@
 
   void AfterTest() override {}
 
   FakeContentLayerClient layer_client_;
   FakePictureLayer* layer_;
   FakeRecordingSource* recording_source_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestGpuRasterizationEnabled);
 
-class LayerTreeHostTestGpuRasterizationReenabled : public LayerTreeHostTest {
+class LayerTreeHostTestGpuRasterizationReenabled
+    : public LayerTreeHostWithGpuRasterizationTest {
  protected:
-  void InitializeSettings(LayerTreeSettings* settings) override {
-    EXPECT_FALSE(settings->gpu_rasterization_enabled);
-    settings->gpu_rasterization_enabled = true;
-  }
-
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
     std::unique_ptr<FakeRecordingSource> recording_source(
         new FakeRecordingSource);
     recording_source_ = recording_source.get();
 
     scoped_refptr<FakePictureLayer> layer =
         FakePictureLayer::CreateWithRecordingSource(
             &layer_client_, std::move(recording_source));
@@ skipping 785 matching lines @@
   FakeContentLayerClient client_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(RasterizeWithGpuRasterizationCreatesResources);
 
 class GpuRasterizationRasterizesBorderTiles : public LayerTreeHostTest {
  protected:
   GpuRasterizationRasterizesBorderTiles() : viewport_size_(1024, 2048) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
-    settings->gpu_rasterization_enabled = true;
     settings->gpu_rasterization_forced = true;
   }
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
 
     std::unique_ptr<FakeRecordingSource> recording(new FakeRecordingSource);
     scoped_refptr<FakePictureLayer> root =
         FakePictureLayer::CreateWithRecordingSource(&client_,
                                                     std::move(recording));
@@ skipping 807 matching lines @@
 // Note that this code path won't always hit the crash, even when incorrect
 // behavior occurs, so this is more of a sanity check.
 // TODO(ericrk): We should improve this so that we can reliably detect the
 // crash.
 class GpuRasterizationSucceedsWithLargeImage : public LayerTreeHostTest {
  protected:
   GpuRasterizationSucceedsWithLargeImage()
       : viewport_size_(1024, 2048), large_image_size_(20000, 10) {}
 
   void InitializeSettings(LayerTreeSettings* settings) override {
-    settings->gpu_rasterization_enabled = true;
     settings->gpu_rasterization_forced = true;
 
     /// Set to 0 to force at-raster GPU image decode.
     settings->gpu_decoded_image_budget_bytes = 0;
   }
 
   void SetupTree() override {
     client_.set_fill_with_nonsolid_color(true);
 
     std::unique_ptr<FakeRecordingSource> recording =
@@ skipping 124 matching lines @@
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSubmitFrameResources);
 
 }  // namespace
 }  // namespace cc