cc: Re-enable GPU rasterization after content veto.

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 4947 matching lines @@
 
   void BeginTest() override {
     // Verify default value.
     EXPECT_FALSE(layer_tree_host()->has_gpu_rasterization_trigger());
 
     // Gpu rasterization trigger is relevant.
     layer_tree_host()->SetHasGpuRasterizationTrigger(true);
     EXPECT_TRUE(layer_tree_host()->has_gpu_rasterization_trigger());
 
     // Content-based veto is relevant as well.
-    recording_source_->SetUnsuitableForGpuRasterization();
+    recording_source_->SetForceUnsuitableForGpuRasterization(true);
 
     // 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 {
@@ skipping 16 matching lines @@
 
   void AfterTest() override {}
 
   FakeContentLayerClient layer_client_;
   FakePictureLayer* layer_;
   FakeRecordingSource* recording_source_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestGpuRasterizationEnabled);
 
+class LayerTreeHostTestGpuRasterizationReenabled : public LayerTreeHostTest {
+ 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));
+    layer_ = layer.get();
+    layer->SetBounds(gfx::Size(10, 10));
+    layer->SetIsDrawable(true);
+    layer_tree_host()->root_layer()->AddChild(layer);
+    layer_client_.set_bounds(layer_->bounds());
+  }
+
+  void BeginTest() override {
+    // Verify default value.
+    EXPECT_FALSE(layer_tree_host()->has_gpu_rasterization_trigger());
+
+    // Gpu rasterization trigger is relevant.
+    layer_tree_host()->SetHasGpuRasterizationTrigger(true);
+    EXPECT_TRUE(layer_tree_host()->has_gpu_rasterization_trigger());
+
+    // Content-based veto is relevant as well.
+    recording_source_->SetForceUnsuitableForGpuRasterization(true);
+
+    // 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());
+    } else {
+      EXPECT_FALSE(host_impl->use_gpu_rasterization());
+    }
+
+    ++num_commits_;
+    // Every 10 commits, we will try to reenable the gpu rasterization until
+    // (and we won't reenable after we've done it 5 times).
+    //
+    // So, the test expects on a multiple of 10 commits to have gpu enabled,
+    // next commit we'll disable it and expect that it's disabled, and the next
+    // commit we'll make content suitable again which should be picked up on the
+    // next multiple of 10. At commit 60, we would've re-enabled it 5 times
+    // already, so we expect it to remain disabled.
+    if (num_commits_ >= 60) {
+      expected_gpu_enabled_ = false;
+    } else if ((num_commits_ % 10) == 0) {
+      expected_gpu_enabled_ = true;
+    } else if ((num_commits_ % 10) == 1) {
+      recording_source_->SetForceUnsuitableForGpuRasterization(true);
+      expected_gpu_enabled_ = false;
+    } else if ((num_commits_ % 10) == 2) {
+      recording_source_->SetForceUnsuitableForGpuRasterization(false);
+    }
+
+    PostSetNeedsCommitToMainThread();
+    if (num_commits_ > 80)
+      EndTest();
+  }
+
+  void AfterTest() override {}
+
+  FakeContentLayerClient layer_client_;
+  FakePictureLayer* layer_;
+  FakeRecordingSource* recording_source_;
+  int num_commits_ = 0;
+  bool expected_gpu_enabled_ = false;
+};
+
+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;
   }
 
   void SetupTree() override {
     LayerTreeHostTest::SetupTree();
 
@@ skipping 14 matching lines @@
 
   void BeginTest() override {
     // Verify default value.
     EXPECT_FALSE(layer_tree_host()->has_gpu_rasterization_trigger());
 
     // With gpu rasterization forced, gpu rasterization trigger is irrelevant.
     layer_tree_host()->SetHasGpuRasterizationTrigger(true);
     EXPECT_TRUE(layer_tree_host()->has_gpu_rasterization_trigger());
 
     // Content-based veto is irrelevant as well.
-    recording_source_->SetUnsuitableForGpuRasterization();
+    recording_source_->SetForceUnsuitableForGpuRasterization(true);
 
     // 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 {
@@ skipping 1641 matching lines @@
     EndTest();
   }
 
   void AfterTest() override {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestPaintedDeviceScaleFactor);
 
 }  // namespace
 }  // namespace cc