Fix use_image_texture_target inconsistencies

cc/trees/layer_tree_settings.cc

 // 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.
 
 #include "cc/trees/layer_tree_settings.h"
 
 #include "cc/proto/gfx_conversions.h"
 #include "cc/proto/layer_tree_settings.pb.h"
 #include "third_party/khronos/GLES2/gl2.h"
 
@@ skipping 32 matching lines @@
   }
   return LayerTreeSettings::ScrollbarAnimator::NO_ANIMATOR;
 }
 
 }  // namespace
 
 LayerTreeSettings::LayerTreeSettings()
     : default_tile_size(gfx::Size(256, 256)),
       max_untiled_layer_size(gfx::Size(512, 512)),
       minimum_occlusion_tracking_size(gfx::Size(160, 160)),
-      use_image_texture_targets(
-          static_cast<size_t>(gfx::BufferFormat::LAST) + 1,
-          GL_TEXTURE_2D),
       memory_policy_(64 * 1024 * 1024,
                      gpu::MemoryAllocation::CUTOFF_ALLOW_EVERYTHING,
                      ManagedMemoryPolicy::kDefaultNumResourcesLimit) {}
 
 LayerTreeSettings::LayerTreeSettings(const LayerTreeSettings& other) = default;
 LayerTreeSettings::~LayerTreeSettings() = default;
 
 bool LayerTreeSettings::operator==(const LayerTreeSettings& other) const {
   return renderer_settings == other.renderer_settings &&
          single_thread_proxy_scheduler == other.single_thread_proxy_scheduler &&
@@ skipping 35 matching lines @@
          tiling_interest_area_padding == other.tiling_interest_area_padding &&
          skewport_target_time_in_seconds ==
              other.skewport_target_time_in_seconds &&
          skewport_extrapolation_limit_in_screen_pixels ==
              other.skewport_extrapolation_limit_in_screen_pixels &&
          max_memory_for_prepaint_percentage ==
              other.max_memory_for_prepaint_percentage &&
          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_clip_tree_calculations == other.verify_clip_tree_calculations &&
          verify_transform_tree_calculations ==
              other.verify_transform_tree_calculations &&
          image_decode_tasks_enabled == other.image_decode_tasks_enabled &&
          wait_for_beginframe_interval == other.wait_for_beginframe_interval &&
          max_staging_buffer_usage_in_bytes ==
@@ skipping 53 matching lines @@
   proto->set_scheduled_raster_task_limit(scheduled_raster_task_limit);
   proto->set_use_occlusion_for_tile_prioritization(
       use_occlusion_for_tile_prioritization);
   proto->set_image_decode_tasks_enabled(image_decode_tasks_enabled);
   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());
   proto->set_use_cached_picture_raster(use_cached_picture_raster);
-
-  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();
@@ skipping 27 matching lines @@
       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_screen_pixels =
       proto.skewport_extrapolation_limit_in_screen_pixels();
   max_memory_for_prepaint_percentage =
       proto.max_memory_for_prepaint_percentage();
   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();
   image_decode_tasks_enabled = proto.image_decode_tasks_enabled();
   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());
   use_cached_picture_raster = proto.use_cached_picture_raster();
-
-  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 =
       use_external_begin_frame_source;
   scheduler_settings.main_frame_before_activation_enabled =
       main_frame_before_activation_enabled;
   scheduler_settings.timeout_and_draw_when_animation_checkerboards =
       timeout_and_draw_when_animation_checkerboards;
   scheduler_settings.using_synchronous_renderer_compositor =
       using_synchronous_renderer_compositor;
   scheduler_settings.throttle_frame_production = wait_for_beginframe_interval;
   scheduler_settings.background_frame_interval =
       base::TimeDelta::FromSecondsD(1.0 / background_animation_rate);
   scheduler_settings.abort_commit_before_output_surface_creation =
       abort_commit_before_output_surface_creation;
   return scheduler_settings;
 }
 
 }  // namespace cc