cc: Remove internal Inputs struct from LayerTree

cc/trees/layer_tree.h

 // Copyright 2016 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_TREES_LAYER_TREE_H_
 #define CC_TREES_LAYER_TREE_H_
 
 #include <memory>
 #include <unordered_map>
 #include <unordered_set>
@@ skipping 26 matching lines @@
 
 class CC_EXPORT LayerTree : public MutatorHostClient {
  public:
   using LayerSet = std::unordered_set<Layer*>;
   using LayerIdMap = std::unordered_map<int, Layer*>;
 
   LayerTree(MutatorHost* mutator_host, LayerTreeHost* layer_tree_host);
   virtual ~LayerTree();
 
   void SetRootLayer(scoped_refptr<Layer> root_layer);
-  Layer* root_layer() { return inputs_.root_layer.get(); }
-  const Layer* root_layer() const { return inputs_.root_layer.get(); }
+  Layer* root_layer() { return root_layer_.get(); }
+  const Layer* root_layer() const { return root_layer_.get(); }
 
   void RegisterViewportLayers(scoped_refptr<Layer> overscroll_elasticity_layer,
                               scoped_refptr<Layer> page_scale_layer,
                               scoped_refptr<Layer> inner_viewport_scroll_layer,
                               scoped_refptr<Layer> outer_viewport_scroll_layer);
 
   Layer* overscroll_elasticity_layer() const {
-    return inputs_.overscroll_elasticity_layer.get();
+    return overscroll_elasticity_layer_.get();
   }
-  Layer* page_scale_layer() const { return inputs_.page_scale_layer.get(); }
+  Layer* page_scale_layer() const { return page_scale_layer_.get(); }
   Layer* inner_viewport_scroll_layer() const {
-    return inputs_.inner_viewport_scroll_layer.get();
+    return inner_viewport_scroll_layer_.get();
   }
   Layer* outer_viewport_scroll_layer() const {
-    return inputs_.outer_viewport_scroll_layer.get();
+    return outer_viewport_scroll_layer_.get();
   }
 
   void RegisterSelection(const LayerSelection& selection);
-  const LayerSelection& selection() const { return inputs_.selection; }
+  const LayerSelection& selection() const { return selection_; }
 
   void SetHaveScrollEventHandlers(bool have_event_handlers);
   bool have_scroll_event_handlers() const {
-    return inputs_.have_scroll_event_handlers;
+    return have_scroll_event_handlers_;
   }
 
   void SetEventListenerProperties(EventListenerClass event_class,
                                   EventListenerProperties event_properties);
   EventListenerProperties event_listener_properties(
       EventListenerClass event_class) const {
-    return inputs_.event_listener_properties[static_cast<size_t>(event_class)];
+    return event_listener_properties_[static_cast<size_t>(event_class)];
   }
 
   void SetViewportSize(const gfx::Size& device_viewport_size);
-  gfx::Size device_viewport_size() const {
-    return inputs_.device_viewport_size;
-  }
+  gfx::Size device_viewport_size() const { return device_viewport_size_; }
 
   void SetBrowserControlsHeight(float height, bool shrink);
   void SetBrowserControlsShownRatio(float ratio);
   void SetBottomControlsHeight(float height);
 
   void SetPageScaleFactorAndLimits(float page_scale_factor,
                                    float min_page_scale_factor,
                                    float max_page_scale_factor);
-  float page_scale_factor() const { return inputs_.page_scale_factor; }
-  float min_page_scale_factor() const { return inputs_.min_page_scale_factor; }
-  float max_page_scale_factor() const { return inputs_.max_page_scale_factor; }
+  float page_scale_factor() const { return page_scale_factor_; }
+  float min_page_scale_factor() const { return min_page_scale_factor_; }
+  float max_page_scale_factor() const { return max_page_scale_factor_; }
 
-  void set_background_color(SkColor color) { inputs_.background_color = color; }
-  SkColor background_color() const { return inputs_.background_color; }
+  void set_background_color(SkColor color) { background_color_ = color; }
+  SkColor background_color() const { return background_color_; }
 
   void set_has_transparent_background(bool transparent) {
-    inputs_.has_transparent_background = transparent;
+    has_transparent_background_ = transparent;
   }
   bool has_transparent_background() const {
-    return inputs_.has_transparent_background;
+    return has_transparent_background_;
   }
 
   void StartPageScaleAnimation(const gfx::Vector2d& target_offset,
                                bool use_anchor,
                                float scale,
                                base::TimeDelta duration);
   bool HasPendingPageScaleAnimation() const;
 
   void SetDeviceScaleFactor(float device_scale_factor);
-  float device_scale_factor() const { return inputs_.device_scale_factor; }
+  float device_scale_factor() const { return device_scale_factor_; }
 
   void SetPaintedDeviceScaleFactor(float painted_device_scale_factor);
   float painted_device_scale_factor() const {
-    return inputs_.painted_device_scale_factor;
+    return painted_device_scale_factor_;
   }
 
   void SetDeviceColorSpace(const gfx::ColorSpace& device_color_space);
   const gfx::ColorSpace& device_color_space() const {
-    return inputs_.device_color_space;
+    return device_color_space_;
   }
 
   // Used externally by blink for setting the PropertyTrees when
   // |settings_.use_layer_lists| is true. This is a SPV2 setting.
   PropertyTrees* property_trees() { return &property_trees_; }
 
   void SetNeedsDisplayOnAllLayers();
 
   void SetNeedsCommit();
 
@@ skipping 77 matching lines @@
 
   void ElementIsAnimatingChanged(ElementId element_id,
                                  ElementListType list_type,
                                  const PropertyAnimationState& mask,
                                  const PropertyAnimationState& state) override;
 
   void ScrollOffsetAnimationFinished() override {}
   gfx::ScrollOffset GetScrollOffsetForAnimation(
       ElementId element_id) const override;
 
-  // Encapsulates the data, callbacks, interfaces received from the embedder.
-  struct Inputs {
-    Inputs();
-    ~Inputs();
+  scoped_refptr<Layer> root_layer_;
 
-    scoped_refptr<Layer> root_layer;
+  scoped_refptr<Layer> overscroll_elasticity_layer_;
+  scoped_refptr<Layer> page_scale_layer_;
+  scoped_refptr<Layer> inner_viewport_scroll_layer_;
+  scoped_refptr<Layer> outer_viewport_scroll_layer_;
 
-    scoped_refptr<Layer> overscroll_elasticity_layer;
-    scoped_refptr<Layer> page_scale_layer;
-    scoped_refptr<Layer> inner_viewport_scroll_layer;
-    scoped_refptr<Layer> outer_viewport_scroll_layer;
+  float top_controls_height_ = 0.f;
+  float top_controls_shown_ratio_ = 0.f;
+  bool browser_controls_shrink_blink_size_ = false;
 
-    float top_controls_height;
-    float top_controls_shown_ratio;
-    bool browser_controls_shrink_blink_size;
+  float bottom_controls_height_ = 0.f;
 
-    float bottom_controls_height;
+  float device_scale_factor_ = 1.f;
+  float painted_device_scale_factor_ = 1.f;
+  float page_scale_factor_ = 1.f;
+  float min_page_scale_factor_ = 1.f;
+  float max_page_scale_factor_ = 1.f;
+  gfx::ColorSpace device_color_space_;
 
-    float device_scale_factor;
-    float painted_device_scale_factor;
-    float page_scale_factor;
-    float min_page_scale_factor;
-    float max_page_scale_factor;
-    gfx::ColorSpace device_color_space;
+  SkColor background_color_ = SK_ColorWHITE;
+  bool has_transparent_background_ = false;
 
-    SkColor background_color;
-    bool has_transparent_background;
+  LayerSelection selection_;
 
-    LayerSelection selection;
+  gfx::Size device_viewport_size_;
 
-    gfx::Size device_viewport_size;
+  bool have_scroll_event_handlers_ = false;
+  EventListenerProperties event_listener_properties_[static_cast<size_t>(
+      EventListenerClass::kNumClasses)];
 
-    bool have_scroll_event_handlers;
-    EventListenerProperties event_listener_properties[static_cast<size_t>(
-        EventListenerClass::kNumClasses)];
-
-    std::unique_ptr<PendingPageScaleAnimation> pending_page_scale_animation;
-  };
-
-  Inputs inputs_;
+  std::unique_ptr<PendingPageScaleAnimation> pending_page_scale_animation_;
 
   PropertyTrees property_trees_;
 
-  bool needs_full_tree_sync_;
-  bool needs_meta_info_recomputation_;
+  bool needs_full_tree_sync_ = true;
+  bool needs_meta_info_recomputation_ = true;
 
   gfx::Vector2dF elastic_overscroll_;
 
   scoped_refptr<HeadsUpDisplayLayer> hud_layer_;
 
   // Set of layers that need to push properties.
   LayerSet layers_that_should_push_properties_;
 
   // Layer id to Layer map.
   LayerIdMap layer_id_map_;
 
   using ElementLayersMap = std::unordered_map<ElementId, Layer*, ElementIdHash>;
   ElementLayersMap element_layers_map_;
 
-  bool in_paint_layer_contents_;
+  bool in_paint_layer_contents_ = false;
 
   MutatorHost* mutator_host_;
   LayerTreeHost* layer_tree_host_;
 
   DISALLOW_COPY_AND_ASSIGN(LayerTree);
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_H_