Adding fading effect for paint rectangles in HUD.

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 <limits>
 
 #include "base/basictypes.h"
@@ skipping 698 matching lines @@
   // frame at all.
   RenderSurfaceImpl* root_surface =
       active_tree_->root_layer()->render_surface();
   bool root_surface_has_no_visible_damage =
       !root_surface->damage_tracker()->current_damage_rect().Intersects(
           root_surface->content_rect());
   bool root_surface_has_contributing_layers =
       !root_surface->layer_list().empty();
   if (root_surface_has_contributing_layers &&
       root_surface_has_no_visible_damage &&
-      active_tree_->LayersWithCopyOutputRequest().empty()) {
+      active_tree_->LayersWithCopyOutputRequest().empty() &&
+      (!active_tree_->hud_layer() ||

[danakj, 2014/03/06 19:03:21]

I'm not sure why this is needed. The HUD layer always causes there to be damage
via
https://code.google.com/p/chromium/codesearch#chromium/src/cc/layers/heads_up...

This makes any frame we produce be damaged over the hud layer's area.

However it does not cause compositor to trigger new frames. It seems like to do
fading, you will need the HUD layer to cause SetNeedsRedraw() after each frame,
unless you only want it to fade during new main thread frames? What's the
intention?

[caseq, 2014/03/07 09:08:21]

From what I can see, we explicitly exclude HUD from the damage calculation via
check of layer against HUD
(https://code.google.com/p/chromium/codesearch#chromium/src/cc/trees/damage_tr...),


This effectively excludes any code that is conditional on layerIsAlwaysDamaged()
returning true -- if we keep this check, we might as well get rid of
layerIsAlwaysDamaged() :-)

If we just remove the check, though, we'll stop bailing out of
LayerTreeHostImpl::DrawLayers() on frame->has_no_damage as long as HUD is
present and will keep updating HUD (and FPS rate) even when there's no actual
damage to regular layers and no need to redraw the HUD. This may be alright
since this would not happen unless SetNeedsRedraw() is called, but I'd like
someone with the CC expertise to validate that :-) I guess we can also consider
renaming layerIsAlwaysDamaged() to something else and only return true in case
HUD has something to update.
The intent is to fade paint rects even if there are no main thread frames and
even in the case where no impl-side frames would normally be scheduled (i.e. if
the page draws something and goes idle, we need to fade its paint rects out to
make evident we do not keep repainting).

[danakj, 2014/03/07 20:50:20]

OK this looks reasonable to me, now that I understand how HUD damage is (or
isn't) working again. I'd prefer to split these hud checks off into a separate
temporary bool (hud_wants_to_draw?) and add that bool to this if() statement
instead.

[malch, 2014/03/11 16:14:42]

Done.

+       !active_tree_->hud_layer()->NeedsUpdate())) {
     TRACE_EVENT0("cc",
                  "LayerTreeHostImpl::CalculateRenderPasses::EmptyDamageRect");
     frame->has_no_damage = true;
     DCHECK(!output_surface_->capabilities()
                .draw_and_swap_full_viewport_every_frame);
     return DrawSwapReadbackResult::DRAW_SUCCESS;
   }
 
   TRACE_EVENT1("cc",
                "LayerTreeHostImpl::CalculateRenderPasses",
@@ skipping 2296 matching lines @@
   swap_promise_monitor_.erase(monitor);
 }
 
 void LayerTreeHostImpl::NotifySwapPromiseMonitorsOfSetNeedsRedraw() {
   std::set<SwapPromiseMonitor*>::iterator it = swap_promise_monitor_.begin();
   for (; it != swap_promise_monitor_.end(); it++)
     (*it)->OnSetNeedsRedrawOnImpl();
 }
 
 }  // namespace cc