Add support for LayerTreeSettings (de)serialization

As part of serializing cc::LayerTreeHost, we also need to
serialize the cc::LayerTreeSettings.

BUG=561210
CQ_INCLUDE_TRYBOTS=tryserver.blink:linux_blink_rel

Review URL: https://codereview.chromium.org/1504273002

Cr-Commit-Position: refs/heads/master@{#364452}

8 files changed, 493 insertions, 2 deletions

diff --git a/cc/BUILD.gn b/cc/BUILD.gn
index 3be4ebb..35551e6 100644
--- a/cc/BUILD.gn
+++ b/cc/BUILD.gn
@@ -884,6 +884,7 @@ test("cc_unittests") {
     "trees/layer_tree_host_unittest_scroll.cc",
     "trees/layer_tree_host_unittest_video.cc",
     "trees/layer_tree_impl_unittest.cc",
+    "trees/layer_tree_settings_unittest.cc",
     "trees/occlusion_tracker_unittest.cc",
     "trees/occlusion_unittest.cc",
     "trees/property_tree_unittest.cc",
diff --git a/cc/cc.gyp b/cc/cc.gyp
index 7bce8be..0ae6cbb 100644
--- a/cc/cc.gyp
+++ b/cc/cc.gyp
@@ -603,6 +603,7 @@
         'proto/layer.proto',
         'proto/layer_position_constraint.proto',
         'proto/layer_tree_debug_state.proto',
+        'proto/layer_tree_settings.proto',
         'proto/managed_memory_policy.proto',
         'proto/memory_allocation.proto',
         'proto/point.proto',
diff --git a/cc/cc_tests.gyp b/cc/cc_tests.gyp
index 8ce17e2..dba083e 100644
--- a/cc/cc_tests.gyp
+++ b/cc/cc_tests.gyp
@@ -144,6 +144,7 @@
       'trees/layer_tree_host_unittest_scroll.cc',
       'trees/layer_tree_host_unittest_video.cc',
       'trees/layer_tree_impl_unittest.cc',
+      'trees/layer_tree_settings_unittest.cc',
       'trees/occlusion_tracker_unittest.cc',
       'trees/occlusion_unittest.cc',
       'trees/property_tree_unittest.cc',
diff --git a/cc/proto/BUILD.gn b/cc/proto/BUILD.gn
index 6983a04a..7a15f79 100644
--- a/cc/proto/BUILD.gn
+++ b/cc/proto/BUILD.gn
@@ -34,6 +34,7 @@ proto_library("proto_internal") {
     "layer.proto",
     "layer_position_constraint.proto",
     "layer_tree_debug_state.proto",
+    "layer_tree_settings.proto",
     "managed_memory_policy.proto",
     "memory_allocation.proto",
     "point.proto",
diff --git a/cc/proto/layer_tree_settings.proto b/cc/proto/layer_tree_settings.proto
new file mode 100644
index 0000000..1c0bb85
--- /dev/null
+++ b/cc/proto/layer_tree_settings.proto
@@ -0,0 +1,73 @@
+// Copyright 2015 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.
+
+syntax = "proto2";
+
+import "layer_tree_debug_state.proto";
+import "managed_memory_policy.proto";
+import "renderer_settings.proto";
+import "size.proto";
+
+package cc.proto;
+
+option optimize_for = LITE_RUNTIME;
+
+message LayerTreeSettings {
+  enum ScrollbarAnimator {
+    UNKNOWN = 0;
+    NO_ANIMATOR = 1;
+    LINEAR_FADE = 2;
+    THINNING = 3;
+  };
+
+  optional RendererSettings renderer_settings = 1;
+  optional bool single_thread_proxy_scheduler = 2;
+  optional bool use_external_begin_frame_source = 3;
+  optional bool main_frame_before_activation_enabled = 4;
+  optional bool using_synchronous_renderer_compositor = 5;
+  optional bool accelerated_animation_enabled = 6;
+  optional bool can_use_lcd_text = 7;
+  optional bool use_distance_field_text = 8;
+  optional bool gpu_rasterization_enabled = 9;
+  optional bool gpu_rasterization_forced = 10;
+  optional int32 gpu_rasterization_msaa_sample_count = 11;
+  optional float gpu_rasterization_skewport_target_time_in_seconds = 12;
+  optional bool create_low_res_tiling = 13;
+  optional ScrollbarAnimator scrollbar_animator = 14;
+  optional int32 scrollbar_fade_delay_ms = 15;
+  optional int32 scrollbar_fade_resize_delay_ms = 16;
+  optional int32 scrollbar_fade_duration_ms = 17;
+  optional uint32 solid_color_scrollbar_color = 18; /* SkColor */
+  optional bool timeout_and_draw_when_animation_checkerboards = 19;
+  optional bool layer_transforms_should_scale_layer_contents = 20;
+  optional bool layers_always_allowed_lcd_text = 21;
+  optional float minimum_contents_scale = 22;
+  optional float low_res_contents_scale_factor = 23;
+  optional float top_controls_show_threshold = 24;
+  optional float top_controls_hide_threshold = 25;
+  optional double background_animation_rate = 26;
+  optional Size default_tile_size = 27;
+  optional Size max_untiled_layer_size = 28;
+  optional Size minimum_occlusion_tracking_size = 29;
+  optional uint32 tiling_interest_area_padding = 30;
+  optional float skewport_target_time_in_seconds = 31;
+  optional int32 skewport_extrapolation_limit_in_content_pixels = 32;
+  optional uint32 max_memory_for_prepaint_percentage = 33;
+  optional bool strict_layer_property_change_checking = 34;
+  optional bool use_zero_copy = 35;
+  optional bool use_partial_raster = 36;
+  optional bool enable_elastic_overscroll = 37;
+  repeated uint32 use_image_texture_targets = 38;
+  optional bool ignore_root_layer_flings = 39;
+  optional uint32 scheduled_raster_task_limit = 40;
+  optional bool use_occlusion_for_tile_prioritization = 41;
+  optional bool verify_property_trees = 42;
+  optional bool use_property_trees = 43;
+  optional bool image_decode_tasks_enabled = 44;
+  optional bool use_compositor_animation_timelines = 45;
+  optional bool wait_for_beginframe_interval = 46;
+  optional int32 max_staging_buffer_usage_in_bytes = 47;
+  optional ManagedMemoryPolicy memory_policy = 48;
+  optional LayerTreeDebugState initial_debug_state = 49;
+}
diff --git a/cc/trees/layer_tree_settings.cc b/cc/trees/layer_tree_settings.cc
index 1a978fb..7c27273 100644
--- a/cc/trees/layer_tree_settings.cc
+++ b/cc/trees/layer_tree_settings.cc
@@ -10,10 +10,49 @@
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/strings/string_number_conversions.h"
+#include "cc/proto/gfx_conversions.h"
+#include "cc/proto/gpu_conversions.h"
+#include "cc/proto/layer_tree_settings.pb.h"
 #include "ui/gfx/buffer_types.h"
 
 namespace cc {
 
+namespace {
+
+proto::LayerTreeSettings_ScrollbarAnimator
+LayerTreeSettingsScrollbarAnimatorToProto(
+    const LayerTreeSettings::ScrollbarAnimator& animator) {
+  switch (animator) {
+    case LayerTreeSettings::ScrollbarAnimator::NO_ANIMATOR:
+      return proto::LayerTreeSettings_ScrollbarAnimator_NO_ANIMATOR;
+    case LayerTreeSettings::ScrollbarAnimator::LINEAR_FADE:
+      return proto::LayerTreeSettings_ScrollbarAnimator_LINEAR_FADE;
+    case LayerTreeSettings::ScrollbarAnimator::THINNING:
+      return proto::LayerTreeSettings_ScrollbarAnimator_THINNING;
+  }
+  NOTREACHED() << "proto::LayerTreeSettings_ScrollbarAnimator_UNKNOWN";
+  return proto::LayerTreeSettings_ScrollbarAnimator_UNKNOWN;
+}
+
+LayerTreeSettings::ScrollbarAnimator
+LayerTreeSettingsScrollbarAnimatorFromProto(
+    const proto::LayerTreeSettings_ScrollbarAnimator& animator) {
+  switch (animator) {
+    case proto::LayerTreeSettings_ScrollbarAnimator_NO_ANIMATOR:
+      return LayerTreeSettings::ScrollbarAnimator::NO_ANIMATOR;
+    case proto::LayerTreeSettings_ScrollbarAnimator_LINEAR_FADE:
+      return LayerTreeSettings::ScrollbarAnimator::LINEAR_FADE;
+    case proto::LayerTreeSettings_ScrollbarAnimator_THINNING:
+      return LayerTreeSettings::ScrollbarAnimator::THINNING;
+    case proto::LayerTreeSettings_ScrollbarAnimator_UNKNOWN:
+      NOTREACHED() << "proto::LayerTreeSettings_ScrollbarAnimator_UNKNOWN";
+      return LayerTreeSettings::ScrollbarAnimator::NO_ANIMATOR;
+  }
+  return LayerTreeSettings::ScrollbarAnimator::NO_ANIMATOR;
+}
+
+}  // namespace
+
 LayerTreeSettings::LayerTreeSettings()
     : single_thread_proxy_scheduler(true),
       use_external_begin_frame_source(false),
@@ -70,6 +109,207 @@ LayerTreeSettings::LayerTreeSettings()
 
 LayerTreeSettings::~LayerTreeSettings() {}
 
+bool LayerTreeSettings::operator==(const LayerTreeSettings& other) const {
+  return renderer_settings == other.renderer_settings &&
+         single_thread_proxy_scheduler == other.single_thread_proxy_scheduler &&
+         use_external_begin_frame_source ==
+             other.use_external_begin_frame_source &&
+         main_frame_before_activation_enabled ==
+             other.main_frame_before_activation_enabled &&
+         using_synchronous_renderer_compositor ==
+             other.using_synchronous_renderer_compositor &&
+         accelerated_animation_enabled == other.accelerated_animation_enabled &&
+         can_use_lcd_text == other.can_use_lcd_text &&
+         use_distance_field_text == other.use_distance_field_text &&
+         gpu_rasterization_enabled == other.gpu_rasterization_enabled &&
+         gpu_rasterization_forced == other.gpu_rasterization_forced &&
+         gpu_rasterization_msaa_sample_count ==
+             other.gpu_rasterization_msaa_sample_count &&
+         create_low_res_tiling == other.create_low_res_tiling &&
+         scrollbar_animator == other.scrollbar_animator &&
+         scrollbar_fade_delay_ms == other.scrollbar_fade_delay_ms &&
+         scrollbar_fade_resize_delay_ms ==
+             other.scrollbar_fade_resize_delay_ms &&
+         scrollbar_fade_duration_ms == other.scrollbar_fade_duration_ms &&
+         solid_color_scrollbar_color == other.solid_color_scrollbar_color &&
+         timeout_and_draw_when_animation_checkerboards ==
+             other.timeout_and_draw_when_animation_checkerboards &&
+         layer_transforms_should_scale_layer_contents ==
+             other.layer_transforms_should_scale_layer_contents &&
+         layers_always_allowed_lcd_text ==
+             other.layers_always_allowed_lcd_text &&
+         minimum_contents_scale == other.minimum_contents_scale &&
+         low_res_contents_scale_factor == other.low_res_contents_scale_factor &&
+         top_controls_show_threshold == other.top_controls_show_threshold &&
+         top_controls_hide_threshold == other.top_controls_hide_threshold &&
+         background_animation_rate == other.background_animation_rate &&
+         default_tile_size == other.default_tile_size &&
+         max_untiled_layer_size == other.max_untiled_layer_size &&
+         minimum_occlusion_tracking_size ==
+             other.minimum_occlusion_tracking_size &&
+         tiling_interest_area_padding == other.tiling_interest_area_padding &&
+         skewport_target_time_in_seconds ==
+             other.skewport_target_time_in_seconds &&
+         skewport_extrapolation_limit_in_content_pixels ==
+             other.skewport_extrapolation_limit_in_content_pixels &&
+         max_memory_for_prepaint_percentage ==
+             other.max_memory_for_prepaint_percentage &&
+         strict_layer_property_change_checking ==
+             other.strict_layer_property_change_checking &&
+         use_zero_copy == other.use_zero_copy &&
+         use_partial_raster == other.use_partial_raster &&
+         enable_elastic_overscroll == other.enable_elastic_overscroll &&
+         use_image_texture_targets == other.use_image_texture_targets &&
+         ignore_root_layer_flings == other.ignore_root_layer_flings &&
+         scheduled_raster_task_limit == other.scheduled_raster_task_limit &&
+         use_occlusion_for_tile_prioritization ==
+             other.use_occlusion_for_tile_prioritization &&
+         verify_property_trees == other.verify_property_trees &&
+         use_property_trees == other.use_property_trees &&
+         image_decode_tasks_enabled == other.image_decode_tasks_enabled &&
+         use_compositor_animation_timelines ==
+             other.use_compositor_animation_timelines &&
+         wait_for_beginframe_interval == other.wait_for_beginframe_interval &&
+         max_staging_buffer_usage_in_bytes ==
+             other.max_staging_buffer_usage_in_bytes &&
+         memory_policy_ == other.memory_policy_ &&
+         LayerTreeDebugState::Equal(initial_debug_state,
+                                    other.initial_debug_state);
+}
+
+void LayerTreeSettings::ToProtobuf(proto::LayerTreeSettings* proto) const {
+  renderer_settings.ToProtobuf(proto->mutable_renderer_settings());
+  proto->set_single_thread_proxy_scheduler(single_thread_proxy_scheduler);
+  proto->set_use_external_begin_frame_source(use_external_begin_frame_source);
+  proto->set_main_frame_before_activation_enabled(
+      main_frame_before_activation_enabled);
+  proto->set_using_synchronous_renderer_compositor(
+      using_synchronous_renderer_compositor);
+  proto->set_accelerated_animation_enabled(accelerated_animation_enabled);
+  proto->set_can_use_lcd_text(can_use_lcd_text);
+  proto->set_use_distance_field_text(use_distance_field_text);
+  proto->set_gpu_rasterization_enabled(gpu_rasterization_enabled);
+  proto->set_gpu_rasterization_forced(gpu_rasterization_forced);
+  proto->set_gpu_rasterization_msaa_sample_count(
+      gpu_rasterization_msaa_sample_count);
+  proto->set_create_low_res_tiling(create_low_res_tiling);
+  proto->set_scrollbar_animator(
+      LayerTreeSettingsScrollbarAnimatorToProto(scrollbar_animator));
+  proto->set_scrollbar_fade_delay_ms(scrollbar_fade_delay_ms);
+  proto->set_scrollbar_fade_resize_delay_ms(scrollbar_fade_resize_delay_ms);
+  proto->set_scrollbar_fade_duration_ms(scrollbar_fade_duration_ms);
+  proto->set_solid_color_scrollbar_color(solid_color_scrollbar_color);
+  proto->set_timeout_and_draw_when_animation_checkerboards(
+      timeout_and_draw_when_animation_checkerboards);
+  proto->set_layer_transforms_should_scale_layer_contents(
+      layer_transforms_should_scale_layer_contents);
+  proto->set_layers_always_allowed_lcd_text(layers_always_allowed_lcd_text);
+  proto->set_minimum_contents_scale(minimum_contents_scale);
+  proto->set_low_res_contents_scale_factor(low_res_contents_scale_factor);
+  proto->set_top_controls_show_threshold(top_controls_show_threshold);
+  proto->set_top_controls_hide_threshold(top_controls_hide_threshold);
+  proto->set_background_animation_rate(background_animation_rate);
+  SizeToProto(default_tile_size, proto->mutable_default_tile_size());
+  SizeToProto(max_untiled_layer_size, proto->mutable_max_untiled_layer_size());
+  SizeToProto(minimum_occlusion_tracking_size,
+              proto->mutable_minimum_occlusion_tracking_size());
+  proto->set_tiling_interest_area_padding(tiling_interest_area_padding);
+  proto->set_skewport_target_time_in_seconds(skewport_target_time_in_seconds);
+  proto->set_skewport_extrapolation_limit_in_content_pixels(
+      skewport_extrapolation_limit_in_content_pixels);
+  proto->set_max_memory_for_prepaint_percentage(
+      max_memory_for_prepaint_percentage);
+  proto->set_strict_layer_property_change_checking(
+      strict_layer_property_change_checking);
+  proto->set_use_zero_copy(use_zero_copy);
+  proto->set_use_partial_raster(use_partial_raster);
+  proto->set_enable_elastic_overscroll(enable_elastic_overscroll);
+  proto->set_ignore_root_layer_flings(ignore_root_layer_flings);
+  proto->set_scheduled_raster_task_limit(scheduled_raster_task_limit);
+  proto->set_use_occlusion_for_tile_prioritization(
+      use_occlusion_for_tile_prioritization);
+  proto->set_verify_property_trees(verify_property_trees);
+  proto->set_use_property_trees(use_property_trees);
+  proto->set_image_decode_tasks_enabled(image_decode_tasks_enabled);
+  proto->set_use_compositor_animation_timelines(
+      use_compositor_animation_timelines);
+  proto->set_wait_for_beginframe_interval(wait_for_beginframe_interval);
+  proto->set_max_staging_buffer_usage_in_bytes(
+      max_staging_buffer_usage_in_bytes);
+  memory_policy_.ToProtobuf(proto->mutable_memory_policy());
+  initial_debug_state.ToProtobuf(proto->mutable_initial_debug_state());
+
+  for (unsigned u : use_image_texture_targets)
+    proto->add_use_image_texture_targets(u);
+}
+
+void LayerTreeSettings::FromProtobuf(const proto::LayerTreeSettings& proto) {
+  renderer_settings.FromProtobuf(proto.renderer_settings());
+  single_thread_proxy_scheduler = proto.single_thread_proxy_scheduler();
+  use_external_begin_frame_source = proto.use_external_begin_frame_source();
+  main_frame_before_activation_enabled =
+      proto.main_frame_before_activation_enabled();
+  using_synchronous_renderer_compositor =
+      proto.using_synchronous_renderer_compositor();
+  accelerated_animation_enabled = proto.accelerated_animation_enabled();
+  can_use_lcd_text = proto.can_use_lcd_text();
+  use_distance_field_text = proto.use_distance_field_text();
+  gpu_rasterization_enabled = proto.gpu_rasterization_enabled();
+  gpu_rasterization_forced = proto.gpu_rasterization_forced();
+  gpu_rasterization_msaa_sample_count =
+      proto.gpu_rasterization_msaa_sample_count();
+  create_low_res_tiling = proto.create_low_res_tiling();
+  scrollbar_animator =
+      LayerTreeSettingsScrollbarAnimatorFromProto(proto.scrollbar_animator());
+  scrollbar_fade_delay_ms = proto.scrollbar_fade_delay_ms();
+  scrollbar_fade_resize_delay_ms = proto.scrollbar_fade_resize_delay_ms();
+  scrollbar_fade_duration_ms = proto.scrollbar_fade_duration_ms();
+  solid_color_scrollbar_color = proto.solid_color_scrollbar_color();
+  timeout_and_draw_when_animation_checkerboards =
+      proto.timeout_and_draw_when_animation_checkerboards();
+  layer_transforms_should_scale_layer_contents =
+      proto.layer_transforms_should_scale_layer_contents();
+  layers_always_allowed_lcd_text = proto.layers_always_allowed_lcd_text();
+  minimum_contents_scale = proto.minimum_contents_scale();
+  low_res_contents_scale_factor = proto.low_res_contents_scale_factor();
+  top_controls_show_threshold = proto.top_controls_show_threshold();
+  top_controls_hide_threshold = proto.top_controls_hide_threshold();
+  background_animation_rate = proto.background_animation_rate();
+  default_tile_size = ProtoToSize(proto.default_tile_size());
+  max_untiled_layer_size = ProtoToSize(proto.max_untiled_layer_size());
+  minimum_occlusion_tracking_size =
+      ProtoToSize(proto.minimum_occlusion_tracking_size());
+  tiling_interest_area_padding = proto.tiling_interest_area_padding();
+  skewport_target_time_in_seconds = proto.skewport_target_time_in_seconds();
+  skewport_extrapolation_limit_in_content_pixels =
+      proto.skewport_extrapolation_limit_in_content_pixels();
+  max_memory_for_prepaint_percentage =
+      proto.max_memory_for_prepaint_percentage();
+  strict_layer_property_change_checking =
+      proto.strict_layer_property_change_checking();
+  use_zero_copy = proto.use_zero_copy();
+  use_partial_raster = proto.use_partial_raster();
+  enable_elastic_overscroll = proto.enable_elastic_overscroll();
+  // |use_image_texture_targets| contains default values, so clear first.
+  use_image_texture_targets.clear();
+  ignore_root_layer_flings = proto.ignore_root_layer_flings();
+  scheduled_raster_task_limit = proto.scheduled_raster_task_limit();
+  use_occlusion_for_tile_prioritization =
+      proto.use_occlusion_for_tile_prioritization();
+  verify_property_trees = proto.verify_property_trees();
+  use_property_trees = proto.use_property_trees();
+  image_decode_tasks_enabled = proto.image_decode_tasks_enabled();
+  use_compositor_animation_timelines =
+      proto.use_compositor_animation_timelines();
+  wait_for_beginframe_interval = proto.wait_for_beginframe_interval();
+  max_staging_buffer_usage_in_bytes = proto.max_staging_buffer_usage_in_bytes();
+  memory_policy_.FromProtobuf(proto.memory_policy());
+  initial_debug_state.FromProtobuf(proto.initial_debug_state());
+
+  for (int i = 0; i < proto.use_image_texture_targets_size(); ++i)
+    use_image_texture_targets.push_back(proto.use_image_texture_targets(i));
+}
+
 SchedulerSettings LayerTreeSettings::ToSchedulerSettings() const {
   SchedulerSettings scheduler_settings;
   scheduler_settings.use_external_begin_frame_source =
diff --git a/cc/trees/layer_tree_settings.h b/cc/trees/layer_tree_settings.h
index 9fb59cb..0939ba0 100644
--- a/cc/trees/layer_tree_settings.h
+++ b/cc/trees/layer_tree_settings.h
@@ -18,11 +18,22 @@
 
 namespace cc {
 
+namespace proto {
+class LayerTreeSettings;
+}  // namespace proto
+
 class CC_EXPORT LayerTreeSettings {
  public:
   LayerTreeSettings();
   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 use_external_begin_frame_source;
@@ -80,8 +91,6 @@ class CC_EXPORT LayerTreeSettings {
   ManagedMemoryPolicy memory_policy_;
 
   LayerTreeDebugState initial_debug_state;
-
-  SchedulerSettings ToSchedulerSettings() const;
 };
 
 }  // namespace cc
diff --git a/cc/trees/layer_tree_settings_unittest.cc b/cc/trees/layer_tree_settings_unittest.cc
new file mode 100644
index 0000000..48e6122
--- /dev/null
+++ b/cc/trees/layer_tree_settings_unittest.cc
@@ -0,0 +1,165 @@
+// Copyright 2015 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.
+
+#include "cc/trees/layer_tree_settings.h"
+
+#include "cc/proto/layer_tree_settings.pb.h"
+#include "testing/gtest/include/gtest/gtest.h"
+
+namespace cc {
+namespace {
+
+void VerifySerializeAndDeserialize(const LayerTreeSettings& settings1) {
+  proto::LayerTreeSettings proto;
+  settings1.ToProtobuf(&proto);
+  LayerTreeSettings settings2;
+  settings2.FromProtobuf(proto);
+  EXPECT_EQ(settings1, settings2);
+}
+
+TEST(LayerTreeSettingsTest, DefaultValues) {
+  LayerTreeSettings settings;
+  VerifySerializeAndDeserialize(settings);
+}
+
+TEST(LayerTreeSettingsTest, AllMembersChanged) {
+  LayerTreeSettings settings;
+  RendererSettings rs;
+  rs.texture_id_allocation_chunk_size =
+      rs.texture_id_allocation_chunk_size * 3 + 1;
+  settings.renderer_settings = rs;
+  settings.single_thread_proxy_scheduler =
+      !settings.single_thread_proxy_scheduler;
+  settings.use_external_begin_frame_source =
+      !settings.use_external_begin_frame_source;
+  settings.main_frame_before_activation_enabled =
+      !settings.main_frame_before_activation_enabled;
+  settings.using_synchronous_renderer_compositor =
+      !settings.using_synchronous_renderer_compositor;
+  settings.accelerated_animation_enabled =
+      !settings.accelerated_animation_enabled;
+  settings.can_use_lcd_text = !settings.can_use_lcd_text;
+  settings.use_distance_field_text = !settings.use_distance_field_text;
+  settings.gpu_rasterization_enabled = !settings.gpu_rasterization_enabled;
+  settings.gpu_rasterization_forced = !settings.gpu_rasterization_forced;
+  settings.gpu_rasterization_msaa_sample_count =
+      settings.gpu_rasterization_msaa_sample_count * 3 + 1;
+  settings.gpu_rasterization_skewport_target_time_in_seconds =
+      settings.gpu_rasterization_skewport_target_time_in_seconds * 3 + 1;
+  settings.create_low_res_tiling = !settings.create_low_res_tiling;
+  settings.scrollbar_animator = LayerTreeSettings::THINNING;
+  settings.scrollbar_fade_delay_ms = settings.scrollbar_fade_delay_ms * 3 + 1;
+  settings.scrollbar_fade_resize_delay_ms =
+      settings.scrollbar_fade_resize_delay_ms * 3 + 1;
+  settings.scrollbar_fade_duration_ms =
+      settings.scrollbar_fade_duration_ms * 3 + 1;
+  settings.solid_color_scrollbar_color = SK_ColorCYAN;
+  settings.timeout_and_draw_when_animation_checkerboards =
+      !settings.timeout_and_draw_when_animation_checkerboards;
+  settings.layer_transforms_should_scale_layer_contents =
+      !settings.layer_transforms_should_scale_layer_contents;
+  settings.layers_always_allowed_lcd_text =
+      !settings.layers_always_allowed_lcd_text;
+  settings.minimum_contents_scale = 0.42f;
+  settings.low_res_contents_scale_factor = 0.43f;
+  settings.top_controls_show_threshold = 0.44f;
+  settings.top_controls_hide_threshold = 0.45f;
+  settings.background_animation_rate = 0.46f;
+  settings.default_tile_size = gfx::Size(47, 48);
+  settings.max_untiled_layer_size = gfx::Size(49, 50);
+  settings.minimum_occlusion_tracking_size = gfx::Size(51, 52);
+  settings.tiling_interest_area_padding =
+      settings.tiling_interest_area_padding * 3 + 1;
+  settings.skewport_target_time_in_seconds = 0.53f;
+  settings.skewport_extrapolation_limit_in_content_pixels =
+      settings.skewport_extrapolation_limit_in_content_pixels * 3 + 1;
+  settings.max_memory_for_prepaint_percentage =
+      settings.max_memory_for_prepaint_percentage * 3 + 1;
+  settings.strict_layer_property_change_checking =
+      !settings.strict_layer_property_change_checking;
+  settings.use_zero_copy = !settings.use_zero_copy;
+  settings.use_partial_raster = !settings.use_partial_raster;
+  settings.enable_elastic_overscroll = !settings.enable_elastic_overscroll;
+  settings.use_image_texture_targets.push_back(54);
+  settings.use_image_texture_targets.push_back(55);
+  settings.ignore_root_layer_flings = !settings.ignore_root_layer_flings;
+  settings.scheduled_raster_task_limit =
+      settings.scheduled_raster_task_limit * 3 + 1;
+  settings.use_occlusion_for_tile_prioritization =
+      !settings.use_occlusion_for_tile_prioritization;
+  settings.use_property_trees = !settings.use_property_trees;
+  settings.use_compositor_animation_timelines =
+      !settings.use_compositor_animation_timelines;
+  settings.wait_for_beginframe_interval =
+      !settings.wait_for_beginframe_interval;
+  settings.max_staging_buffer_usage_in_bytes =
+      settings.max_staging_buffer_usage_in_bytes * 3 + 1;
+  settings.memory_policy_ = ManagedMemoryPolicy(
+      56, gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE, 57);
+  LayerTreeDebugState debug_state;
+  debug_state.show_fps_counter = !debug_state.show_fps_counter;
+  settings.initial_debug_state = debug_state;
+  VerifySerializeAndDeserialize(settings);
+}
+
+TEST(LayerTreeSettingsTest, ArbitraryValues) {
+  LayerTreeSettings settings;
+  RendererSettings rs;
+  rs.texture_id_allocation_chunk_size = 42;
+  settings.renderer_settings = rs;
+  settings.single_thread_proxy_scheduler = true;
+  settings.use_external_begin_frame_source = true;
+  settings.main_frame_before_activation_enabled = true;
+  settings.using_synchronous_renderer_compositor = false;
+  settings.accelerated_animation_enabled = true;
+  settings.can_use_lcd_text = false;
+  settings.use_distance_field_text = false;
+  settings.gpu_rasterization_enabled = false;
+  settings.gpu_rasterization_forced = true;
+  settings.gpu_rasterization_msaa_sample_count = 10;
+  settings.gpu_rasterization_skewport_target_time_in_seconds = 0.909f;
+  settings.create_low_res_tiling = false;
+  settings.scrollbar_animator = LayerTreeSettings::LINEAR_FADE;
+  settings.scrollbar_fade_delay_ms = 13;
+  settings.scrollbar_fade_resize_delay_ms = 61;
+  settings.scrollbar_fade_duration_ms = 23;
+  settings.solid_color_scrollbar_color = SK_ColorCYAN;
+  settings.timeout_and_draw_when_animation_checkerboards = true;
+  settings.layer_transforms_should_scale_layer_contents = true;
+  settings.layers_always_allowed_lcd_text = true;
+  settings.minimum_contents_scale = 0.314f;
+  settings.low_res_contents_scale_factor = 0.49f;
+  settings.top_controls_hide_threshold = 0.666f;
+  settings.top_controls_hide_threshold = 0.51f;
+  settings.background_animation_rate = 0.52f;
+  settings.default_tile_size = gfx::Size(53, 54);
+  settings.max_untiled_layer_size = gfx::Size(55, 56);
+  settings.minimum_occlusion_tracking_size = gfx::Size(57, 58);
+  settings.tiling_interest_area_padding = 59;
+  settings.skewport_target_time_in_seconds = 0.6f;
+  settings.skewport_extrapolation_limit_in_content_pixels = 61;
+  settings.max_memory_for_prepaint_percentage = 62;
+  settings.strict_layer_property_change_checking = true;
+  settings.use_zero_copy = true;
+  settings.use_partial_raster = true;
+  settings.enable_elastic_overscroll = false;
+  settings.use_image_texture_targets.push_back(10);
+  settings.use_image_texture_targets.push_back(19);
+  settings.ignore_root_layer_flings = true;
+  settings.scheduled_raster_task_limit = 41;
+  settings.use_occlusion_for_tile_prioritization = true;
+  settings.use_property_trees = true;
+  settings.use_compositor_animation_timelines = true;
+  settings.wait_for_beginframe_interval = true;
+  settings.max_staging_buffer_usage_in_bytes = 70;
+  settings.memory_policy_ = ManagedMemoryPolicy(
+      71, gpu::MemoryAllocation::CUTOFF_ALLOW_NICE_TO_HAVE, 77);
+  LayerTreeDebugState debug_state;
+  debug_state.show_fps_counter = true;
+  settings.initial_debug_state = debug_state;
+  VerifySerializeAndDeserialize(settings);
+}
+
+}  // namespace
+}  // namespace cc