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

cc/trees/layer_tree_host_impl.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_impl.h"
 
 #include <algorithm>
 
 #include "base/basictypes.h"
 #include "base/debug/trace_event.h"
@@ skipping 116 matching lines @@
     time_source_->SetClient(this);
   }
 
   LayerTreeHostImpl* layer_tree_host_impl_;
   scoped_refptr<DelayBasedTimeSource> time_source_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTreeHostImplTimeSourceAdapter);
 };
 
 LayerTreeHostImpl::FrameData::FrameData()
-    : contains_incomplete_tile(false) {}
+    : contains_incomplete_tile(false), has_no_damage(false) {}
 
 LayerTreeHostImpl::FrameData::~FrameData() {}
 
 scoped_ptr<LayerTreeHostImpl> LayerTreeHostImpl::Create(
     const LayerTreeSettings& settings,
     LayerTreeHostImplClient* client,
     Proxy* proxy,
     RenderingStatsInstrumentation* rendering_stats_instrumentation) {
   return make_scoped_ptr(
       new LayerTreeHostImpl(settings,
@@ skipping 22 matching lines @@
           0,
           ManagedMemoryPolicy::CUTOFF_ALLOW_NOTHING),
       pinch_gesture_active_(false),
       fps_counter_(FrameRateCounter::Create(proxy_->HasImplThread())),
       paint_time_counter_(PaintTimeCounter::Create()),
       memory_history_(MemoryHistory::Create()),
       debug_rect_history_(DebugRectHistory::Create()),
       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());
   DidVisibilityChange(this, visible_);
 
   SetDebugState(settings.initial_debug_state);
 
   if (settings.calculate_top_controls_position) {
     top_controls_manager_ =
         TopControlsManager::Create(this,
@@ skipping 301 matching lines @@
 
 bool LayerTreeHostImpl::CalculateRenderPasses(FrameData* frame) {
   DCHECK(frame->render_passes.empty());
 
   if (!CanDraw() || !active_tree_->root_layer())
     return false;
 
   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()",
                static_cast<long long unsigned>(
                    frame->render_surface_layer_list->size()));
 
   // Create the render passes in dependency order.
   for (int surface_index = frame->render_surface_layer_list->size() - 1;
        surface_index >= 0 ;
        --surface_index) {
@@ skipping 146 matching lines @@
                             occlusion_tracker);
   }
 
   if (draw_frame)
     occlusion_tracker.overdraw_metrics()->RecordMetrics(this);
 
   RemoveRenderPasses(CullRenderPassesWithNoQuads(), 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;
 }
 
 void LayerTreeHostImpl::SetBackgroundTickingEnabled(bool enabled) {
   // Lazily create the time_source adapter so that we can vary the interval for
   // testing.
   if (!time_source_client_adapter_) {
     time_source_client_adapter_ = LayerTreeHostImplTimeSourceAdapter::Create(
         this,
         DelayBasedTimeSource::Create(LowFrequencyAnimationInterval(),
@@ skipping 128 matching lines @@
       // change. So, capture the iterator position from the end of the
       // list, and restore it after the change.
       size_t position_from_end = frame->render_passes.size() - it;
       RemoveRenderPassesRecursive(render_pass_quad->render_pass_id, frame);
       it = frame->render_passes.size() - position_from_end;
       DCHECK_GE(frame->render_passes.size(), position_from_end);
     }
   }
 }
 
-bool LayerTreeHostImpl::PrepareToDraw(FrameData* frame) {
+bool LayerTreeHostImpl::PrepareToDraw(FrameData* frame,
+                                      gfx::Rect device_viewport_damage_rect) {
   TRACE_EVENT0("cc", "LayerTreeHostImpl::PrepareToDraw");
 
   active_tree_->UpdateDrawProperties(
       LayerTreeImpl::UPDATE_ACTIVE_TREE_FOR_DRAW);
 
   frame->render_surface_layer_list = &active_tree_->RenderSurfaceLayerList();
   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;
 
   // If we return true, then we expect DrawLayers() to be called before this
   // function is called again.
   return true;
 }
 
 void LayerTreeHostImpl::EnforceManagedMemoryPolicy(
@@ skipping 108 matching lines @@
 
   metadata.root_scroll_offset = RootScrollLayer()->TotalScrollOffset();
 
   return metadata;
 }
 
 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);
 
   rendering_stats_instrumentation_->SetScreenFrameCount(
       fps_counter_->current_frame_number());
   rendering_stats_instrumentation_->SetDroppedFrameCount(
       fps_counter_->dropped_frame_count());
 
   if (tile_manager_) {
@@ skipping 52 matching lines @@
 
 bool LayerTreeHostImpl::IsContextLost() {
   DCHECK(proxy_->IsImplThread());
   return renderer_ && renderer_->IsContextLost();
 }
 
 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();
 }
 
 gfx::Size LayerTreeHostImpl::DeviceViewportSize() const {
   return device_viewport_size();
 }
 
 gfx::SizeF LayerTreeHostImpl::VisibleViewportSize() const {
   gfx::SizeF dip_size =
       gfx::ScaleSize(DeviceViewportSize(), 1.f / device_scale_factor());
@@ skipping 680 matching lines @@
   scoped_ptr<ScrollAndScaleSet> scroll_info(new ScrollAndScaleSet());
 
   CollectScrollDeltas(scroll_info.get(), active_tree_->root_layer());
   scroll_info->page_scale_delta = active_tree_->page_scale_delta();
   active_tree_->set_sent_page_scale_delta(scroll_info->page_scale_delta);
 
   return scroll_info.Pass();
 }
 
 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) {
   if (!page_scale_animation_ || !RootScrollLayer())
     return;
 
   double monotonic_time = (time - base::TimeTicks()).InSecondsF();
   gfx::Vector2dF scroll_total = RootScrollLayer()->scroll_offset() +
                                 RootScrollLayer()->scroll_delta();
 
@@ skipping 280 matching lines @@
   debug_state_ = debug_state;
 }
 
 void LayerTreeHostImpl::SavePaintTime(const base::TimeDelta& total_paint_time,
                                       int commit_number) {
   DCHECK(debug_state_.continuous_painting);
   paint_time_counter_->SavePaintTime(total_paint_time, commit_number);
 }
 
 }  // namespace cc