Browser side changes for software compositing

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/command_line.h"
 #include "base/debug/trace_event.h"
@@ skipping 528 matching lines @@
     cc::TransferableResourceArray* list) {
   if (delegated_renderer_layer_)
     delegated_renderer_layer_->TakeUnusedResourcesForChildCompositor(list);
 }
 
 void Layer::SetColor(SkColor color) {
   GetAnimator()->SetColor(color);
 }
 
 bool Layer::SchedulePaint(const gfx::Rect& invalid_rect) {
-  if (type_ == LAYER_SOLID_COLOR || (!delegate_ && !texture_))
+  if (type_ == LAYER_SOLID_COLOR)
     return false;
 
   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 ((delegate_ || texture_) && !damaged_region_.isEmpty()) {

[piman, 2013/04/05 21:07:29]

The whole point of this logic is that we don't want to send damage rects if we
don't have a delegate any more. This is needed to avoid black-outs when we close
the window and it fades away (delegate is gone but layer is still there).

How does it affect software?

-    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());
+  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());
 
-      gfx::Rect damaged_in_pixel = ConvertRectToPixel(this, damaged);
-      cc_layer_->SetNeedsDisplayRect(damaged_in_pixel);
-    }
-    damaged_region_.setEmpty();
+    gfx::Rect damaged_in_pixel = ConvertRectToPixel(this, damaged);
+    cc_layer_->SetNeedsDisplayRect(damaged_in_pixel);
   }
+  damaged_region_.setEmpty();
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SendDamagedRects();
 }
 
 void Layer::SuppressPaint() {
   if (!delegate_)
     return;
   delegate_ = NULL;
   for (size_t i = 0; i < children_.size(); ++i)
     children_[i]->SuppressPaint();
@@ skipping 333 matching lines @@
     texture_layer_->SetUV(uv_top_left, uv_bottom_right);
   } else if (delegated_renderer_layer_.get()) {
     delegated_renderer_layer_->SetDisplaySize(
         ConvertSizeToPixel(this, delegated_frame_size_in_dip_));
     size.ClampToMax(delegated_frame_size_in_dip_);
   }
   cc_layer_->SetBounds(ConvertSizeToPixel(this, size));
 }
 
 }  // namespace ui