ui: Clean up damaged rects and clear them after painting.

ui/compositor/layer.cc

 // Copyright (c) 2012 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 "ui/compositor/layer.h"
 
 #include <algorithm>
 
 #include "base/auto_reset.h"
 #include "base/command_line.h"
@@ skipping 639 matching lines @@
   nine_patch_layer_->SetBorder(border);
 }
 
 void Layer::SetColor(SkColor color) { GetAnimator()->SetColor(color); }
 
 bool Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
   if ((type_ == LAYER_SOLID_COLOR && !texture_layer_.get()) ||
       type_ == LAYER_NINE_PATCH || (!delegate_ && !mailbox_.IsValid()))
     return false;
 
-  damaged_region_.op(invalid_rect.x(),
-                     invalid_rect.y(),
-                     invalid_rect.right(),
-                     invalid_rect.bottom(),
-                     SkRegion::kUnion_Op);
+  damaged_region_.Union(invalid_rect);
   ScheduleDraw();
   return true;
 }
 
 void Layer::ScheduleDraw() {
   Compositor* compositor = GetCompositor();
   if (compositor)
     compositor->ScheduleDraw();
 }
 
 void Layer::SendDamagedRects() {
-  if ((delegate_ || mailbox_.IsValid()) && !damaged_region_.isEmpty()) {
-    for (SkRegion::Iterator iter(damaged_region_); !iter.done(); iter.next()) {
-      const SkIRect& sk_damaged = iter.rect();
-      gfx::Rect damaged(
-          sk_damaged.x(),
-          sk_damaged.y(),
-          sk_damaged.width(),
-          sk_damaged.height());
-      cc_layer_->SetNeedsDisplayRect(damaged);
-    }
-    damaged_region_.setEmpty();
-  }
-  for (size_t i = 0; i < children_.size(); ++i)
-    children_[i]->SendDamagedRects();
+  if (damaged_region_.IsEmpty())
+    return;
+  if (!delegate_ && !mailbox_.IsValid())
+    return;
+
+  for (cc::Region::Iterator iter(damaged_region_); iter.has_rect(); iter.next())
+    cc_layer_->SetNeedsDisplayRect(iter.rect());
+}
+
+void Layer::ClearDamagedRects() {
+  damaged_region_.Clear();
 }
 
 void Layer::CompleteAllAnimations() {
   typedef std::vector<scoped_refptr<LayerAnimator> > LayerAnimatorVector;
   LayerAnimatorVector animators;
   CollectAnimators(&animators);
   for (LayerAnimatorVector::const_iterator it = animators.begin();
        it != animators.end();
        ++it) {
     (*it)->StopAnimating();
@@ skipping 42 matching lines @@
 
 void Layer::PaintContents(
     SkCanvas* sk_canvas,
     const gfx::Rect& clip,
     ContentLayerClient::PaintingControlSetting painting_control) {
   TRACE_EVENT1("ui", "Layer::PaintContents", "name", name_);
   scoped_ptr<gfx::Canvas> canvas(gfx::Canvas::CreateCanvasWithoutScaling(
       sk_canvas, device_scale_factor_));
   if (delegate_)
     delegate_->OnPaintLayer(PaintContext(canvas.get(), clip));
+  ClearDamagedRects();

[sky, 2015/04/21 23:56:54]

What happens if as part of painting something gets damaged? Should the clear
happen before calling to paint?

[piman, 2015/04/22 03:32:13]

Conversely, what happens if damage to the layer is added between SendDamageRects
and PaintContents?

OTOH, with display lists I wonder if we can remove the damage logic altogether.
It was added so that we could send damage and then cancel it because the
delegate would go away but we may have lost pixels. With display lists, assuming
we can keep them around, this wouldn't be a problem any more.

[danakj, 2015/04/22 16:32:21]

It's possible, I wanted to think of that as a bug, but we have a unit test
covering this behaviour (which was failing), so I guess it's something we have
explicitly supported in the past.

I've moved the Clear above, which also fixes the test.
Ya, this has always been kinda sketchy lookin'. I think the good news here is
that the ui embedder code has no chance to do anything between Layout() which
sends the rects and Paint() which uses/clears them. These both happen in the
same task (BeginMainFrame) that the compositor controls.

It means that invalidations during paint will show up /next/ frame, but that's
the behaviour we seem to want with a unit test guarding it.
The ui::Layer isn't the thing holding the cache, it would still need its
delegate around to give back DisplayItems. Without a delegate, the next
recording for the layer would be empty.

 }
 
 void Layer::PaintContentsToDisplayList(
     cc::DisplayItemList* display_list,
     const gfx::Rect& clip,
     ContentLayerClient::PaintingControlSetting painting_control) {
   TRACE_EVENT1("ui", "Layer::PaintContentsToDisplayList", "name", name_);
   if (delegate_) {
     // TODO(danakj): Save the invalidation on the layer and pass that down
     // instead of the |clip| here. That will break everything until View
     // early-outs emit cached display items instead of nothing.
     gfx::Rect invalidation = clip;
     DCHECK(clip.Contains(invalidation));
     delegate_->OnPaintLayer(
         PaintContext(display_list, device_scale_factor_, clip, invalidation));
   }
+  ClearDamagedRects();
 }
 
 bool Layer::FillsBoundsCompletely() const { return fills_bounds_completely_; }
 
 bool Layer::PrepareTextureMailbox(
     cc::TextureMailbox* mailbox,
     scoped_ptr<cc::SingleReleaseCallback>* release_callback,
     bool use_shared_memory) {
   if (!mailbox_release_callback_)
     return false;
@@ skipping 313 matching lines @@
       children_.end(),
       std::bind2nd(std::mem_fun(&Layer::RemoveAnimatorsInTreeFromCollection),
                    collection));
 }
 
 bool Layer::IsAnimating() const {
   return animator_.get() && animator_->is_animating();
 }
 
 }  // namespace ui