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

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 <algorithm>
 
 #include "base/synchronization/lock.h"
 #include "cc/animation/timing_function.h"
@@ skipping 102 matching lines @@
 
 // A setNeedsCommit should lead to 1 commit. Issuing a second commit after that
 // first committed frame draws should lead to another commit.
 class LayerTreeHostTestSetNeedsCommit2 : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSetNeedsCommit2() : num_commits_(0), num_draws_(0) {}
 
   virtual void BeginTest() OVERRIDE { PostSetNeedsCommitToMainThread(); }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+    ++num_draws_;
+  }
+
+  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
+    ++num_commits_;
     if (impl->active_tree()->source_frame_number() == 0)
       PostSetNeedsCommitToMainThread();
     else if (impl->active_tree()->source_frame_number() == 1)
       EndTest();
   }
 
-  virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
-    num_commits_++;
-  }
-
   virtual void AfterTest() OVERRIDE {
     EXPECT_EQ(2, num_commits_);
-    EXPECT_GE(2, num_draws_);
+    EXPECT_LE(1, num_draws_);
   }
 
  private:
   int num_commits_;
   int num_draws_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommit2);
 
 // 1 setNeedsRedraw after the first commit has completed should lead to 1
@@ skipping 541 matching lines @@
 
     LayerImpl* root = impl->active_tree()->root_layer();
     LayerImpl* child = impl->active_tree()->root_layer()->children()[0];
 
     // Positions remain in layout pixels.
     EXPECT_EQ(gfx::Point(0, 0), root->position());
     EXPECT_EQ(gfx::Point(2, 2), child->position());
 
     // Compute all the layer transforms for the frame.
     LayerTreeHostImpl::FrameData frame_data;
-    impl->PrepareToDraw(&frame_data);
+    impl->PrepareToDraw(&frame_data, gfx::Rect());
     impl->DidDrawAllLayers(frame_data);
 
     const LayerImplList& render_surface_layer_list =
         *frame_data.render_surface_layer_list;
 
     // Both layers should be drawing into the root render surface.
     ASSERT_EQ(1u, render_surface_layer_list.size());
     ASSERT_EQ(root->render_surface(),
               render_surface_layer_list[0]->render_surface());
     ASSERT_EQ(2u, root->render_surface()->layer_list().size());
@@ skipping 409 matching lines @@
 
   virtual void AfterTest() OVERRIDE {}
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestCompositeAndReadbackCleanup);
 
 class LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit
     : public LayerTreeHostTest {
  public:
   LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit()
-      : root_layer_(ContentLayerWithUpdateTracking::Create(&fake_delegate_)),
+      : root_layer_(FakeContentLayer::Create(&client_)),
         surface_layer1_(
-            ContentLayerWithUpdateTracking::Create(&fake_delegate_)),
+            FakeContentLayer::Create(&client_)),
         replica_layer1_(
-            ContentLayerWithUpdateTracking::Create(&fake_delegate_)),
+            FakeContentLayer::Create(&client_)),
         surface_layer2_(
-            ContentLayerWithUpdateTracking::Create(&fake_delegate_)),
+            FakeContentLayer::Create(&client_)),
         replica_layer2_(
-            ContentLayerWithUpdateTracking::Create(&fake_delegate_)) {}
+            FakeContentLayer::Create(&client_)) {}
 
   virtual void InitializeSettings(LayerTreeSettings* settings) OVERRIDE {
     settings->cache_render_pass_contents = true;
   }
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size(100, 100),
                                        gfx::Size(100, 100));
 
     root_layer_->SetBounds(gfx::Size(100, 100));
@@ skipping 39 matching lines @@
         EXPECT_FALSE(renderer->HaveCachedResourcesForRenderPassId(
             surface1_render_pass_id));
         EXPECT_FALSE(renderer->HaveCachedResourcesForRenderPassId(
             surface2_render_pass_id));
 
         EndTest();
         break;
     }
   }
 
+  virtual void DidCommitAndDrawFrame() OVERRIDE {
+    if (!TestEnded())
+      root_layer_->SetNeedsDisplay();
+  }
+
   virtual void AfterTest() OVERRIDE {
-    EXPECT_EQ(2, root_layer_->PaintContentsCount());
-    EXPECT_EQ(2, surface_layer1_->PaintContentsCount());
-    EXPECT_EQ(2, surface_layer2_->PaintContentsCount());
+    EXPECT_EQ(3u, root_layer_->update_count());
+    EXPECT_EQ(3u, surface_layer1_->update_count());
+    EXPECT_EQ(3u, surface_layer2_->update_count());
   }
 
  private:
-  FakeContentLayerClient fake_delegate_;
-  scoped_refptr<ContentLayerWithUpdateTracking> root_layer_;
-  scoped_refptr<ContentLayerWithUpdateTracking> surface_layer1_;
-  scoped_refptr<ContentLayerWithUpdateTracking> replica_layer1_;
-  scoped_refptr<ContentLayerWithUpdateTracking> surface_layer2_;
-  scoped_refptr<ContentLayerWithUpdateTracking> replica_layer2_;
+  FakeContentLayerClient client_;
+  scoped_refptr<FakeContentLayer> root_layer_;
+  scoped_refptr<FakeContentLayer> surface_layer1_;
+  scoped_refptr<FakeContentLayer> replica_layer1_;
+  scoped_refptr<FakeContentLayer> surface_layer2_;
+  scoped_refptr<FakeContentLayer> replica_layer2_;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(
     LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit);
 
 class EvictionTestLayer : public Layer {
  public:
   static scoped_refptr<EvictionTestLayer> Create() {
     return make_scoped_refptr(new EvictionTestLayer());
   }
@@ skipping 137 matching lines @@
   // Commit 6: Triggered by the eviction, post an eviction task in
   // Layout(), which will be a noop, letting the commit (which recreates the
   // textures) go through and draw a frame, then end the test.
   //
   // Commits 1+2 test the eviction recovery path where eviction happens outside
   // of the beginFrame/commit pair.
   // Commits 3+4 test the eviction recovery path where eviction happens inside
   // the beginFrame/commit pair.
   // Commits 5+6 test the path where an eviction happens during the eviction
   // recovery path.
-  virtual void DidCommitAndDrawFrame() OVERRIDE {
+  virtual void DidCommit() OVERRIDE {
     switch (num_commits_) {
       case 1:
         EXPECT_TRUE(layer_->HaveBackingTexture());
         PostEvictTextures();
         break;
       case 2:
         EXPECT_TRUE(layer_->HaveBackingTexture());
         layer_tree_host()->SetNeedsCommit();
         break;
       case 3:
@@ skipping 66 matching lines @@
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
     layer_tree_host()->root_layer()->SetBounds(gfx::Size(10, 10));
 
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommit() OVERRIDE {
     if (num_draw_layers_ == 2)
       return;
-    PostSetNeedsCommitToMainThread();
+    layer_tree_host()->root_layer()->SetNeedsDisplay();
   }
 
   virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     if (num_draw_layers_ == 1)
       num_commit_complete_++;
   }
 
   virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE {
     num_draw_layers_++;
     if (num_draw_layers_ == 2)
@@ skipping 14 matching lines @@
 
 class LayerTreeHostTestContinuousInvalidate : public LayerTreeHostTest {
  public:
   LayerTreeHostTestContinuousInvalidate()
       : num_commit_complete_(0), num_draw_layers_(0) {}
 
   virtual void BeginTest() OVERRIDE {
     layer_tree_host()->SetViewportSize(gfx::Size(10, 10), gfx::Size(10, 10));
     layer_tree_host()->root_layer()->SetBounds(gfx::Size(10, 10));
 
-    content_layer_ = ContentLayer::Create(&fake_delegate_);
+    content_layer_ = ContentLayer::Create(&client_);
     content_layer_->SetBounds(gfx::Size(10, 10));
     content_layer_->SetPosition(gfx::PointF(0.f, 0.f));
     content_layer_->SetAnchorPoint(gfx::PointF(0.f, 0.f));
     content_layer_->SetIsDrawable(true);
     layer_tree_host()->root_layer()->AddChild(content_layer_);
 
     PostSetNeedsCommitToMainThread();
   }
 
   virtual void DidCommit() OVERRIDE {
@@ skipping 12 matching lines @@
     if (num_draw_layers_ == 2)
       EndTest();
   }
 
   virtual void AfterTest() OVERRIDE {
     // Check that we didn't commit twice between first and second draw.
     EXPECT_EQ(1, num_commit_complete_);
   }
 
  private:
-  FakeContentLayerClient fake_delegate_;
+  FakeContentLayerClient client_;
   scoped_refptr<Layer> content_layer_;
   int num_commit_complete_;
   int num_draw_layers_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestContinuousInvalidate);
 
 class LayerTreeHostTestDeferCommits : public LayerTreeHostTest {
  public:
   LayerTreeHostTestDeferCommits()
@@ skipping 643 matching lines @@
   }
 
  private:
   base::TimeTicks frame_time_;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestVSyncNotification);
 
 }  // namespace
 }  // namespace cc