cc: Add support for partial swaps when using impl-side painting.

cc/layers/layer_impl.h

 // 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.
 
 #ifndef CC_LAYERS_LAYER_IMPL_H_
 #define CC_LAYERS_LAYER_IMPL_H_
 
 #include <set>
 #include <string>
 
@@ skipping 436 matching lines @@
   void SetTransform(const gfx::Transform& transform);
   const gfx::Transform& transform() const { return transform_; }
   bool TransformIsAnimating() const;
   bool TransformIsAnimatingOnImplOnly() const;
 
   // Note this rect is in layer space (not content space).
   void SetUpdateRect(const gfx::RectF& update_rect);
 
   const gfx::RectF& update_rect() const { return update_rect_; }
 
+  void UnionDamageContentRect(gfx::RectF damage_content_rect);

[reveman, 2014/04/15 16:25:59]

nit: pass by const reference instead

[reveman, 2014/04/15 16:25:59]

I would prefer SetContentDamageRect() and have the caller responsible for union
of rects. The code in NotifyTileInitialized would look something like this:

layer_impl->SetContentDamageRect(
    gfx::UnionRects(layer_impl->content_damage_rect(),
                    tile_content_rect_in_layer_space))

[enne (OOO), 2014/04/15 17:27:27]

(Personally I think what you suggest is a violation of demeter, since it makes
TileManager responsible for the representation of damage on layers.  It exposes
that damage is kept as a RectF internally, rather than as a region or something.
 Not that we want to, but it's just API smell, in my opinion.  I preferred the
original version.)

[reveman, 2014/04/15 17:50:48]

Makes sense. I prefer AddContentDamageRect() in that case.

[enne (OOO), 2014/04/15 17:55:42]

How about AddLayerDamageRect?

Sorry to keep quibble, but it's awkward to keep content rects on
PictureLayerImpl because it modifies its own content scale during pinch zoom. 
So, whenever you changed it, you'd have to rescale the content damage rect. 
It's better to keep damage in layer space to avoid potentially forgetting to do
this.

+
+  const gfx::RectF& damage_content_rect() const { return damage_content_rect_; }

[reveman, 2014/04/15 16:25:59]

content_damage_rect()? makes it sound more like a getter.

+
   virtual base::DictionaryValue* LayerTreeAsJson() const;
 
   void SetStackingOrderChanged(bool stacking_order_changed);
 
   bool LayerPropertyChanged() const { return layer_property_changed_; }
 
   void ResetAllChangeTrackingForSubtree();
 
   LayerAnimationController* layer_animation_controller() {
     return layer_animation_controller_.get();
@@ skipping 178 matching lines @@
   int num_dependents_need_push_properties_;
 
   DrawMode current_draw_mode_;
 
  private:
   // Rect indicating what was repainted/updated during update.
   // Note that plugin layers bypass this and leave it empty.
   // Uses layer (not content) space.
   gfx::RectF update_rect_;
 
+  gfx::RectF damage_content_rect_;
+
   // Manages animations for this layer.
   scoped_refptr<LayerAnimationController> layer_animation_controller_;
 
   // Manages scrollbars for this layer
   scoped_ptr<ScrollbarAnimationController> scrollbar_animation_controller_;
 
   scoped_ptr<ScrollbarSet> scrollbars_;
 
   ScopedPtrVector<CopyOutputRequest> copy_requests_;
 
   // Group of properties that need to be computed based on the layer tree
   // hierarchy before layers can be drawn.
   DrawProperties<LayerImpl> draw_properties_;
 
   scoped_refptr<base::debug::ConvertableToTraceFormat> debug_info_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_IMPL_H_