cc: remove the veto-to-software for complex content.

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 5287 matching lines @@
     // Since we are manually marking the source as unsuitable,
     // make sure that the layer gets a chance to update.
     layer_->SetNeedsDisplay();
     PostSetNeedsCommitToMainThread();
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     // Ensure the suitability bit sticks.
     EXPECT_FALSE(layer_->IsSuitableForGpuRasterization());
 
-    EXPECT_FALSE(host_impl->pending_tree()->use_gpu_rasterization());
-    EXPECT_FALSE(host_impl->use_gpu_rasterization());
+    EXPECT_TRUE(host_impl->pending_tree()->use_gpu_rasterization());
+    EXPECT_TRUE(host_impl->use_gpu_rasterization());
   }
 
   void DidActivateTreeOnThread(LayerTreeHostImpl* host_impl) override {
     EXPECT_FALSE(layer_->IsSuitableForGpuRasterization());
 
-    EXPECT_FALSE(host_impl->active_tree()->use_gpu_rasterization());
-    EXPECT_FALSE(host_impl->use_gpu_rasterization());
+    EXPECT_TRUE(host_impl->active_tree()->use_gpu_rasterization());
+    EXPECT_TRUE(host_impl->use_gpu_rasterization());
     EndTest();
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient layer_client_;
   FakePictureLayer* layer_;
   FakeRecordingSource* recording_source_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestGpuRasterizationEnabled);
 
 class LayerTreeHostTestGpuRasterizationReenabled
     : public LayerTreeHostWithGpuRasterizationTest {
  protected:
+  void InitializeSettings(LayerTreeSettings* settings) override {
+    settings->gpu_rasterization_msaa_sample_count = 4;
+  }
+
+  std::unique_ptr<TestCompositorFrameSink> CreateCompositorFrameSink(
+      scoped_refptr<ContextProvider> compositor_context_provider,
+      scoped_refptr<ContextProvider> worker_context_provider) override {
+    std::unique_ptr<TestWebGraphicsContext3D> context =
+        TestWebGraphicsContext3D::Create();
+    context->SetMaxSamples(4);
+    context->set_gpu_rasterization(true);
+    compositor_context_provider =
+        TestContextProvider::Create(std::move(context));
+    return LayerTreeTest::CreateCompositorFrameSink(compositor_context_provider,
+                                                    worker_context_provider);
+  }
+
   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 18 matching lines @@
     // Veto will take effect when layers are updated.
     // The results will be verified after commit is completed below.
     // Since we are manually marking the source as unsuitable,
     // make sure that the layer gets a chance to update.
     layer_->SetNeedsDisplay();
     PostSetNeedsCommitToMainThread();
   }
 
   void CommitCompleteOnThread(LayerTreeHostImpl* host_impl) override {
     SCOPED_TRACE(base::StringPrintf("commit %d", num_commits_));
-    if (expected_gpu_enabled_) {
-      EXPECT_TRUE(host_impl->use_gpu_rasterization());
+    if (expected_use_msaa_) {
+      EXPECT_TRUE(host_impl->use_msaa());
     } else {
-      EXPECT_FALSE(host_impl->use_gpu_rasterization());
+      EXPECT_FALSE(host_impl->use_msaa());
     }
 
     ++num_commits_;
     switch (num_commits_) {
       case 1:
         layer_->set_force_unsuitable_for_gpu_rasterization(false);
         break;
       case 30:
         layer_->set_force_unsuitable_for_gpu_rasterization(true);
         break;
       case 31:
         layer_->set_force_unsuitable_for_gpu_rasterization(false);
         break;
       case 90:
-        expected_gpu_enabled_ = true;
+        expected_use_msaa_ = false;
         break;
     }
     PostSetNeedsCommitToMainThread();
     if (num_commits_ > 100)
       EndTest();
   }
 
   void AfterTest() override {}
 
   FakeContentLayerClient layer_client_;
   FakePictureLayer* layer_;
   FakeRecordingSource* recording_source_;
   int num_commits_ = 0;
-  bool expected_gpu_enabled_ = false;
+  bool expected_use_msaa_ = true;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestGpuRasterizationReenabled);
 
 class LayerTreeHostTestGpuRasterizationForced : public LayerTreeHostTest {
  protected:
   void InitializeSettings(LayerTreeSettings* settings) override {
     EXPECT_FALSE(settings->gpu_rasterization_forced);
     settings->gpu_rasterization_forced = true;
   }
@@ skipping 1918 matching lines @@
     DCHECK_EQ(hud->scroll_tree_index(), root_layer->scroll_tree_index());
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestHudLayerWithLayerLists);
 
 }  // namespace
 }  // namespace cc