cc: Make LayerTreeSettings have in-member initialization.

cc/trees/layer_tree_settings.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_TREES_LAYER_TREE_SETTINGS_H_
 #define CC_TREES_LAYER_TREE_SETTINGS_H_
 
+#include <GLES2/gl2.h>

[danakj, 2016/05/31 20:28:58]

I think I prefer include "third_party/khronos/GLES2/gl2.h" so it is easier to
tell where the file is. We're a bit inconsistent in this.

[vmpstr, 2016/05/31 21:01:43]

Done.

 #include <stddef.h>
 
 #include <vector>
 
 #include "cc/base/cc_export.h"
 #include "cc/debug/layer_tree_debug_state.h"
 #include "cc/output/managed_memory_policy.h"
 #include "cc/output/renderer_settings.h"
 #include "cc/scheduler/scheduler_settings.h"
 #include "third_party/skia/include/core/SkColor.h"
@@ skipping 12 matching lines @@
   virtual ~LayerTreeSettings();
 
   bool operator==(const LayerTreeSettings& other) const;
 
   void ToProtobuf(proto::LayerTreeSettings* proto) const;
   void FromProtobuf(const proto::LayerTreeSettings& proto);
 
   SchedulerSettings ToSchedulerSettings() const;
 
   RendererSettings renderer_settings;
-  bool single_thread_proxy_scheduler;
+  bool single_thread_proxy_scheduler = true;
   // TODO(enne): Remove this after everything uses output surface begin frames.
-  bool use_external_begin_frame_source;
+  bool use_external_begin_frame_source = false;
   // TODO(enne): Temporary staging for unified begin frame source work.
-  bool use_output_surface_begin_frame_source;
-  bool main_frame_before_activation_enabled;
-  bool using_synchronous_renderer_compositor;
-  bool can_use_lcd_text;
-  bool use_distance_field_text;
-  bool gpu_rasterization_enabled;
-  bool gpu_rasterization_forced;
-  bool async_worker_context_enabled;
-  int gpu_rasterization_msaa_sample_count;
-  float gpu_rasterization_skewport_target_time_in_seconds;
-  bool create_low_res_tiling;
+  bool use_output_surface_begin_frame_source = false;
+  bool main_frame_before_activation_enabled = false;
+  bool using_synchronous_renderer_compositor = false;
+  bool can_use_lcd_text = true;
+  bool use_distance_field_text = false;
+  bool gpu_rasterization_enabled = false;
+  bool gpu_rasterization_forced = false;
+  bool async_worker_context_enabled = false;
+  int gpu_rasterization_msaa_sample_count = 0;
+  float gpu_rasterization_skewport_target_time_in_seconds = 0.2f;
+  bool create_low_res_tiling = false;
 
   enum ScrollbarAnimator {
     NO_ANIMATOR,
     LINEAR_FADE,
     THINNING,
   };
-  ScrollbarAnimator scrollbar_animator;
-  int scrollbar_fade_delay_ms;
-  int scrollbar_fade_resize_delay_ms;
-  int scrollbar_fade_duration_ms;
-  SkColor solid_color_scrollbar_color;
-  bool timeout_and_draw_when_animation_checkerboards;
-  bool layer_transforms_should_scale_layer_contents;
-  bool layers_always_allowed_lcd_text;
-  float minimum_contents_scale;
-  float low_res_contents_scale_factor;
-  float top_controls_show_threshold;
-  float top_controls_hide_threshold;
-  double background_animation_rate;
-  gfx::Size default_tile_size;
-  gfx::Size max_untiled_layer_size;
-  gfx::Size minimum_occlusion_tracking_size;
-  int tiling_interest_area_padding;
-  float skewport_target_time_in_seconds;
-  int skewport_extrapolation_limit_in_screen_pixels;
-  size_t max_memory_for_prepaint_percentage;
-  bool use_zero_copy;
-  bool use_partial_raster;
-  bool enable_elastic_overscroll;
+  ScrollbarAnimator scrollbar_animator = NO_ANIMATOR;
+  int scrollbar_fade_delay_ms = 0;
+  int scrollbar_fade_resize_delay_ms = 0;
+  int scrollbar_fade_duration_ms = 0;
+  SkColor solid_color_scrollbar_color = SK_ColorWHITE;
+  bool timeout_and_draw_when_animation_checkerboards = true;
+  bool layer_transforms_should_scale_layer_contents = false;
+  bool layers_always_allowed_lcd_text = false;
+  float minimum_contents_scale = 0.0625f;
+  float low_res_contents_scale_factor = 0.25f;
+  float top_controls_show_threshold = 0.5f;
+  float top_controls_hide_threshold = 0.5f;
+  double background_animation_rate = 1.0;
+  gfx::Size default_tile_size = gfx::Size(256, 256);

[danakj, 2016/05/31 20:28:58]

This does compile as a copy. But we make these LayerTreeSettings rarely, and
none of these are move-only.. (I know cuz I tried to do this with a moveonly
thing once). Maybe if the constructor was a constexpr it would not copy. So I'm
a bit ambivalent about putting Size in the header, I wouldn't say it's good in
general but probly fine here.

[vmpstr, 2016/05/31 21:01:43]

It does?

+  gfx::Size max_untiled_layer_size = gfx::Size(512, 512);
+  gfx::Size minimum_occlusion_tracking_size = gfx::Size(160, 160);
+  // 3000 pixels should give sufficient area for prepainting.
+  int tiling_interest_area_padding = 3000;
+  float skewport_target_time_in_seconds = 1.0f;
+  int skewport_extrapolation_limit_in_screen_pixels = 2000;
+  size_t max_memory_for_prepaint_percentage = 100;
+  bool use_zero_copy = false;
+  bool use_partial_raster = false;
+  bool enable_elastic_overscroll = false;
   // An array of image texture targets for each GpuMemoryBuffer format.
-  std::vector<unsigned> use_image_texture_targets;
-  bool ignore_root_layer_flings;
-  size_t scheduled_raster_task_limit;
-  bool use_occlusion_for_tile_prioritization;
-  bool verify_clip_tree_calculations;
-  bool image_decode_tasks_enabled;
-  bool wait_for_beginframe_interval;
-  bool abort_commit_before_output_surface_creation;
-  bool use_mouse_wheel_gestures;
-  bool use_layer_lists;
-  int max_staging_buffer_usage_in_bytes;
-  ManagedMemoryPolicy memory_policy_;
-  size_t gpu_decoded_image_budget_bytes;
-  size_t software_decoded_image_budget_bytes;
+  std::vector<unsigned> use_image_texture_targets =
+      std::vector<unsigned>(static_cast<size_t>(gfx::BufferFormat::LAST) + 1,

[danakj, 2016/05/31 20:28:58]

copying vectors tho seems like bad practice. I think this should stay in the .cc
file.

[vmpstr, 2016/05/31 21:01:43]

I think this would be elided or at the very least moved. 

+                            GL_TEXTURE_2D);
+  bool ignore_root_layer_flings = false;
+  size_t scheduled_raster_task_limit = 32;
+  bool use_occlusion_for_tile_prioritization = false;
+  bool verify_clip_tree_calculations = false;
+  bool image_decode_tasks_enabled = false;
+  bool wait_for_beginframe_interval = true;
+  bool abort_commit_before_output_surface_creation = true;
+  bool use_mouse_wheel_gestures = false;
+  bool use_layer_lists = false;
+  int max_staging_buffer_usage_in_bytes = 32 * 1024 * 1024;
+  ManagedMemoryPolicy memory_policy_ =
+      ManagedMemoryPolicy(64 * 1024 * 1024,
+                          gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
+                          ManagedMemoryPolicy::kDefaultNumResourcesLimit);
+  size_t gpu_decoded_image_budget_bytes = 96 * 1024 * 1024;
+  size_t software_decoded_image_budget_bytes = 128 * 1024 * 1024;
 
   // If set to true, the display item list will internally cache a SkPicture for
   // raster rather than directly using the display items.
-  bool use_cached_picture_raster;
+  bool use_cached_picture_raster = true;
 
   LayerTreeDebugState initial_debug_state;
 };
 
 }  // namespace cc
 
 #endif  // CC_TREES_LAYER_TREE_SETTINGS_H_