Revert of 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_.Union(invalid_rect);
+  damaged_region_.op(invalid_rect.x(),
+                     invalid_rect.y(),
+                     invalid_rect.right(),
+                     invalid_rect.bottom(),
+                     SkRegion::kUnion_Op);
   ScheduleDraw();
   return true;
 }
 
 void Layer::ScheduleDraw() {
   Compositor* compositor = GetCompositor();
   if (compositor)
     compositor->ScheduleDraw();
 }
 
 void Layer::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();
+  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();
 }
 
 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 38 matching lines @@
 
 void Layer::RequestCopyOfOutput(scoped_ptr<cc::CopyOutputRequest> request) {
   cc_layer_->RequestCopyOfOutput(request.Pass());
 }
 
 void Layer::PaintContents(
     SkCanvas* sk_canvas,
     const gfx::Rect& clip,
     ContentLayerClient::PaintingControlSetting painting_control) {
   TRACE_EVENT1("ui", "Layer::PaintContents", "name", name_);
-  ClearDamagedRects();
   scoped_ptr<gfx::Canvas> canvas(gfx::Canvas::CreateCanvasWithoutScaling(
       sk_canvas, device_scale_factor_));
   if (delegate_)
     delegate_->OnPaintLayer(PaintContext(canvas.get(), clip));
 }
 
 void Layer::PaintContentsToDisplayList(
     cc::DisplayItemList* display_list,
     const gfx::Rect& clip,
     ContentLayerClient::PaintingControlSetting painting_control) {
   TRACE_EVENT1("ui", "Layer::PaintContentsToDisplayList", "name", name_);
-  ClearDamagedRects();
-  if (!delegate_)
-    return;
-  // 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));
+  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));
+  }
 }
 
 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