cc : Stop pushing layers from hidden subtrees at commit

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 <stddef.h>
 #include <stdint.h>
 
 #include <set>
 #include <string>
 #include <unordered_map>
 #include <vector>
 
 #include "base/callback.h"
 #include "base/macros.h"
 #include "base/memory/ref_counted.h"
 #include "base/observer_list.h"
 #include "cc/base/filter_operations.h"
 #include "cc/base/region.h"
 #include "cc/benchmarks/micro_benchmark.h"
 #include "cc/cc_export.h"
 #include "cc/input/input_handler.h"
 #include "cc/layers/layer_collections.h"
 #include "cc/layers/layer_position_constraint.h"
 #include "cc/paint/paint_record.h"
+#include "cc/surfaces/surface_id.h"
 #include "cc/trees/element_id.h"
 #include "cc/trees/mutator_host_client.h"
 #include "cc/trees/property_tree.h"
 #include "cc/trees/target_property.h"
 #include "third_party/skia/include/core/SkColor.h"
 #include "ui/gfx/geometry/point3_f.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gfx/geometry/rect_f.h"
 #include "ui/gfx/geometry/scroll_offset.h"
 #include "ui/gfx/transform.h"
@@ skipping 268 matching lines @@
   virtual bool IsSuitableForGpuRasterization() const;
 
   virtual std::unique_ptr<base::trace_event::ConvertableToTraceFormat>
   TakeDebugInfo();
   virtual void didUpdateMainThreadScrollingReasons();
 
   void SetLayerClient(LayerClient* client) { inputs_.client = client; }
 
   virtual bool IsSnapped();
 
+  virtual bool IsSurfaceLayer() const;

[enne (OOO), 2017/05/19 22:27:05]

I'm not really that keen on virtuals that say what kind of layer a layer is,
because then other code starts depending on it.  I think I'd prefer a pattern
that was either:

(1) Have each surface layer register itself with LTH (like picture layers
register with LayerTreeImpl) and then just iterate through all surface layers on
commit to append surface ids.  Don't worry about hidden vs not and just put all
surface ids in the referenced list.

(2) Have each surface layer register its surface id with LTH whenever it changes
/ gets a new LTH.  Similarly don't worry about hidden vs not.

[jaydasika, 2017/05/23 00:25:14]

(2) done

+
+  virtual const SurfaceId* GetSurfaceId() const;
+
   virtual void PushPropertiesTo(LayerImpl* layer);
 
   LayerTreeHost* GetLayerTreeHostForTesting() const { return layer_tree_host_; }
 
   virtual ScrollbarLayerInterface* ToScrollbarLayer();
 
   virtual sk_sp<SkPicture> GetPicture() const;
 
   // Constructs a LayerImpl of the correct runtime type for this Layer type.
   virtual std::unique_ptr<LayerImpl> CreateLayerImpl(LayerTreeImpl* tree_impl);
@@ skipping 44 matching lines @@
   void set_should_flatten_transform_from_property_tree(bool should_flatten) {
     if (should_flatten_transform_from_property_tree_ == should_flatten)
       return;
     should_flatten_transform_from_property_tree_ = should_flatten;
     SetNeedsPushProperties();
   }
   bool should_flatten_transform_from_property_tree() const {
     return should_flatten_transform_from_property_tree_;
   }
 
+  void SetIsHidden(bool is_hidden);
+
+  bool is_hidden() const { return is_hidden_; }
+
   const gfx::Rect& visible_layer_rect_for_testing() const {
     return visible_layer_rect_;
   }
   void set_visible_layer_rect(const gfx::Rect& rect) {
     visible_layer_rect_ = rect;
   }
 
   // This is for tracking damage.
   void SetSubtreePropertyChanged();
   bool subtree_property_changed() const { return subtree_property_changed_; }
@@ skipping 216 matching lines @@
 
   int num_descendants_that_draw_content_;
   int transform_tree_index_;
   int effect_tree_index_;
   int clip_tree_index_;
   int scroll_tree_index_;
   int property_tree_sequence_number_;
   gfx::Vector2dF offset_to_transform_parent_;
   bool should_flatten_transform_from_property_tree_ : 1;
   bool draws_content_ : 1;
+  bool is_hidden_ : 1;
   bool use_local_transform_for_backface_visibility_ : 1;
   bool should_check_backface_visibility_ : 1;
   bool force_render_surface_for_testing_ : 1;
   bool subtree_property_changed_ : 1;
   bool may_contain_video_ : 1;
   bool is_scroll_clip_layer_ : 1;
   bool needs_show_scrollbars_ : 1;
   // This value is valid only when LayerTreeHost::has_copy_request() is true
   bool subtree_has_copy_request_ : 1;
   SkColor safe_opaque_background_color_;
   std::unique_ptr<std::set<Layer*>> scroll_children_;
 
   std::unique_ptr<std::set<Layer*>> clip_children_;
 
   // These all act like draw properties, so don't need push properties.
   gfx::Rect visible_layer_rect_;
   size_t num_unclipped_descendants_;
 
   DISALLOW_COPY_AND_ASSIGN(Layer);
 };
 
 }  // namespace cc
 
 #endif  // CC_LAYERS_LAYER_H_