cc: Don't draw and swap if the frame will not change.

cc/trees/layer_tree_host_perftest.cc

 // Copyright 2012 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 "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
 #include "base/string_piece.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/nine_patch_layer.h"
 #include "cc/layers/solid_color_layer.h"
 #include "cc/test/fake_content_layer_client.h"
 #include "cc/test/layer_tree_json_parser.h"
 #include "cc/test/layer_tree_test.h"
 #include "cc/test/paths.h"
 
 namespace cc {
 namespace {
 
 static const int kTimeLimitMillis = 2000;
 static const int kWarmupRuns = 5;
 static const int kTimeCheckInterval = 10;
 
 class LayerTreeHostPerfTest : public LayerTreeTest {
  public:
   LayerTreeHostPerfTest()
-      : num_draws_(0) {
+      : num_draws_(0),
+        full_damage_each_frame_(false) {
     fake_content_layer_client_.set_paint_all_opaque(true);
   }
 
   virtual void BeginTest() OVERRIDE {
     BuildTree();
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     ++num_draws_;
     if (num_draws_ == kWarmupRuns)
       start_time_ = base::TimeTicks::HighResNow();
 
     if (!start_time_.is_null() && (num_draws_ % kTimeCheckInterval) == 0) {
       base::TimeDelta elapsed = base::TimeTicks::HighResNow() - start_time_;
       if (elapsed >= base::TimeDelta::FromMilliseconds(kTimeLimitMillis)) {
         elapsed_ = elapsed;
         EndTest();
         return;
       }
     }
     impl->setNeedsRedraw();
+    if (full_damage_each_frame_)
+      impl->SetFullRootLayerDamage();
   }
 
   virtual void BuildTree() {}
 
   virtual void AfterTest() OVERRIDE {
     // Format matches chrome/test/perf/perf_test.h:PrintResult
     printf("*RESULT %s: frames= %.2f runs/s\n",
            test_name_.c_str(),
            num_draws_ / elapsed_.InSecondsF());
   }
 
  protected:
   base::TimeTicks start_time_;
   int num_draws_;
   std::string test_name_;
   base::TimeDelta elapsed_;
   FakeContentLayerClient fake_content_layer_client_;
+  bool full_damage_each_frame_;
 };
 
 
 class LayerTreeHostPerfTestJsonReader : public LayerTreeHostPerfTest {
  public:
   LayerTreeHostPerfTestJsonReader()
       : LayerTreeHostPerfTest() {
   }
 
   void ReadTestFile(std::string name) {
@@ skipping 16 matching lines @@
  private:
   std::string json_;
 };
 
 // Simulates a tab switcher scene with two stacks of 10 tabs each.
 TEST_F(LayerTreeHostPerfTestJsonReader, TenTenSingleThread) {
   ReadTestFile("10_10_layer_tree");
   RunTest(false);
 }
 
+// Simulates a tab switcher scene with two stacks of 10 tabs each.
+TEST_F(LayerTreeHostPerfTestJsonReader,
+       TenTenSingleThread_FullDamageEachFrame) {
+  full_damage_each_frame_ = true;
+  ReadTestFile("10_10_layer_tree");
+  RunTest(false);
+}
+
 // Simulates main-thread scrolling on each frame.
 class ScrollingLayerTreePerfTest : public LayerTreeHostPerfTestJsonReader {
  public:
   ScrollingLayerTreePerfTest()
       : LayerTreeHostPerfTestJsonReader() {
   }
 
   virtual void BuildTree() OVERRIDE {
     LayerTreeHostPerfTestJsonReader::BuildTree();
     scrollable_ = layer_tree_host()->root_layer()->children()[1];
     ASSERT_TRUE(scrollable_);
   }
 
   virtual void Layout() OVERRIDE {
     static const gfx::Vector2d delta = gfx::Vector2d(0, 10);
     scrollable_->SetScrollOffset(scrollable_->scroll_offset() + delta);
   }
 
  private:
   scoped_refptr<Layer> scrollable_;
 };
 
 TEST_F(ScrollingLayerTreePerfTest, LongScrollablePage) {
   ReadTestFile("long_scrollable_page");
   RunTest(false);
 }
 
 }  // namespace
 }  // namespace cc