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 "base/synchronization/lock.h"
 #include "cc/animation/timing_function.h"
 #include "cc/layers/content_layer.h"
 #include "cc/layers/content_layer_client.h"
@@ skipping 124 matching lines @@
     {
     }
 
     virtual void BeginTest() OVERRIDE
     {
         PostSetNeedsCommitToMainThread();
     }
 
     virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
+        ++m_numDraws;
+    }
+
+    virtual void CommitCompleteOnThread(LayerTreeHostImpl* impl) OVERRIDE
+    {
+        m_numCommits++;
+
         if (impl->active_tree()->source_frame_number() == 0)
             PostSetNeedsCommitToMainThread();
         else if (impl->active_tree()->source_frame_number() == 1)
             EndTest();
     }
 
-    virtual void CommitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
-    {
-        m_numCommits++;
-    }
-
     virtual void AfterTest() OVERRIDE
     {
         EXPECT_EQ(2, m_numCommits);
-        EXPECT_GE(2, m_numDraws);
+        EXPECT_EQ(1, m_numDraws);
     }
 
 private:
     int m_numCommits;
     int m_numDraws;
 };
 
 MULTI_THREAD_TEST_F(LayerTreeHostTestSetNeedsCommit2)
 
 // 1 setNeedsRedraw after the first commit has completed should lead to 1
@@ skipping 663 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 frameData;
-        impl->PrepareToDraw(&frameData);
+        impl->PrepareToDraw(&frameData, gfx::Rect());
         impl->DidDrawAllLayers(frameData);
 
         const LayerTreeHostImpl::LayerList& renderSurfaceLayerList =
           *frameData.render_surface_layer_list;
 
         // Both layers should be drawing into the root render surface.
         ASSERT_EQ(1u, renderSurfaceLayerList.size());
         ASSERT_EQ(root->render_surface(), renderSurfaceLayerList[0]->render_surface());
         ASSERT_EQ(2u, root->render_surface()->layer_list().size());
 
@@ skipping 427 matching lines @@
     virtual void AfterTest() OVERRIDE
     {
     }
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestCompositeAndReadbackCleanup)
 
 class LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit : public LayerTreeHostTest {
 public:
     LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit()
-        : m_rootLayer(ContentLayerWithUpdateTracking::Create(&m_fakeDelegate))
-        , m_surfaceLayer1(ContentLayerWithUpdateTracking::Create(&m_fakeDelegate))
-        , m_replicaLayer1(ContentLayerWithUpdateTracking::Create(&m_fakeDelegate))
-        , m_surfaceLayer2(ContentLayerWithUpdateTracking::Create(&m_fakeDelegate))
-        , m_replicaLayer2(ContentLayerWithUpdateTracking::Create(&m_fakeDelegate))
+            : m_rootLayer(FakeContentLayer::Create(&m_client))
+            , m_surfaceLayer1(FakeContentLayer::Create(&m_client))
+            , m_replicaLayer1(FakeContentLayer::Create(&m_client))
+            , m_surfaceLayer2(FakeContentLayer::Create(&m_client))
+            , m_replicaLayer2(FakeContentLayer::Create(&m_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));
 
         m_rootLayer->SetBounds(gfx::Size(100, 100));
+        m_rootLayer->SetIsDrawable(true);
         m_surfaceLayer1->SetBounds(gfx::Size(100, 100));
         m_surfaceLayer1->SetForceRenderSurface(true);
         m_surfaceLayer1->SetOpacity(0.5);
+        m_surfaceLayer1->SetIsDrawable(true);
         m_surfaceLayer2->SetBounds(gfx::Size(100, 100));
         m_surfaceLayer2->SetForceRenderSurface(true);
         m_surfaceLayer2->SetOpacity(0.5);
+        m_surfaceLayer2->SetIsDrawable(true);
 
         m_surfaceLayer1->SetReplicaLayer(m_replicaLayer1.get());
         m_surfaceLayer2->SetReplicaLayer(m_replicaLayer2.get());
 
         m_rootLayer->AddChild(m_surfaceLayer1);
         m_surfaceLayer1->AddChild(m_surfaceLayer2);
         layer_tree_host()->SetRootLayer(m_rootLayer);
 
         PostSetNeedsCommitToMainThread();
     }
 
     virtual void DrawLayersOnThread(LayerTreeHostImpl* hostImpl) OVERRIDE
     {
         Renderer* renderer = hostImpl->renderer();
         RenderPass::Id surface1RenderPassId = hostImpl->active_tree()->root_layer()->children()[0]->render_surface()->RenderPassId();
         RenderPass::Id surface2RenderPassId = hostImpl->active_tree()->root_layer()->children()[0]->children()[0]->render_surface()->RenderPassId();
 
-        switch (hostImpl->active_tree()->source_frame_number()) {
+        int source_frame = hostImpl->active_tree()->source_frame_number();
+        switch (source_frame) {
         case 0:
             EXPECT_TRUE(renderer->HaveCachedResourcesForRenderPassId(surface1RenderPassId));
             EXPECT_TRUE(renderer->HaveCachedResourcesForRenderPassId(surface2RenderPassId));
 
             // Reduce the memory limit to only fit the root layer and one render surface. This
             // prevents any contents drawing into surfaces from being allocated.
             hostImpl->SetManagedMemoryPolicy(ManagedMemoryPolicy(100 * 100 * 4 * 2));
             break;
         case 1:
             EXPECT_FALSE(renderer->HaveCachedResourcesForRenderPassId(surface1RenderPassId));
             EXPECT_FALSE(renderer->HaveCachedResourcesForRenderPassId(surface2RenderPassId));
 
             EndTest();
             break;
         }
     }
 
+    virtual void DidCommitAndDrawFrame() OVERRIDE {
+        if (!TestEnded())
+            m_rootLayer->SetNeedsDisplay();
+    }
+
     virtual void AfterTest() OVERRIDE
     {
-        EXPECT_EQ(2, m_rootLayer->paintContentsCount());
-        EXPECT_EQ(2, m_surfaceLayer1->paintContentsCount());
-        EXPECT_EQ(2, m_surfaceLayer2->paintContentsCount());
-
-        // Clear layer references so LayerTreeHost dies.
-        m_rootLayer = NULL;
-        m_surfaceLayer1 = NULL;
-        m_replicaLayer1 = NULL;
-        m_surfaceLayer2 = NULL;
-        m_replicaLayer2 = NULL;
+        EXPECT_EQ(3, m_rootLayer->update_count());
+        EXPECT_EQ(3, m_surfaceLayer1->update_count());
+        EXPECT_EQ(3, m_surfaceLayer2->update_count());
     }
 
 private:
-    FakeContentLayerClient m_fakeDelegate;
-    scoped_refptr<ContentLayerWithUpdateTracking> m_rootLayer;
-    scoped_refptr<ContentLayerWithUpdateTracking> m_surfaceLayer1;
-    scoped_refptr<ContentLayerWithUpdateTracking> m_replicaLayer1;
-    scoped_refptr<ContentLayerWithUpdateTracking> m_surfaceLayer2;
-    scoped_refptr<ContentLayerWithUpdateTracking> m_replicaLayer2;
+    FakeContentLayerClient m_client;
+    scoped_refptr<FakeContentLayer> m_rootLayer;
+    scoped_refptr<FakeContentLayer> m_surfaceLayer1;
+    scoped_refptr<FakeContentLayer> m_replicaLayer1;
+    scoped_refptr<FakeContentLayer> m_surfaceLayer2;
+    scoped_refptr<FakeContentLayer> m_replicaLayer2;
 };
 
 SINGLE_AND_MULTI_THREAD_TEST_F(LayerTreeHostTestSurfaceNotAllocatedForLayersOutsideMemoryLimit)
 
 class EvictionTestLayer : public Layer {
 public:
     static scoped_refptr<EvictionTestLayer> Create() { return make_scoped_refptr(new EvictionTestLayer()); }
 
     virtual void Update(ResourceUpdateQueue*, const OcclusionTracker*, RenderingStats*) OVERRIDE;
     virtual bool DrawsContent() const OVERRIDE { return true; }
@@ skipping 127 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 (m_numCommits) {
         case 1:
             EXPECT_TRUE(m_layer->haveBackingTexture());
             postEvictTextures();
             break;
         case 2:
             EXPECT_TRUE(m_layer->haveBackingTexture());
             layer_tree_host()->SetNeedsCommit();
             break;
@@ skipping 74 matching lines @@
         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 (m_numDrawLayers == 2)
             return;
-        PostSetNeedsCommitToMainThread();
+        layer_tree_host()->root_layer()->SetNeedsDisplay();
     }
 
     virtual void CommitCompleteOnThread(LayerTreeHostImpl*) OVERRIDE
     {
         if (m_numDrawLayers == 1)
             m_numCommitComplete++;
     }
 
     virtual void DrawLayersOnThread(LayerTreeHostImpl* impl) OVERRIDE
     {
@@ skipping 720 matching lines @@
     }
 
 private:
     NotificationClient client_;
 };
 
 SINGLE_THREAD_TEST_F(LayerTreeHostTestLCDNotification)
 
 }  // namespace
 }  // namespace cc