cc: Commit property trees to the compositor thread

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 <map>
 #include <set>
 #include <string>
@@ skipping 41 matching lines @@
 }
 
 namespace cc {
 
 class LayerTreeHostImpl;
 class LayerTreeImpl;
 class MicroBenchmarkImpl;
 class Occlusion;
 template <typename LayerType>
 class OcclusionTracker;
+class OpacityTree;
 class RenderPass;
 class RenderPassId;
 class Renderer;
 class ScrollbarAnimationController;
 class ScrollbarLayerImplBase;
 class SimpleEnclosedRegion;
 class Tile;
+class TransformTree;
 
 struct AppendQuadsData;
 
 enum DrawMode {
   DRAW_MODE_NONE,
   DRAW_MODE_HARDWARE,
   DRAW_MODE_SOFTWARE,
   DRAW_MODE_RESOURCELESS_SOFTWARE
 };
 
@@ skipping 62 matching lines @@
   LayerImpl* scroll_parent() { return scroll_parent_; }
   const LayerImpl* scroll_parent() const { return scroll_parent_; }
 
   void SetScrollChildren(std::set<LayerImpl*>* children);
 
   std::set<LayerImpl*>* scroll_children() { return scroll_children_.get(); }
   const std::set<LayerImpl*>* scroll_children() const {
     return scroll_children_.get();
   }
 
+  void set_transform_tree_index(int index) {
+    transform_tree_index_ = index;
+    SetNeedsPushProperties();
+  }
+  void set_clip_tree_index(int index) {
+    clip_tree_index_ = index;
+    SetNeedsPushProperties();
+  }
+  void set_opacity_tree_index(int index) {
+    opacity_tree_index_ = index;
+    SetNeedsPushProperties();
+  }
+  int clip_tree_index() const { return clip_tree_index_; }
+  int transform_tree_index() const { return transform_tree_index_; }
+  int opacity_tree_index() const { return opacity_tree_index_; }
+
+  void set_offset_to_transform_parent(gfx::Vector2dF offset) {
+    offset_to_transform_parent_ = offset;
+    SetNeedsPushProperties();
+  }
+  gfx::Vector2dF offset_to_transform_parent() const {
+    return offset_to_transform_parent_;
+  }
+
+  const gfx::Rect& visible_rect_from_property_trees() const {
+    return visible_rect_from_property_trees_;
+  }
+  void set_visible_rect_from_property_trees(const gfx::Rect& rect) {
+    visible_rect_from_property_trees_ = rect;
+  }
+
+  void set_should_flatten_transform_from_property_tree(bool should_flatten) {
+    should_flatten_transform_from_property_tree_ = should_flatten;
+    SetNeedsPushProperties();
+  }
+  bool should_flatten_transform_from_property_tree() const {
+    return should_flatten_transform_from_property_tree_;
+  }
+
+  // For compatibility with Layer.
+  bool has_render_surface() const { return !!render_surface(); }
+
   void SetNumDescendantsThatDrawContent(int num_descendants);
   void SetClipParent(LayerImpl* ancestor);
 
   LayerImpl* clip_parent() {
     return clip_parent_;
   }
   const LayerImpl* clip_parent() const {
     return clip_parent_;
   }
 
@@ skipping 498 matching lines @@
   LayerTreeImpl* layer_tree_impl_;
 
   // Properties dynamically changeable on active tree.
   scoped_refptr<SyncedScrollOffset> scroll_offset_;
   gfx::Vector2dF bounds_delta_;
 
   // Properties synchronized from the associated Layer.
   gfx::Point3F transform_origin_;
   gfx::Size bounds_;
   LayerImpl* scroll_clip_layer_;
+
+  gfx::Vector2dF offset_to_transform_parent_;
+
   bool scrollable_ : 1;
   bool should_scroll_on_main_thread_ : 1;
   bool have_wheel_event_handlers_ : 1;
   bool have_scroll_event_handlers_ : 1;
 
   static_assert(SCROLL_BLOCKS_ON_MAX < (1 << 3), "ScrollBlocksOn too big");
   ScrollBlocksOn scroll_blocks_on_ : 3;
 
   bool user_scrollable_horizontal_ : 1;
   bool user_scrollable_vertical_ : 1;
   bool stacking_order_changed_ : 1;
   // Whether the "back" of this layer should draw.
   bool double_sided_ : 1;
   bool should_flatten_transform_ : 1;
+  bool should_flatten_transform_from_property_tree_ : 1;
 
   // Tracks if drawing-related properties have changed since last redraw.
   bool layer_property_changed_ : 1;
 
   bool masks_to_bounds_ : 1;
   bool contents_opaque_ : 1;
   bool is_root_for_isolated_group_ : 1;
   bool use_parent_backface_visibility_ : 1;
   bool draw_checkerboard_for_missing_tiles_ : 1;
   bool draws_content_ : 1;
   bool hide_layer_and_subtree_ : 1;
 
   // Cache transform_'s invertibility.
   bool transform_is_invertible_ : 1;
 
   // Set for the layer that other layers are fixed to.
   bool is_container_for_fixed_position_layers_ : 1;
+
   Region non_fast_scrollable_region_;
   Region touch_event_handler_region_;
   SkColor background_color_;
 
   float opacity_;
   SkXfermode::Mode blend_mode_;
   gfx::PointF position_;
   gfx::Transform transform_;
 
   LayerPositionConstraint position_constraint_;
 
   gfx::Vector2dF scroll_compensation_adjustment_;
 
   int num_descendants_that_draw_content_;
 
+  gfx::Rect visible_rect_from_property_trees_;
+  int transform_tree_index_;
+  int opacity_tree_index_;
+  int clip_tree_index_;
+
   // The global depth value of the center of the layer. This value is used
   // to sort layers from back to front.
   float draw_depth_;
 
   FilterOperations filters_;
   FilterOperations background_filters_;
 
  protected:
   friend class TreeSynchronizer;
 
@@ skipping 41 matching lines @@
 
   std::vector<FrameTimingRequest> frame_timing_requests_;
   bool frame_timing_requests_dirty_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerImpl);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_IMPL_H_