Stop painting when receiving delegated frame

ui/compositor/layer_unittest.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 "base/basictypes.h"
 #include "base/bind.h"
 #include "base/compiler_specific.h"
 #include "base/debug/trace_event.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
@@ skipping 48 matching lines @@
     set_delegate(this);
   }
 
   virtual ~ColoredLayer() { }
 
   // Overridden from LayerDelegate:
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
     canvas->DrawColor(color_);
   }
 
+  virtual void OnDelegatedFrameDamage(
+      const gfx::Rect& damage_rect_in_dip) OVERRIDE {}
+
   virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
   }
 
   virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE {
     return base::Closure();
   }
 
  private:
   SkColor color_;
 };
@@ skipping 154 matching lines @@
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
     SkISize size = canvas->sk_canvas()->getBaseLayerSize();
     paint_size_ = gfx::Size(size.width(), size.height());
     canvas->FillRect(gfx::Rect(paint_size_), colors_[color_index_]);
     color_index_ = (color_index_ + 1) % static_cast<int>(colors_.size());
     const SkMatrix& matrix = canvas->sk_canvas()->getTotalMatrix();
     scale_x_ = matrix.getScaleX();
     scale_y_ = matrix.getScaleY();
   }
 
+  virtual void OnDelegatedFrameDamage(
+      const gfx::Rect& damage_rect_in_dip) OVERRIDE {}
+
   virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
     device_scale_factor_ = device_scale_factor;
   }
 
   virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE {
     return base::Closure();
   }
 
   void reset() {
     color_index_ = 0;
@@ skipping 23 matching lines @@
     painted_ = false;
   }
 
   bool painted() const { return painted_; }
 
  private:
   // Overridden from LayerDelegate:
   virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
     painted_ = true;
   }
+  virtual void OnDelegatedFrameDamage(
+      const gfx::Rect& damage_rect_in_dip) OVERRIDE {}
   virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
   }
   virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE {
     return base::Closure();
   }
 
   bool painted_;
 
   DISALLOW_COPY_AND_ASSIGN(DrawTreeLayerDelegate);
 };
 
 // The simplest possible layer delegate. Does nothing.
 class NullLayerDelegate : public LayerDelegate {
  public:
   NullLayerDelegate() {}
   virtual ~NullLayerDelegate() {}
 
  private:
   // Overridden from LayerDelegate:
-  virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {
-  }
-  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
-  }
+  virtual void OnPaintLayer(gfx::Canvas* canvas) OVERRIDE {}
+  virtual void OnDelegatedFrameDamage(
+      const gfx::Rect& damage_rect_in_dip) OVERRIDE {}
+  virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {}
   virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE {
     return base::Closure();
   }
 
   DISALLOW_COPY_AND_ASSIGN(NullLayerDelegate);
 };
 
 // Remembers if it has been notified.
 class TestCompositorObserver : public CompositorObserver {
  public:
@@ skipping 795 matching lines @@
     paint_count_++;
     if (!schedule_paint_rect_.IsEmpty()) {
       layer_->SchedulePaint(schedule_paint_rect_);
       schedule_paint_rect_ = gfx::Rect();
     }
     SkRect sk_clip_rect;
     if (canvas->sk_canvas()->getClipBounds(&sk_clip_rect))
       last_clip_rect_ = gfx::SkRectToRectF(sk_clip_rect);
   }
 
+  virtual void OnDelegatedFrameDamage(
+      const gfx::Rect& damage_rect_in_dip) OVERRIDE {}
+
   virtual void OnDeviceScaleFactorChanged(float device_scale_factor) OVERRIDE {
   }
 
   virtual base::Closure PrepareForLayerBoundsChange() OVERRIDE {
     return base::Closure();
   }
 
   int paint_count_;
   Layer* layer_;
   gfx::Rect schedule_paint_rect_;
@@ skipping 450 matching lines @@
             Vector2dFTo100thPercisionString(c11->subpixel_position_offset()));
 
   c11->SetBounds(gfx::Rect(2, 2, 10, 10));
   SnapLayerToPhysicalPixelBoundary(root.get(), c11.get());
   // c11 is now off the pixel.
   // 0.5 / 1.5 = 0.333...
   EXPECT_EQ("0.33 0.33",
             Vector2dFTo100thPercisionString(c11->subpixel_position_offset()));
 }
 
+class FrameDamageCheckingDelegate : public TestLayerDelegate {
+ public:
+  FrameDamageCheckingDelegate() : delegated_frame_damage_called_(false) {}
+
+  virtual void OnDelegatedFrameDamage(
+      const gfx::Rect& damage_rect_in_dip) OVERRIDE {
+    delegated_frame_damage_called_ = true;
+    delegated_frame_damage_rect_ = damage_rect_in_dip;
+  }
+
+  const gfx::Rect& delegated_frame_damage_rect() const {
+    return delegated_frame_damage_rect_;
+  }
+  bool delegated_frame_damage_called() const {
+    return delegated_frame_damage_called_;
+  }
+
+ private:
+  gfx::Rect delegated_frame_damage_rect_;
+  bool delegated_frame_damage_called_;
+};
+
+TEST(LayerDelegateTest, DelegatedFrameDamage) {
+  scoped_ptr<Layer> layer(new Layer(LAYER_TEXTURED));
+  gfx::Rect damage_rect(2, 1, 5, 3);
+
+  FrameDamageCheckingDelegate delegate;
+  layer->set_delegate(&delegate);
+  scoped_refptr<cc::DelegatedFrameResourceCollection> resource_collection =
+      new cc::DelegatedFrameResourceCollection;
+  scoped_refptr<cc::DelegatedFrameProvider> frame_provider(
+      new cc::DelegatedFrameProvider(resource_collection.get(),
+                                     MakeFrameData(gfx::Size(10, 10))));
+  layer->SetShowDelegatedContent(frame_provider, gfx::Size(10, 10));
+
+  EXPECT_FALSE(delegate.delegated_frame_damage_called());
+  layer->OnDelegatedFrameDamage(damage_rect);
+  EXPECT_TRUE(delegate.delegated_frame_damage_called());
+  EXPECT_EQ(damage_rect, delegate.delegated_frame_damage_rect());
+}
+
 }  // namespace ui