From 2fe752c3c8b169b515990c2cb189805836adfcd2 Mon Sep 17 00:00:00 2001 From: nyquist Date: Thu, 10 Dec 2015 12:12:51 -0800 Subject: 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} --- cc/BUILD.gn | 1 + cc/cc.gyp | 1 + cc/cc_tests.gyp | 1 + cc/proto/BUILD.gn | 1 + cc/proto/layer_tree_settings.proto | 73 ++++++++++ cc/trees/layer_tree_settings.cc | 240 +++++++++++++++++++++++++++++++ cc/trees/layer_tree_settings.h | 13 +- cc/trees/layer_tree_settings_unittest.cc | 165 +++++++++++++++++++++ 8 files changed, 493 insertions(+), 2 deletions(-) create mode 100644 cc/proto/layer_tree_settings.proto create mode 100644 cc/trees/layer_tree_settings_unittest.cc 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 -- cgit v1.1