Moving RenderSurface creation outside of CalcDrawProps

cc/layers/layer.h

 // Copyright 2010 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_H_
 #define CC_LAYERS_LAYER_H_
 
 #include <set>
 #include <string>
 
@@ skipping 38 matching lines @@
 
 class Animation;
 class AnimationDelegate;
 struct AnimationEvent;
 class CopyOutputRequest;
 class LayerAnimationDelegate;
 class LayerAnimationEventObserver;
 class LayerClient;
 class LayerImpl;
 class LayerTreeHost;
+class LayerTreeHostCommon;
 class LayerTreeImpl;
 class PriorityCalculator;
 class RenderingStatsInstrumentation;
 class ResourceUpdateQueue;
 class ScrollbarLayerInterface;
 class SimpleEnclosedRegion;
 struct AnimationEvent;
 template <typename LayerType>
 class OcclusionTracker;
 
@@ skipping 101 matching lines @@
   bool IsContainerForFixedPositionLayers() const;
 
   void SetPositionConstraint(const LayerPositionConstraint& constraint);
   const LayerPositionConstraint& position_constraint() const {
     return position_constraint_;
   }
 
   void SetTransform(const gfx::Transform& transform);
   const gfx::Transform& transform() const { return transform_; }
   bool TransformIsAnimating() const;
+  bool AnimationsPreserveAxisAlignment() const;
   bool transform_is_invertible() const { return transform_is_invertible_; }
 
   void SetTransformOrigin(const gfx::Point3F&);
   gfx::Point3F transform_origin() { return transform_origin_; }
 
   void SetScrollParent(Layer* parent);
 
   Layer* scroll_parent() { return scroll_parent_; }
   const Layer* scroll_parent() const { return scroll_parent_; }
 
@@ skipping 58 matching lines @@
   Layer* render_target() {
     DCHECK(!draw_properties_.render_target ||
            draw_properties_.render_target->render_surface());
     return draw_properties_.render_target;
   }
   const Layer* render_target() const {
     DCHECK(!draw_properties_.render_target ||
            draw_properties_.render_target->render_surface());
     return draw_properties_.render_target;
   }
-  RenderSurface* render_surface() const {
-    return draw_properties_.render_surface.get();
-  }
   int num_unclipped_descendants() const {
     return draw_properties_.num_unclipped_descendants;
   }
 
+  RenderSurface* render_surface() const { return render_surface_.get(); }
   void SetScrollOffset(const gfx::ScrollOffset& scroll_offset);
   gfx::ScrollOffset scroll_offset() const { return scroll_offset_; }
   void SetScrollOffsetFromImplSide(const gfx::ScrollOffset& scroll_offset);
 
   void SetScrollClipLayerId(int clip_layer_id);
   bool scrollable() const { return scroll_clip_layer_id_ != INVALID_ID; }
 
   void SetUserScrollable(bool horizontal, bool vertical);
   bool user_scrollable_horizontal() const {
     return user_scrollable_horizontal_;
@@ skipping 94 matching lines @@
   virtual bool IsSuitableForGpuRasterization() const;
 
   virtual scoped_refptr<base::debug::ConvertableToTraceFormat> TakeDebugInfo();
 
   void SetLayerClient(LayerClient* client) { client_ = client; }
 
   virtual void PushPropertiesTo(LayerImpl* layer);
 
   void CreateRenderSurface();
   void ClearRenderSurface();
+
   void ClearRenderSurfaceLayerList();
 
   // The contents scale converts from logical, non-page-scaled pixels to target
   // pixels. The contents scale is 1 for the root layer as it is already in
   // physical pixels. By default contents scale is forced to be 1 except for
   // subclasses of ContentsScalingLayer.
   float contents_scale_x() const { return draw_properties_.contents_scale_x; }
   float contents_scale_y() const { return draw_properties_.contents_scale_y; }
   gfx::Size content_bounds() const { return draw_properties_.content_bounds; }
 
@@ skipping 145 matching lines @@
   // will be handled implicitly after the update completes.
   bool ignore_set_needs_commit_;
 
   // Layers that share a sorting context id will be sorted together in 3d
   // space.  0 is a special value that means this layer will not be sorted and
   // will be drawn in paint order.
   int sorting_context_id_;
 
  private:
   friend class base::RefCounted<Layer>;
-
+  friend class LayerTreeHostCommon;
   void SetParent(Layer* layer);
   bool DescendantIsFixedToContainerLayer() const;
 
+  // This should only be called during BeginMainFrame since it does not
+  // trigger a Commit.
+  void SetHasRenderSurface(bool has_render_surface);
+
   // Returns the index of the child or -1 if not found.
   int IndexOfChild(const Layer* reference);
 
   // This should only be called from RemoveFromParent().
   void RemoveChildOrDependent(Layer* child);
 
   // LayerAnimationValueProvider implementation.
   gfx::ScrollOffset ScrollOffsetForAnimation() const override;
 
   // LayerAnimationValueObserver implementation.
@@ skipping 42 matching lines @@
   bool draws_content_ : 1;
   bool hide_layer_and_subtree_ : 1;
   bool masks_to_bounds_ : 1;
   bool contents_opaque_ : 1;
   bool double_sided_ : 1;
   bool should_flatten_transform_ : 1;
   bool use_parent_backface_visibility_ : 1;
   bool draw_checkerboard_for_missing_tiles_ : 1;
   bool force_render_surface_ : 1;
   bool transform_is_invertible_ : 1;
+  bool has_render_surface_ : 1;
   Region non_fast_scrollable_region_;
   Region touch_event_handler_region_;
   gfx::PointF position_;
   SkColor background_color_;
   float opacity_;
   SkXfermode::Mode blend_mode_;
   FilterOperations filters_;
   FilterOperations background_filters_;
   LayerPositionConstraint position_constraint_;
   Layer* scroll_parent_;
@@ skipping 13 matching lines @@
 
   LayerClient* client_;
 
   ScopedPtrVector<CopyOutputRequest> copy_requests_;
 
   base::Closure did_scroll_callback_;
 
   DrawProperties<Layer> draw_properties_;
 
   PaintProperties paint_properties_;
+  // TODO(awoloszyn): This is redundant with has_render_surface_,
+  // and should get removed once it is no longer needed on main thread.
+  scoped_ptr<RenderSurface> render_surface_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_H_