Move have_wheel_event_handlers to WebLayerTreeView.

cc/trees/layer_tree_host.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_host.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <algorithm>
@@ skipping 124 matching lines @@
       painted_device_scale_factor_(1.f),
       visible_(false),
       page_scale_factor_(1.f),
       min_page_scale_factor_(1.f),
       max_page_scale_factor_(1.f),
       has_gpu_rasterization_trigger_(false),
       content_is_suitable_for_gpu_rasterization_(true),
       gpu_rasterization_histogram_recorded_(false),
       background_color_(SK_ColorWHITE),
       has_transparent_background_(false),
+      have_wheel_event_handlers_(false),
       did_complete_scale_animation_(false),
       in_paint_layer_contents_(false),
       id_(s_layer_tree_host_sequence_number.GetNext() + 1),
       next_commit_forces_redraw_(false),
       shared_bitmap_manager_(params->shared_bitmap_manager),
       gpu_memory_buffer_manager_(params->gpu_memory_buffer_manager),
       task_graph_runner_(params->task_graph_runner),
       surface_id_namespace_(0u),
       next_surface_sequence_(1u) {
   DCHECK(task_graph_runner_);
@@ skipping 159 matching lines @@
   if (hud_layer_.get()) {
     LayerImpl* hud_impl = LayerTreeHostCommon::FindLayerInSubtree(
         sync_tree->root_layer(), hud_layer_->id());
     sync_tree->set_hud_layer(static_cast<HeadsUpDisplayLayerImpl*>(hud_impl));
   } else {
     sync_tree->set_hud_layer(NULL);
   }
 
   sync_tree->set_background_color(background_color_);
   sync_tree->set_has_transparent_background(has_transparent_background_);
+  sync_tree->set_have_wheel_event_handlers(have_wheel_event_handlers_);
 
   if (page_scale_layer_.get() && inner_viewport_scroll_layer_.get()) {
     sync_tree->SetViewportLayersFromIds(
         overscroll_elasticity_layer_.get() ? overscroll_elasticity_layer_->id()
                                            : Layer::INVALID_ID,
         page_scale_layer_->id(), inner_viewport_scroll_layer_->id(),
         outer_viewport_scroll_layer_.get() ? outer_viewport_scroll_layer_->id()
                                            : Layer::INVALID_ID);
     DCHECK(inner_viewport_scroll_layer_->IsContainerForFixedPositionLayers());
   } else {
@@ skipping 693 matching lines @@
 }
 
 void LayerTreeHost::RegisterSelection(const LayerSelection& selection) {
   if (selection_ == selection)
     return;
 
   selection_ = selection;
   SetNeedsCommit();
 }
 
+void LayerTreeHost::SetHaveWheelEventHandlers(bool have_event_handlers) {
+  if (have_wheel_event_handlers_ == have_event_handlers)
+    return;
+
+  have_wheel_event_handlers_ = have_event_handlers;
+  SetNeedsCommit();
+}
+
 int LayerTreeHost::ScheduleMicroBenchmark(
     const std::string& benchmark_name,
     scoped_ptr<base::Value> value,
     const MicroBenchmark::DoneCallback& callback) {
   return micro_benchmark_controller_.ScheduleRun(benchmark_name,
                                                  std::move(value), callback);
 }
 
 bool LayerTreeHost::SendMessageToMicroBenchmark(int id,
                                                 scoped_ptr<base::Value> value) {
@@ skipping 294 matching lines @@
   proto->set_painted_device_scale_factor(painted_device_scale_factor_);
   proto->set_page_scale_factor(page_scale_factor_);
   proto->set_min_page_scale_factor(min_page_scale_factor_);
   proto->set_max_page_scale_factor(max_page_scale_factor_);
   Vector2dFToProto(elastic_overscroll_, proto->mutable_elastic_overscroll());
   proto->set_has_gpu_rasterization_trigger(has_gpu_rasterization_trigger_);
   proto->set_content_is_suitable_for_gpu_rasterization(
       content_is_suitable_for_gpu_rasterization_);
   proto->set_background_color(background_color_);
   proto->set_has_transparent_background(has_transparent_background_);
+  proto->set_have_wheel_event_handlers(have_wheel_event_handlers_);
   proto->set_in_paint_layer_contents(in_paint_layer_contents_);
   proto->set_id(id_);
   proto->set_next_commit_forces_redraw(next_commit_forces_redraw_);
 
   // Viewport layers.
   proto->set_overscroll_elasticity_layer_id(
       overscroll_elasticity_layer_ ? overscroll_elasticity_layer_->id()
                                    : Layer::INVALID_ID);
   proto->set_page_scale_layer_id(page_scale_layer_ ? page_scale_layer_->id()
                                                    : Layer::INVALID_ID);
@@ skipping 44 matching lines @@
   painted_device_scale_factor_ = proto.painted_device_scale_factor();
   page_scale_factor_ = proto.page_scale_factor();
   min_page_scale_factor_ = proto.min_page_scale_factor();
   max_page_scale_factor_ = proto.max_page_scale_factor();
   elastic_overscroll_ = ProtoToVector2dF(proto.elastic_overscroll());
   has_gpu_rasterization_trigger_ = proto.has_gpu_rasterization_trigger();
   content_is_suitable_for_gpu_rasterization_ =
       proto.content_is_suitable_for_gpu_rasterization();
   background_color_ = proto.background_color();
   has_transparent_background_ = proto.has_transparent_background();
+  have_wheel_event_handlers_ = proto.have_wheel_event_handlers();
   in_paint_layer_contents_ = proto.in_paint_layer_contents();
   id_ = proto.id();
   next_commit_forces_redraw_ = proto.next_commit_forces_redraw();
 
   hud_layer_ = static_cast<HeadsUpDisplayLayer*>(
       UpdateAndGetLayer(hud_layer_.get(), proto.hud_layer_id(), layer_id_map_));
   overscroll_elasticity_layer_ =
       UpdateAndGetLayer(overscroll_elasticity_layer_.get(),
                         proto.overscroll_elasticity_layer_id(), layer_id_map_);
   page_scale_layer_ = UpdateAndGetLayer(
@@ skipping 20 matching lines @@
   LayerTreeHostCommon::CallFunctionForSubtree(
       root_layer(), [seq_num](Layer* layer) {
         layer->set_property_tree_sequence_number(seq_num);
       });
 
   surface_id_namespace_ = proto.surface_id_namespace();
   next_surface_sequence_ = proto.next_surface_sequence();
 }
 
 }  // namespace cc