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

cc/trees/layer_tree_host_impl.cc

Index: cc/trees/layer_tree_host_impl.cc
diff --git a/cc/trees/layer_tree_host_impl.cc b/cc/trees/layer_tree_host_impl.cc
index 36659f54319650a115266e2858959aa0dc0f5201..02c399f178c13cec6b2aef9cbc94c44ef375d3fa 100644
--- a/cc/trees/layer_tree_host_impl.cc
+++ b/cc/trees/layer_tree_host_impl.cc
@@ -134,7 +134,7 @@ class LayerTreeHostImplTimeSourceAdapter : public TimeSourceClient {
 };
 
 LayerTreeHostImpl::FrameData::FrameData()
-    : contains_incomplete_tile(false) {}
+    : contains_incomplete_tile(false), has_no_damage(false) {}
 
 LayerTreeHostImpl::FrameData::~FrameData() {}
 
@@ -177,6 +177,7 @@ LayerTreeHostImpl::LayerTreeHostImpl(
       last_sent_memory_visible_bytes_(0),
       last_sent_memory_visible_and_nearby_bytes_(0),
       last_sent_memory_use_bytes_(0),
+      next_frame_damages_full_device_viewport_(false),
       animation_registrar_(AnimationRegistrar::Create()),
       rendering_stats_instrumentation_(rendering_stats_instrumentation) {
   DCHECK(proxy_->IsImplThread());
@@ -498,6 +499,23 @@ bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
   TrackDamageForAllSurfaces(active_tree_->root_layer(),
                             *frame->render_surface_layer_list);
 
+  // If the root render surface has no visible damage, then don't generate a
+  // frame at all.
+  RenderSurfaceImpl* root_surface =
+      active_tree_->root_layer()->render_surface();
+  bool root_surface_has_no_visible_damage =
+      gfx::IntersectRects(root_surface->damage_tracker()->current_damage_rect(),

[enne (OOO), 2013/03/26 01:42:07]

I think you're looking for gfx::Rect::Intersects

[danakj, 2013/03/26 02:00:10]

So I am!

+                          root_surface->content_rect()).IsEmpty();
+  bool root_surface_has_contributing_layers =
+      !root_surface->layer_list().empty();
+  if (root_surface_has_contributing_layers &&
+      root_surface_has_no_visible_damage) {
+    TRACE_EVENT0("cc",
+                 "LayerTreeHostImpl::CalculateRenderPasses::EmptyDamageRect");
+    frame->has_no_damage = true;
+    return true;
+  }
+
   TRACE_EVENT1("cc",
                "LayerTreeHostImpl::CalculateRenderPasses",
                "render_surface_layer_list.size()",
@@ -664,6 +682,8 @@ bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
   renderer_->DecideRenderPassAllocationsForFrame(frame->render_passes);
   RemoveRenderPasses(CullRenderPassesWithCachedTextures(*renderer_), frame);
 
+  // If we're making a frame to draw, it better have at least one render pass.
+  DCHECK(!frame->render_passes.empty());
   return draw_frame;
 }
 
@@ -812,7 +832,8 @@ void LayerTreeHostImpl::RemoveRenderPasses(RenderPassCuller culler,
   }
 }
 
-bool LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
+bool LayerTreeHostImpl::PrepareToDraw(FrameData* frame,
+                                      gfx::Rect device_viewport_damage_rect) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::PrepareToDraw");
 
   active_tree_->UpdateDrawProperties(
@@ -822,6 +843,17 @@ bool LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
   frame->render_passes.clear();
   frame->render_passes_by_id.clear();
   frame->will_draw_layers.clear();
+  frame->contains_incomplete_tile = false;
+  frame->has_no_damage = false;
+
+  if (active_tree_->root_layer()) {

[enne (OOO), 2013/03/26 01:42:07]

Why only do this if there's a root layer? If there's not a root layer, then
adding layers the next time we draw will cause damage.

[danakj, 2013/03/26 02:00:10]

That is true, but it may not be a full frame if the root layer doesn't cover the
viewport. Until you add a root layer, we don't draw, so we don't clear damage,
so this seemed right to me.

+    if (next_frame_damages_full_device_viewport_)
+      device_viewport_damage_rect.Union(gfx::Rect(device_viewport_size_));
+
+    active_tree_->root_layer()->render_surface()->damage_tracker()->
+        AddDamageNextUpdate(device_viewport_damage_rect);
+  }
+  next_frame_damages_full_device_viewport_ = false;
 
   if (!CalculateRenderPasses(frame))
     return false;
@@ -950,6 +982,10 @@ void LayerTreeHostImpl::DrawLayers(FrameData* frame,
                                    base::TimeTicks frame_begin_time) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::DrawLayers");
   DCHECK(CanDraw());
+
+  if (frame->has_no_damage)
+    return;
+
   DCHECK(!frame->render_passes.empty());
 
   fps_counter_->SaveTimeStamp(frame_begin_time);
@@ -1022,7 +1058,9 @@ const RendererCapabilities& LayerTreeHostImpl::GetRendererCapabilities() const {
   return renderer_->Capabilities();
 }
 
-bool LayerTreeHostImpl::SwapBuffers() {
+bool LayerTreeHostImpl::SwapBuffers(const LayerTreeHostImpl::FrameData& frame) {
+  if (frame.has_no_damage)
+    return false;
   return renderer_->SwapBuffers();
 }
 
@@ -1723,12 +1761,7 @@ scoped_ptr<ScrollAndScaleSet> LayerTreeHostImpl::ProcessScrollDeltas() {
 }
 
 void LayerTreeHostImpl::SetFullRootLayerDamage() {
-  if (active_tree_->root_layer()) {
-    RenderSurfaceImpl* render_surface =
-        active_tree_->root_layer()->render_surface();
-    if (render_surface)
-      render_surface->damage_tracker()->ForceFullDamageNextUpdate();
-  }
+  next_frame_damages_full_device_viewport_ = true;
 }
 
 void LayerTreeHostImpl::AnimatePageScale(base::TimeTicks time) {